symbolized 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: a3f2960d6622db153aa61342406a2bc60d86d073
-  data.tar.gz: 168b0e7e2d7c85977c7b1df7eb6c7751b99b8fb0
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ODFiMWZjNjFhZjdjMzk1MDYyMmMzNDIxMzI4YmE4MTE2YTY2OWQzMw==
+  data.tar.gz: !binary |-
+    NmUwZGYzMDk0ZGI3ZTJiMjcxZWY5MmQxNjFhZWY3ZDJhOTIzY2U1NA==
 SHA512:
-  metadata.gz: 431a2428e5f47e2e897251f5121c4bcb791c36c1311867583b2ef9d171805906df8d7c7b8351e191ebcf50595327bbc3f7257a7c9df6657ad5def12b7c327f02
-  data.tar.gz: ff265ce246d29bd4b16972ab48704b5d255fc9c48ad12a204cc30efaf0736a62915dc2adc5d285f086c8cece9896a08c1abe1662a96ce3f53392db9662298300
+  metadata.gz: !binary |-
+    YjJhYTMyZDZkM2I2OWQ3N2UzNzAxY2RjZmE1MThiM2I5MGJjM2QwNTdjZDAx
+    ODBmMzZhNWNiNGVlNTEwMDFiOTY1MDdiZmRhYjUyNDJjNTIwYzAzMjM4N2M4
+    M2M5ZWUwNWM5OTY0OGE5ZjFiYWU1ODRiZDBhYTMxMTQ3YmIwYWU=
+  data.tar.gz: !binary |-
+    MDYyOGQ1N2ExNjEyNjQxNmI1NzY4NDVmOGUyMTY3NTVmNTgyMDVjNThkM2Nm
+    YWMyMzhiNmU2ZTIxMjU1OGE0MDFkYjQ3NDAzMDRmM2NlMGNhMDg4NTU2NmVh
+    MjA5ZWFjOTJiODFlM2MzMDk4NjllOGJhOTNkZmQ2NTg0NDlkMTA=

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Tamer Shlash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,85 @@
+# Symbolized
+
+[![Build Status](https://travis-ci.org/TamerShlash/symbolized.svg?branch=master)](https://travis-ci.org/TamerShlash/symbolized)
+
+Symbolized provides a Hash with indifferent access, but with keys stored internally as symbols.
+This is particularly useful when you have a very big amount of hashes that share the same keys,
+and it may become inefficient to keep all these identical keys as strings. An example of this
+case is when you have data processing pipelines that process millions of hashes with the same
+keys.
+
+## Installation
+
+You can either install it manually:
+
+    % [sudo] gem install symbolized
+
+Or include it in your Gemfile:
+
+    gem 'symbolized'
+
+And then run `bundle install`.
+
+## Usage
+
+```ruby
+require 'symbolized'
+
+# You can create a SymbolizedHash directly:
+
+symbolized_hash = SymbolizedHash.new
+symbolized_hash['a'] = 'b'
+symbolized_hash['a'] #=> 'b'
+symbolized_hash[:a]  #=> 'b'
+symbolized_hash.keys #=> [:a]
+
+# Or initialize it with a normal hash:
+
+symbolized_hash = SymbolizedHash.new({'a' => 'b'})
+symbolized_hash['a'] #=> 'b'
+symbolized_hash[:a]  #=> 'b'
+symbolized_hash.keys #=> [:a]
+
+# Or use the Hash#to_symbolized_hash core extension:
+
+h = { 'a' => 'b' }
+h['a'] #=> 'b'
+h[:a]  #=> nil
+h.keys #=> ['a']
+
+symbolized_hash = h.to_symbolized_hash
+symbolized_hash['a'] #=> 'b'
+symbolized_hash[:a]  #=> 'b'
+symbolized_hash.keys #=> [:a]
+
+```
+
+The gem provides almost the same methods and functionality provided by ActiveSupport's `HashWithIndifferentAccess`, while storing keys internally as Symbols.
+
+## `ActiveSupport` Compatibility
+
+This gem is built with intent to be as much as possible compatible with ActiveSupport. You can include both `Symbolized` and `ActiveSupport`, and you are guaranteed to get ActiveSupport functionality and core extensions, and still have `Symbolized` core extension and class.
+
+## Testing
+
+Checkout [travis.yml](.travis.yml) to see which Ruby versions the gem has been tested against. Alternatively, if you want to test it yourself, you can clone the repo, run `bundle install` and then run `rake test`.
+
+## Suggestions, Discussions and Issues
+
+Please propose suggestions, open discussions, or report bugs and issues [here](https://github.com/TamerShlash/symbolized/issues).
+
+## Contributing
+
+1. Fork the [repo](https://github.com/TamerShlash/symbolized)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## Credits
+
+The current code of this gem is heavily based on [ActiveSupport 4.2 HashWithIndifferentAccess](https://github.com/rails/rails/tree/4-2-stable/activesupport). Some parts are direct clones, other parts have been modified and/or refactored.
+
+## License
+
+Copyright (c) 2015 [Tamer Shlash](https://github.com/TamerShlash) ([@TamerShlash](https://twitter.com/TamerShlash)). Released under the MIT [License](LICENSE).

data/lib/symbolized.rb

@@ -0,0 +1,2 @@
+require 'symbolized/symbolized_hash'
+require 'symbolized/core_ext/hash/symbolized_hash'

data/lib/symbolized/core_ext/hash/keys.rb

@@ -0,0 +1,166 @@
+class Hash
+  # Returns a new hash with all keys converted using the block operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys{ |key| key.to_s.upcase }
+  #  # => {"NAME"=>"Rob", "AGE"=>"28"}
+  def transform_keys
+    return enum_for(:transform_keys) unless block_given?
+    result = self.class.new
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Destructively convert all keys using the block operations.
+  # Same as transform_keys but modifies +self+.
+  def transform_keys!
+    return enum_for(:transform_keys!) unless block_given?
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def stringify_keys
+    transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    transform_keys!{ |key| key.to_s }
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   # => {:name=>"Rob", :age=>"28"}
+  def symbolize_keys
+    transform_keys{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options,  :symbolize_keys
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    transform_keys!{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options!, :symbolize_keys!
+
+  # Validate all keys in a hash match <tt>*valid_keys</tt>, raising
+  # ArgumentError on a mismatch.
+  #
+  # Note that keys are treated differently than HashWithIndifferentAccess,
+  # meaning that string and symbol keys will not match.
+  #
+  #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      unless valid_keys.include?(k)
+        raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
+      end
+    end
+  end
+
+  # Returns a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def deep_transform_keys(&block)
+    _deep_transform_keys_in_object(self, &block)
+  end
+
+  # Destructively convert all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_transform_keys!(&block)
+    _deep_transform_keys_in_object!(self, &block)
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+  def deep_stringify_keys
+    deep_transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_stringify_keys!
+    deep_transform_keys!{ |key| key.to_s }
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes and arrays.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+  def deep_symbolize_keys
+    deep_transform_keys{ |key| key.to_sym rescue key }
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_symbolize_keys!
+    deep_transform_keys!{ |key| key.to_sym rescue key }
+  end
+
+  private
+    # support methods for deep transforming nested hashes and arrays
+    def _deep_transform_keys_in_object(object, &block)
+      case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+        end
+      when Array
+        object.map {|e| _deep_transform_keys_in_object(e, &block) }
+      else
+        object
+      end
+    end
+
+    def _deep_transform_keys_in_object!(object, &block)
+      case object
+      when Hash
+        object.keys.each do |key|
+          value = object.delete(key)
+          object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+        end
+        object
+      when Array
+        object.map! {|e| _deep_transform_keys_in_object!(e, &block)}
+      else
+        object
+      end
+    end
+end unless defined? ActiveSupport

data/lib/symbolized/core_ext/hash/reverse_merge.rb

@@ -0,0 +1,22 @@
+class Hash
+  # Merges the caller into +other_hash+. For example,
+  #
+  #   options = options.reverse_merge(size: 25, velocity: 10)
+  #
+  # is equivalent to
+  #
+  #   options = { size: 25, velocity: 10 }.merge(options)
+  #
+  # This is particularly useful for initializing an options hash
+  # with default values.
+  def reverse_merge(other_hash)
+    other_hash.merge(self)
+  end
+
+  # Destructive +reverse_merge+.
+  def reverse_merge!(other_hash)
+    # right wins if there is no left
+    merge!( other_hash ){|key,left,right| left }
+  end
+  alias_method :reverse_update, :reverse_merge!
+end unless defined? ActiveSupport

data/lib/symbolized/core_ext/hash/symbolized_hash.rb

@@ -0,0 +1,21 @@
+require 'symbolized'
+
+class Hash
+  # Returns a <tt>Symbolized::SymbolizedHash</tt> out of its receiver:
+  #
+  #   { 'a' => 1 }.to_symbolized_hash[:a] # => 1
+  def to_symbolized_hash
+    Symbolized::SymbolizedHash.new_from_hash_copying_default(self)
+  end
+
+  # Called when object is nested under an object that receives
+  # #to_symbolized_hash. This method will be called on the current object
+  # by the enclosing object and is aliased to #to_symbolized_hash by
+  # default. Subclasses of Hash may overwrite this method to return +self+ if
+  # converting to a <tt>Symbolized::SymbolizedHash</tt> would not be desirable.
+  #
+  #   b = { 'b' => 1 }
+  #   { a: b }.with_indifferent_access['a'] # calls b.nested_under_indifferent_access
+  #   # => { :b => 1 }
+  alias nested_under_symbolized_hash to_symbolized_hash
+end

data/lib/symbolized/core_ext/object/deep_dup.rb

@@ -0,0 +1,48 @@
+unless defined? ActiveSupport
+  require 'symbolized/core_ext/object/duplicable'
+
+  class Object
+    # Returns a deep copy of object if it's duplicable. If it's
+    # not duplicable, returns +self+.
+    #
+    #   object = Object.new
+    #   dup    = object.deep_dup
+    #   dup.instance_variable_set(:@a, 1)
+    #
+    #   object.instance_variable_defined?(:@a) # => false
+    #   dup.instance_variable_defined?(:@a)    # => true
+    def deep_dup
+      duplicable? ? dup : self
+    end
+  end
+
+  class Array
+    # Returns a deep copy of array.
+    #
+    #   array = [1, [2, 3]]
+    #   dup   = array.deep_dup
+    #   dup[1][2] = 4
+    #
+    #   array[1][2] # => nil
+    #   dup[1][2]   # => 4
+    def deep_dup
+      map { |it| it.deep_dup }
+    end
+  end
+
+  class Hash
+    # Returns a deep copy of hash.
+    #
+    #   hash = { a: { b: 'b' } }
+    #   dup  = hash.deep_dup
+    #   dup[:a][:c] = 'c'
+    #
+    #   hash[:a][:c] # => nil
+    #   dup[:a][:c]  # => "c"
+    def deep_dup
+      each_with_object(dup) do |(key, value), hash|
+        hash[key.deep_dup] = value.deep_dup
+      end
+    end
+  end
+end

data/lib/symbolized/core_ext/object/duplicable.rb

@@ -0,0 +1,105 @@
+#--
+# Most objects are cloneable, but not all. For example you can't dup +nil+:
+#
+#   nil.dup # => TypeError: can't dup NilClass
+#
+# Classes may signal their instances are not duplicable removing +dup+/+clone+
+# or raising exceptions from them. So, to dup an arbitrary object you normally
+# use an optimistic approach and are ready to catch an exception, say:
+#
+#   arbitrary_object.dup rescue object
+#
+# Rails dups objects in a few critical spots where they are not that arbitrary.
+# That rescue is very expensive (like 40 times slower than a predicate), and it
+# is often triggered.
+#
+# That's why we hardcode the following cases and check duplicable? instead of
+# using that rescue idiom.
+#++
+unless defined? ActiveSupport
+  class Object
+    # Can you safely dup this object?
+    #
+    # False for +nil+, +false+, +true+, symbol, number and BigDecimal(in 1.9.x) objects;
+    # true otherwise.
+    def duplicable?
+      true
+    end
+  end
+
+  class NilClass
+    # +nil+ is not duplicable:
+    #
+    #   nil.duplicable? # => false
+    #   nil.dup         # => TypeError: can't dup NilClass
+    def duplicable?
+      false
+    end
+  end
+
+  class FalseClass
+    # +false+ is not duplicable:
+    #
+    #   false.duplicable? # => false
+    #   false.dup         # => TypeError: can't dup FalseClass
+    def duplicable?
+      false
+    end
+  end
+
+  class TrueClass
+    # +true+ is not duplicable:
+    #
+    #   true.duplicable? # => false
+    #   true.dup         # => TypeError: can't dup TrueClass
+    def duplicable?
+      false
+    end
+  end
+
+  class Symbol
+    # Symbols are not duplicable:
+    #
+    #   :my_symbol.duplicable? # => false
+    #   :my_symbol.dup         # => TypeError: can't dup Symbol
+    def duplicable?
+      false
+    end
+  end
+
+  class Numeric
+    # Numbers are not duplicable:
+    #
+    #  3.duplicable? # => false
+    #  3.dup         # => TypeError: can't dup Fixnum
+    def duplicable?
+      false
+    end
+  end
+
+  require 'bigdecimal'
+  class BigDecimal
+    # Needed to support Ruby 1.9.x, as it doesn't allow dup on BigDecimal, instead
+    # raises TypeError exception. Checking here on the runtime whether BigDecimal
+    # will allow dup or not.
+    begin
+      BigDecimal.new('4.56').dup
+
+      def duplicable?
+        true
+      end
+    rescue TypeError
+      # can't dup, so use superclass implementation
+    end
+  end
+
+  class Method
+    # Methods are not duplicable:
+    #
+    #  method(:puts).duplicable? # => false
+    #  method(:puts).dup         # => TypeError: allocator undefined for Method
+    def duplicable?
+      false
+    end
+  end
+end

data/lib/symbolized/symbolized_hash.rb

@@ -0,0 +1,291 @@
+require 'symbolized/core_ext/hash/keys'
+require 'symbolized/core_ext/hash/reverse_merge'
+
+module Symbolized
+  # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
+  # to be the same.
+  #
+  #   rgb = SymbolizedHash.new
+  #
+  #   rgb[:black] = '#000000'
+  #   rgb[:black]  # => '#000000'
+  #   rgb['black'] # => '#000000'
+  #
+  #   rgb['white'] = '#FFFFFF'
+  #   rgb[:white]  # => '#FFFFFF'
+  #   rgb['white'] # => '#FFFFFF'
+  #
+  # Internally strings are mapped to symbols when used as keys in the entire
+  # writing interface (calling <tt>[]=</tt>, <tt>merge</tt>, etc). This
+  # mapping belongs to the public interface. For example, given:
+  #
+  #   hash = SymbolizedHash.new('a' => 1)
+  #
+  # You are guaranteed that the key is returned as a symbol:
+  #
+  #   hash.keys # => [:a]
+  #
+  # Technically other types of keys are accepted:
+  #
+  #   hash = SymbolizedHash.new('a' => 1)
+  #   hash[0] = 0
+  #   hash # => { :a => 1, 0 => 0 }
+  #
+  # but this class is intended for use cases where strings or symbols are the
+  # expected keys and it is convenient to understand both as the same. For
+  # example, processing data throught a multi-step pipeline where steps can 
+  # be written by other people.
+  #
+  # Note that core extensions define <tt>Hash#to_symbolized_hash</tt>:
+  #
+  #   rgb = { black: '#000000', 'white' => '#FFFFFF' }.to_symbolized_hash
+  #
+  # which may be handy.
+  class SymbolizedHash < Hash
+    # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
+    # this class.
+    def extractable_options?
+      true
+    end
+
+    def symbolized
+      dup
+    end
+
+    def nested_under_symbolized_hash
+      self
+    end
+
+    def initialize(constructor = {})
+      if constructor.respond_to?(:to_hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(String) && include?(key = key.to_sym)
+        self[key]
+      else
+        super
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      hash = hash.to_hash
+      new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+        new_hash.default_proc = hash.default_proc if hash.default_proc
+      end
+    end
+
+    def self.[](*args)
+      new.merge!(Hash[*args])
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = SymbolizedHash.new
+    #   hash[:key] = 'value'
+    #
+    # This value can be later fetched using either +:key+ or +'key'+.
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value, for: :assignment))
+    end
+
+    alias_method :store, :[]=
+
+    # Updates the receiver in-place, merging in the hash passed as argument:
+    #
+    #   hash_1 = SymbolizedHash.new
+    #   hash_1['key'] = 'value'
+    #
+    #   hash_2 = SymbolizedHash.new
+    #   hash_2['key'] = 'New Value!'
+    #
+    #   hash_1.update(hash_2) # => { :key => 'New Value!' }
+    #
+    # The argument can be either a <tt>SymbolizedHash</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 }
+    def update(other_hash)
+      if other_hash.is_a? SymbolizedHash
+        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
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = SymbolizedHash.new
+    #   hash[:key] = 'value'
+    #   hash.key?(:key)  # => true
+    #   hash.key?('key') # => true
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
+    # either a string or a symbol:
+    #
+    #   counters = SymbolizedHash.new
+    #   counters['foo'] = 1
+    #
+    #   counters.fetch(:foo)          # => 1
+    #   counters.fetch(:bar, 0)        # => 0
+    #   counters.fetch(:bar) { |key| 0 } # => 0
+    #   counters.fetch('zoo')           # => KeyError: key not found: :zoo
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = SymbolizedHash.new
+    #   hash['a'] = 'x'
+    #   hash['b'] = 'y'
+    #   hash.values_at(:a, :b) # => ["x", "y"]
+    def values_at(*indices)
+      indices.collect { |key| self[convert_key(key)] }
+    end
+
+    # Returns a shallow copy of the hash.
+    #
+    #   hash = SymbolizedHash.new({ a: { b: 'b' } })
+    #   dup  = hash.dup
+    #   dup[:a][:c] = 'c'
+    #
+    #   hash[:a][:c] # => nil
+    #   dup[:a][:c]  # => "c"
+    def dup
+      self.class.new(self).tap do |new_hash|
+        set_defaults(new_hash)
+      end
+    end
+
+    # This method has the same semantics of +update+, except it does not
+    # modify the receiver but rather returns a new symbolized hash with
+    # indifferent access with the result of the merge.
+    def merge(hash, &block)
+      self.dup.update(hash, &block)
+    end
+
+    # Like +merge+ but the other way around: Merges the receiver into the
+    # argument and returns a new hash with indifferent access as result:
+    #
+    #   hash = SymbolizedHash.new
+    #   hash[:a] = nil
+    #   hash.reverse_merge('a' => 0, 'b' => 1) # => { :a => nil, :b => 1 }
+    def reverse_merge(other_hash)
+      super(self.class.new_from_hash_copying_default(other_hash))
+    end
+
+    # Same semantics as +reverse_merge+ but modifies the receiver in-place.
+    def reverse_merge!(other_hash)
+      replace(reverse_merge( other_hash ))
+    end
+
+    # Replaces the contents of this hash with other_hash.
+    #
+    #   h = { "a" => 100, "b" => 200 }
+    #   h.replace({ "c" => 300, "d" => 400 }) # => { :c => 300, :d => 400 }
+    def replace(other_hash)
+      super(self.class.new_from_hash_copying_default(other_hash))
+    end
+
+    # Removes the specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def symbolize_keys!; self end
+    def deep_symbolize_keys!; self end
+    def symbolize_keys; dup end
+    def deep_symbolize_keys; dup end
+    undef :stringify_keys! if method_defined? :stringify_keys!
+    undef :deep_stringify_keys! if method_defined? :deep_stringify_keys!
+    def stringify_keys; to_hash.stringify_keys! end
+    def deep_stringify_keys; to_hash.deep_stringify_keys! end
+    def to_options!; self end
+
+    def select(*args, &block)
+      dup.tap { |hash| hash.select!(*args, &block) }
+    end
+
+    def reject(*args, &block)
+      dup.tap { |hash| hash.reject!(*args, &block) }
+    end
+
+    # Convert to a regular hash with symbol keys.
+    def to_hash
+      _new_hash = Hash.new
+      set_defaults(_new_hash)
+
+      each do |key, value|
+        _new_hash[key] = convert_value(value, for: :to_hash)
+      end
+      _new_hash
+    end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(String) ? key.to_sym : key
+      end
+
+      def convert_value(value, options = {})
+        if value.is_a? Hash
+          if options[:for] == :to_hash
+            value.to_hash
+          else
+            value.nested_under_symbolized_hash
+          end
+        elsif value.is_a?(Array)
+          unless options[:for] == :assignment
+            value = value.dup
+          end
+          value.map! { |e| convert_value(e, options) }
+        else
+          value
+        end
+      end
+
+      def set_defaults(target)
+        if default_proc
+          target.default_proc = default_proc.dup
+        else
+          target.default = default
+        end
+      end
+  end
+end
+
+SymbolizedHash = Symbolized::SymbolizedHash

data/lib/symbolized/version.rb

@@ -0,0 +1,3 @@
+module Symbolized
+  VERSION = '0.0.1'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: symbolized
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Tamer Shlash
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-17 00:00:00.000000000 Z
+date: 2015-07-19 00:00:00.000000000 Z
 dependencies: []
 description: Hash with indifferent access, with keys stored internally as symbols.
 email: mr.tamershlash@gmail.com
@@ -16,7 +16,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- README.md
 - lib/symbolized.rb
+- lib/symbolized/core_ext/hash/keys.rb
+- lib/symbolized/core_ext/hash/reverse_merge.rb
+- lib/symbolized/core_ext/hash/symbolized_hash.rb
+- lib/symbolized/core_ext/object/deep_dup.rb
+- lib/symbolized/core_ext/object/duplicable.rb
+- lib/symbolized/symbolized_hash.rb
+- lib/symbolized/version.rb
 homepage: https://github.com/TamerShlash/symbolized
 licenses:
 - MIT
@@ -27,17 +36,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Symbolized HashWithIndifferentAccess