class Hash

Author: Stefano Harding <riddopic@gmail.com> License: Apache License, Version 2.0 Copyright: © 2014-2015 Stefano Harding

Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Public Instance Methods

argumentize(args_field = nil) click to toggle source

Turn a hash into a method arguments.

h = { :list => [1,2], :base => "HI" }

Without an argument field.

h.argumentize #=> [ { :list => [1,2], :base => "HI" } ]

With an argument field.

h.argumentize(:list)   #=> [ 1, 2, { :base => "HI" } ]
h.argumentize(:base)   #=> [ "HI", { :list => [1,2] } ]
# File lib/garcon/core_ext/hash.rb, line 34
def argumentize(args_field = nil)
  config = dup
  if args_field
    args = [config.delete(args_field)].flatten.compact
  else
    args = []
  end
  args << config
  return args
end
capitalize_keys() click to toggle source

Returns a new hash with all keys converted to strings and the first letter capitalized.

@return [Hash]

# File lib/garcon/core_ext/hash.rb, line 168
def capitalize_keys
  transform_keys { |key| key.to_s.capitalize rescue key }
end
compact() click to toggle source

Returns a compacted copy (contains no key/value pairs having nil? values)

@example

hash = { a: 100, b: nil, c: false, d: '' }
hash.compact   # => { a: 100, c: false, d: '' }
hash           # => { a: 100, b: nil, c: false, d: '' }

@return [Hash]

@api public

# File lib/garcon/core_ext/hash.rb, line 81
def compact
  select { |_, value| !value.nil? }
end
except(*rejected) click to toggle source

Create a hash with all key/value pairs in receiver except rejected

{ :one => 1, :two => 2, :three => 3 }.except(:one)
 # => { :two => 2, :three => 3 }

@param [Array[String, Symbol]] *rejected The hash keys to exclude.

@return [Hash] A new hash without the selected keys.

@api public

# File lib/garcon/core_ext/hash.rb, line 217
def except(*rejected)
  hash = self.dup
  rejected.each {|k| hash.delete(k) }
  hash
end
normalize_keys() click to toggle source

Returns a new hash with all keys downcased and converted to symbols.

@return [Hash]

# File lib/garcon/core_ext/hash.rb, line 118
def normalize_keys
  transform_keys { |key| key.downcase.to_sym rescue key }
end
object_state(data = nil) click to toggle source

Get or set state of object. You can think of object_state as an in-code form of marshalling.

# File lib/garcon/core_ext/hash.rb, line 57
def object_state(data = nil)
  data ? replace(data) : dup
end
only(*allowed) click to toggle source

Create a hash with only key/value pairs in receiver and allowed

{ :one => 1, :two => 2, :three => 3 }.only(:one)    # => { :one => 1 }

@param [Array[String, Symbol]] *allowed The hash keys to include.

@return [Hash] A new hash with only the selected keys.

@api public

# File lib/garcon/core_ext/hash.rb, line 201
def only(*allowed)
  hash = {}
  allowed.each {|k| hash[k] = self[k] if self.has_key?(k) }
  hash
end
recursive_fetch(*args, &block) click to toggle source

Recursively searchs a nested datastructure for a key and returns the value. If a block is provided its value will be returned if the key does not exist

@example

options = { server: { location: { row: { rack: 34 } } } }
options.recursive_fetch :server, :location, :row, :rack
            # => 34
options.recursive_fetch(:non_existent_key) { 'default' }
            # => "default"

@return [Hash, Array, String] value for key

# File lib/garcon/core_ext/hash.rb, line 237
def recursive_fetch(*args, &block)
  args.reduce(self) do |obj, arg|
    begin
      arg = Integer(arg) if obj.is_a? Array
      obj.fetch(arg)
    rescue ArgumentError, IndexError, NoMethodError => e
      break block.call(arg) if block
      raise UndefinedPathError,
        "Could not fetch path (#{args.join(' > ')}) at #{arg}", e.backtrace
    end
  end
end
recursive_merge(other) click to toggle source
# File lib/garcon/core_ext/hash.rb, line 250
def recursive_merge(other)
  hash = self.dup
  other.each do |key, value|
    myval = self[key]
    if value.is_a?(Hash) && myval.is_a?(Hash)
      hash[key] = myval.recursive_merge(value)
    else
      hash[key] = value
    end
  end
  hash
end
recursively_capitalize_key() click to toggle source

Returns a new Hash, recursively converting all keys to strings and the first letter capitalized.

@return [Hash]

# File lib/garcon/core_ext/hash.rb, line 177
def recursively_capitalize_key
  recursively_transform_keys { |key| key.to_s.capitalize rescue key }
end
recursively_normalize_keys() click to toggle source

Returns a new Hash, recursively downcasing and converting all keys to symbols.

@return [Hash]

# File lib/garcon/core_ext/hash.rb, line 127
def recursively_normalize_keys
  recursively_transform_keys { |key| key.downcase.to_sym rescue key }
end
recursively_stringify_key() click to toggle source

Returns a new Hash, recursively converting all keys to strings.

@return [Hash]

# File lib/garcon/core_ext/hash.rb, line 159
def recursively_stringify_key
  recursively_transform_keys { |key| key.to_s rescue key }
end
recursively_symbolize_keys() click to toggle source

Returns a new Hash, recursively converting all keys to symbols.

@return [Hash]

# File lib/garcon/core_ext/hash.rb, line 143
def recursively_symbolize_keys
  recursively_transform_keys { |key| key.to_sym rescue key }
end
recursively_transform_keys(&block) click to toggle source

Returns a new hash, recursively converting all keys by the block operation.

@return [Hash]

# File lib/garcon/core_ext/hash.rb, line 109
def recursively_transform_keys(&block)
  _recursively_transform_keys_in_object(self, &block)
end
stringify_keys() click to toggle source

Returns a new hash with all keys converted to strings.

@return [Hash]

# File lib/garcon/core_ext/hash.rb, line 151
def stringify_keys
  transform_keys { |key| key.to_s rescue key }
end
symbolize_keys() click to toggle source

Returns a new hash with all keys converted to symbols.

@return [Hash]

# File lib/garcon/core_ext/hash.rb, line 135
def symbolize_keys
  transform_keys { |key| key.to_sym rescue key }
end
to_struct(struct_name) click to toggle source

A method to convert a Hash into a Struct.

h = { :name => "Earl", "age" => 20, "sex" => "lots", "worries" => "none" }
s = h.to_struct("Foo")
# File lib/garcon/core_ext/hash.rb, line 50
def to_struct(struct_name)
  Struct.new(struct_name,*keys).new(*values)
end
transform_keys() { |key| ... } click to toggle source

Returns a new hash with all keys converted using the block operation.

@example

hash = { name: 'Tiggy', age: '15' }
hash.transform_keys{ |key| key.to_s.upcase }
  # => { "AGE" => "15", "NAME" => "Tiggy" }

@return [Hash]

@api public

# File lib/garcon/core_ext/hash.rb, line 95
def transform_keys
  enum_for(:transform_keys) unless block_given?
  result = self.class.new
  each_key do |key|
    result[yield(key)] = self[key]
  end
  result
end
zip(col1, col2) click to toggle source

Creates a new hash from two separate arrays, a keys array and a values array.

@example

Hash.zip(['a','b','c'], [1,2,3])
# => { "a"=>1, "b"=>2, "c"=>3 }
# File lib/garcon/core_ext/hash.rb, line 188
def zip(col1, col2)
  col1.zip(col2).inject({}) { |r, i| r[i[0]] = i[1]; r }
end