insensitive_hash 0.2.3 → 0.2.4

data/CHANGELOG.markdown

@@ -1,12 +1,16 @@
+### 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 `Insensitive#safe=`
+* Key-clash detection made optional with `InsensitiveHash#safe=`
 * Ruby 1.8 compatibility
 
 ### 0.2.2 / 2012/02/13
 * :underscore option added
-* `Insensitive::KeyClashError` added for safer operations
+* `InsensitiveHash::KeyClashError` added for safer operations
 * Bug fix: Preserve default/default_proc on merge/replace/insensitive
-* Subtle behavioral change in `Insensitive#replace` when called with an ordinary Hash
+* Subtle behavioral change in `InsensitiveHash#replace` when called with an ordinary Hash
 
 ### 0.2.1 / 2012/02/10
 * Bug fix: Insensitive `fetch`

data/README.markdown

@@ -12,23 +12,41 @@ Examples
 --------
 
 ### Instantiation
+
 ```ruby
 require 'insensitive_hash'
 
-# Monkey-patched Hash#insensitive method
-ih = {'abc' => 1, :def => 2}.insensitive
+ih = {}.insensitive
+ih = { 'abc' => 1, :def => 2 }.insensitive
+ih = { 'hello world' => true }.insensitive(:underscore => true)
+  # :underscore option allows ih[:hello_world]
+```
+
+### Instantiation 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 { |h, k| :default_value_from_block }
+
+ih = InsensitiveHash[ 'abc' => 1, :def => 2 ]
+ih = InsensitiveHash[ 'abc', 1, :def, 2 ]
+ih = InsensitiveHash[ [['abc', 1], [:def, 2]] ]
 
-# Or,
-ih = InsensitiveHash[ :abc => 1, 'DEF' => 2 ]
-ih = InsensitiveHash[ :abc, 1, 'DEF', 2 ]
+ih = InsensitiveHash[ 'hello world' => true ].tap { |ih| ih.underscore = true }
+```
+
+### Revert to normal Hash
 
-# Revert to normal Hash
+```ruby
 h = ih.sensitive
 h = ih.to_hash
 ```
 
-If you don't like to have Hash#insensitive method, `require 'insensitive_hash/minimal'`
-
 ### Basic usage
 ```ruby
 ih = InsensitiveHash[:abc => 1, 'DEF' => 2]
@@ -76,16 +94,29 @@ db[:production][:adapter]
 ```ruby
 h = { 'A key with spaces' => true }
 
-ih = h.insensitive :underscore => true
+ih = h.insensitive(:underscore => true)
 ih[:a_key_with_spaces]  # true
 
-# Or,
-ih = InsensitiveHash[ h ]
-ih.underscore = true
+# Or without Hash#insensitive,
+ih = InsensitiveHash[ h ].tap { |ih| ih.underscore = true }
 ih.underscore?          # true
 ih[:a_key_with_spaces]  # true
 ```
 
+### Enabling key-clash detection
+```ruby
+ih = InsensitiveHash.new.tap { |ih| ih.safe = true }
+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
@@ -98,6 +129,6 @@ ih[:a_key_with_spaces]  # true
 
 ## Copyright
 
-Copyright (c) 2011 Junegunn Choi. See LICENSE.txt for
+Copyright (c) 2012 Junegunn Choi. See LICENSE.txt for
 further details.
 

data/lib/insensitive_hash.rb

@@ -7,6 +7,7 @@ class Hash
     InsensitiveHash.new.tap do |ih|
       ih.replace self
       ih.underscore = options[:underscore] if options.has_key?(:underscore)
+      ih.safe       = options[:safe]       if options.has_key?(:safe)
     end
   end
 end

data/lib/insensitive_hash/insensitive_hash.rb

@@ -4,6 +4,7 @@ class InsensitiveHash < Hash
 
   def initialize default = nil, &block
     if block_given?
+      raise ArgumentError.new('wrong number of arguments') unless default.nil?
       super &block
     else
       super
@@ -41,7 +42,7 @@ class InsensitiveHash < Hash
   # @param [Boolean] 
   # @return [Boolean]
   def safe= s
-    raise ArgumentError.new("Not true or false") unless [true, false].include?(s)
+    raise ArgumentError.new("Neither true nor false") unless [true, false].include?(s)
     @safe = s
   end
 
@@ -139,6 +140,18 @@ class InsensitiveHash < Hash
     super *args, &block
   end
 
+  def dup
+    super.tap { |copy|
+      copy.instance_variable_set :@key_map, @key_map.dup
+    }
+  end
+
+  def clone
+    super.tap { |copy|
+      copy.instance_variable_set :@key_map, @key_map.dup
+    }
+  end
+
 private
   def wrap value, us
     case value

data/lib/insensitive_hash/version.rb

@@ -1,3 +1,3 @@
 class InsensitiveHash < Hash
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/test/test_insensitive_hash.rb

@@ -17,7 +17,6 @@ class TestInsensitiveHash < Test::Unit::TestCase
     else
       assert_equal set1, set2
     end
-
   end
 
   def test_has_key_set
@@ -142,6 +141,19 @@ class TestInsensitiveHash < Test::Unit::TestCase
     ih.underscore = true
     assert ih[:a_key_with_spaces]
     assert ih.underscore?
+
+    # :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
@@ -563,7 +575,7 @@ class TestInsensitiveHash < Test::Unit::TestCase
     h['HELLO_world'] = 2
     assert_equal 1, h['HELLO WORLD']
     assert_equal 2, h['HELLO_WORLD']
-    assert_equal ['hello world', 'HELLO_world'], h.keys
+    assert_equal ['hello world', 'HELLO_world'], h.keys unless eight? # Not order-preserving
 
     assert_raise(InsensitiveHash::KeyClashError) { h.underscore = true }
     h.delete('hello world')
@@ -584,5 +596,35 @@ class TestInsensitiveHash < Test::Unit::TestCase
     assert_keys  [:hello_world, 'hello world'], h.keys
     assert_equal 2, h['Hello World']
   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
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: insensitive_hash
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-17 00:00:00.000000000 Z
+date: 2012-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
-  requirement: &2160341260 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,12 @@ dependencies:
         version: 2.3.0
   type: :development
   prerelease: false
-  version_requirements: *2160341260
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
 description: Hash with case-insensitive, Symbol/String-indifferent key access
 email:
 - junegunn.c@gmail.com
@@ -61,10 +66,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: insensitive_hash
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Case-insensitive Ruby Hash
 test_files:
 - test/test_insensitive_hash.rb
-has_rdoc: