methodmissing-hwia 1.0.0

data/README

@@ -0,0 +1,4 @@
+Attempt at a zippier HashWithIndifferentAccess for Ruby MRI
+  (c) 2009 Lourens Naudé (methodmissing), James Tucker (raggi)
+
+Work in progress

data/Rakefile

@@ -0,0 +1,68 @@
+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

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,40 @@
+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 }.strhash
+HWIA_HASH = HashWithIndifferentAccess.new({ :a  => 1, 'b' => 2 })
+HASH = { :d => :d, 'e' => :e } 
+
+TESTS = 10_000
+Benchmark.bmbm do |results|
+  results.report("StrHash#[:sym]") { TESTS.times { STR_HASH[:a] } }
+  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#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#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 } }
+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,524 @@
+#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 (!RHASH(hash)->ntbl)
+        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 (TYPE(a) == T_STRING && RBASIC(a)->klass == rb_cString &&
+	TYPE(b) == T_STRING && RBASIC(b)->klass == rb_cString) {
+	return rb_str_cmp(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 (a == Qundef || b == Qundef) return -1;
+    if (SYMBOL_P(a) && SYMBOL_P(b)) {
+	return 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
+}
+
+VALUE
+rb_strhash(VALUE obj)
+{
+    VALUE hval = rb_funcall(obj, id_hash, 0);
+#ifdef RUBY18
+	return hval; 
+#else	
+ retry:
+    switch (TYPE(hval)) {
+      case T_FIXNUM:
+	return hval;
+
+      case T_BIGNUM:
+	return LONG2FIX(((long*)(RBIGNUM_DIGITS(hval)))[0]);
+
+      default:
+	hval = rb_to_int(hval);
+	goto retry;
+    }
+#endif
+}
+
+/* hash.c */
+static int
+rb_strhash_hash(VALUE a)
+{
+    VALUE hval, hnum;
+
+    switch (TYPE(a)) {
+      case T_FIXNUM:
+#ifdef RUBY18
+	return (int)a;  
+#else
+    hnum = a;
+	break;
+#endif	  
+      case T_SYMBOL:
+	hnum = rb_sym_strhash_m(a);
+	break;
+      case T_STRING:
+	hnum = rb_str_strhash_m(a);
+	break;
+
+      default:
+	hval = rb_hash(a);
+#ifdef RUBY18
+	if (!FIXNUM_P(hval)) {
+	    hval = rb_funcall(hval, '%', 1, hash_format);
+	}
+#endif	
+	hnum = FIX2LONG(hval);
+    }
+#ifdef RUBY18
+    return (int)hnum;
+#else
+    hnum <<= 1;
+    return (int)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;
+}
+
+VALUE
+rb_strhash_new()
+{
+    return strhash_alloc(rb_cStrHash);
+}
+
+static VALUE rb_hash_strhash(VALUE hash);
+static VALUE rb_strhash_convert(VALUE hash, VALUE value);
+
+/* hash.c */
+static int
+rb_hash_rehash_i(VALUE key, VALUE value, st_table *tbl)
+{
+    if (key != Qundef) st_insert(tbl, key, rb_strhash_convert(Qnil, 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;
+}
+
+/* temp. public API */
+static VALUE
+rb_strhash_convert(VALUE hash, VALUE val)
+{
+    int i;
+    VALUE values;
+
+    switch (TYPE(val)) {
+      case T_HASH:
+           return rb_hash_strhash(val);    
+      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);
+            } 
+           return values;
+      default:
+           return val;
+    }
+}
+
+static VALUE
+rb_strhash_aset(VALUE hash, VALUE key, VALUE val){
+	VALUE converted = rb_strhash_convert(hash,val);
+	rb_hash_aset(hash, key, converted);
+    return converted;
+}
+
+/* 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;
+    st_insert(HASH_TBL(hash), key, rb_strhash_convert(hash,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);
+    }
+    st_insert(HASH_TBL(hash), key, rb_strhash_convert(hash,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 */
+	VALUE duped = rb_hash_strhash(hash1);
+	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);
+      rb_hash_aset(hash, rb_obj_as_string(key), 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, "convert", rb_strhash_convert, 1);
+    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.0"
+  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,20 @@
+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  
+end
+
+begin
+ old, $VERBOSE = $VERBOSE, nil
+ ActiveSupport::HashWithIndifferentAccess = StrHash
+ HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
+ensure
+  $VERBOSE = old
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: methodmissing-hwia
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- "Lourens Naud\xC3\xA9 (methodmissing)"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-23 00:00:00 -07: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
+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: 2
+summary: A faster HashWithIndifferentAccess (hwia) for MRI
+test_files: []
+