Class: Hash

Inherits:
Object show all
Defined in:
lib/hashery/stash.rb,
lib/hashery/core_ext.rb

Direct Known Subclasses

Hashery::CRUDHash, Hashery::OrderedHash, Hashery::PathHash

Class Method Summary (collapse)

Instance Method Summary (collapse)

Class Method Details

+ (Object) create(initial_hash = {}, &block)

Create a hash given an `initial_hash`.

initial_hash - Hash or hash-like object to use as priming data. block - Procedure used by initialize (e.g. default_proc).

Returns a `Hash`.



11
12
13
14
15
# File 'lib/hashery/core_ext.rb', line 11

def self.create(initial_hash={}, &block)
  o = new &block
  o.update(initial_hash)
  o
end

Instance Method Details

- (Object) rekey(key_map = nil, &block)

Synonym for Hash#rekey, but modifies the receiver in place (and returns it).

key_map - Hash of old key to new key. block - Procedure to convert keys, which can take just the key

or both key and value as arguments.

Examples

foo = { :name=>'Gavin', :wife=>:Lisa }
foo.rekey!{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
foo.inspect               #=>  { "name"=>"Gavin", "wife"=>:Lisa }

Returns `Hash`.



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
# File 'lib/hashery/core_ext.rb', line 58

def rekey(key_map=nil, &block)
  if !(key_map or block)
    block = lambda{|k| k.to_sym}
  end

  key_map ||= {} 

  hash = {}

  (keys - key_map.keys).each do |key|
    hash[key] = self[key]
  end

  key_map.each do |from, to|
    hash[to] = self[from] if key?(from)
  end

  hash2 = {}

  if block
    case block.arity
    when 0
      raise ArgumentError, "arity of 0 for #{block.inspect}"
    when 2
      hash.each do |k,v|
        nk = block.call(k,v)
        hash2[nk] = v
      end
    else
      hash.each do |k,v|
        nk = block[k]
        hash2[nk] = v
      end
    end
  else
    hash2 = hash
  end

  hash2
end

- (Object) rekey!(key_map = nil, &block)

Synonym for Hash#rekey, but modifies the receiver in place (and returns it).

key_map - Hash of old key to new key. block - Procedure to convert keys, which can take just the key

or both key and value as arguments.

Examples

foo = { :name=>'Gavin', :wife=>:Lisa }
foo.rekey!{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
foo                       #=>  { "name"=>"Gavin", "wife"=>:Lisa }

Returns `Hash`.



114
115
116
# File 'lib/hashery/core_ext.rb', line 114

def rekey!(key_map=nil, &block)
  replace(rekey(key_map, &block))
end

- (Object) retrieve(key)

Like #fetch but returns the results of calling `default_proc`, if defined, otherwise `default`.

key - Hash key to lookup.

Returns value of Hash entry or `nil`.



25
26
27
# File 'lib/hashery/core_ext.rb', line 25

def retrieve(key)
  fetch(key, default_proc ? default_proc[self, key] : default)
end

- (Object) to_hash Also known as: to_h



32
33
34
# File 'lib/hashery/core_ext.rb', line 32

def to_hash
  dup  # -or- `h = {}; each{ |k,v| h[k] = v }; h` ?
end

- (Object) to_stash

Convert Hash to Stash.



10
11
12
# File 'lib/hashery/stash.rb', line 10

def to_stash
  Hashery::Stash[self]
end