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:



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

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.



77
78
79
80
 
# File 'lib/mash.rb', line 77

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.



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

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.



122
123
124
 
# File 'lib/mash.rb', line 122

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.



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

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

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.



64
65
66
67
68
69
70
 
# File 'lib/mash.rb', line 64

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.



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

def dup
  Mash.new(self)
end

#id ⇒ Object

:nodoc:



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

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.



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

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.



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

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) 


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

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

#picky_key? ⇒ Object 



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

alias_method :picky_key?, :key?

#regular_dup ⇒ Object 



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

alias_method :regular_dup, :dup

#regular_inspect ⇒ Object 



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

alias_method :regular_inspect, :inspect

#regular_reader ⇒ Object 



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

alias_method :regular_reader, :[]

#regular_writer ⇒ Object 



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

alias_method :regular_writer, :[]=

#to_hash ⇒ Object

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



163
164
165
 
# File 'lib/mash.rb', line 163

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

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

Parameters

other_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.



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

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