hwia 1.0.2

data/README

@@ -0,0 +1,93 @@
+Attempt at a zippier HashWithIndifferentAccess for Ruby MRI
+  (c) 2009 Lourens Naudé (methodmissing), James Tucker (raggi)
+
+  http://github.com/methodmissing/hwia
+
+This library works with Ruby MRI > 1.8.6 && 1.9.2 and is a more efficient implementation of
+ActiveSupport::HashWithIndifferentAccess, which allows interchangeable use of string and symbol
+hash keys.
+
+The numbers ?
+
+  methodmissing:hwia lourens$ rake bench
+  (in /Users/lourens/projects/hwia)
+  /opt/local/bin/ruby extconf.rb
+  checking for rb_thread_blocking_region()... no
+  checking for rb_trap_immediate in ruby.h,rubysig.h... yes
+  creating Makefile
+  make
+  gcc -I. -I. -I/opt/local/lib/ruby/1.8/i686-darwin9.5.1 -I. -DHAVE_RB_TRAP_IMMEDIATE -DRUBY18    -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE   -fno-common -O2 -pipe -fno-common   -c hwia.c
+  cc -dynamic -bundle -undefined suppress -flat_namespace -o hwia.bundle hwia.o -L. -L/opt/local/lib -L.     -ldl -lobjc  
+  /opt/local/bin/ruby bench/bench.rb
+  Rehearsal ------------------------------------------------------------------------------
+  StrHash#[:sym]                               0.000000   0.000000   0.000000 (  0.002999)
+  HashWithIndifferentAccess#[:sym]             0.020000   0.000000   0.020000 (  0.021942)
+  StrHash#['str']                              0.010000   0.000000   0.010000 (  0.004590)
+  HashWithIndifferentAccess#['str]             0.000000   0.000000   0.000000 (  0.003842)
+  StrHash#key?(:sym)                           0.010000   0.000000   0.010000 (  0.002902)
+  HashWithIndifferentAccess#key?(:sym)         0.010000   0.000000   0.010000 (  0.013906)
+  StrHash#key?('str')                          0.000000   0.000000   0.000000 (  0.004245)
+  HashWithIndifferentAccess#key?('str')        0.010000   0.000000   0.010000 (  0.010769)
+  StrHash#fetch(:sym)                          0.010000   0.000000   0.010000 (  0.003285)
+  HashWithIndifferentAccess#fetch(:sym)        0.020000   0.000000   0.020000 (  0.019375)
+  StrHash#fetch('str')                         0.000000   0.000000   0.000000 (  0.003811)
+  HashWithIndifferentAccess#fetch('str')       0.010000   0.000000   0.010000 (  0.014550)
+  StrHash#values_at(:sym)                      0.010000   0.000000   0.010000 (  0.006830)
+  HashWithIndifferentAccess#values_at(:sym)    0.020000   0.000000   0.020000 (  0.020391)
+  StrHash#values_at('str')                     0.010000   0.000000   0.010000 (  0.007286)
+  HashWithIndifferentAccess#values_at('str')   0.020000   0.000000   0.020000 (  0.019495)
+  StrHash#['str']=                             0.000000   0.000000   0.000000 (  0.004249)
+  HashWithIndifferentAccess#['str]=            0.020000   0.000000   0.020000 (  0.017406)
+  StrHash#[:sym]=                              0.000000   0.000000   0.000000 (  0.003898)
+  HashWithIndifferentAccess#[:sym]=            0.020000   0.000000   0.020000 (  0.020366)
+  StrHash#update                               0.010000   0.000000   0.010000 (  0.005549)
+  HashWithIndifferentAccess#update             0.050000   0.000000   0.050000 (  0.058935)
+  StrHash#dup                                  0.030000   0.000000   0.030000 (  0.029752)
+  HashWithIndifferentAccess#dup                0.120000   0.000000   0.120000 (  0.128600)
+  StrHash#merge                                0.030000   0.000000   0.030000 (  0.027572)
+  HashWithIndifferentAccess#merge              0.180000   0.000000   0.180000 (  0.179814)
+  StrHash#to_hash                              0.030000   0.000000   0.030000 (  0.034352)
+  HashWithIndifferentAccess#to_hash            0.040000   0.000000   0.040000 (  0.038520)
+  --------------------------------------------------------------------- total: 0.690000sec
+
+                                                   user     system      total        real
+  StrHash#[:sym]                               0.010000   0.000000   0.010000 (  0.003005)
+  HashWithIndifferentAccess#[:sym]             0.020000   0.000000   0.020000 (  0.020551)
+  StrHash#['str']                              0.000000   0.000000   0.000000 (  0.003312)
+  HashWithIndifferentAccess#['str]             0.000000   0.000000   0.000000 (  0.003213)
+  StrHash#key?(:sym)                           0.000000   0.000000   0.000000 (  0.002851)
+  HashWithIndifferentAccess#key?(:sym)         0.010000   0.000000   0.010000 (  0.012139)
+  StrHash#key?('str')                          0.010000   0.000000   0.010000 (  0.003496)
+  HashWithIndifferentAccess#key?('str')        0.010000   0.000000   0.010000 (  0.009912)
+  StrHash#fetch(:sym)                          0.000000   0.000000   0.000000 (  0.003172)
+  HashWithIndifferentAccess#fetch(:sym)        0.020000   0.000000   0.020000 (  0.017662)
+  StrHash#fetch('str')                         0.000000   0.000000   0.000000 (  0.003850)
+  HashWithIndifferentAccess#fetch('str')       0.020000   0.000000   0.020000 (  0.014771)
+  StrHash#values_at(:sym)                      0.000000   0.000000   0.000000 (  0.004340)
+  HashWithIndifferentAccess#values_at(:sym)    0.030000   0.000000   0.030000 (  0.020821)
+  StrHash#values_at('str')                     0.000000   0.000000   0.000000 (  0.004842)
+  HashWithIndifferentAccess#values_at('str')   0.020000   0.000000   0.020000 (  0.017479)
+  StrHash#['str']=                             0.010000   0.000000   0.010000 (  0.004225)
+  HashWithIndifferentAccess#['str]=            0.010000   0.000000   0.010000 (  0.018206)
+  StrHash#[:sym]=                              0.010000   0.000000   0.010000 (  0.003825)
+  HashWithIndifferentAccess#[:sym]=            0.020000   0.000000   0.020000 (  0.019323)
+  StrHash#update                               0.000000   0.000000   0.000000 (  0.005478)
+  HashWithIndifferentAccess#update             0.050000   0.000000   0.050000 (  0.048082)
+  StrHash#dup                                  0.030000   0.000000   0.030000 (  0.023855)
+  HashWithIndifferentAccess#dup                0.110000   0.000000   0.110000 (  0.120992)
+  StrHash#merge                                0.030000   0.000000   0.030000 (  0.027412)
+  HashWithIndifferentAccess#merge              0.180000   0.000000   0.180000 (  0.173209)
+  StrHash#to_hash                              0.030000   0.000000   0.030000 (  0.034561)
+  HashWithIndifferentAccess#to_hash            0.030000   0.000000   0.030000 (  0.025392)
+
+Installation
+
+  1. sudo gem install methodmissing-hwia
+  2. 'require "hwia_rails"' from within an initializer
+  
+  There's no step three, however, if the gem hasn't built due to github queue delays today (22/08/2009), clone, 'rake gem' and install.
+
+It's unlikely you'd see these improvements for most apps as at the framework level, especially for Rails 3.0, 
+this mostly negates query params access overheads.Any pointers and refactoring suggestions much appreciated.
+
+Have fun, happy hacking! 

data/Rakefile

@@ -0,0 +1,73 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+
+HWIA_ROOT = 'ext/hwia'
+
+desc 'Default: test'
+task :default => :test
+
+desc 'Run hwia tests.'
+Rake::TestTask.new(:test) do |t|
+  t.libs = [HWIA_ROOT]
+  t.pattern = 'test/test_*.rb'
+  t.verbose = true
+end
+task :test => :build
+
+namespace :build do
+  file "#{HWIA_ROOT}/hwia.c"
+  file "#{HWIA_ROOT}/extconf.rb"
+  file "#{HWIA_ROOT}/Makefile" => %W(#{HWIA_ROOT}/hwia.c #{HWIA_ROOT}/extconf.rb) do
+    Dir.chdir(HWIA_ROOT) do
+      ruby 'extconf.rb'
+    end
+  end
+
+  desc "generate makefile"
+  task :makefile => %W(#{HWIA_ROOT}/Makefile #{HWIA_ROOT}/hwia.c)
+
+  dlext = Config::CONFIG['DLEXT']
+  file "#{HWIA_ROOT}/hwia.#{dlext}" => %W(#{HWIA_ROOT}/Makefile #{HWIA_ROOT}/hwia.c) do
+    Dir.chdir(HWIA_ROOT) do
+      sh 'make' # TODO - is there a config for which make somewhere?
+    end
+  end
+
+  desc "compile hwia extension"
+  task :compile => "#{HWIA_ROOT}/hwia.#{dlext}"
+
+  task :clean do
+    Dir.chdir(HWIA_ROOT) do
+      sh 'make clean'
+    end if File.exists?("#{HWIA_ROOT}/Makefile")
+  end
+
+  CLEAN.include("#{HWIA_ROOT}/Makefile")
+  CLEAN.include("#{HWIA_ROOT}/hwia.#{dlext}")
+end
+
+task :clean => %w(build:clean)
+
+desc "compile"
+task :build => %w(build:compile)
+
+task :install do |t|
+  Dir.chdir(HWIA_ROOT) do
+    sh 'sudo make install'
+  end
+end
+
+desc "clean build install"
+task :setup => %w(clean build install)
+
+desc "run benchmarks"
+task :bench do
+  ruby "bench/bench.rb"
+end
+task :bench => :build
+
+desc "build gem"
+task :gem do
+  sh "gem build hwia.gemspec"
+end

data/bench/as_hwia.rb

@@ -0,0 +1,137 @@
+# This class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+# and they get the same value for both keys.
+
+module ActiveSupport
+  class HashWithIndifferentAccess < Hash
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    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 = HashWithIndifferentAccess.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    # Updates the instantized hash with values from the second:
+    #
+    #   hash_1 = HashWithIndifferentAccess.new
+    #   hash_1[:key] = "value"
+    #
+    #   hash_2 = HashWithIndifferentAccess.new
+    #   hash_2[:key] = "New Value!"
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    def update(other_hash)
+      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = HashWithIndifferentAccess.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?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = HashWithIndifferentAccess.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 an exact copy of the hash.
+    def dup
+      HashWithIndifferentAccess.new(self)
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+    def reverse_merge(other_hash)
+      super other_hash.with_indifferent_access
+    end
+
+    def reverse_merge!(other_hash)
+      replace(reverse_merge( other_hash ))
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def symbolize_keys!; self end
+    def to_options!; self end
+
+    # Convert to a Hash with String keys.
+    def to_hash
+      Hash.new(default).merge!(self)
+    end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value)
+        case value
+        when Hash
+          value.with_indifferent_access
+        when Array
+          value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+        else
+          value
+        end
+      end
+  end
+end
+
+HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess

data/bench/bench.rb

@@ -0,0 +1,52 @@
+require "benchmark"
+$:.unshift "." #ruby 1.9.2
+require File.dirname(__FILE__) + "/../ext/hwia/hwia"
+require File.dirname(__FILE__) + "/as_hwia"
+
+STR_HASH = { :a  => 1, 'b' => 2, 1 => 1, [1] => 1 }.strhash
+HWIA_HASH = HashWithIndifferentAccess.new({ :a  => 1, 'b' => 2, 1 => 1, [1] => 1 })
+HASH = { :d => :d, 'e' => :e } 
+
+TESTS = 100_000
+Benchmark.bmbm do |results|
+  results.report("StrHash#[:sym]") { TESTS.times { STR_HASH[:sym] } }
+  results.report("HashWithIndifferentAccess#[:sym]") { TESTS.times { HWIA_HASH[:a] } }   
+  results.report("StrHash#['str']") { TESTS.times { STR_HASH['b'] } }
+  results.report("HashWithIndifferentAccess#['str]") { TESTS.times { HWIA_HASH['b'] } }
+  results.report("StrHash#[1]") { TESTS.times { STR_HASH[1] } }
+  results.report("HashWithIndifferentAccess#[1]") { TESTS.times { HWIA_HASH[1] } }  
+  results.report("StrHash#[[1]]") { TESTS.times { STR_HASH[[1]] } }
+  results.report("HashWithIndifferentAccess#[[1]]") { TESTS.times { HWIA_HASH[[1]] } }  
+  results.report("StrHash#key?(:sym)") { TESTS.times { STR_HASH.key?(:a) } }
+  results.report("HashWithIndifferentAccess#key?(:sym)") { TESTS.times { HWIA_HASH.key?(:a) } }  
+  results.report("StrHash#key?('str')") { TESTS.times { STR_HASH.key?('a') } }
+  results.report("HashWithIndifferentAccess#key?('str')") { TESTS.times { HWIA_HASH.key?('a') } } 
+  results.report("StrHash#fetch(:sym)") { TESTS.times { STR_HASH.fetch(:a) } }
+  results.report("HashWithIndifferentAccess#fetch(:sym)") { TESTS.times { HWIA_HASH.fetch(:a) } }  
+  results.report("StrHash#fetch('str')") { TESTS.times { STR_HASH.fetch('a') } }
+  results.report("HashWithIndifferentAccess#fetch('str')") { TESTS.times { HWIA_HASH.fetch('a') } }  
+  results.report("StrHash#values_at(:sym)") { TESTS.times { STR_HASH.values_at(:a) } }
+  results.report("HashWithIndifferentAccess#values_at(:sym)") { TESTS.times { HWIA_HASH.values_at(:a) } }  
+  results.report("StrHash#values_at('str')") { TESTS.times { STR_HASH.values_at('a') } }
+  results.report("HashWithIndifferentAccess#values_at('str')") { TESTS.times { HWIA_HASH.values_at('a') } }   
+  results.report("StrHash#['str']=") { TESTS.times { STR_HASH['c'] = :c } }
+  results.report("HashWithIndifferentAccess#['str]=") { TESTS.times { HWIA_HASH['c'] = :c } }  
+  results.report("StrHash#[:sym]=") { TESTS.times { STR_HASH[:c] = :c } }
+  results.report("HashWithIndifferentAccess#[:sym]=") { TESTS.times { HWIA_HASH[:c] = :c } }
+  results.report("StrHash#[2]=") { TESTS.times { STR_HASH[2] = 2 } }
+  results.report("HashWithIndifferentAccess#[2]=") { TESTS.times { HWIA_HASH[2] = 2 } } 
+  results.report("StrHash#[[2]]=") { TESTS.times { STR_HASH[[2]] = 2 } }
+  results.report("HashWithIndifferentAccess#[[2]]=") { TESTS.times { HWIA_HASH[[2]] = 2 } }   
+  results.report("StrHash#update") { TESTS.times { STR_HASH.update(HASH) } }
+  results.report("HashWithIndifferentAccess#update") { TESTS.times { HWIA_HASH.update(HASH) } } 
+  results.report("StrHash#dup") { TESTS.times { STR_HASH.dup } }
+  results.report("HashWithIndifferentAccess#dup") { TESTS.times { HWIA_HASH.dup } }   
+  results.report("StrHash#merge") { TESTS.times { STR_HASH.merge(HASH) } }
+  results.report("HashWithIndifferentAccess#merge") { TESTS.times { HWIA_HASH.merge(HASH) } }
+  results.report("StrHash#to_hash") { TESTS.times { STR_HASH.to_hash } }
+  results.report("HashWithIndifferentAccess#to_hash") { TESTS.times { HWIA_HASH.to_hash } }
+  results.report("StrHash#keys") { TESTS.times { STR_HASH.keys } }
+  results.report("HashWithIndifferentAccess#keys") { TESTS.times { HWIA_HASH.keys } } 
+  results.report("StrHash#values") { TESTS.times { STR_HASH.values } }
+  results.report("HashWithIndifferentAccess#values") { TESTS.times { HWIA_HASH.values } }   
+end  

data/ext/hwia/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+
+def add_define(name)
+  $defs.push("-D#{name}")
+end
+
+dir_config('hwia')
+
+add_define 'RUBY19' if have_func('rb_thread_blocking_region') and have_macro('RUBY_UBF_IO', 'ruby.h')
+add_define 'RUBY18' if have_var('rb_trap_immediate', ['ruby.h', 'rubysig.h'])
+
+create_makefile('hwia')

data/ext/hwia/hwia.c

@@ -0,0 +1,497 @@
+#include "ruby.h"
+#ifdef RUBY19
+#include "ruby/st.h"
+#else
+#include "st.h"
+#endif
+
+VALUE rb_cStrHash;
+
+static ID id_strhash, id_hash;
+static VALUE hash_format;
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(obj) RSTRING(obj)->ptr
+#endif
+ 
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(obj) RSTRING(obj)->len
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(obj) RARRAY(obj)->heap.ptr
+#endif
+ 
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(obj) RARRAY(obj)->heap.len
+#endif
+
+#ifdef RUBY19
+#define HASH_TBL(obj) RHASH(obj)->ntbl
+#else
+#define HASH_TBL(obj) RHASH(obj)->tbl
+#endif
+
+static int 
+strhash(register const char *string)
+{
+    register int c;
+    register int val = 0;
+    while ((c = *string++) != '\0') {
+    val = val*997 + c;
+    }
+    return val + (val>>5);
+}
+
+int
+rb_sym_strhash(VALUE *sym)
+{
+    ID id = SYM2ID(*sym);
+    return strhash((char*)rb_id2name(id));
+}
+
+static VALUE
+rb_sym_strhash_m(VALUE sym)
+{
+    return INT2FIX(rb_sym_strhash(&sym));
+}
+
+int
+rb_str_strhash(VALUE *str)
+{
+    return strhash((char*)RSTRING_PTR(*str));
+}
+
+static VALUE
+rb_str_strhash_m(VALUE str)
+{
+    return INT2FIX(rb_str_strhash(&str));
+}
+
+int
+rb_strhash_cmp(VALUE *s1,VALUE *s2)
+{
+    int s1_hash = SYMBOL_P(*s1) ? rb_sym_strhash(s1) : rb_str_strhash(s1);
+    int s2_hash = SYMBOL_P(*s2) ? rb_sym_strhash(s2) : rb_str_strhash(s2);
+    if (s1_hash == s2_hash) return 0;
+    if (s1_hash > s2_hash) return 1;
+    return -1;	
+}
+
+/* hash.c */
+static VALUE
+rb_hash_has_key(hash, key)
+    VALUE hash;
+    VALUE key;
+{
+#ifdef RUBY19
+    if (!HASH_TBL(hash))
+        return Qfalse;
+#endif
+    if (st_lookup(HASH_TBL(hash), key, 0)) {
+    return Qtrue;
+    }
+    return Qfalse;
+}
+
+/* hash.c */
+#ifdef RUBY18
+static VALUE
+eql(VALUE *args)
+{
+    return (VALUE)rb_eql(args[0], args[1]);
+}
+#endif
+
+/* hash.c */
+static int
+rb_strhash_hash_cmp(VALUE a, VALUE b)
+{
+#ifdef RUBY18	
+    VALUE args[2];
+#endif
+    if (a == b) return 0;
+    if (FIXNUM_P(a) && FIXNUM_P(b)) return a != b;
+    if (a == Qundef || b == Qundef) return -1;
+    if (SYMBOL_P(a) && SYMBOL_P(b)) return a != b;
+    if ((TYPE(a) == T_STRING && RBASIC(a)->klass == rb_cString && SYMBOL_P(b)) || (TYPE(b) == T_STRING && RBASIC(b)->klass == rb_cString && SYMBOL_P(a))) {
+    return rb_strhash_cmp(&a, &b);
+    }
+    if (TYPE(a) == T_STRING && RBASIC(a)->klass == rb_cString &&
+    TYPE(b) == T_STRING && RBASIC(b)->klass == rb_cString) {
+    return rb_str_cmp(a, b);
+    }
+#ifdef RUBY18
+    args[0] = a;
+    args[1] = b;
+    return !rb_with_disable_interrupt(eql, (VALUE)args);
+#else
+    return !rb_eql(a, b);
+#endif
+}
+
+/* hash.c */
+static int
+rb_strhash_hash(VALUE a)
+{
+    VALUE hval;
+    int hnum;  
+
+    switch (TYPE(a)) {
+      case T_FIXNUM:
+#ifdef RUBY18
+	return (int)a;  
+#else
+    hnum = (int)a;
+    break;
+#endif	  
+      case T_SYMBOL:
+    hnum = rb_sym_strhash(&a);
+    break;
+      case T_STRING:
+    hnum = rb_str_strhash(&a);
+    break;
+
+      default:
+    hval = rb_hash(a);
+#ifdef RUBY18
+    if (!FIXNUM_P(hval)) {
+       hval = rb_funcall(hval, '%', 1, hash_format);
+    }
+#endif	
+    hnum = (int)hval;
+    }
+#ifdef RUBY18
+    return hnum;
+#else
+    hnum <<= 1;
+    return RSHIFT(hnum, 1);
+#endif
+}
+
+static struct st_hash_type objstrhash = {
+    rb_strhash_hash_cmp,
+    rb_strhash_hash,
+};
+
+static void 
+rb_hash_modify_check(VALUE *hash){
+    if (OBJ_FROZEN(*hash)) rb_error_frozen("hash");
+    if (!OBJ_TAINTED(*hash) && rb_safe_level() >= 4)
+    rb_raise(rb_eSecurityError, "Insecure: can't modify hash");
+}
+
+/* hash.c */
+static void
+rb_hash_modify(VALUE hash)
+{
+#ifdef RUBY18	
+    if (!HASH_TBL(hash)) rb_raise(rb_eTypeError, "uninitialized Hash");
+#endif
+    rb_hash_modify_check(&hash);
+#ifdef RUBY19
+   if (!HASH_TBL(hash)) HASH_TBL(hash) = st_init_table(&objstrhash);
+#endif
+}
+
+static VALUE strhash_alloc0 _((VALUE*));
+static VALUE strhash_alloc _((VALUE));
+/* hash.c */
+static VALUE
+strhash_alloc0(VALUE *klass)
+{
+    NEWOBJ(hash, struct RHash);
+    OBJSETUP(hash, *klass, T_HASH);
+
+    hash->ifnone = Qnil;
+
+    return (VALUE)hash;
+}
+
+static VALUE
+strhash_alloc(VALUE klass)
+{
+    VALUE hash = strhash_alloc0(&klass);
+
+    HASH_TBL(hash) = st_init_table(&objstrhash);
+
+    return hash;
+}
+
+static VALUE rb_hash_strhash(VALUE hash);
+static void rb_strhash_convert(VALUE *value);
+
+/* hash.c */
+static int
+rb_hash_rehash_i(VALUE key, VALUE value, st_table *tbl)
+{
+    if (key != Qundef){ 
+      rb_strhash_convert(&value);
+      st_insert(tbl, key, value);
+    }
+    return ST_CONTINUE;
+}
+
+/* hash.c */
+static VALUE
+rb_strhash_rehash(VALUE hash)
+{
+    st_table *tbl;
+#ifdef RUBY19
+    if (RHASH(hash)->iter_lev > 0) {
+    rb_raise(rb_eRuntimeError, "rehash during iteration");
+    }
+    rb_hash_modify_check(&hash);
+    if (!RHASH(hash)->ntbl)
+        return hash;
+#endif
+    rb_hash_modify(hash);
+    tbl = st_init_table_with_size(&objstrhash, HASH_TBL(hash)->num_entries);
+    rb_hash_foreach(hash, rb_hash_rehash_i, (st_data_t)tbl);
+    st_free_table(HASH_TBL(hash));
+    HASH_TBL(hash) = tbl;
+
+    return hash;
+}
+
+static void
+rb_strhash_convert(VALUE *val)
+{
+    int i;
+    VALUE values;
+
+    switch (TYPE(*val)) {
+      case T_HASH:
+           *val = rb_hash_strhash(*val); 
+           break;   
+      case T_ARRAY:
+            values = rb_ary_new2(RARRAY_LEN(*val));
+            for (i = 0; i < RARRAY_LEN(*val); i++) {
+               VALUE el = RARRAY_PTR(*val)[i];
+               rb_ary_push(values, (TYPE(el) == T_HASH) ? rb_hash_strhash(el) : el);
+            } 
+           *val = values;
+           break;
+    }
+}
+
+static VALUE
+rb_strhash_aset(VALUE hash, VALUE key, VALUE val){
+    rb_strhash_convert(&val);
+    rb_hash_aset(hash, key, val);
+    return val;
+}
+
+/* hash.c */
+static VALUE
+rb_strhash_s_create(int argc, VALUE *argv, VALUE klass)
+{
+    VALUE hash;
+    int i;
+
+    if (argc == 1 && TYPE(argv[0]) == T_HASH) {
+    hash = strhash_alloc0(&klass);
+    HASH_TBL(hash) = st_copy(HASH_TBL(argv[0]));
+    HASH_TBL(hash)->type = &objstrhash;
+    RHASH(hash)->ifnone = RHASH(argv[0])->ifnone;
+    return rb_strhash_rehash(hash);
+    }
+
+    if (argc % 2 != 0) {
+    rb_raise(rb_eArgError, "odd number of arguments for Hash");
+    }
+
+    hash = strhash_alloc(klass);
+    for (i=0; i<argc; i+=2) {
+        rb_strhash_aset(hash, argv[i], argv[i + 1]);
+    }
+
+    return hash;
+}
+
+static VALUE
+rb_strhash_strhash(VALUE hash)
+{
+    return hash;
+}
+
+static VALUE
+rb_hash_strhash(VALUE hash)
+{
+    VALUE args[1];
+    args[0] = hash;
+    return rb_strhash_s_create(1, (VALUE *)args, rb_cStrHash);
+}
+
+/* hash.c */
+static VALUE
+to_strhash(hash)
+    VALUE hash;
+{
+    return rb_convert_type(hash, T_HASH, "StrHash", "to_hash");
+}
+
+/* hash.c */
+static int
+rb_strhash_update_i(VALUE key, VALUE value, VALUE *hash)
+{
+    if (key == Qundef) return ST_CONTINUE;
+    rb_strhash_convert(&value);
+    st_insert(HASH_TBL(*hash), key, value);
+    return ST_CONTINUE;
+}
+
+/* hash.c */
+static int
+rb_strhash_update_block_i(VALUE key, VALUE value, VALUE *hash)
+{
+    if (key == Qundef) return ST_CONTINUE;
+    if (rb_hash_has_key(*hash, key)) {
+    value = rb_yield_values(3, key, rb_hash_aref(*hash, key), value);
+    }
+    rb_strhash_convert(&value);
+    st_insert(HASH_TBL(*hash), key, value);
+    return ST_CONTINUE;
+}
+
+/* hash.c */
+static VALUE
+rb_strhash_update(VALUE hash1, VALUE hash2)
+{
+#ifdef RUBY19	
+    rb_hash_modify(hash1);
+#endif
+    hash2 = to_strhash(hash2);
+    if (rb_block_given_p()) {
+    rb_hash_foreach(hash2, rb_strhash_update_block_i, &hash1);
+    }
+    else {
+    rb_hash_foreach(hash2, rb_strhash_update_i, &hash1);
+    }
+    return hash1;
+}
+
+static VALUE
+rb_strhash_initialize(int argc, VALUE *argv, VALUE hash){
+    VALUE constructor;
+    rb_scan_args(argc, argv, "01", &constructor);
+    if(TYPE(constructor) == T_HASH){
+      return rb_strhash_update(hash,constructor);
+    }else{
+      return rb_call_super(argc,argv);
+    }
+}
+
+static VALUE
+rb_strhash_merge(VALUE hash1, VALUE hash2){
+    /* see note in Init */
+   return rb_strhash_update(hash1,hash2);
+}
+
+/*hash.c, see rb_strhash_to_hash*/
+static VALUE
+to_hash(hash)
+    VALUE hash;
+{
+    return rb_convert_type(hash, T_HASH, "Hash", "to_hash");
+}
+
+/*hash.c, see rb_strhash_to_hash*/
+static int
+rb_hash_update_i(key, value, hash)
+    VALUE key, value;
+    VALUE *hash;
+{
+    if (key == Qundef) return ST_CONTINUE;
+#ifdef RUBY19
+    st_insert(RHASH(*hash)->ntbl, key, value);
+#else
+    rb_hash_aset(*hash, key, value);
+#endif
+    return ST_CONTINUE;
+}
+
+/*hash.c, see rb_strhash_to_hash*/
+static int
+rb_hash_update_block_i(key, value, hash)
+    VALUE key, value;
+    VALUE *hash;
+{
+    if (key == Qundef) return ST_CONTINUE;
+    if (rb_hash_has_key(*hash, key)) {
+    value = rb_yield_values(3, key, rb_hash_aref(*hash, key), value);
+    }
+#ifdef RUBY19
+    st_insert(RHASH(*hash)->ntbl, key, value);
+#else
+    rb_hash_aset(*hash, key, value);
+#endif
+    return ST_CONTINUE;
+}
+
+/*hash.c, see rb_strhash_to_hash*/
+static VALUE
+rb_hash_update(hash1, hash2)
+    VALUE hash1, hash2;
+{
+#ifdef RUBY19
+    rb_hash_modify(hash1);
+#endif	
+    hash2 = to_hash(hash2);
+    if (rb_block_given_p()) {
+    rb_hash_foreach(hash2, rb_hash_update_block_i, &hash1);
+    }
+    else {
+    rb_hash_foreach(hash2, rb_hash_update_i, &hash1);
+    }
+    return hash1;
+}
+
+static int
+rb_strhash_to_hash_i(VALUE key, VALUE value, VALUE *hash){
+    if (SYMBOL_P(key)){
+      rb_hash_delete(*hash,key);
+      VALUE str = rb_str_new2(rb_id2name(SYM2ID(key)));
+      OBJ_FREEZE(str);
+      rb_hash_aset(*hash, str, value);
+    }
+    return ST_CONTINUE;
+}
+
+static VALUE
+rb_strhash_to_hash(VALUE hash){
+    VALUE hsh = rb_hash_update(rb_hash_new(), hash);
+    RHASH(hsh)->ifnone = RHASH(hash)->ifnone;
+    rb_hash_foreach(hsh, rb_strhash_to_hash_i, &hsh);
+    return hsh;
+}
+
+void
+Init_hwia()
+{
+    id_hash = rb_intern("hash");
+    id_strhash = rb_intern("strhash");
+    hash_format = INT2FIX(536870923);
+
+    rb_cStrHash = rb_define_class("StrHash", rb_cHash);
+
+    rb_undef_alloc_func(rb_cStrHash);
+    rb_define_alloc_func(rb_cStrHash, strhash_alloc);
+    rb_define_singleton_method(rb_cStrHash, "[]", rb_strhash_s_create, -1);
+  
+    rb_define_method(rb_cString, "strhash", rb_str_strhash_m, 0);
+    rb_define_method(rb_cSymbol, "strhash", rb_sym_strhash_m, 0);
+
+    rb_define_method(rb_cStrHash,"initialize", rb_strhash_initialize, -1); 
+    rb_define_method(rb_cStrHash, "rehash", rb_strhash_rehash, 0);
+    /* revist, same API, but may be clobbered */
+    rb_define_method(rb_cStrHash, "dup", rb_hash_strhash, 0);
+    rb_define_method(rb_cStrHash, "strhash", rb_strhash_strhash, 0);
+    rb_define_method(rb_cStrHash, "[]=", rb_strhash_aset, 2);
+    rb_define_method(rb_cStrHash, "store", rb_strhash_aset, 2);
+    rb_define_method(rb_cStrHash, "update", rb_strhash_update, 1);
+    rb_define_method(rb_cStrHash, "merge!", rb_strhash_update, 1);
+    rb_define_method(rb_cStrHash, "merge", rb_strhash_merge, 1);
+    rb_define_method(rb_cStrHash, "to_hash", rb_strhash_to_hash, 0);
+    rb_define_method(rb_cHash, "strhash", rb_hash_strhash, 0);
+}

data/hwia.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |s|
+  s.name     = "hwia"
+  s.version  = "1.0.2"
+  s.date     = "2009-08-23"
+  s.summary  = "A faster HashWithIndifferentAccess (hwia) for MRI"
+  s.email    = "lourens@methodmissing.com"
+  s.homepage = "http://github.com/methodmissing/hwia"
+  s.description = "A faster HashWithIndifferentAccess (hwia) for MRI (1.8.{6,7} and 1.9.2)"
+  s.has_rdoc = true
+  s.authors  = ["Lourens Naudé (methodmissing)"]
+  s.platform = Gem::Platform::RUBY
+  s.files    = %w[
+    README
+    Rakefile
+    bench/bench.rb
+    bench/as_hwia.rb
+    ext/hwia/extconf.rb
+    ext/hwia/hwia.c
+    lib/hwia_rails.rb
+    hwia.gemspec
+  ] + Dir.glob('test/*')
+  s.rdoc_options = ["--main", "README"]
+  s.extra_rdoc_files = ["README"]
+  s.extensions << "ext/hwia/extconf.rb"
+end

data/lib/hwia_rails.rb

@@ -0,0 +1,26 @@
+require 'hwia'
+raise LoadError.new("Rails environment required!") unless Object.const_defined?(:ActiveSupport)
+
+class Hash
+  alias hash_with_indifferent_access strhash
+end
+
+class StrHash
+  def stringify_keys!; self end
+  def symbolize_keys!; self end
+  def to_options!; self end
+  
+  protected
+  # AS test suite compat only
+  def convert_key(key)
+    key.kind_of?(Symbol) ? key.to_s : key
+  end  
+end
+
+begin
+  old, $VERBOSE = $VERBOSE, nil
+  ActiveSupport::HashWithIndifferentAccess = StrHash
+  HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
+ensure
+  $VERBOSE = old
+end

data/test/helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require 'hwia'

data/test/test_hwia.rb

@@ -0,0 +1,284 @@
+$:.unshift "." # 1.9.2
+require File.dirname(__FILE__) + '/helper'
+
+class TestSymbolAndStringHash < Test::Unit::TestCase  
+  def test_hwia_hash
+    assert_hash_keys 'key', :key
+    assert_hash_keys 'under_scored_key', :under_scored_key
+    assert_hash_keys '@ivar', :@ivar 
+  end  
+  
+  private
+  def assert_hash_keys(str,sym)
+    assert_equal str.strhash, sym.strhash
+  end  
+end
+
+class HashToStrHash < Test::Unit::TestCase
+  def test_strhash
+    hash = { 'a' => 1, 'b' => 2 }
+    assert_instance_of StrHash, hash.strhash
+    assert_equal %w(a b), hash.keys
+    assert_equal [1,2], hash.values
+  end  
+end
+
+class TestStrHash < Test::Unit::TestCase
+  def setup
+    @strings = { 'a' => 1, 'b' => 2 }.strhash
+    @symbols = { :a  => 1, :b  => 2 }.strhash
+    @mixed   = { :a  => 1, 'b' => 2 }.strhash
+    @fixnums = {  0  => 1,  1  => 2 }.strhash
+  end
+  
+  def test_inherits_hash
+    assert_equal Hash, StrHash.superclass
+  end  
+    
+  def test_strhash
+    assert_equal @strings.object_id, @strings.strhash.object_id
+    assert_instance_of StrHash, { 'a' => 1, 'b' => 2 }.strhash
+  end
+  
+  def test_initialize
+    strhash = StrHash.new({ 'a' => 1, 'b' => 2 })
+    assert_equal 1, strhash[:a] 
+    strhash = StrHash.new
+    strhash[:a] = 'a'
+    assert_equal 'a', strhash[:a]
+  end
+  
+  def test_convert
+    assert_equal 'a', @strings['a'] = 'a'
+    hash = { 'a' => 1, 'b' => 2 }
+    @strings[:str_hash] = hash
+    assert_instance_of StrHash, @strings[:str_hash] 
+    assert_equal %w(a b), @strings[:str_hash].keys
+    assert_equal [:a,:b,:c], @strings[:array] = [:a,:b,:c]
+    array_with_hash = [{ 'a' => 1, 'b' => 2 }, [:a,:b,:c]]
+    @strings[:array_with_hash] = array_with_hash
+    assert_instance_of StrHash, @strings[:array_with_hash].shift   
+    assert_equal [:a,:b,:c], @strings[:array_with_hash].pop 
+    @strings[:other_hash] = { 'a' => 1, 'b' => 2 }
+    assert_instance_of StrHash, @strings[:other_hash]
+    nested_hash = { "urls" => { "url" => [ { "address" => "1" }, { "address" => "2" } ] }}
+    @strings[:nested_hash] = nested_hash
+    assert_instance_of Array, @strings[:nested_hash][:urls][:url] 
+  end
+  
+  def test_set
+    array = [{ 'a' => 1, 'b' => 2 }, [:a,:b,:c]]
+    @strings[:array] = array
+    assert_instance_of StrHash, @strings[:array].shift
+    assert_instance_of Array, @strings[:array] = array    
+    assert_instance_of StrHash, @strings[:hash] = { 'a' => 1, 'b' => 2 }
+  end
+  
+  def test_dup
+    assert_equal @strings, @strings.dup
+    assert_equal @mixed, @mixed.dup
+    assert_not_equal @mixed.object_id, @mixed.dup.object_id
+  end
+    
+  def test_keys
+    assert_equal ["a", "b"], @strings.keys
+    assert_equal [:a, :b], @symbols.keys
+    assert_equal [:a, "b"], @mixed.keys
+    assert_equal [0, 1], @fixnums.keys            
+  end
+  
+  def test_values
+    assert_equal [1, 2], @strings.values
+    assert_equal [1, 2], @symbols.values
+    assert_equal [1, 2], @mixed.values
+    assert_equal [1, 2], @fixnums.values         
+  end  
+ 
+  def test_fetch
+    assert_equal 1, @strings.fetch('a')
+    assert_equal 1, @strings.fetch(:a.to_s)
+    assert_equal 1, @strings.fetch(:a)
+  end
+  
+  def test_key?
+    assert @strings.key?(:a)
+    assert @strings.include?('a')
+    assert @mixed.has_key?('b')
+  end
+  
+  def test_delete
+    @strings.delete('a')
+    assert !@strings.key?(:a)
+  end
+  
+  def test_assorted
+    hashes = { :@strings => @strings, :@symbols => @symbols, :@mixed => @mixed }
+    method_map = { :'[]' => 1, :fetch => 1, :values_at => [1],
+      :has_key? => true, :include? => true, :key? => true,
+      :member? => true }
+
+    hashes.each do |name, hash|
+      method_map.sort_by { |m| m.to_s }.each do |meth, expected|
+        assert_equal(expected, hash.__send__(meth, 'a'),
+                     "Calling #{name}.#{meth} 'a'")
+        assert_equal(expected, hash.__send__(meth, :a),
+                     "Calling #{name}.#{meth} :a")
+      end
+    end
+
+    assert_equal [1, 2], @strings.values_at('a', 'b')
+    assert_equal [1, 2], @strings.values_at(:a, :b)
+    assert_equal [1, 2], @symbols.values_at('a', 'b')
+    assert_equal [1, 2], @symbols.values_at(:a, :b)
+    assert_equal [1, 2], @mixed.values_at('a', 'b')
+    assert_equal [1, 2], @mixed.values_at(:a, :b)
+  end
+  
+  def test_reading
+    hash = StrHash.new
+    hash["a"] = 1
+    hash["b"] = true
+    hash["c"] = false
+    hash["d"] = nil
+
+    assert_equal 1, hash[:a]
+    assert_equal true, hash[:b]
+    assert_equal false, hash[:c]
+    assert_equal nil, hash[:d]
+    assert_equal nil, hash[:e]
+  end  
+  
+  def test_reading_with_nonnil_default
+    hash = StrHash.new(1)
+    hash["a"] = 1
+    hash["b"] = true
+    hash["c"] = false
+    hash["d"] = nil
+
+    assert_equal 1, hash[:a]
+    assert_equal true, hash[:b]
+    assert_equal false, hash[:c]
+    assert_equal nil, hash[:d]
+    assert_equal 1, hash[:e]
+  end  
+
+  def test_writing
+    hash = StrHash.new
+    hash[:a] = 1
+    hash['b'] = 2
+    hash[3] = 3
+
+    assert_equal hash['a'], 1
+    assert_equal hash['b'], 2
+    assert_equal hash[:a], 1
+    assert_equal hash[:b], 2
+    assert_equal hash[3], 3
+  end  
+
+  def test_update
+    hash = StrHash.new
+    hash[:a] = 'a'
+    hash['b'] = 'b'
+
+    updated_with_strings = hash.update(@strings)
+    updated_with_symbols = hash.update(@symbols)
+    updated_with_mixed = hash.update(@mixed)
+
+    assert_equal updated_with_strings[:a], 1
+    assert_equal updated_with_strings['a'], 1
+    assert_equal updated_with_strings['b'], 2
+
+    assert_equal updated_with_symbols[:a], 1
+    assert_equal updated_with_symbols['b'], 2
+    assert_equal updated_with_symbols[:b], 2
+
+    assert_equal updated_with_mixed[:a], 1
+    assert_equal updated_with_mixed['b'], 2
+
+    assert [updated_with_strings, updated_with_symbols, updated_with_mixed].all? { |h| h.keys.size == 2 }
+  end  
+  
+  def test_merging
+    hash = StrHash.new
+    hash[:a] = 'failure'
+    hash['b'] = 'failure'
+
+    other = { 'a' => 1, :b => 2 }
+
+    merged = hash.merge(other)
+
+    assert_equal StrHash, merged.class
+    assert_equal 1, merged[:a]
+    assert_equal 2, merged['b']
+
+    hash.update(other)
+
+    assert_equal 1, hash[:a]
+    assert_equal 2, hash['b']
+  end  
+  
+  def test_deleting
+    get_hash = proc{ StrHash[ :a => 'foo' ] }
+    hash = get_hash.call
+    assert_equal hash.delete(:a), 'foo'
+    assert_equal hash.delete(:a), nil
+    hash = get_hash.call
+    assert_equal hash.delete('a'), 'foo'
+    assert_equal hash.delete('a'), nil
+  end  
+
+  def test_to_hash
+    assert_instance_of Hash, @strings.to_hash
+    assert_equal %w(a b), @strings.to_hash.keys
+    # Should convert to a Hash with String keys.
+    assert_equal @strings, @mixed.strhash.to_hash
+
+    # Should preserve the default value.
+    mixed_with_default = @mixed.dup
+    mixed_with_default.default = '1234'
+    roundtrip = mixed_with_default.strhash.to_hash
+    assert_equal @strings, roundtrip
+    assert_equal '1234', roundtrip.default    
+  end
+
+  def test_hash_with_array_of_hashes
+    hash = { "urls" => { "url" => [ { "address" => "1" }, { "address" => "2" } ] }}
+    hwia = StrHash[hash]
+    assert_equal "1", hwia[:urls][:url].first[:address]
+  end
+
+  def test_indifferent_subhashes
+    h = {'user' => {'id' => 5}}.strhash
+    ['user', :user].each {|user| [:id, 'id'].each {|id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5"}}
+
+    h = {:user => {:id => 5}}.strhash
+    ['user', :user].each {|user| [:id, 'id'].each {|id| assert_equal 5, h[user][id], "h[#{user.inspect}][#{id.inspect}] should be 5"}}
+  end  
+
+  def test_assorted_keys_not_stringified
+    original = {Object.new => 2, 1 => 2, [] => true}
+    indiff = original.strhash
+    assert(!indiff.keys.any? {|k| k.kind_of? String}, "A key was converted to a string!")
+  end
+
+  def test_should_use_default_value_for_unknown_key
+    hash_wia = StrHash.new(3)
+    assert_equal 3, hash_wia[:new_key]
+  end
+
+  def test_should_use_default_value_if_no_key_is_supplied
+    hash_wia = StrHash.new(3)
+    assert_equal 3, hash_wia.default
+  end
+
+  def test_should_nil_if_no_default_value_is_supplied
+    hash_wia = StrHash.new
+    assert_nil hash_wia.default
+  end
+
+  def test_should_copy_the_default_value_when_converting_to_hash_with_indifferent_access
+    hash = Hash.new(3)
+    hash_wia = hash.strhash
+    assert_equal 3, hash_wia.default
+  end      
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: hwia
+version: !ruby/object:Gem::Version 
+  version: 1.0.2
+platform: ruby
+authors: 
+- "Lourens Naud\xC3\xA9 (methodmissing)"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-23 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: A faster HashWithIndifferentAccess (hwia) for MRI (1.8.{6,7} and 1.9.2)
+email: lourens@methodmissing.com
+executables: []
+
+extensions: 
+- ext/hwia/extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- README
+- Rakefile
+- bench/bench.rb
+- bench/as_hwia.rb
+- ext/hwia/extconf.rb
+- ext/hwia/hwia.c
+- lib/hwia_rails.rb
+- hwia.gemspec
+- test/helper.rb
+- test/test_hwia.rb
+has_rdoc: true
+homepage: http://github.com/methodmissing/hwia
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A faster HashWithIndifferentAccess (hwia) for MRI
+test_files: []
+