Class: Hash

Inherits:
Object show all
Defined in:
lib/quickbooks/ruby_magic.rb

Instance Method Summary collapse

Instance Method Details

#-(v) ⇒ Object 



104
105
106
107
108
 
# File 'lib/quickbooks/ruby_magic.rb', line 104

def -(v)
  hsh = self.dup
  (v.is_a?(Array) ? v : [v]).each { |k| hsh.delete(k) }
  hsh
end

#camelize_keys(specials = {}) ⇒ Object

Transform all the keys in the hash to CamelCase format.



58
59
60
 
# File 'lib/quickbooks/ruby_magic.rb', line 58

def camelize_keys(specials={})
  self.dup.camelize_keys!(specials)
end

#camelize_keys!(specials = {}) ⇒ Object 



61
62
63
64
65
66
 
# File 'lib/quickbooks/ruby_magic.rb', line 61

def camelize_keys!(specials={})
  self.each_key do |k|
    self[specials.has_key?(k) ? specials[k] : k.camelize] = self.delete(k)
  end
  self
end

#diff(hsh) ⇒ Object

Returns values in this hash that are uniq or different than in the hash provided. Example:

{:a => :b, :f => :g, :z => :e}.diff(:a => :b, :f => :r, :u => :o) # => {:f => :g, :z => :e}



91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/quickbooks/ruby_magic.rb', line 91

def diff(hsh)
  dif = {}
  self.each do |k,v|
    dif[k] = v if !hsh.has_key?(k)
    if self[k].respond_to?(:===)
      dif[k] = v if !(self[k] === hsh[k])
    else
      dif[k] = v if !(self[k] == hsh[k])
    end
  end
  dif
end

#only(*keys) ⇒ Object 



110
111
112
 
# File 'lib/quickbooks/ruby_magic.rb', line 110

def only(*keys)
  self.dup.only!(*keys)
end

#only!(*keys) ⇒ Object 



113
114
115
116
117
 
# File 'lib/quickbooks/ruby_magic.rb', line 113

def only!(*keys)
  keys = keys.flatten
  self.keys.each { |k| self.delete(k) unless keys.include?(k) }
  self
end

#order!(*keys_in_order) ⇒ Object

Sets a static order for any group operations on the hash, specifically: keys, values, each, each_key, and each_value



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/quickbooks/ruby_magic.rb', line 120

def order!(*keys_in_order)
  self.instance_variable_set('@keys_in_order', keys_in_order.flatten & self.keys) # (only the keys_in_order that are currently existing keys)
  class << self
    def keys
      @keys_in_order
    end
    def values
      self.keys.collect {|k| self[k]}
    end
    def each(&block)
      self.keys.each do |k|
        block.call(k, self[k])
      end
    end
    def each_key(&block)
      self.keys.each &block
    end
    def each_value(&block)
      self.values.each &block
    end
  end
  self
end

#stringify_values ⇒ Object 



78
79
80
 
# File 'lib/quickbooks/ruby_magic.rb', line 78

def stringify_values
  self.dup.stringify_values!
end

#stringify_values! ⇒ Object 



81
82
83
84
85
86
 
# File 'lib/quickbooks/ruby_magic.rb', line 81

def stringify_values!
  self.each do |k,v|
    self[k] = v.to_s
  end
  self
end

#transform_keys(trans_hash) ⇒ Object 



144
145
146
 
# File 'lib/quickbooks/ruby_magic.rb', line 144

def transform_keys(trans_hash)
  self.dup.transform_keys!(trans_hash)
end

#transform_keys!(trans_hash) ⇒ Object

Raises:

  • (ArgumentError) 


147
148
149
150
151
152
153
 
# File 'lib/quickbooks/ruby_magic.rb', line 147

def transform_keys!(trans_hash)
  raise ArgumentError, "transform_keys takes a single hash argument" unless trans_hash.is_a?(Hash)
  self.each_key do |k|
    self[trans_hash.has_key?(k) ? trans_hash[k] : k] = self.delete(k)
  end
  self
end

#underscore_keys(specials = {}) ⇒ Object 



68
69
70
 
# File 'lib/quickbooks/ruby_magic.rb', line 68

def underscore_keys(specials={})
  self.dup.underscore_keys!(specials)
end

#underscore_keys!(specials = {}) ⇒ Object 



71
72
73
74
75
76
 
# File 'lib/quickbooks/ruby_magic.rb', line 71

def underscore_keys!(specials={})
  self.each_key do |k|
    self[specials.has_key?(k) ? specials[k] : k.underscore] = self.delete(k)
  end
  self
end