Class: Hash

Inherits:
Object show all
Includes:
LuxJson
Defined in:
lib/overload/hash.rb,
lib/overload/json.rb,
lib/overload/blank.rb

Class Method Summary collapse

Instance Method Summary collapse

Methods included from LuxJson

#to_jsonc, #to_jsonp, #to_jsons

Class Method Details

.deep_compact(value) ⇒ Object 



111
112
113
 
# File 'lib/overload/hash.rb', line 111

def self.deep_compact value
  (value || {}).deep_compact
end

Instance Method Details

#blank? ⇒ Boolean

Returns:



2
3
4
 
# File 'lib/overload/hash.rb', line 2

def blank?
  self.keys.count == 0
end

#deep_compact(value = nil) ⇒ Object

clean empty values from hash, deep



96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/overload/hash.rb', line 96

def deep_compact value = nil
  value ||= self

  res_hash = value.map do |key, value|
    value = deep_compact(value) if value.is_a?(Hash)

    # we need to remove '0' because that is what empty checkbox inserts, but it is nil
    value = nil if [{}, [], '0'].include?(value)
    value = nil if value.blank?
    [key, value]
  end

  res_hash.to_h.compact
end

#except(*keys) ⇒ Object

Returns a hash that includes everything but the given keys.

hash = { a: true, b: false, c: nil}
hash.except(:c) # => { a: true, b: false}
hash # => { a: true, b: false, c: nil}

This is useful for limiting a set of parameters to everything but a few known toggles:

@person.update(params[:person].except(:admin))



57
58
59
 
# File 'lib/overload/hash.rb', line 57

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

#except!(*keys) ⇒ Object

Hash#except in place, modifying current hash



62
63
64
65
 
# File 'lib/overload/hash.rb', line 62

def except!(*keys)
  keys.each { |key| delete(key.to_s); delete(key.to_sym)  }
  self
end

#html_safe(key) ⇒ Object 



115
116
117
118
119
 
# File 'lib/overload/hash.rb', line 115

def html_safe key
  if data = self[key]
    self[key] = data.html_safe
  end
end

#pluck(*args) ⇒ Object 



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

def pluck *args
  string_args = args.map(&:to_s)
  self.select{ |k,v| string_args.index(k.to_s) }
end

#remove_empty(covert_to_s = false) ⇒ Object 



67
68
69
70
71
72
73
 
# File 'lib/overload/hash.rb', line 67

def remove_empty covert_to_s = false
  self.keys.inject({}) do |t, el|
    v = self[el]
    t[covert_to_s ? el.to_s : el] = v if el.present? && v.present?
    t
  end
end

#slice(*keys) ⇒ Object

Returns hash with only selected keys



35
36
37
38
 
# File 'lib/overload/hash.rb', line 35

def slice *keys
  keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
  keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
end

#slice!(*keys) ⇒ Object 



40
41
42
43
44
45
46
47
48
 
# File 'lib/overload/hash.rb', line 40

def slice! *keys
  keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
  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 



26
27
28
 
# File 'lib/overload/hash.rb', line 26

def stringify_keys
  transform_keys { |key| key.to_s }
end

#symbolize_keys ⇒ Object 



30
31
32
 
# File 'lib/overload/hash.rb', line 30

def symbolize_keys
  transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
end

#to_attributes ⇒ Object 



17
18
19
 
# File 'lib/overload/hash.rb', line 17

def to_attributes
  self.keys.sort.map{ |k| '%s="%s"' % [k, self[k].to_s.gsub('"', '"')]}.join(' ')
end

#to_js(opts = {}) ⇒ Object 



75
76
77
78
79
80
 
# File 'lib/overload/hash.rb', line 75

def to_js opts = {}
  data = opts[:empty] ? self : remove_empty
  data = data.to_json.gsub(/"(\w+)":/, "\\1:")
  data = data.gsub(/",(\w)/, '", \1') unless opts[:narrow]
  data
end

#to_query(namespace = nil) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/overload/hash.rb', line 6

def to_query namespace=nil
  keys = self.keys.sort

  return unless keys.first

  '?' + keys.map do |k|
    name = namespace ? "#{namespace}[#{k}]" : k
    "#{name}=#{CGI::escape(self[k].to_s)}"
  end.join('&')
end

#transform_keys(&block) ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/overload/hash.rb', line 82

def transform_keys &block
  if block
    Hash.new.tap do |result|
      for key, value in self
        value = value.transform_keys(&block) if value.is_a?(Hash)
        result[block.call(key)] = value
      end
    end
  else
    enum_for(:transform_keys)
  end
end