Class: Mash

Inherits:
Hash show all
Defined in:
lib/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 inherited from Hash

#stringify_keys, #stringify_keys!, #to_mash

Constructor Details

#initialize(source_hash = 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.



47
48
49
50
 
# File 'lib/mash.rb', line 47

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

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args) ⇒ Object

:nodoc:



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/mash.rb', line 169

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.



79
80
81
82
 
# File 'lib/mash.rb', line 79

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.



86
87
88
89
 
# File 'lib/mash.rb', line 86

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.



124
125
126
 
# File 'lib/mash.rb', line 124

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.



130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/mash.rb', line 130

def deep_update(other_hash)
  other_hash = other_hash.to_hash if other_hash.is_a?(Mash)
  other_hash = other_hash.stringify_keys
  other_hash.each_pair do |k,v|
    k = convert_key(k)
    self[k] = self[k].to_mash if self[k].is_a?(Hash) unless self[k].is_a?(Mash)
    if self[k].is_a?(Hash) && other_hash[k].is_a?(Hash)
      self[k] = self[k].deep_merge(other_hash[k]).dup
    else
      self.send(k + "=", convert_value(other_hash[k],true))
    end
  end
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.



66
67
68
69
70
71
72
 
# File 'lib/mash.rb', line 66

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

#dup ⇒ Object

Duplicates the current mash as a new mash.



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

def dup
  Mash.new(self)
end

#id ⇒ Object

:nodoc:



54
55
56
 
# File 'lib/mash.rb', line 54

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.



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

def initializing_reader(key)
  return self[key] if key?(key)
  self[key] = Mash.new
end

#inspect ⇒ Object Also known as: to_s

Prints out a pretty object-like string of the defined attributes.



112
113
114
115
116
117
118
119
 
# File 'lib/mash.rb', line 112

def inspect
  ret = "<#{self.class.to_s}"
  keys.sort.each do |key|
    ret << " #{key}=#{self[key].inspect}"
  end
  ret << ">"
  ret
end

#key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#picky_key? ⇒ Object 



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

alias_method :picky_key?, :key?

#regular_dup ⇒ Object 



98
 
# File 'lib/mash.rb', line 98

alias_method :regular_dup, :dup

#regular_inspect ⇒ Object 



109
 
# File 'lib/mash.rb', line 109

alias_method :regular_inspect, :inspect

#regular_reader ⇒ Object 



74
 
# File 'lib/mash.rb', line 74

alias_method :regular_reader, :[]

#regular_writer ⇒ Object 



75
 
# File 'lib/mash.rb', line 75

alias_method :regular_writer, :[]=

#to_hash ⇒ Object

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



165
166
167
 
# File 'lib/mash.rb', line 165

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.



152
153
154
155
156
157
158
159
160
161
 
# File 'lib/mash.rb', line 152

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