assign hash to properties
333484
def properties= value
      value.each do |k,v|
        self.add_property k.to_s, v
      end
    end
471077
def evolve_hash(value)
      value.inject({}) do |hash, (field, _value)|
        name, serializer = storage_pair(field)
        hash[normalized_key(name, serializer)] = _value
        hash
      end
    end
221373
def stringify( hash )

            keys = @sorted ? hash.keys.sort : hash.keys
            vals = keys.map{ |key|
                val = ''
                if hash[key].kind_of?( Array ) 
                    val = rotate( hash[key] )
                elsif hash[key].kind_of?( Hash )
                    val = @sorted ? hash[key].keys.sort[0] : hash[key].keys[0]
                else
                    val = hash[key]
                end
                "#{key}: #{val}"
            }
            return vals.join( '; ' ) + (vals.length ? ';' : '')

        end
73980
def assign_attributes(new_attributes)
      if !new_attributes.respond_to?(:stringify_keys)
        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
      end
      return if new_attributes.empty?

      # stringify keys just like https://github.com/rails/rails/blob/4f99a2186479d5f77460622f2c0f37708b3ec1bc/activemodel/lib/active_model/attribute_assignment.rb#L34
      new_attributes.stringify_keys.each do |k, v|
        setter = :"#{k}="
        if respond_to?(setter)
          public_send(setter, v)
        else
          _attr_json_write_unknown_attribute(k, v)
        end
      end
    end
812032
def build_mapping(values)
      {}.tap do |hash|
        values.each_with_index { |key, index| hash[key] = (0b1 << index) }
      end
    end
1130645
def attributes_hash
      attributes = @scope.attributes.collect do |attr|
        value = fetch_property(attr)

        if value.kind_of?(BigDecimal)
          value = value.to_f
        end

        [attr, value]
      end

      Hash[attributes]
    end
1264632
def properties_from_hash(hash)
      hash.each_with_object({}) do |(k, v), newhash|
        k = k.tr("-", "_")
        k = "_#{k}" if k =~ /^\d/
        self.class.property :"#{k}"
        newhash[k] = v
        newhash
      end
    end
727679
def to_hash()
      rethash = {
        "permissions" => @permissions
      }
      (@user.attributes - [:links]).each do |attr_sym|
        rethash[attr_sym.to_s] = @user.send(attr_sym.to_s)
      end
      rethash
    end
649463
function hash(sess) {
  // serialize
  var str = JSON.stringify(sess, function (key, val) {
    // ignore sess.cookie property
    if (this === sess && key === 'cookie') {
      return
    }

    return val
  })

  // hash
  return crypto
    .createHash('sha1')
    .update(str, 'utf8')
    .digest('hex')
}
90231
function(older_hash, newer_hash){

	if( ! older_hash ){ older_hash = {}; }
	if( ! newer_hash ){ newer_hash = {}; }

	var ret_hash = {};
	function _add (val, key){
	    ret_hash[key] = val;
	}
	each(older_hash, _add);
	each(newer_hash, _add);
	return ret_hash;
    }
451167
function hashHas(key) {
  var data = this.__data__;
  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty$9.call(data, key);
}
79156
def to_hash
      {
        :installer => installer,
        :installer_arguments => installer_arguments,
        :iso_path => iso_path,
        :iso_upload_path => iso_upload_path,
        :iso_mount_point => iso_mount_point,
        :auto_update => auto_update,
        :auto_reboot => auto_reboot,
        :no_install => no_install,
        :no_remote => no_remote,
        :yes => yes
      }
    end
474497
function hashHas(key) {
              var data = this.__data__;
              return _nativeCreate ? (data[key] !== undefined) : hasOwnProperty$6.call(data, key);
            }
38937
def hash(mapping, bind, values):
    
    for v in values:
        if v is None:
            continue
        if not isinstance(v, six.string_types):
            v = six.text_type(v)
        yield sha1(v.encode('utf-8')).hexdigest()
124743
def to_hash
      _new_hash= {}
      each do |key, value|
        _new_hash[convert_key(key)] = convert_value(value, for: :to_hash)
      end
      Hash.new(default).merge!(_new_hash)
    end
142102
def to_hash
      hash = {}
      each_pair do |key, value|
        if value.kind_of?(ConfigHash)
          value = value.to_hash
        end
        
        hash[key] = value
      end
      hash
    end
530368
def hash(self, val):
        """"""

        if not isinstance(val, bytes):
            raise _TypeError("val", "bytes", val)

        rv = self.compute(val)

        if not isinstance(val, bytes):
            raise _TypeError("val", "bytes", rv)

        return rv