insensitive_hash_bxf 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 280229258001084e66fcc3b09e9f8691759dd9b2f1dff3d93b8e0346720edf9a
+  data.tar.gz: 67b834f76f1158d9bd11cca3c9a3364a262eacd77d3532df7c7f242416760157
+SHA512:
+  metadata.gz: 9486c4192d63d6ce5f8b07aa980ac9aea15d23e9225d723c08945254bd0e28bf85101c8174995ab8822cf739d58f9376fbd3d67ce8088d28100b6ad78f09c7df
+  data.tar.gz: 8c5212705169beb3e7cc8f6cde8074fe29118b1d814578500bb9d173b5e8dce1cba20a404e4c756e6e581676a25c0191bda1b6a6da6fd5a95db6c7e35fdc06fd

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp
+*.swo

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7

data/CHANGELOG.markdown

@@ -0,0 +1,65 @@
+### 0.3.3
+
+- Code refactoring
+- List new contributors
+
+### 0.3.2
+
+- Supports custom key encoder
+- Added `InsensitiveHash#merge_recursive!`
+
+### 0.3.0
+
+- Now allowing underscores for spaces is by default on, and cannot be turned off.
+- "Inherited insensitivity" had been a great source of confusion,
+  as it stores transformed version of the given Array of Hash.
+  From 0.3.0, Hash values and descendant Hashes are converted to be insensitive
+  only on the initialization of InsensitiveHash.
+  Refer to the following code
+
+```ruby
+  ih = {}.insensitive
+  ih[:a] = { :b => :c }
+
+  ih[:a]['B']           # nil
+
+  # Initialize another InsensitiveHash
+  ih2 = ih.insensitive
+  ih2[:a]['B']           # :c
+```
+
+### 0.2.4
+
+- Bug fix: Invalid `dup`, `clone` behavior
+- :safe setting from `Hash#insensitive`
+
+### 0.2.3 / 2012/02/18
+
+- Key-clash detection made optional with `InsensitiveHash#safe=`
+- Ruby 1.8 compatibility
+
+### 0.2.2 / 2012/02/13
+
+- :underscore option added
+- `InsensitiveHash::KeyClashError` added for safer operations
+- Bug fix: Preserve default/default_proc on merge/replace/insensitive
+- Subtle behavioral change in `InsensitiveHash#replace` when called with an ordinary Hash
+
+### 0.2.1 / 2012/02/10
+
+- Bug fix: Insensitive `fetch`
+
+### 0.2.0 / 2012/02/01
+
+- Major rewrite
+- Constructor syntaxes have been changed to match those of standard Hash (not backward-compatible)
+- (Almost) Complete implementation of standard Hash spec.
+
+### 0.1.0 / 2011/12/20
+
+- Can opt-out of monkey-patching Hash with `require 'insensitive_hash/minimal'`
+
+### 0.0.2-3 / 2011/10/28
+
+- Removed duplicated code in the constructor
+- More tests

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in insensitive_hash.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) 2013 Junegunn Choi
+Copyright (c) 2018-2020 Box Factura
+
+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,149 @@
+# insensitive_hash_bxf
+
+[![Build Status](https://travis-ci.org/BoxFactura/insensitive_hash.svg?branch=master)](https://travis-ci.org/BoxFactura/insensitive_hash)
+
+Hash with case-insensitive, Symbol/String-indifferent key access.
+
+> This project is a fork from [https://github.com/junegunn/insensitive_hash](https://github.com/junegunn/insensitive_hash) and it was made to continue its maintenance.
+
+## Installation
+
+```
+gem install insensitive_hash_bxf
+```
+
+## Instantiation
+
+### Hash#insensitive
+
+```ruby
+require 'insensitive_hash'
+
+ih = {}.insensitive
+
+ih = { :abc => 1, 'hello world' => true }.insensitive
+
+ih['ABC']         # 1
+ih[:Hello_World]  # true
+```
+
+### Without monkey-patching Hash
+
+If you don't like to have Hash#insensitive method, `require 'insensitive_hash/minimal'`
+
+```ruby
+require 'insensitive_hash/minimal'
+
+ih = InsensitiveHash.new
+ih = InsensitiveHash.new(:default_value)
+ih = InsensitiveHash.new { |ih, k| ih[k] = InsensitiveHash.new }
+
+ih = InsensitiveHash[ 'abc' => 1, :def => 2 ]
+ih = InsensitiveHash[ 'abc', 1, :def, 2 ]
+ih = InsensitiveHash[ [['abc', 1], [:def, 2]] ]
+
+ih = InsensitiveHash[ 'hello world' => true ]
+```
+
+### Revert to normal Hash
+
+```ruby
+h = ih.sensitive
+h = ih.to_hash
+```
+
+## Basic usage
+
+```ruby
+ih = {:abc => 1, 'DEF' => 2}.insensitive
+
+# Case-insensitive, Symbol/String-indifferent access.
+ih['Abc']          # 1
+ih[:ABC]           # 1
+ih['abc']          # 1
+ih[:abc]           # 1
+ih.has_key?(:DeF)  # true
+
+ih['ABC'] = 10
+
+# keys and values
+ih.keys            # ['DEF', 'ABC']
+ih.values          # [2, 10]
+
+# delete
+ih.delete :Abc     # 10
+ih.keys            # ['DEF']
+```
+
+## Inherited insensitivity
+
+When an InsensitiveHash is built from another Hash,
+descendant Hash values are recursively converted to be insensitive.
+
+```ruby
+
+ih = { 'kids' => { :hello => [ { :world => '!!!' } ] } }.insensitive
+ih[:kids]['Hello'].first['WORLD']  # !!!
+
+ih = {:one => [ [ [ { :a => { :b => { :c => 'd' } } } ] ] ]}.insensitive
+ih['one'].first.first.first['A']['b'][:C]  # 'd'
+```
+
+However, once InsensitiveHash is initialized,
+descendant Hashes (or Hashes in Arrays) are not automatically converted.
+
+```ruby
+ih = {}.insensitive
+ih[:abc] = { :def => true }
+
+ih['ABC']['DEF']     # nil
+```
+
+Simply build a new InsensitiveHash out of it if you need recursive conversion.
+
+```ruby
+ih2 = ih.insensitive
+ih2['ABC']['DEF']    # true
+```
+
+### Example: Processing case-insensitive YAML input
+
+```ruby
+db = YAML.load(File.read 'database.yml').insensitive
+
+# Access values however you like
+db['Development']['ADAPTER']
+db[:production][:adapter]
+```
+
+## Enabling key-clash detection (Safe mode)
+
+```ruby
+ih = InsensitiveHash.new
+ih.safe = true
+
+# Will raise InsensitiveHash::KeyClashError
+h.merge!('hello world' => 1, :hello_world => 2)
+
+# Disables key-clash detection
+h.safe = false
+h.merge!('hello world' => 1, :hello_world => 2)
+h['Hello World']  # 2
+```
+
+## Contributing to insensitive_hash
+
+- Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+- Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+- Fork the project
+- Start a feature/bugfix branch
+- Commit and push until you are happy with your contribution
+- Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+- Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+- Copyright (c) 2013 Junegunn Choi.
+- Copyright (c) 2018-2020 Box Factura
+
+See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc 'Run tests'
+task default: :test

data/insensitive_hash.gemspec

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+$:.push File.expand_path('../lib', __FILE__)
+require 'insensitive_hash/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'insensitive_hash_bxf'
+  s.version     = InsensitiveHash::VERSION
+  s.authors     = ['Junegunn Choi', 'Arandi Lopez']
+  s.email       = ['junegunn.c@gmail.com', 'arandilopez.93@gmail.com']
+  s.homepage    = 'https://github.com/BoxFactura/insensitive_hash'
+  s.summary     = 'Case-insensitive Ruby Hash'
+
+  s.description = 'Hash with case-insensitive, Symbol/String-indifferent key access'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'test-unit', '>= 2.3.0'
+end

data/lib/insensitive_hash.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'insensitive_hash/version'
+require 'insensitive_hash/insensitive_hash'
+
+# :nodoc:
+class Hash
+  # @param [Hash] options Options
+  # @option options [Boolean] :safe Whether to detect key clash on merge
+  # @return [InsensitiveHash]
+  def insensitive options = {}
+    InsensitiveHash.new.tap do |ih|
+      ih.safe         = options[:safe] if options.key?(:safe)
+      ih.default      = default
+      ih.default_proc = default_proc if default_proc
+
+      ih.merge_recursive!(self)
+    end
+  end
+end

data/lib/insensitive_hash/insensitive_hash.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+# Insensitive Hash.
+# @author Junegunn Choi <junegunn.c@gmail.com>
+class InsensitiveHash < Hash
+  # Thrown when safe mode is on and another Hash with conflicting keys cannot be merged safely
+  class KeyClashError < RuntimeError; end
+
+  def initialize(default = nil, &block)
+    if block_given?
+      raise ArgumentError, 'wrong number of arguments' unless default.nil?
+
+      super(&block)
+    else
+      super
+    end
+
+    @key_map = {}
+    @safe    = false
+  end
+
+  # Sets whether to detect key clashes
+  # @param [Boolean]
+  # @return [Boolean]
+  def safe=(safe_val)
+    raise ArgumentError, 'Neither true nor false' unless [true, false].include?(safe_val)
+
+    @safe = safe_val
+  end
+
+  # @return [Boolean] Key-clash detection enabled?
+  def safe?
+    @safe
+  end
+
+  # Returns a normal, sensitive Hash
+  # @return [Hash]
+  def to_hash
+    {}.merge self
+  end
+  alias sensitive to_hash
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
+  def self.[](*init)
+    h = Hash[*init]
+    new.tap do |ih|
+      ih.merge_recursive! h
+    end
+  end
+
+  %w[[] assoc has_key? include? key? member?].each do |symb|
+    class_eval <<-EVAL, __FILE__, __LINE__ + 1
+      def #{symb}(key)
+        super lookup_key(key)
+      end
+    EVAL
+  end
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
+  def []=(key, value)
+    delete key
+    ekey = encode key
+    @key_map[ekey] = key
+    super key, value
+  end
+  alias store []=
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
+  def merge!(other_hash)
+    detect_clash other_hash
+    other_hash.each do |key, value|
+      store key, value
+    end
+    self
+  end
+  alias update! merge!
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
+  def merge(other_hash)
+    self.class.new.tap do |ih|
+      ih.replace self
+      ih.merge! other_hash
+    end
+  end
+  alias update merge
+
+  # Merge another hash recursively.
+  # @param [Hash|InsensitiveHash] other_hash
+  # @return [self]
+  def merge_recursive!(other_hash)
+    detect_clash other_hash
+    other_hash.each do |key, value|
+      deep_set key, value
+    end
+    self
+  end
+  alias update_recursive! merge_recursive!
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
+  def delete(key, &block)
+    super lookup_key(key, true), &block
+  end
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
+  def clear
+    @key_map.clear
+    super
+  end
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
+  def replace(other)
+    super other
+
+    self.safe = other.respond_to?(:safe?) ? other.safe? : safe?
+
+    @key_map.clear
+    each do |k, _v|
+      ekey = encode k
+      @key_map[ekey] = k
+    end
+  end
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
+  def shift
+    super.tap do |ret|
+      @key_map.delete_if { |_k, v| v == ret.first }
+    end
+  end
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
+  def values_at(*keys)
+    keys.map { |k| self[k] }
+  end
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
+  def fetch(*args, &block)
+    args[0] = lookup_key(args[0]) if args.first
+    super(*args, &block)
+  end
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
+  def dup
+    super.tap { |copy| copy.instance_variable_set :@key_map, @key_map.dup }
+  end
+
+  # @see http://www.ruby-doc.org/core-1.9.3/Hash.html Hash
+  def clone
+    super.tap { |copy| copy.instance_variable_set :@key_map, @key_map.dup }
+  end
+
+  private
+
+  def deep_set(key, value)
+    wv = wrap value
+    self[key] = wv
+  end
+
+  def wrap(value)
+    case value
+    when InsensitiveHash
+      value.tap { |ih| ih.safe = safe? }
+    when Hash
+      self.class.new.tap do |ih|
+        ih.safe = safe?
+        ih.merge_recursive!(value)
+      end
+    when Array
+      value.map { |v| wrap v }
+    else
+      value
+    end
+  end
+
+  def lookup_key(key, delete = false)
+    @key_map = {} if @key_map.nil?
+    ekey = encode key
+    if @key_map.key?(ekey)
+      delete ? @key_map.delete(ekey) : @key_map[ekey]
+    else
+      key
+    end
+  end
+
+  def encode(key)
+    case key
+    when String, Symbol
+      key.to_s.downcase.gsub(' ', '_')
+    else
+      key
+    end
+  end
+
+  def detect_clash(hash)
+    return unless @safe
+
+    hash.keys.map { |k| encode k }.tap do |ekeys|
+      raise KeyClashError, 'Key clash detected' if ekeys != ekeys.uniq
+    end
+  end
+end

data/lib/insensitive_hash/minimal.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'insensitive_hash/version'
+require 'insensitive_hash/insensitive_hash'

data/lib/insensitive_hash/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# :nodoc:
+class InsensitiveHash < Hash
+  VERSION = '0.4.0'
+end

data/test/test_insensitive_hash.rb

@@ -0,0 +1,572 @@
+# frozen_string_literal: true
+
+$VERBOSE = true
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, :development)
+require 'test/unit'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'insensitive_hash'
+require 'yaml'
+
+class TestInsensitiveHash < Test::Unit::TestCase
+  def eight?
+    RUBY_VERSION =~ /^1\.8\./
+  end
+
+  def assert_keys set1, set2
+    if eight?
+      assert_equal(set1.sort { |a, b| a.to_s <=> b.to_s }, set2.sort { |a, b| a.to_s <=> b.to_s })
+    else
+      assert_equal set1, set2
+    end
+  end
+
+  def test_has_key_set
+    ih = InsensitiveHash.new
+    ih['a'] = 1
+    ih.store 'A', 2
+
+    ['a', 'A', :a, :A].each do |a|
+      assert       ih.has_key?(a)
+      assert       ih.key?(a)
+      assert       ih.include?(a)
+      assert       ih.member?(a)
+      assert_equal 2, ih[a]
+    end
+
+    assert_keys  ['A'], ih.keys
+    assert_equal [2], ih.values
+
+    ih[:A] = 4
+    assert_keys  [:A], ih.keys
+    assert_equal [4], ih.values
+
+    ih[:b] = { :c => 5 }
+    assert          ih.keys.include?(:A)
+    assert          ih.keys.include?(:b)
+    assert_equal 2, ih.keys.length
+    assert_equal({ :c => 5 }, ih['B'])
+    assert_equal 5, ih['B'][:c]
+    assert_equal nil, ih['B']['C']
+
+    ih['c'] = [{ 'x' => 1 }, { :y => 2 }]
+    assert       ih.keys.include?('c')
+    assert_equal 3, ih.keys.length
+
+    assert_equal nil, ih[:c].first[:x]
+    assert_equal nil, ih[:c].last['Y']
+
+    ih = ih.insensitive
+    assert_equal 1, ih[:c].first[:x]
+    assert_equal 2, ih[:c].last['Y']
+
+    # Deeeeeper nesting
+    ih['c'] = [[[{ 'x' => 1 }, { :y => 2 }]]]
+    assert_equal nil, ih[:c].first.first.last[:Y]
+    ih = ih.insensitive
+    assert_equal 2, ih[:c].first.first.last[:Y]
+
+    ih['c'] = { 'a' => { 'a' => { 'a' => 100 } } }.insensitive
+    assert_equal 100, ih[:C][:a][:A]['A']
+
+    ih[5] = 50
+    assert_equal 50, ih[5]
+  end
+
+  def test_from_hash
+    hash = {
+      'a' => 1,
+      'B' => 2,
+      :c  => { :D => [{ 'e' => 3 }] }
+    }
+
+    pend('TODO') do
+      assert_raise(NoMethodError) { hash.insensitive }
+    end
+
+    [hash.insensitive, InsensitiveHash[hash]].each do |ih|
+      assert       ih.is_a?(Hash)
+      assert_equal InsensitiveHash, ih.class
+      ['c', 'C', :c, :C].each do |c|
+        assert_equal InsensitiveHash, ih[c].class
+
+        ['d', 'D', :d, :D].each do |d|
+          assert_equal InsensitiveHash, ih[c][d].first.class
+        end
+      end
+    end
+
+    # Changelog 0.3.0
+    ih = {}.insensitive
+    ih[:a] = { :b => :c }
+    assert_nil ih[:a]['B']
+    ih2 = ih.insensitive
+    assert_equal :c, ih2[:a]['B']
+
+    # InsensitiveHash#insensitive
+    ihash1 = hash.insensitive
+    ihash1.default = :default
+    ihash2 = ihash1.insensitive.insensitive.insensitive
+
+    assert_equal InsensitiveHash, ihash2.class
+    assert_equal :default, ihash2.default
+
+    # Preserving default
+    [:default, nil].each do |d|
+      hash.default = d
+      assert_equal d, hash.insensitive.insensitive.insensitive[:anything]
+    end
+
+    # Preserving default_proc
+    unless eight?
+      hash2 = {}
+      hash2.replace hash
+      hash2.default_proc = proc { |h, k| h[k] = :default }
+
+      ihash2 = hash2.insensitive.insensitive.insensitive
+      assert !ihash2.has_key?(:anything)
+      assert_equal :default, ihash2[:anything]
+      assert ihash2.has_key?(:anything)
+    end
+
+    # FIXME: test insensitive call with encoder
+    h = InsensitiveHash[{ 'Key with spaces' => 1 }]
+    h2 = h.insensitive
+
+    assert_equal 1, h['key with spaces']
+    assert_equal 1, h[:key_with_spaces]
+    assert_equal 1, h2[:KEY_WITH_SPACES]
+    assert_equal 1, h2[:Key_with_spaces]
+
+    assert_equal ['Key with spaces'], h.keys
+    assert_equal ['Key with spaces'], h2.keys
+
+    h = { 'A key with spaces' => true }
+    ih = h.insensitive
+    assert ih[:a_key_with_spaces]
+
+    # FIXME: from README
+    ih = InsensitiveHash[h]
+    assert ih[:a_key_with_spaces]
+
+    # :safe
+    ih = {}.insensitive
+    assert_raise(ArgumentError) { ihs = {'a' => 1}.insensitive(:safe => 1) }
+    ihs = {'a' => 1}.insensitive(:safe => true)
+    assert !ih.safe?
+    assert ihs.safe?
+
+    assert_raise(InsensitiveHash::KeyClashError) { ihs.merge(:a => 2, 'A' => 3) }
+  end
+
+  def test_delete
+    ih = InsensitiveHash[:a => 1]
+    assert_equal [:a], ih.keys
+    assert_equal [1], ih.values
+
+    assert_equal nil, ih.delete('B')
+    assert_equal 1, ih.delete('A')
+    assert_equal :notfound, ih.delete('A') { |a| :notfound }
+    assert_equal [], ih.keys
+  end
+
+  def test_merge
+    %i[merge update].each do |method|
+      ih = InsensitiveHash[:a => 1, 'hello world' => 2]
+      nh = { :d => :e }
+      ih2 = ih.send(method, :b => 2, :c => nh)
+
+      assert_keys [:a, 'hello world'], ih.keys
+      assert_keys [:a, 'hello world', :b, :c], ih2.keys
+      assert ih2.has_key?('B'), 'correctly merged another hash'
+      # No recursive merge
+      assert_equal :e, ih2[:c][:d]
+      assert_equal nil, ih2[:c][:D]
+      assert_equal nh.object_id, ih2[:c].object_id
+
+      assert_equal 2, ih[:hello_world]
+      assert_equal 2, ih.send(method, :b => 2)[:hello_world]
+
+      ih.default = 10
+      assert_equal 10, ih.send(method, :b => 2)[:anything]
+
+      ih.default = nil
+      assert_nil ih.send(method, :b => 2)[:anything]
+
+      unless eight?
+        ih.default_proc = proc { |h, k| h[k] = :default }
+        mh = ih.send(method, :b => 2)
+        assert       !mh.has_key?(:anything)
+        assert_equal :default, mh[:anything]
+        assert        mh.has_key?(:anything)
+      end
+
+      ih2.delete 'b'
+      assert ih2.has_key?('B') == false
+    end
+  end
+
+  def test_merge!
+    %i[merge! update!].each do |method|
+      ih = InsensitiveHash[:a => 1]
+      ih2 = ih.send(method, :b => 2)
+
+      assert_keys [:a, :b], ih.keys
+      assert_keys [:a, :b], ih2.keys
+      assert ih2.has_key?('B'), 'correctly merged another hash'
+
+      ih2.delete 'b'
+      assert ih2.has_key?('B') == false
+    end
+  end
+
+  def test_merge_recursive!
+    %i[merge_recursive! update_recursive!].each do |method|
+      ih = InsensitiveHash.new
+      ih[:a] = 1
+      ih[:b] = 2
+
+      nh = { 'b' => 3, :c => :d }
+      ih.send(method, nh)
+      assert_equal 3, ih[:b]
+      assert_equal :d, ih['C']
+
+      ih.safe = true
+      nh = { 'd' => 4, 'D' => 5 }
+      assert_raise(InsensitiveHash::KeyClashError) { ih.send(method, nh) }
+      ih.safe = false
+      ih.send(method, nh)
+    end
+  end
+
+  def test_merge_clash_overwritten
+    ih = InsensitiveHash.new
+
+    ih = ih.merge(:a => 1, :A =>2)
+    # No guarantee in order in 1.8
+    unless eight?
+      assert_equal 2, ih.values.first
+      assert_equal 2, ih['A']
+    end
+    assert_equal 1, ih.length
+
+    ih = InsensitiveHash.new
+    ih.merge!(:hello_world => 1, 'hello world' => 2)
+    unless eight?
+      assert_equal 2, ih.values.first
+      assert_equal 2, ih[:Hello_World]
+    end
+    assert_equal 1, ih.length
+  end
+
+  def test_merge_clash
+    ih = InsensitiveHash.new
+    ih2 = InsensitiveHash.new
+
+    sih = InsensitiveHash.new
+    sih.safe = true
+
+    %i[merge merge! update update!].each do |method|
+      # No problem
+      [ih, ih2].each do |h|
+        h.send(method, { :a => 1, :A => 1, 'A' => 1})
+        h.send(method, { 'a' => 1, 'A' => 1 })
+      end
+
+      assert_raise(InsensitiveHash::KeyClashError) {
+        sih.send(method, { :a => 1, :A => 1, 'A' => 1})
+      }
+      assert_raise(InsensitiveHash::KeyClashError) {
+        sih.send(method, { 'a' => 1, 'A' => 1 })
+      }
+
+      assert_raise(InsensitiveHash::KeyClashError) {
+        sih.send(method, { :hello_world => 1, 'hello world' => 2})
+      }
+      ih2.send(method, { :hello_world => 1, 'hello world' => 2})
+    end
+
+    ih.merge({ :a => 1, :A => 1, 'A' => 1})
+    assert_raise(InsensitiveHash::KeyClashError) {
+      sih.merge({ :a => 1, :A => 1, 'A' => 1})
+    }
+  end
+
+  def test_assoc
+    pend "1.8" if eight?
+
+    h = InsensitiveHash[{
+      'colors'  => ['red', 'blue', 'green'],
+      :Letters => ['a', 'b', 'c' ]
+    }]
+    assert_equal [:Letters, ['a', 'b', 'c']], h.assoc('letters')
+    assert_equal ['colors', ['red', 'blue', 'green']], h.assoc(:COLORS)
+  end
+
+  def test_clear_empty?
+    h = InsensitiveHash[:a, 1]
+    h.clear
+    assert_equal [], h.keys
+    assert h.empty?
+  end
+
+  def test_to_hash
+    h = InsensitiveHash[:a, 1, :b, { :c => 2 }]
+    assert_equal 1, h[:A]
+    assert_equal 2, h['B']['C']
+
+    h = h.to_hash
+    assert_equal Hash, h.class
+    assert_equal nil, h[:A]
+    assert_equal 1, h[:a]
+    assert_equal 2, h[:b][:c]
+    pend('TBD: Recursive conversion') do
+      assert_equal nil, h[:b]['C']
+    end
+  end
+
+  def test_compare_by_identity
+    pend 'Not Implemented'
+
+    key = 'a'
+    key2 = 'a'.clone
+    h = InsensitiveHash.new
+    h[key] = 1
+    h[:b] = 2
+
+    assert !h.compare_by_identity?
+
+    assert_equal 1, h['A']
+    assert_equal 2, h[:b]
+    h.compare_by_identity
+
+    assert h.compare_by_identity?
+
+    assert_equal nil, h[key2]
+    assert_equal nil, h[key]
+    assert_equal 2,   h[:B]
+
+    h[key] = 3
+    assert_not_equal 'a'.object_id, key.object_id
+    assert_equal nil, h[key2]
+    assert_equal 3,   h[key]
+  end
+
+  def test_initializer
+    # Hash
+    h = InsensitiveHash[{ :a => 1 }]
+    assert_equal 1, h['A']
+    assert_equal [:a], h.keys
+    assert_equal [1], h.values
+
+    # Pairs
+    h = InsensitiveHash['a', 2, 3, 4]
+    assert_equal 2, h[:a]
+
+    # Wrong number of arguments
+    assert_raise(ArgumentError) { h = InsensitiveHash['a', 2, 3] }
+  end
+
+  def test_default
+    h = InsensitiveHash.new
+    assert_nil h.default
+
+    h = InsensitiveHash.new 'a'
+    assert_equal 'a', h.default
+    assert_equal 'a', h[:not_there]
+
+    h = InsensitiveHash.new { |h, k| h[k] = k == :right ? :ok : nil }
+    assert_equal nil, h.default
+    assert_equal nil, h.default(:wrong)
+    assert_equal :ok, h.default(:right)
+  end
+
+  def test_default_proc_patch
+    h = InsensitiveHash.new { |h, k| k }
+    assert_equal 1, h[1]
+    assert_equal 2, h[2]
+
+    h = InsensitiveHash.new { |h, k| h[k] = [] }
+    h[:abc] << 1
+    h[:abc] << 2
+    h[:abc] << 3
+    assert_equal [1, 2, 3], h[:abc]
+
+    h = InsensitiveHash.new { |h, k| h[k] = {} }
+    h[:abc][:def] = 1
+    h[:abc][:ghi] = { :xyz => true }
+    assert_equal 1, h[:abc][:def]
+    assert_equal true, h[:abc][:ghi][:xyz]
+    assert_equal nil, h[:abc][:ghi][:XYZ] # This shouldn't work anymore from 0.3.0
+
+    h = InsensitiveHash.new
+    h[:abc] = arr = [1, 2, 3]
+    arr << 4
+    assert_equal [1, 2, 3, 4], h[:ABC]
+  end
+
+  def test_delete_if
+    # FIXME: Test passes, but key_map not updated
+    h = InsensitiveHash[:a => 100, :tmp_a => 200, :c => 300]
+    h.delete_if.each { |k, v| k == :tmp_a }
+    assert_keys [:a, :c], h.keys
+  end
+
+  def test_has_key_after_delete
+    set = [:a, :A, 'a', 'A', :b, :B, 'b', 'B']
+    h = InsensitiveHash[:a => 1, :b => 2]
+
+    set.each { |s| assert h.has_key?(s) }
+    h.delete_if { |k, v| true }
+    set.each { |s| assert !h.has_key?(s) }
+  end
+
+  def test_nil
+    h = InsensitiveHash.new(1)
+    h[nil] = 2
+    assert h.has_key?(nil)
+    assert !h.has_key?(:not_there)
+    assert_equal 1, h[:not_there]
+    assert_equal 2, h[nil]
+
+    h = InsensitiveHash[nil => 1]
+    assert_equal :notfound, h.delete('a') { :notfound }
+    assert_equal 1, h.delete(nil) { :notfound }
+  end
+
+  def test_each
+    h = InsensitiveHash[{ :a => 1, :b => 2, :c => 3}]
+    assert_equal 3, h.each.count
+  end
+
+  def test_has_value
+    h = InsensitiveHash[{ :a => 1, :b => 2, :c => 3}]
+    assert h.value?(3)
+  end
+
+  def test_replace
+    h = InsensitiveHash[:a, 1]
+    assert h.has_key?('A')
+
+    h.replace({ :b => 2 })
+
+    assert !h.has_key?('A')
+    assert h.has_key?('B')
+
+    # Default value
+    h.replace(Hash.new(5))
+    assert_equal 5, h[:anything]
+    assert_equal [], h.keys
+
+    # Default proc
+    h.replace(Hash.new { |h, k| h[k] = :default })
+    assert_equal :default, h[:anything]
+    assert_equal [:anything], h.keys
+  end
+
+  def test_rassoc
+    pend "1.8" if eight?
+
+    a = InsensitiveHash[{1=> 'one', 2 => 'two', 3 => 'three', 'ii' => 'two'}]
+    assert_equal [2, 'two'], a.rassoc('two')
+    assert_nil a.rassoc('four')
+  end
+
+  def test_shift
+    h = InsensitiveHash[{:a => 1, :b => 2}]
+    assert_equal [:a, 1], h.shift
+    assert !h.has_key?('A')
+    assert h.has_key?('B')
+  end
+
+  def test_values_at
+    h = InsensitiveHash[{:a => 1, :b => 2}]
+    assert_equal [2, 1], h.values_at('B', :A)
+  end
+
+  def test_fetch
+    h = InsensitiveHash[{:a => 1, :b => 2}]
+    ['a', 'A', :A].each do |k|
+      assert_equal 1, h.fetch(k)
+      assert_equal 1, h.fetch(k) { nil }
+    end
+    assert_equal 3, h.fetch(:c, 3)
+    assert_equal 3, h.fetch(:c) { 3 }
+    assert_raise(eight? ? IndexError : KeyError) { h.fetch('D') }
+  end
+
+  def test_underscore_inheritance
+    h =
+      {
+        'Key with spaces' => {
+          'Another key with spaces' => 1
+        },
+        'Key 2 with spaces' =>
+          InsensitiveHash['Yet another key with spaces' => 2],
+        'Key 3 with spaces' =>
+          InsensitiveHash['Yet another key with spaces' => 3]
+      }.insensitive
+
+    assert_equal 1,     h['key with spaces']['another key with spaces']
+
+    assert_equal 2, h['key 2 with spaces']['yet another key with spaces']
+    assert_equal 2, h['key 2 with spaces'][:yet_another_key_with_spaces]
+
+    assert_equal 3, h['key 3 with spaces']['yet another key with spaces']
+
+    assert_equal 1,    h[:key_with_spaces][:another_key_with_spaces]
+    assert_equal 2,    h[:key_2_with_spaces][:yet_another_key_with_spaces]
+    assert_equal 3,    h[:key_3_with_spaces][:yet_another_key_with_spaces]
+  end
+
+  def test_constructor_default
+    h = InsensitiveHash.new :default
+    assert_equal :default, h[:xxx]
+
+    h = InsensitiveHash.new { :default_from_block }
+    assert_equal :default_from_block, h[:xxx]
+
+    # But not both!
+    assert_raise(ArgumentError) {
+      InsensitiveHash.new(:default) { :default_from_block }
+    }
+  end
+
+  def test_dup_clone
+    a = InsensitiveHash.new
+    a[:key] = :value
+
+    b = a.dup
+    b.delete 'key'
+    assert_nil b[:key]
+
+    assert_equal :value, a[:key]
+
+    c = a.clone
+    c.delete 'KEY'
+    assert_nil c[:key]
+
+    assert_equal :value, a[:key]
+  end
+
+  def test_yaml_serialization
+    hash = { 'hello' => 'Hola' }.insensitive
+
+    yaml = YAML.dump hash
+    assert yaml.is_a? String
+
+    new_hash = YAML.load yaml
+    assert new_hash.is_a? InsensitiveHash
+    assert new_hash.is_a? Hash
+  end
+
+  class MyInsensitiveHash < InsensitiveHash
+  end
+
+  def test_subclassing
+    mih = MyInsensitiveHash[{ 'a' => { 'b' => 3 } }]
+    assert_instance_of MyInsensitiveHash, mih
+    assert_instance_of MyInsensitiveHash, mih['a']
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: insensitive_hash_bxf
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Junegunn Choi
+- Arandi Lopez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-10-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+description: Hash with case-insensitive, Symbol/String-indifferent key access
+email:
+- junegunn.c@gmail.com
+- arandilopez.93@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.markdown
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- insensitive_hash.gemspec
+- lib/insensitive_hash.rb
+- lib/insensitive_hash/insensitive_hash.rb
+- lib/insensitive_hash/minimal.rb
+- lib/insensitive_hash/version.rb
+- test/test_insensitive_hash.rb
+homepage: https://github.com/BoxFactura/insensitive_hash
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Case-insensitive Ruby Hash
+test_files: []