Class: Hash

Inherits:
Object show all
Defined in:
lib/qbxml/support.rb,
lib/quickbooks/structure.rb,
lib/quickbooks/ruby_magic.rb

Direct Known Subclasses

OrderedHash

Instance Method Summary collapse

Instance Method Details

#-(v) ⇒ Object 



116
117
118
119
120
 
# File 'lib/quickbooks/ruby_magic.rb', line 116

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.



91
92
93
 
# File 'lib/qbxml/support.rb', line 91

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

#camelize_keys!(specials = {}) ⇒ Object 



94
95
96
97
98
99
 
# File 'lib/qbxml/support.rb', line 94

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}



103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/quickbooks/ruby_magic.rb', line 103

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

#expand_slashes(seed = nil) ⇒ Object 



282
283
284
285
 
# File 'lib/quickbooks/structure.rb', line 282

def expand_slashes(seed=nil)
  return self.dup if empty?
  [self.dup].flatten_slashes.expand_slashes(seed)
end

#expand_slashes!(seed = nil) ⇒ Object 



286
287
288
289
 
# File 'lib/quickbooks/structure.rb', line 286

def expand_slashes!(seed=nil)
  return self if empty?
  replace(expand_slashes(seed))
end

#flatten_slashes ⇒ Object 



264
265
266
 
# File 'lib/quickbooks/structure.rb', line 264

def flatten_slashes
  self.dup.flatten_slashes!
end

#flatten_slashes! ⇒ Object 



267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
 
# File 'lib/quickbooks/structure.rb', line 267

def flatten_slashes!
  hsh = {} #.ordered!
  self.each do |k,v|
    if v.is_a?(Hash)
      v.flatten_slashes.each do |vk,vv|
        hsh[k.to_s+'/'+vk.to_s] = vv
      end
    elsif v.is_a?(Array)
      hsh[k] = v.flatten_slashes
    else
      hsh[k] = v
    end
  end
  hsh
end

#only(*keys) ⇒ Object 



111
112
113
 
# File 'lib/qbxml/support.rb', line 111

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

#only!(*keys) ⇒ Object 



114
115
116
117
118
 
# File 'lib/qbxml/support.rb', line 114

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

#ordered!(*keys_in_order) ⇒ Object 



291
292
293
 
# File 'lib/quickbooks/structure.rb', line 291

def ordered!(*keys_in_order)
  OrderedHash.new(*keys_in_order).replace(self)
end

#ordered? ⇒ Boolean

Returns:

  • (Boolean) 


294
295
296
 
# File 'lib/quickbooks/structure.rb', line 294

def ordered?
  false
end

#reverse_merge(hsh) ⇒ Object 



131
132
133
 
# File 'lib/quickbooks/ruby_magic.rb', line 131

def reverse_merge(hsh)
  hsh.dup.merge(self)
end

#reverse_merge!(hsh) ⇒ Object 



134
135
136
 
# File 'lib/quickbooks/ruby_magic.rb', line 134

def reverse_merge!(hsh)
  self.replace(hsh.merge(self))
end

#slash_camelize_keys!(specials = {}) ⇒ Object 



297
298
299
300
301
302
 
# File 'lib/quickbooks/structure.rb', line 297

def slash_camelize_keys!(specials={})
  self.each_key do |k|
    self[specials.has_key?(k) ? specials[k] : (k.is_a?(Symbol) ? k.to_s.camelize.to_sym : k.split('/').map {|e| e.camelize}.join('/'))] = self.delete(k)
  end
  self
end

#slashed! ⇒ Object 



259
260
261
262
263
 
# File 'lib/quickbooks/structure.rb', line 259

def slashed!
  expand_slashes!
  SlashedHash.prepare_for_overwrites!(self) unless self.respond_to?(:set_value_unslashed)
  extend SlashedHash
end

#slashed? ⇒ Boolean

Returns:

  • (Boolean) 


256
257
258
 
# File 'lib/quickbooks/structure.rb', line 256

def slashed?
  keys.any? {|k| k.to_s =~ /\//}
end

#stringify_keys(specials = {}) ⇒ Object 



101
102
103
 
# File 'lib/qbxml/support.rb', line 101

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

#stringify_keys!(specials = {}) ⇒ Object 



104
105
106
107
108
109
 
# File 'lib/qbxml/support.rb', line 104

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

#stringify_values ⇒ Object 



90
91
92
 
# File 'lib/quickbooks/ruby_magic.rb', line 90

def stringify_values
  self.dup.stringify_values!
end

#stringify_values! ⇒ Object 



93
94
95
96
97
98
 
# File 'lib/quickbooks/ruby_magic.rb', line 93

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

#transform_keys(trans_hash) ⇒ Object 



120
121
122
 
# File 'lib/qbxml/support.rb', line 120

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

#transform_keys!(trans_hash) ⇒ Object

Raises:

  • (ArgumentError) 


123
124
125
126
127
128
129
 
# File 'lib/qbxml/support.rb', line 123

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 



80
81
82
 
# File 'lib/quickbooks/ruby_magic.rb', line 80

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

#underscore_keys!(specials = {}) ⇒ Object 



83
84
85
86
87
88
 
# File 'lib/quickbooks/ruby_magic.rb', line 83

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