Class: Hash

### Home Classes Methods

### In Files

- lib/hashery/core_ext.rb
- lib/hashery/stash.rb

### Parent

Object

### Methods

- ::create
- #rekey
- #rekey!
- #retrieve
- #to_h
- #to_hash
- #to_stash

### Files

- LICENSE.txt
- NOTICE.txt

### Class/Module Index

Quicksearch

- Hashery
- Hashery::Association
- Hashery::Association::Kernel
- Hashery::CRUDHash
- Hashery::CastingHash
- Hashery::Dictionary
- Hashery::FuzzyHash
- Hashery::IniHash
- Hashery::KeyHash
- Hashery::LRUHash
- Hashery::LinkedList
- Hashery::LinkedList::Node
- Hashery::OpenCascade
- Hashery::OpenHash
- Hashery::OrderedHash
- Hashery::PathHash
- Hashery::PropertyHash
- Hashery::QueryHash
- Hashery::Stash
- Hashery::StaticHash
- Hash

No matching classes.

# Hash

### Public Class Methods

create(initial_hash={}, &block) click to toggle source

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`.

    # File lib/hashery/core_ext.rb, line 11
    def self.create(initial_hash={}, &block)
      o = new &block
      o.update(initial_hash)
      o
    end

### Public Instance Methods

rekey(key_map=nil, &block) click to toggle source

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`.

    # 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

rekey!(key_map=nil, &block) click to toggle source

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`.

    # File lib/hashery/core_ext.rb, line 114
    def rekey!(key_map=nil, &block)
      replace(rekey(key_map, &block))
    end

retrieve(key) click to toggle source

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`.

    # File lib/hashery/core_ext.rb, line 25
    def retrieve(key)
      fetch(key, default_proc ? default_proc[self, key] : default)
    end

to_h() click to toggle source

For a Hash, `to_h` is the same as `to_hash`.

Alias for: to_hash
to_hash() click to toggle source

Convert to Hash.

    # File lib/hashery/core_ext.rb, line 32
    def to_hash
      dup  # -or- `h = {}; each{ |k,v| h[k] = v }; h` ?
    end

Also aliased as: to_h
to_stash() click to toggle source

Convert Hash to Stash.

    # File lib/hashery/stash.rb, line 10
    def to_stash
      Hashery::Stash[self]
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.