hipsterhash 0.0.1 → 0.0.2

data/hipsterhash.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |gem|
   gem.name          = "hipsterhash"
-  gem.version       = "0.0.1"
+  gem.version       = "0.0.2"
   gem.authors       = ["Bryan JJ Buckley"]
   gem.email         = ["jjbuckley@gmail.com"]
   gem.description   = %q{A hash which is all, like, whatever.}

data/lib/hipster_hash.rb

@@ -1,17 +1,54 @@
 # -*- encoding : utf-8 -*-
-require 'active_support/hash_with_indifferent_access'
 require 'active_support/core_ext/string/inflections'
 
 # A HipsterHash is like a regular Hash, except the keys are semi case
 # insensitive, and symbols and strings are equivalent. Therefore, :foo_bar,
 # :FooBar, and "foo_bar" are considered to be the same key.
-class HipsterHash < HashWithIndifferentAccess
-  def [](key, *extras)
-    super(convert_key(key), *extras)
+class HipsterHash < Hash
+  def initialize(initial = {}, &block)
+    case initial
+    when Hash 
+      super(&block)
+      initial.each { |k, v| self[k] = v }
+    else
+      super
+    end
+  end
+
+  def [](key)
+    convert_value(super(convert_key(key)))
+  end
+
+  def []=(key, value)
+    super(convert_key(key), value)
+  end
+
+  def method_missing(sym, *args, &block)
+    if args.empty? and !block_given?
+      self[sym] || super
+    else
+      super
+    end
   end
 
 protected
   def convert_key(k)
+    self.class.convert_key(k)
+  end
+
+  def self.convert_key(k)
     k.to_s.underscore.to_sym
   end
+
+  def self.convert_value(arg)
+    case arg
+      when Hash then new(arg)
+      when Array then arg.map { |a| convert_value(a) }
+      else arg
+    end
+  end
+
+  def convert_value(arg)
+    self.class.convert_value(arg)
+  end
 end

data/test/hipster_hash_test.rb

@@ -12,12 +12,18 @@ class HipsterHashTest < Test::Unit::TestCase
   end
 
   def test_indifference_to_input_type
-    hh = HipsterHash.new({ :foo => "bar" })
+    hh = HipsterHash.new(:foo => "bar")
     assert_equal "bar", hh["foo"]
     hh['foo'] = "baz"
     assert_equal "baz", hh[:foo]
   end
 
+  def test_nesting
+    hh = HipsterHash.new(:foo => { :bar => :baz })
+    assert_kind_of HipsterHash, hh[:foo]
+    assert_equal :baz, hh["Foo"][:Bar]
+  end
+
   def test_case_indifference
     hh = HipsterHash.new
     hh[:foo_bar] = "bar"
@@ -25,4 +31,21 @@ class HipsterHashTest < Test::Unit::TestCase
     hh['FooBar'] = "baz"
     assert_equal "baz", hh[:foo_bar]
   end
+
+  def test_creation_with_a_hash
+    hh = HipsterHash.new(:foo_bar => "Bar")
+    assert_equal "Bar", hh["FooBar"]
+  end
+
+  def test_subclassing
+    hc = Class.new(HipsterHash)
+    hh = hc.new(:foo_bar => "Baz")
+    assert_equal "Baz", hh["FooBar"]
+  end
+
+  def test_method_missing
+    hh = HipsterHash.new(:Foo => :bar)
+    assert_equal :bar, hh.foo
+    assert_equal :bar, hh.FOO
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hipsterhash
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-14 00:00:00.000000000 Z
+date: 2012-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport