Provide an easy way to get `NoMethodError` instead of `nil` on undefined keys. about hashie

[scottnicolson]

What about implementing a fetch method that raises a key error much like a hash does? This then stays with the spirit of a hash.

class Hashie::Mash

  def fetch(key)
    raise KeyError, 'key not found' unless self.include?(key)
    self[key]
  end

end

[myronmarston]

@scottnicolson -- but that wouldn't apply to the hashie dot syntax, would it? I like the dot syntax a lot (e.g. users.first.address.city) and I want a way to make my mash (or mash-like object) raise appropriate errors when used in that fashion.

[myronmarston]

BTW, for anyone who tries my snippet above: it works on 1.9 but I discovered it didn't work on 1.8.7 because there is no Hash#default_proc= method on 1.8. I found a work around for 1.8 that you can checkout if you're interested in using it.

[jch]

I'd be happy to help review a pull if you've come up with a solution you like.

[lukaszx0]

@myronmarston any developments?

[dblock]

Bump.

[alex-fedorov]

👍 for that feature

[dblock]

I believe the StrictKeyAccess extension in 3.4.3 does this, can someone confirm and close this issue?

[michaelherold]

@dblock When I was attempting to verify, I discovered that StrictKeyAccess doesn't work with Mash. See the following:

class StrictMash < Hashie::Mash
  include Hashie::Extensions::StrictKeyAccess
end

h = StrictMash.new('a' => {'b' => 3}) #=> Hashie::Extensions::StrictKeyAccess::DefaultError

The reason is because Mash implicitly checks whether #default_proc and #default exist. Those checks for existence raise a DefaultError in the current implementation.

I'm not a big fan of that, but I don't really see a clear way forward. We could make it so accessing #default_proc or #default doesn't raise an error, but I do feel that the current behavior is "correct" because have a default doesn't make sense in strict key access.

We could make a different extension that is only for Mash that is slightly less constraining, but I don't know if that's a good way forward either. What are your thoughts?

[dblock]

Maybe we should build a StringKeyAccess extension for Mash then that is based on Hashie::Extensions::StrictKeyAccess

[jbbarth]

Pretty old issue but in case somebody needs that too: I tried a few approaches and for now, I'm on a variation of @scottnicolson suggestion that override Mash#method_missing instead:

require "hashie/mash"

class StrictMash < Hashie::Mash
  # Extends Hashie::Mash but raises a KeyError when trying to access a property
  # that doens't exist yet. A naive version of this consists in aliasing `[]` to
  # `fetch` but it makes it impossible to use nice Mash aliases such as `<field>!`,
  # `<field>?`, etc.
  # So instead we override `method_missing` with just a tiny patch inside.
  def method_missing(method_name, *args, &blk)
    return self.[](method_name, &blk) if key?(method_name)
    name, suffix = method_name_and_suffix(method_name)
    # PATCH
    if !key?(name) and !suffix
      raise KeyError, %(key not found: "#{name}")
    end
    # EOF PATCH
    case suffix
    when '='.freeze
      assign_property(name, args.first)
    when '?'.freeze
      !!self[name]
    when '!'.freeze
      initializing_reader(name)
    when '_'.freeze
      underbang_reader(name)
    else
      self[method_name]
    end
  end
end

The nice thing is that it preserves all Mash behaviours, including sub-hashes being StrictMash instances (s.foo!.bar!.meh!.class # => StrictMash).

StrictKeyAccess is actually too strict and will prevent using Mash's "!", "?", etc suffixes from what I saw. I think StrictKeyAccess not working in Mash is a bug in either Mash or StrictKeyAccess though: Mash first argument is a hash to be converted, not a default value, so it shouldn't trigger the DefaultError it triggers right now if you don't pass a default value / block.

If somebody finds the issue interesting enough, I'm up for discussing it and work on a clean PR that could be merged at some point. Else I'll keep my dirty hack, "it works" ;-)

[dblock]

I find it interesting enough for a PR!

[michaelherold]

Instead of a module, what would we think of making the handler injectable? Basically, the else case of the case statement is the "default handler". If we make that something you can inject upon creation -- or via an accessor -- it gives an extension point to the Mash itself.

Of course, that increases the responsibilities of an already huge class ... 🤔

[betesh]

@jbbarth's patch, simplified by using Module.prepend:

Module.new do
  def method_missing(method_name, *args, &blk)
    unless key?(method_name)
      name, suffix = method_name_and_suffix(method_name)
      raise KeyError, %(key not found: "#{name}") unless key?(name) || suffix
    end

    super
  end

  Hashie::Mash.prepend self
end

[dblock]

This is the oldest issue in Hashie. Can someone PR the version above as an extension? @betesh

[betesh]

I'm not involved in any projects using hashie at the moment. If you just want someone to open a PR, feel free to use my code.