Class: Kitchen::LazyHash

Inherits:
SimpleDelegator
  • Object
show all
Includes:
Enumerable
Defined in:
lib/kitchen/lazy_hash.rb

Overview

A modified Hash object that may contain callables as a value which must be executed in the context of another object. This allows for delayed evaluation of a hash value while still looking and largely feeling like a normal Ruby Hash.

Examples:

normal hash accessing with regular values


data = {
  :symbol => true,
  "string" => "stuff"
}
context = "any object"
lazy = Kitchen::Hash.new(data, context)

lazy[:symbol] # => true
lazy.fetch("string") # => "stuff"

hash with callable blocks as values


data = {
  :lambda => ->(c) { c.length },
  :proc => Proc.new { |c| c.reverse },
  :simple => "value"
}
context = "any object"
lazy = Kitchen::Hash.new(data, context)

lazy[:lambda] # => 10
lazy.fetch(:proc) # => "tcejbo yna"
lazy[:simple] # => "value"

Author:

Instance Method Summary collapse

Constructor Details

#initialize(obj, context) ⇒ LazyHash

Creates a new LazyHash using a Hash-like object to populate itself and an object that can be used as context in value-callable blocks. The context object can be used to compute values for keys at the time of fetching the value.

Parameters:

  • obj (Hash, Object) —

    a hash-like object

  • context (Object) —

    an object that can be used to compute values



63
64
65
66
 
# File 'lib/kitchen/lazy_hash.rb', line 63

def initialize(obj, context)
  @context = context
  super(obj)
end

Instance Method Details

#[](key) ⇒ Object?

Retrieves the rendered value object corresponding to the key object. If not found, returns the default value.

Parameters:

  • key (Object) —

    hash key

Returns:

  • (Object, nil) —

    the value for key or the default value if key is not found



74
75
76
 
# File 'lib/kitchen/lazy_hash.rb', line 74

def [](key)
  proc_or_val(__getobj__[key])
end

#[]=(key, value) ⇒ Object

Sets the raw value for the given key. Values are stored unrendered, so a callable assigned here is still evaluated lazily on read.

SimpleDelegator would forward this through #method_missing; defining it here keeps the hot path off that dispatch, which every plugin walks once per default attribute while applying its defaults.

Parameters:

  • key (Object) —

    hash key

  • value (Object) —

    the value to store

Returns:

  • (Object) —

    the stored value



108
109
110
 
# File 'lib/kitchen/lazy_hash.rb', line 108

def []=(key, value)
  __getobj__[key] = value
end

#delete_if(&block) ⇒ Hash

Returns a new Hash after deleting the key-value pairs for which the block returns true.

Returns:

  • (Hash) —

    a new hash



165
166
167
 
# File 'lib/kitchen/lazy_hash.rb', line 165

def delete_if(&block)
  to_hash.delete_if(&block)
end

#each(&block) ⇒ Enumerator, Array

If no block provided, returns an enumerator over the keys and rendered values in the underlying object. If a block is provided, calls the block once for each [key, rendered_value] pair in the underlying object.

Returns:

  • (Enumerator, Array) 


157
158
159
 
# File 'lib/kitchen/lazy_hash.rb', line 157

def each(&block)
  to_hash.each(&block)
end

#fetch(key, default = :__undefined__, &block) ⇒ Object?

Returns a rendered value from the hash for the given key. If the key can't be found, there are several options: With no other arguments, it will raise a KeyError exception; if default is given, then that will be returned; if the optional code block is specified, then that will be run and its result returned.

Parameters:

  • key (Object) —

    hash key

  • default (Object) (defaults to: :__undefined__) —

    default value if key is not set (optional)

Returns:

  • (Object, nil) —

    the value for the key or the default value if key is not found

Raises:

  • (KeyError) —

    if the key is not found



89
90
91
92
93
94
95
96
 
# File 'lib/kitchen/lazy_hash.rb', line 89

def fetch(key, default = :__undefined__, &block)
  case default
  when :__undefined__
    proc_or_val(__getobj__.fetch(key, &block))
  else
    proc_or_val(__getobj__.fetch(key, default, &block))
  end
end

#key?(key) ⇒ Boolean

Returns whether the given key is present, without rendering its value.

Defined for the same reason as #[]=: to bypass SimpleDelegator's #method_missing on a hot path.

Parameters:

  • key (Object) —

    hash key

Returns:

  • (Boolean) —

    whether the key is present



119
120
121
 
# File 'lib/kitchen/lazy_hash.rb', line 119

def key?(key)
  __getobj__.key?(key)
end

#keys ⇒ Array

Returns the keys of the underlying hash.

Defined for the same reason as #[]=: to bypass SimpleDelegator's #method_missing on a hot path.

Returns:

  • (Array) —

    the hash keys



129
130
131
 
# File 'lib/kitchen/lazy_hash.rb', line 129

def keys
  __getobj__.keys
end

#select(&block) ⇒ Hash

Yields each key/value pair to the provided block. Returns a new Hash with only the keys and rendered values for which the block returns true.

Returns:

  • (Hash) —

    a new hash



147
148
149
 
# File 'lib/kitchen/lazy_hash.rb', line 147

def select(&block)
  to_hash.select(&block)
end

#to_hash ⇒ Hash

Returns a new Hash with all keys and rendered values of the LazyHash.

Returns:

  • (Hash) —

    a new hash



136
137
138
139
140
 
# File 'lib/kitchen/lazy_hash.rb', line 136

def to_hash
  hash = {}
  __getobj__.each_key { |key| hash[key] = self[key] }
  hash
end