Symbolize keys and freeze values when loading from YAML

[paarthmadan]

Changes introduced

Pysch, Ruby's YAML parser, now supports configuring freeze and symbolize_names as options for YAML#unsafe_load_file and YAML#load_file.

This PR sets both of these parameters to true.

Intended outcomes

In setting freeze: true, all values returned will now be frozen objects. Further, string values will be deduplicated.

In setting symbolize_names: true, keys will be directly parsed as symbols. This is particularly beneficial, as we already eventually perform a call to #deep_symbolize_keys. This way, they'll take on their Symbol representation at parse-time.

[casperisfine]

Suggested change

	YAML.load_file('test/test_data/locales/en.yml', k => v)
	YAML.load('', **{k => v})

Two things here:

• That load_file wouldn't work once loaded in an app because it is relative to the current working directory ($PWD)). But you don't need to load a file anyway, load take the same options.
• It's best to use **{} to make sure it's passed as keyword arguments, not a positional hash.

[paarthmadan]

Initially, I was trying to use #load, but it turns out load's signature wasn't always a good proxy for the signature of load_file.

Until this commit (by yourself), ruby/psych#463, not all kwargs on load were available to load_file.

This is problematic, as for instance on Ruby 2.7.4, load accepts :symbolize_names but load_file doesn't.

Any suggestions? I certainly agree that using load would be optimal, and didn't fully think through the consequence of using load_file as you pointed out above.

[codealchemy]

Could accessing the methods args directly help here? Something along the lines of

YAML_LOAD_OPTIONS = YAML.method(:load_file).parameters.each_with_object({}) do |(context, param_name), args|
  args[param_name] = true if context == :key && %i[symbolize_names freeze].include?(param_name)
end

[casperisfine]

Could accessing the methods args directly help here?

In this instance no, because for a very long time these methods weren't taking keyword args, but one big option hash.

[radar]

Rather than rescuing on an ArgumentError, I would rather a version check (either of Ruby, or of whatever's added the support for these options).

Pseudocode like:

if version >= 3.0.0
  <symbolise code>
else
  <old path>
end

[casperisfine]

The problem is that bundled gem sometimes "lie" about their version because of https://bugs.ruby-lang.org/issues/18169, it happened to me previously hence I I now default to feature testing.

That being said, we could conflate this with the feature testing for unsafe_load_file:

            if YAML.respond_to?(:unsafe_load_file) # Psych 4.0 way
              YAML.unsafe_load_file(filename, symbolize_names: true, freeze: true)
            else
              YAML.load_file(filename)
            end

We'll miss a few versions but that's probably fine.

[radar]

Please do not rescue from ArgumentError.

[casperisfine]

@paarthmadan I took the liberty to update your PR. Now it only applies for psych >= 3.3.2. We could theoretically include a few slightly older versions but it's not worth the trouble.

[paarthmadan]

Thanks @casperisfine, I appreciate it! FWIW, I agree with the proposed strategy 👍 We scope the change to a smaller (but incomplete) subset of versions to avoid needing to rescue from an ArgumentError.

[Sarkar44]

request change

[paarthmadan]

@radar Just bumping this! Addressed your feedback, now we simply append the arguments when we're certain they're supported.

[casperisfine]

A couple note (which doesn't mean they should be added to this PR):

The same could be done for .json files:

• Recent json gems also have symbolize_names and freeze
• They also have load_file which allows bootsnap to really speed up parsing.

That being said, I've never seen a .json translation file in the wild, so...

As for performance, with the keys already parsed as symbols, deep_symbolize_keys will be faster, but it still need to walk the object graph which is quite slow. It would be even faster to not call it because we know it's useless.

The problem is that it's called in load_file, so it would need a bit of a refactoring to achieve this, but that may be better done in a followup.

[radar]

I'd like a check for frozen values here too, please. I think this might work here:

assert data.dig(:en, :foo, :bar).frozen?

[paarthmadan]

Sure, added!

[radar]

Please add check for frozen

[radar]

Please fix the conflict on this branch.