def update(other_hash)
      if other_hash.is_a? HashWithIndifferentAccess
        super(other_hash)
      else
        other_hash.to_hash.each_pair do |key, value|
          if block_given? && key?(key)
            value = yield(convert_key(key), self[key], value)
          end
          regular_writer(convert_key(key), convert_value(value))
        end
        self
      end
    end
def update(other_hash)
      if other_hash.is_a? HashWithIndifferentAccess
        super(other_hash)
      else
        other_hash.to_hash.each_pair do |key, value|
          if block_given? && key?(key)
            value = yield(convert_key(key), self[key], value)
          end
          regular_writer(convert_key(key), convert_value(value))
        end
        self
      end
    end
Updates the receiver in-place, merging in the hash passed as argument:

   hash_1 = ActiveSupport::HashWithIndifferentAccess.new
   hash_1[:key] = 'value'

   hash_2 = ActiveSupport::HashWithIndifferentAccess.new
   hash_2[:key] = 'New Value!'

   hash_1.update(hash_2) # => {"key"=>"New Value!"}

 The argument can be either an
 <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
 In either case the merge respects the semantics of indifferent access.

 If the argument is a regular hash with keys +:key+ and +"key"+ only one
 of the values end up in the receiver, but which one is unspecified.

 When given a block, the value for duplicated keys will be determined
 by the result of invoking the block with the duplicated key, the value
 in the receiver, and the value in +other_hash+. The rules for duplicated
 keys follow the semantics of indifferent access:

   hash_1[:key] = 10
   hash_2['key'] = 12
   hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}