hipsterhash 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bdd5f38b32f9a671fb09d65b478f7f7ef334e286
+  data.tar.gz: 09a15c9f8c71ab5e9688fe8fae12e72ab86c9980
+SHA512:
+  metadata.gz: 8e837e6299ccc72a60bcd331630c4962d5d5783e6a1461cadb12af9c10a20f285dc23bda9df89d58ca490e1b525b3380874e8287600435deec31cad293086821
+  data.tar.gz: fb2bf26f0fcfddc9e96ebc0a3b4ea226887e2285130ea2381e9d4148fec909a6a19816fb5339e65df80213ba9509dcae571a30b808f39ce398a6b88f7c23440f

data/README.md

@@ -24,9 +24,6 @@ hh[:foo_bar] = "Pigs"
 hh["FooBar"] # => "Pigs"
 ```
 
-It uses [ActiveSupport][1] [Inflectors][2] internally, so you can probably muck
-around with them to modify the behaviour.
-
 ## Contributing
 
 1. Fork it
@@ -34,6 +31,3 @@ around with them to modify the behaviour.
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
-
-[1]: https://github.com/rails/rails/tree/master/activesupport/lib/active_support
-[2]: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/inflections.rb

data/Rakefile

@@ -9,4 +9,14 @@ Rake::TestTask.new do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
+desc "Run profiler to see what's slow"
+task :profile do
+  require_relative './test/profile'
+end
+
+desc "Run benchmarks against Hash"
+task :performance do
+  require_relative './test/performance'
+end
+
 task :default => :test

data/hipsterhash.gemspec

@@ -4,11 +4,14 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |gem|
   gem.name          = "hipsterhash"
-  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.}
-  gem.summary       = %q{A HipsterHash is just like a regular ruby Hash, except that it doesn't distinguish between symbols or strings, and the keys are case insensitive.}
+  gem.version       = "0.0.3"
+  gem.authors       = ["bjjb"]
+  gem.email         = ["jj@bjjb.org"]
+  gem.summary       = %q{A Hash which is all, like, whatever.}
+  gem.description   = <<-DESC
+A HipsterHash is just like a regular ruby Hash, except that it doesn't
+distinguish between symbols or strings, and the keys are case insensitive.
+  DESC
   gem.homepage      = "http://jjbuckley.github.com/hipsterhash"
 
   gem.files         = `git ls-files`.split($/)
@@ -16,5 +19,6 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "activesupport"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "minitest-focus"
 end

data/lib/hipster_hash.rb

@@ -1,49 +1,66 @@
 # -*- encoding : utf-8 -*-
-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 < Hash
-  def initialize(initial = {}, &block)
-    case initial
-    when Hash 
-      super(&block)
-      initial.each { |k, v| self[k] = v }
-    else
-      super
+
+  alias store! store
+
+  def store(key, value)
+    memoize(key) do
+      k, v = convert_key(key), convert_value(value)
+      store!(k, v)
     end
   end
 
+  def []=(key, value)
+    memoize(key) do
+      k, v = convert_key(key), convert_value(value)
+      store!(k, v)
+    end
+  end
+
+  def fetch(key)
+    super rescue super(convert_key(key)).tap { |v| store!(key, v) }
+  end
+
   def [](key)
-    convert_value(super(convert_key(key)))
+    super || super(convert_key(key)).tap { |v| store!(key, v) }
   end
 
-  def []=(key, value)
-    super(convert_key(key), value)
+  def key?(sym)
+    super || super(convert_key(sym))
   end
 
-  def method_missing(sym, *args, &block)
-    if args.empty? and !block_given?
-      self[sym] || super
-    else
-      super
-    end
+  def self.[](*args)
+    new.tap { |hh| Hash[*args].each { |k, v| hh.store(k, v) } }
   end
 
 protected
-  def convert_key(k)
-    self.class.convert_key(k)
+  
+  def method_missing(sym, *args, &block)
+    return super if block_given?
+    return store(sym[0...-1], args.first) if sym[-1] == '=' and args.length == 1
+    return fetch(sym) if args.empty? and key?(sym)
+    super
   end
 
-  def self.convert_key(k)
-    k.to_s.underscore.to_sym
+  def converted_keys
+    @converted_keys ||= Hash.new do |h, k|
+      h[k] = underscore(k.to_s).to_sym
+    end
+  end
+
+  def convert_key(k)
+    converted_keys[k]
   end
 
   def self.convert_value(arg)
     case arg
-      when Hash then new(arg)
-      when Array then arg.map { |a| convert_value(a) }
+      when self then arg
+      when Hash then self[arg]
+      when Array then arg.map { |x| convert_value(x) }
       else arg
     end
   end
@@ -51,4 +68,20 @@ protected
   def convert_value(arg)
     self.class.convert_value(arg)
   end
+
+  def underscore(s)
+    s.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+  end
+
+  def memoize(sym, &block)
+    yield.tap do |x|
+      eigenklass.class_eval { define_method(:"#{sym}") { x } } unless @@unmemoizable.key?(convert_key(sym))
+    end
+  end
+
+  def eigenklass
+    @eigenklass ||= (class << self; self; end)
+  end
+
+  @@unmemoizable = Hash[[methods + instance_methods].flatten.uniq.zip([])]
 end

data/lib/hipsterhash.rb

@@ -1,2 +1,2 @@
 # -*- encoding : utf-8 -*-
-require 'hipster_hash'
+require_relative './hipster_hash'

data/test/hipster_hash_test.rb

@@ -1,51 +1,139 @@
 # -*- encoding : utf-8 -*-
-require 'test/unit'
-require File.expand_path('../../lib/hipster_hash', __FILE__)
+require 'test_helper'
+require 'hipster_hash'
 
-class HipsterHashTest < Test::Unit::TestCase
-  def test_normal_behaviour
+describe HipsterHash do
+  it "acts like a hash" do
     hh = HipsterHash.new
-    hh["foo"] = "bar"
-    assert_kind_of Hash, hh
-    assert_equal "bar", hh[:foo]
-    assert_nil hh[:pigs]
+    hh.must_be_kind_of Hash
+    hh.store(:foo, :bar)
+    hh.fetch(:foo).must_equal :bar
+    hh[:bar] = 123
+    hh[:bar].must_equal 123
+    hh.keys.must_equal [:foo, :bar]
+    hh.delete(:foo).must_equal :bar
+    hh.keys.must_equal [:bar]
+    lambda { hh.fetch(:foo) }.must_raise KeyError
+    lambda { hh.fetch('foo') }.must_raise KeyError
+    lambda { hh.fetch('Foo') }.must_raise KeyError
+    hh[:foo].must_be_nil
+    hh = HipsterHash[:foo, 123, :bar, 234]
+    hh[:foo].must_equal 123
+    hh[:bar].must_equal 234
+    hh.fetch(:foo).must_equal 123
+    hh.fetch('foo').must_equal 123
+    hh.fetch('Foo').must_equal 123
+    hh = HipsterHash[[[:foo, 123], [:bar, 234]]]
+    hh[:foo].must_equal 123
+    hh[:bar].must_equal 234
+    hh = HipsterHash[{foo: 123, bar: 234}]
+    hh[:foo].must_equal 123
+    hh[:bar].must_equal 234
+    hh[:bar] = 77
+    hh[:bar].must_equal 77
   end
 
-  def test_indifference_to_input_type
-    hh = HipsterHash.new(:foo => "bar")
-    assert_equal "bar", hh["foo"]
-    hh['foo'] = "baz"
-    assert_equal "baz", hh[:foo]
+  it "treats symbols and strings equally" do
+    hh = HipsterHash[foo: "bar"]
+    hh.keys.must_equal [:foo]
+    hh.key?(:foo).must_equal true
+    hh.foo.must_equal "bar"
+    hh['foo'] = 'baz'
+    hh.keys.must_equal [:foo]
+    hh[:foo].must_equal "baz"
   end
 
-  def test_nesting
-    hh = HipsterHash.new(:foo => { :bar => :baz })
-    assert_kind_of HipsterHash, hh[:foo]
-    assert_equal :baz, hh["Foo"][:Bar]
+  it "handles nested hashes" do
+    hh = HipsterHash[foo: { bar: :baz }]
+    hh.foo.must_be_kind_of HipsterHash
+    hh["Foo"][:Bar].must_equal :baz
   end
 
-  def test_case_indifference
+  it "handles nested arrays" do
+    hh = HipsterHash[{foo: { bar: [ { baz: 1 } ] }}]
+    hh.foo.must_be_kind_of HipsterHash
+    hh.foo.bar[0].baz.must_equal 1
+    hh = HipsterHash[{"foo" => { "bar" => [ { "baz" => 1 } ] }}]
+    hh.foo.bar[0].baz.must_equal 1
+  end
+
+  it "is indifferent to case" do
     hh = HipsterHash.new
     hh[:foo_bar] = "bar"
-    assert_equal "bar", hh["FooBar"]
+    hh["FooBar"].must_equal "bar"
     hh['FooBar'] = "baz"
-    assert_equal "baz", hh[:foo_bar]
+    hh[:foo_bar].must_equal "baz"
   end
 
-  def test_creation_with_a_hash
-    hh = HipsterHash.new(:foo_bar => "Bar")
-    assert_equal "Bar", hh["FooBar"]
+  it "can be inherited" do
+    hc = Class.new(HipsterHash)
+    hh = hc[foo_bar: "Baz"]
+    hh[:foo_bar].must_equal "Baz"
+    hh[:FooBar].must_equal "Baz"
+    hh["FooBar"].must_equal "Baz"
+    hh["foo_bar"].must_equal "Baz"
+    hh.foo_bar.must_equal "Baz"
   end
 
-  def test_subclassing
-    hc = Class.new(HipsterHash)
-    hh = hc.new(:foo_bar => "Baz")
-    assert_equal "Baz", hh["FooBar"]
+  it "acts like an openstruct" do
+    hh = HipsterHash[:foo, 123]
+    hh.bar = 234
+    hh.foo.must_equal 123
+    hh.bar.must_equal 234
+    lambda { hh.baz }.must_raise NoMethodError
+    hh[:foo] = "bar"
+    hh.foo.must_equal "bar"
+    hh.foo = "baz"
+    hh.foo.must_equal "baz"
+    hh.store("foo", "bpb")
+    hh.foo.must_equal "bpb"
+    hh2 = HipsterHash[:foo, 999]
+    hh2.foo.must_equal 999
+    hh.foo.must_equal "bpb"
+  end
+
+  it "doesn't break if you use a special method name" do
+    hh = HipsterHash.new
+    hh[:foo] = 1
+    hh.foo.must_equal 1
+    m = hh.method(:[])
+    hh['[]'] = "blah"
+    hh.method(:[]).must_equal m
+    hh.foo.must_equal 1
+    hh['[]'].must_equal "blah"
+    hh.eigenklass = "blah"
+    hh.foo.must_equal 1
+    hh.foo = 2
+    hh.foo.must_equal 2
+  end
+
+  it "doesn't break with funny keys" do
+    hh = HipsterHash.new
+    hh[0] = 1
+    hh[0].must_equal 1
+    hh[":blah"] = 99
+    hh.send(":blah").must_equal 99
+    hh[nil] = "klm"
+    hh[nil].must_equal "klm"
+    hh[:'→'] = "arrow"
+    hh.send('→').must_equal 'arrow'
   end
 
-  def test_method_missing
-    hh = HipsterHash.new(:Foo => :bar)
-    assert_equal :bar, hh.foo
-    assert_equal :bar, hh.FOO
+  describe "key conversion" do
+    it "leaves underscored symbols alone" do
+      convert(:foo).must_equal :foo
+    end
+    it "converts underscored strings to symbols" do
+      convert("foo").must_equal :foo
+    end
+    it "underscores camelcase symbols" do
+      convert(:FooBar).must_equal :foo_bar
+    end
+    it "underscores and symbolizes camelcased strings" do
+      convert("FooBar").must_equal :foo_bar
+    end
+    def convert(k)
+      HipsterHash.new.send(:convert_key, k)
+    end
   end
 end

data/test/performance.rb

@@ -0,0 +1,16 @@
+#! /usr/bin/env ruby -w
+require 'benchmark'
+require_relative '../lib/hipsterhash'
+
+h = { foo: { bar: { x: "123", y: [ 1, 2, 3 ] } }, baz: "123" }
+hh = HipsterHash[h.dup]
+
+n = 1000000
+Benchmark.bmbm do |x|
+  x.report("Hash#[]                   ") { n.times { h[:foo][:bar][:x] } }
+  x.report("HipsterHash#[]            ") { n.times { hh[:foo][:bar][:x] } }
+  x.report("Hash#fetch                ") { n.times { h.fetch(:foo).fetch(:bar).fetch(:x) } }
+  x.report("HipsterHash#fetch         ") { n.times { hh.fetch(:foo).fetch(:bar).fetch(:x) } }
+  x.report("HipsterHash#fetch2        ") { n.times { hh.fetch(:"Foo").fetch(:"Bar").fetch(:"X") } }
+  x.report("HipsterHash#method_missing") { n.times { hh.foo.bar.x } }
+end

data/test/profile.rb

@@ -0,0 +1,12 @@
+#! /usr/bin/env ruby -w
+
+require_relative '../lib/hipsterhash'
+
+
+require 'profile'
+hh = HipsterHash[foo: { bar: { x: "123" } }]
+
+n = 1000
+n.times do
+  hh.foo["Bar"].x
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'minitest/autorun'
+require 'minitest/focus'

metadata

@@ -1,40 +1,53 @@
 --- !ruby/object:Gem::Specification
 name: hipsterhash
 version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+  version: 0.0.3
 platform: ruby
 authors:
-- Bryan JJ Buckley
+- bjjb
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-22 00:00:00.000000000 Z
+date: 2014-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A hash which is all, like, whatever.
+- !ruby/object:Gem::Dependency
+  name: minitest-focus
+  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'
+description: |
+  A HipsterHash is just like a regular ruby Hash, except that it doesn't
+  distinguish between symbols or strings, and the keys are case insensitive.
 email:
-- jjbuckley@gmail.com
+- jj@bjjb.org
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -43,30 +56,34 @@ files:
 - lib/hipster_hash.rb
 - lib/hipsterhash.rb
 - test/hipster_hash_test.rb
+- test/performance.rb
+- test/profile.rb
+- test/test_helper.rb
 homepage: http://jjbuckley.github.com/hipsterhash
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
-summary: A HipsterHash is just like a regular ruby Hash, except that it doesn't distinguish
-  between symbols or strings, and the keys are case insensitive.
+specification_version: 4
+summary: A Hash which is all, like, whatever.
 test_files:
 - test/hipster_hash_test.rb
+- test/performance.rb
+- test/profile.rb
+- test/test_helper.rb