Allow #fetch access in Rash

[teliosdev]

This allows developers to use the #fetch method on a Rash, the idea being that it either raises a KeyError or yields if there is nothing that matched the given key. Also defines respond_to_missing? on the Rash class, since it was missing that.

On a side note, I keep saying find instead of fetch. I don't know why. 🍰

[dblock]

Is this expected to yield on key and not on value?

[teliosdev]

In the fetch method, it calls all with the block; for the first element that all matches, it returns. If the block given to all isn't called at all, it will then try to determine a default value to return. If a block is given, it yields the key, and returns the value of the block. If an argument is given, it returns that argument (I use the constant NO_DEFAULT which is set to an instance of a generic object to make sure that if an argument is given, it'll use its value). Otherwise, it raises an error.

It follows the behavior of Hash#fetch.

[dblock]

I don't think I like this whole yield business. It's very hard to guess what it does. Generally yields match something and yield, not the other way around. This is the case of ActiveRecord or Mongoid or so many other libraries. IMO this should just be:

def fetch(key, &block)
    all(key) do |value|
        yield value if block_given?
    end
    nil
end

What am I missing?

[teliosdev]

Let's say that you had a hash that you were using as a cache; if the cache missed, then you need to generate the data. Unfortunately, nil and false are both possible values; by default, if you try to access a key that doesn't have a pair in the hash table, then it returns nil (this is also why I use the NO_DEFAULT constant to denote the default value instead of nil), so you couldn't do hash[key] ||= generate_value(key). #fetch lets us customize this behaviour. We can pass it a value to return if the value doesn't exist; or, in case we need to generate the data on the fly (or even just set the value in the hash), we can pass it a block to do so. An example of something that might require this would be this.

ActiveSupport actually has something like this; see #find_or_create_by. The new instance is passed to the block, not the retrieved instance.

[dblock]

I understand now. You want to mimic behavior of a cache. However, I think that's too specific with a name that is too general for Hashie::Rash. I would be open to to a find_or_create_by method that is very explicitly doing what you'd expect it to do, and it would probably need to be built as an extension that can be mixed into a few hashes.

[teliosdev]

The reason I chose #fetch as the name is because the built-in Hash class has the #fetch method; since Rash is meant to act like a Hash in terms of accessing, I thought that the #fetch method should follow the semantics of the Hash's #fetch.

This cannot be extracted into an extension well; the behavior of the #fetch method is too dependent on the class it's defined on to be able to do so. Mash even has a #fetch method that does something similar (I'm not sure if it follows the block semantics).

While I agree in that the name fetch isn't that descriptive of what the method does, the core API implements fetch in that manner; therefore, for the sake of understandability, I believe it should be named after the core API.

[teliosdev]

I also want to point out that #fetch isn't just used for caching - you can use it in methods that accept a hash argument to determine values for keys, like in this example:

def some_method(options)
  prints = options.fetch(:prints, 1)
  body   = options.fetch(:body) { "Hello, #{options.fetch(:subject)}" }

  prints.times { puts body }
end

some_method(subject: "world")

Or, somewhere in the Rails repository, this example.

[dblock]

Ok, I am wrapping my head around this, thanks for being patient. I didn't realize Ruby Hash has these fetch semantics, I should have read it. So, it says "Returns a value from the hash for the given key. If the key can’t be found, there are several options: With no other arguments, it will raise an KeyError exception; if default is given, then that will be returned; if the optional code block is specified, then that will be run and its result returned."

This isn't quite what's implemented here, beginning with this NO_DEFAULT thing.

h = { "a" => 100, "b" => 200 }
h.fetch("a")                            #=> 100
h.fetch("z", "go fish")                 #=> "go fish"
h.fetch("z") { |el| "go fish, #{el}"}   #=> "go fish, z"

Can we get closer to these semantics?

[teliosdev]

The purpose of the NO_DEFAULT was so that I could guarantee that the call was passed no other arguments. If, for example, I had used nil instead of NO_DEFAULT, and the call was passed nil to be the default value, then the call would act as if it wasn't passed an argument and would error. Hash#fetch is probably written in C, which would make it easier to determine if the second argument was passed (the function prototype would be something like VALUE Hash_fetch(int argc, VALUE* argv, VALUE self), and argc would be 2 if it was passed 2 arguments).

Looking at it now, I could probably use the spat operator and check the length of the array instead.

[dblock]

Is there any precedent for the way you did NO_DEFAULT? I would certainly prefer another solution, but I understand why you're doing this, thanks.

[dblock]

Should probably just say "Added Rash#fetch".

[dblock]

Merged via ae4cab2, thanks.