Class: Hash

Inherits:
Object show all
Defined in:
lib/active_object/hash.rb

Instance Method Summary collapse

Instance Method Details

#assert_valid_keys(*valid_keys) ⇒ Object 



4
5
6
7
8
9
10
11
12
 
# File 'lib/active_object/hash.rb', line 4

def assert_valid_keys(*valid_keys)
  valid_keys.flatten!
  each_key do |k|
    unless valid_keys.include?(k)
      raise ArgumentError,
        "Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
    end
  end
end

#compact ⇒ Object 



16
17
18
 
# File 'lib/active_object/hash.rb', line 16

def compact
  select { |k,v| !v.nil? }
end

#compact! ⇒ Object 



22
23
24
 
# File 'lib/active_object/hash.rb', line 22

def compact!
  reject! { |k,v| v.nil? }
end

#deep_merge(other_hash, &block) ⇒ Object 



28
29
30
 
# File 'lib/active_object/hash.rb', line 28

def deep_merge(other_hash, &block)
  dup.deep_merge!(other_hash, &block)
end

#deep_merge!(other_hash, &block) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/active_object/hash.rb', line 34

def deep_merge!(other_hash, &block)
  other_hash.each_pair do |current_key, other_value|
    this_value = self[current_key]

    self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
      this_value.deep_merge(other_value, &block)
    else
      block_given? && key?(current_key) ? block.call(current_key, this_value, other_value) : other_value
    end
  end
  self
end

#except(*keys) ⇒ Object 



49
50
51
 
# File 'lib/active_object/hash.rb', line 49

def except(*keys)
  dup.except!(*keys)
end

#except!(*keys) ⇒ Object 



55
56
57
58
 
# File 'lib/active_object/hash.rb', line 55

def except!(*keys)
  keys.each { |k| delete(k) }
  self
end

#nillify ⇒ Object 



61
62
63
 
# File 'lib/active_object/hash.rb', line 61

def nillify
  dup.nillify!
end

#nillify! ⇒ Object 



65
66
67
68
69
70
71
 
# File 'lib/active_object/hash.rb', line 65

def nillify!
  each do |k, v|
    if !v.nil? && ((v.respond_to?(:blank?) && v.blank?) || (v.respond_to?(:to_s) && v.to_s.blank?))
      self[k] = nil
    end
  end
end

#only(*keys) ⇒ Object 



74
75
76
 
# File 'lib/active_object/hash.rb', line 74

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

#only!(*args) ⇒ Object 



80
81
82
83
84
 
# File 'lib/active_object/hash.rb', line 80

def only!(*args)
  hash = {}
  args.each {|k| hash[k] = self[k] if self.has_key?(k) }
  hash
end

#rename_keys(*args) ⇒ Object 



87
88
89
 
# File 'lib/active_object/hash.rb', line 87

def rename_keys(*args)
  dup.rename_keys!(*args)
end

#rename_keys!(*args) ⇒ Object 



91
92
93
94
95
 
# File 'lib/active_object/hash.rb', line 91

def rename_keys!(*args)
  keys = Hash[*args.flatten]
  keys.each { |k, v| self[v] = delete(k) if self[k] }
  self
end

#reverse_merge(other_hash) ⇒ Object 



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

def reverse_merge(other_hash)
  other_hash.merge(self)
end

#reverse_merge!(other_hash) ⇒ Object 



104
105
106
 
# File 'lib/active_object/hash.rb', line 104

def reverse_merge!(other_hash)
  other_hash.merge!(self)
end

#slice(*keys) ⇒ Object 



110
111
112
 
# File 'lib/active_object/hash.rb', line 110

def slice(*keys)
  keys.each_with_object(self.class.new) { |k, h| h[k] = self[k] if has_key?(k) }
end

#slice!(*keys) ⇒ Object 



116
117
118
119
120
121
122
123
124
125
 
# File 'lib/active_object/hash.rb', line 116

def slice!(*keys)
  omit = slice(*self.keys - keys)
  hash = slice(*keys)

  hash.default      = default
  hash.default_proc = default_proc if default_proc

  replace(hash)
  omit
end

#stringify_keys ⇒ Object 



129
130
131
 
# File 'lib/active_object/hash.rb', line 129

def stringify_keys
  dup.stringify_keys!
end

#stringify_keys! ⇒ Object 



135
136
137
138
139
140
 
# File 'lib/active_object/hash.rb', line 135

def stringify_keys!
  inject({}) do |options,(k,v)|
    options[k.to_s] = v
    options
  end
end

#strip ⇒ Object 



143
144
145
 
# File 'lib/active_object/hash.rb', line 143

def strip
  select { |k,v| !v.blank? }
end

#strip! ⇒ Object 



147
148
149
 
# File 'lib/active_object/hash.rb', line 147

def strip!
  reject! { |k,v| v.blank? }
end

#symbolize_and_underscore_keys ⇒ Object 



166
167
168
 
# File 'lib/active_object/hash.rb', line 166

def symbolize_and_underscore_keys
  dup.symbolize_and_underscore_keys!
end

#symbolize_and_underscore_keys! ⇒ Object 



170
171
172
173
174
175
 
# File 'lib/active_object/hash.rb', line 170

def symbolize_and_underscore_keys!
  inject({}) do |options, (k,v)|
    options[(k.to_s.gsub(" ", "_").underscore.to_sym rescue k) || k] = v
    options
  end
end

#symbolize_keys ⇒ Object 



152
153
154
 
# File 'lib/active_object/hash.rb', line 152

def symbolize_keys
  dup.symbolize_keys!
end

#symbolize_keys! ⇒ Object 



158
159
160
161
162
163
 
# File 'lib/active_object/hash.rb', line 158

def symbolize_keys!
  inject({}) do |options, (k,v)|
    options[(k.to_sym rescue k) || k] = v
    options
  end
end

#transform_keys(&block) ⇒ Object 



178
179
180
 
# File 'lib/active_object/hash.rb', line 178

def transform_keys(&block)
  dup.transform_keys!(&block)
end

#transform_keys!(&block) ⇒ Object 



184
185
186
187
188
 
# File 'lib/active_object/hash.rb', line 184

def transform_keys!(&block)
  return(enum_for(:transform_keys!)) unless block_given?
  keys.each { |k| self[yield(k)] = delete(k) }
  self
end

#transform_values(&block) ⇒ Object 



192
193
194
 
# File 'lib/active_object/hash.rb', line 192

def transform_values(&block)
  dup.transform_values!(&block)
end

#transform_values!(&block) ⇒ Object 



198
199
200
201
 
# File 'lib/active_object/hash.rb', line 198

def transform_values!(&block)
  return(enum_for(:transform_values!)) unless block_given?
  each { |k,v| self[k] = yield(v) }
end