Evaluates every element and returns a hash.  Accepts context and arbitrary arguments.
357246
def call(context, *args)
      Hash[ collect { |k,v| [k,v.(context, *args) ] } ]
    end
1152173
def context(nodes, &block)
      nodes = nodes.first.is_a?(Matcher) ? nodes.first : WhitelistMatcher.new(nodes)
      @contexts << context = {:nodes => nodes, :block => block}
      
      # Evaluate the new context for existing nodes
      each {|node| eval_context(context, node)}
      
      context
    end
305644
def get_hash_for(self, value):
        
        if isinstance(value,dict) and '__ref__' in value:
            return self.get_hash_for(value['__ref__'])
        serialized_value = self._serializer(value)
        if isinstance(serialized_value, dict):
            # Hash each item and return the hash of all the hashes
            return hash(frozenset([
                self.get_hash_for(x)
                for x in serialized_value.items()
            ]))
        elif isinstance(serialized_value, (list,tuple)):
            # Hash each element and return the hash of all the hashes
            return hash(tuple([
                self.get_hash_for(x) for x in serialized_value
            ]))
        return value
592302
def to_hash
      load

      {}.tap do |hash|
        @_definition.each do |k, v|
          hash[k] = v
        end
      end
    end
479418
def to_hash
      hash = {}
      instance_variables.each do |name|
        value = instance_variable_get(name)
        next if value.nil?
        name = name[1..-1]
        key = self.class.names.key?(name) ? self.class.names[name] : name
        if value.instance_of? Array
          hash[key] = value.map { |v| v.is_a?(BaseModel) ? v.to_hash : v }
        elsif value.instance_of? Hash
          hash[key] = {}
          value.each do |k, v|
            hash[key][k] = v.is_a?(BaseModel) ? v.to_hash : v
          end
        else
          hash[key] = value.is_a?(BaseModel) ? value.to_hash : value
        end
      end
      hash
    end
122878
def and_yield(*args)
      yield eval_context = Object.new if block_given?
      @plan = Proc.new do |&block|
        eval_context.instance_exec(*args, &block)
      end
      self
    end
288115
def to_hash
    self.instance_variables.inject({}) { |m,v| m[v[1,v.length].to_sym] = instance_variable_get(v); m }
  end
1021642
def hash(self):
        '''
        
        '''
        hashed = super(TakeFrom, self).hash()
        return khash(hashed, self.min_elements, self.max_elements, self.seed)
35790
def evaluate_in(context, periods = [])
      sandbox = Sandbox.new context, periods
      sandbox.instance_eval &@equation_block
    end
914904
def each
      return to_enum unless block_given?
      seen = {}
      tuples.each do |tuple|
        tuple = Tuple.coerce(header, tuple)
        yield seen[tuple] = tuple unless seen.key?(tuple)
      end
      self
    end
1200826
def _hash(x, elementType, relicHashFunc):
    
    # Combine all inputs into a single bytearray
    barray = bytearray()
    map(barray.extend, bytes(x))

    # Create an element of the correct type to hold the hash result
    result = elementType()

    # Convert barray into a modifiable ctypes buffer, hash using the provided
    # function, and return the result.
    buf = getBuffer(barray)
    relicHashFunc(byref(result), byref(buf), sizeof(buf))
    return result
681837
def to_hash
      result = {}
      @lines.entries.each do |section|
        result[section.key] ||= {}
        section.entries.each do |option|
          opts = Array(option)
          val = opts.map { |o| o.respond_to?(:value) ? o.value : o }
          val = val.size > 1 ? val : val.first
          result[section.key][opts.first.key] = val
        end
      end
      result
    end
563962
def hash(self, build_context) -> str:
        """"""
        if self._hash is None:
            self.compute_hash(build_context)
        return self._hash
1090081
def hash(self):
        '''
        
        '''
        hashed = super(Dynamic, self).hash()
        return khash(hashed, self._key, self._length)
285498
def filter_to_hash(valid_filters, keys_case=:undescore)
			hashed_filter = {}
			filter.each do |key, value|
				hashed_filter[get_attribute_key(key, keys_case)] = solve_filter_value(key, value)
			end
			return hashed_filter
		end
575458
def each_with_index
      return to_enum unless block_given?
      start_index = -1
      data.each do |row|
        yield row.to_a, start_index += 1
      end
      self
    end
1288972
def result(_binding_or_hash=TOPLEVEL_BINDING)
      _arg = _binding_or_hash
      if _arg.is_a?(Hash)
        _b = binding()
        eval _arg.collect{|k,v| "#{k} = _arg[#{k.inspect}]; "}.join, _b
      elsif _arg.is_a?(Binding)
        _b = _arg
      elsif _arg.nil?
        _b = binding()
      else
        raise ArgumentError.new("#{self.class.name}#result(): argument should be Binding or Hash but passed #{_arg.class.name} object.")
      end
      return eval(@src, _b, (@filename || '(erubis'))
    end