Class: Hashie::Mash

Inherits:
Hash
  • Object
show all
Includes:
PrettyInspect
Defined in:
lib/hashie/mash.rb

Overview

Mash allows you to create pseudo-objects that have method-like accessors for hash keys. This is useful for such implementations as an API-accessing library that wants to fake robust objects without the overhead of actually doing so. Think of it as OpenStruct with some additional goodies.

A Mash will look at the methods you pass it and perform operations based on the following rules:

  • No punctuation: Returns the value of the hash for that key, or nil if none exists.

  • Assignment (=): Sets the attribute of the given method name.

  • Existence (?): Returns true or false depending on whether that key has been set.

  • Bang (!): Forces the existence of this key, used for deep Mashes. Think of it as “touch” for mashes.

Basic Example

mash = Mash.new
mash.name? # => false
mash.name = "Bob"
mash.name # => "Bob"
mash.name? # => true

Hash Conversion Example

hash = {:a => {:b => 23, :d => {:e => "abc"}}, :f => [{:g => 44, :h => 29}, 12]}
mash = Mash.new(hash)
mash.a.b # => 23
mash.a.d.e # => "abc"
mash.f.first.g # => 44
mash.f.last # => 12

Bang Example

mash = Mash.new
mash.author # => nil
mash.author! # => <Mash>

mash = Mash.new
mash.author!.name = "Michael Bleigh"
mash.author # => <Mash name="Michael Bleigh">

Instance Method Summary collapse

Methods included from PrettyInspect

#hashie_inspect, included

Methods included from HashExtensions

#hashie_stringify_keys, #hashie_stringify_keys!, included, #to_mash

Constructor Details

#initialize(source_hash = nil, default = nil, &blk) ⇒ Mash

If you pass in an existing hash, it will convert it to a Mash including recursively descending into arrays and hashes, converting them as well.



51
52
53
54
55
 
# File 'lib/hashie/mash.rb', line 51

def initialize(source_hash = nil, default = nil, &blk)
  deep_update(source_hash) if source_hash
  super default if default
  super &blk if blk
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args) ⇒ Object

:nodoc:



164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/hashie/mash.rb', line 164

def method_missing(method_name, *args) #:nodoc:
  if (match = method_name.to_s.match(/(.*)=$/)) && args.size == 1
    self[match[1]] = args.first
  elsif (match = method_name.to_s.match(/(.*)\?$/)) && args.size == 0
    key?(match[1])
  elsif (match = method_name.to_s.match(/(.*)!$/)) && args.size == 0
    initializing_reader(match[1])
  elsif key?(method_name)
    self[method_name]
  elsif match = method_name.to_s.match(/^([a-z][a-z0-9A-Z_]+)$/)
    default(method_name)
  else
    super
  end
end

Instance Method Details

#[](key) ⇒ Object

Retrieves an attribute set in the Mash. Will convert any key passed in to a string before retrieving.



84
85
86
87
 
# File 'lib/hashie/mash.rb', line 84

def [](key)
  key = convert_key(key)
  regular_reader(key)
end

#[]=(key, value) ⇒ Object

Sets an attribute in the Mash. Key will be converted to a string before it is set, and Hashes will be converted into Mashes for nesting purposes.



92
93
94
95
 
# File 'lib/hashie/mash.rb', line 92

def []=(key,value) #:nodoc:
  key = convert_key(key)
  regular_writer(key, convert_value(value))
end

#deep_merge(other_hash) ⇒ Object

Performs a deep_update on a duplicate of the current mash.



117
118
119
 
# File 'lib/hashie/mash.rb', line 117

def deep_merge(other_hash)
  dup.deep_merge!(other_hash)
end

#deep_update(other_hash) ⇒ Object Also known as: deep_merge!

Recursively merges this mash with the passed in hash, merging each hash in the hierarchy.



123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/hashie/mash.rb', line 123

def deep_update(other_hash)
  other_hash = Hashie::Hash[other_hash].stringify_keys!
  
  other_hash.each_pair do |k,v|
    k = convert_key(k)
    self[k] = Hashie::Mash.new(self[k]).to_mash if self[k].is_a?(Hash) unless self[k].is_a?(Hashie::Mash)
    if self[k].is_a?(Hashie::Mash) && other_hash[k].is_a?(Hash)
      self[k] = self[k].deep_merge(other_hash[k])
    else
      self[k] = convert_value(other_hash[k],true)
    end
  end
  
  self
end

#default(key = nil) ⇒ Object

Borrowed from Merb’s Mash object.

Parameters

key<Object>

The default value for the mash. Defaults to nil.

Alternatives

If key is a Symbol and it is a key in the mash, then the default value will be set to the value matching the key.



71
72
73
74
75
76
77
 
# File 'lib/hashie/mash.rb', line 71

def default(key = nil) 
  if key.is_a?(Symbol) && key?(key.to_s) 
    self[key] 
  else 
    key ? super : super()
  end 
end

#dup ⇒ Object

Duplicates the current mash as a new mash.



106
107
108
 
# File 'lib/hashie/mash.rb', line 106

def dup
  Mash.new(self, self.default)
end

#id ⇒ Object

:nodoc:



59
60
61
 
# File 'lib/hashie/mash.rb', line 59

def id #:nodoc:
  self["id"] ? self["id"] : super
end

#initializing_reader(key) ⇒ Object

This is the bang method reader, it will return a new Mash if there isn’t a value already assigned to the key requested.



99
100
101
102
 
# File 'lib/hashie/mash.rb', line 99

def initializing_reader(key)
  self[key] = Hashie::Mash.new unless key?(key)
  self[key]
end

#key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


111
112
113
 
# File 'lib/hashie/mash.rb', line 111

def key?(key)
  picky_key?(convert_key(key))
end

#picky_key? ⇒ Object 



110
 
# File 'lib/hashie/mash.rb', line 110

alias_method :picky_key?, :key?

#regular_dup ⇒ Object 



104
 
# File 'lib/hashie/mash.rb', line 104

alias_method :regular_dup, :dup

#regular_reader ⇒ Object 



79
 
# File 'lib/hashie/mash.rb', line 79

alias_method :regular_reader, :[]

#regular_writer ⇒ Object 



80
 
# File 'lib/hashie/mash.rb', line 80

alias_method :regular_writer, :[]=

#to_hash ⇒ Object

Converts a mash back to a hash (with stringified keys)



160
161
162
 
# File 'lib/hashie/mash.rb', line 160

def to_hash
  Hash.new(default).merge(self)
end

#update(other_hash) ⇒ Object Also known as: merge!

Parameters

other_hash<Hash>

A hash to update values in the mash with. Keys will be stringified and Hashes will be converted to Mashes.

Returns

Mash

The updated mash.



147
148
149
150
151
152
153
154
155
156
 
# File 'lib/hashie/mash.rb', line 147

def update(other_hash)
  other_hash.each_pair do |key, value|
    if respond_to?(convert_key(key) + "=")
      self.send(convert_key(key) + "=", convert_value(value))
    else
      regular_writer(convert_key(key), convert_value(value))
    end
  end
  self
end