Implement Hash#path_to_key

[rudy-on-rails]

This PR is a first attempt to contribute to MRI, done at the RubyHackChallenge at Cookpad office in Bristol. I apologize in advance for anything that might be missing here, in relation to how this should be approached.

It has been started with ko1/rubyhackchallenge#41. After the implementation, me and @skateman had a chart with @matz about how applicable would it be to have that code merged.

Matz suggested that a method like this, described afterwards in ko1/rubyhackchallenge#44, would have more applicability and just generally be more useful.

[rudy-on-rails]

@skateman This is the implementation I came up with.

[nobu]

Where h = {a: 1}, both of h.path_to_key(:a) and h.path_to_key(:b) return [].
Is this intentional?

For recursive hash, h = {}; h[:x] = h, h.path_to_key(:a) returns [:x], but h doesn't contain :a.

[rudy-on-rails]

@nobu Interesting comment....
Number 1 is intentional, yes, although might not be the most ideal way of exposing that the path is unexistent or it's in the first-level (root) of the Hash object.

About number two, I will add a test for this case and fix it.

[nobu]

declaration in for is not C89.

[nobu]

Why not nil when the key does not exist?

[rudy-on-rails]

I think it might make more sense, @nobu . I will check it out on how can I approach that and change it.

[nobu]

I guess that you'd expect {a: {b: 0, x: 1}}.path_to_key(:x) to be [:a].

[rudy-on-rails]

Yes @nobu. Just fixed that and another recursive hash issue...

[rudy-on-rails]

I will have to slightly change the implementation of this, because hashes like

hsh = {:x=>{:e=>1}, :y=>[1, 2, 3], :z=>{:a=>{:w=>100}}}
hsh.path_to_key(:w)

will be expected to return [:z, :a] but are not in the moment due to the way sub-hashes are analised.

[nobu]

{a: {}, b: {x: 1}}.path_to_key(:x) returns nil.

[nobu]

h = {a: {}}; h[:a][:b] = h; h.path_to_key(:x) doesn't return.

[nobu]

What do you expect when a hash has multiple paths to the same key, e.g., {a: {x: 0}, b: {x: 1}}.path_to_key(:x)?

[rudy-on-rails]

The right expectation would be [:a], the first path found that matches.

[rudy-on-rails]

Hey @nobu. Can you re-check this? I have re-implemented using a recursive approach, but I don't know how much my recursion design might hurt some other parts. I've used some of the recursions over the hash as base. Cheers

[hsbt]

@rudy-on-rails Can you address this feature request to https://bugs.ruby-lang.org?

We do not handle new feature on GitHub.

[rudy-on-rails]

Hey @hsbt , sure thing. I will write the rationale there.

[rudy-on-rails]

Done @hsbt https://bugs.ruby-lang.org/issues/14636

[k0kubun]

It seems to have a conflict now. Could you rebase this from master?

[k0kubun]

Let me close this as it has not been updated for a while. Please reopen this after resolving conflicts. Thanks.