remi-indifferent-variable-hash 0.1.0

data/README.markdown

@@ -0,0 +1,69 @@
+Indifferent Variable Hash
+=========================
+
+This tiny library / gem could likely use a new name as "Indifferent Hash" 
+can mean a number of things.
+
+Here's what this let's you do:
+
+    $ sudo gem install remi-indifferent-variable-hash -s http://gems.github.com
+    $ irb
+
+    >> require 'rubygems'
+    >> require 'indifferent-variable-hash'
+
+    # extend a class with IndifferentVariableHash
+
+    >> class Dog
+         extend IndifferentVariableHash
+       end
+
+    >> Dog.foo = 'bar'
+    => "bar"
+
+    >> Dog.foo
+    => "bar"
+
+    >> Dog.variables
+    => {"foo"=>"bar"}
+
+    >> Dog['foo']
+    => "bar"
+
+    >> Dog.new.foo
+    NoMethodError: undefined method `foo' for #<Dog:0x7f37c87d87d0>
+      from (irb):8
+      from :0
+
+    # include IndifferentVariableHash in a class, for instances
+
+    >> class Dog
+         include IndifferentVariableHash
+       end
+
+    >> Dog.new.foo
+    => nil
+
+    >> rover = Dog.new
+    => #<Dog:0x7f37c87bfe38>
+
+    >> rover.foo = 'bar'
+    => "bar"
+
+    >> rover.foo
+    => "bar"
+
+    >> rover[:foo]
+    => "bar"
+
+    >> rover.variables
+    => {"foo"=>"bar"}
+
+... why?
+--------
+
+Why not!  I often add functionality similar to this to some classes that hold config-like information.  eg. MyApp.config might return an object that includes IndifferentVariableHash so I can say `MyApp.config.foo = 'bar'` or `MyApp.config[:foo] = 'bar'`.  Alternatively, I might like the syntax `MyApp.foo = 'bar'` or `MyApp[:foo] = 'bar'` ... *OR* I might want both syntaxes, so I extend MyApp with IndifferentVariableHash but I also alias 'config' to 'variables.'
+
+I use this often enough that I figured I should gem-ify it so I can easily use it in some of my projects, when I want it.
+
+If it helps anyone else out there, so be it!  Enjoy  :)

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rake'
+require 'rubygems'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name        = "indifferent-variable-hash"
+    s.summary     = "easily add hash-like features to any class / instance"
+    s.email       = "remi@remitaylor.com"
+    s.homepage    = "http://github.com/remi/indifferent-variable-hash"
+    s.description = "easily add hash-like features to any class / instance"
+    s.authors     = %w( remi )
+    s.files       = FileList["[A-Z]*", "{lib,spec,examples,rails_generators}/**/*"] 
+    # s.executables = "foo" 
+    # s.add_dependency 'person-project' 
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'indifferent-variable-hash'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('RDOC_README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Confirm that gemspec is $SAFE'
+task :safe do
+  require 'yaml'
+  require 'rubygems/specification'
+  data = File.read('indifferent-variable-hash.gemspec')
+  spec = nil
+  if data !~ %r{!ruby/object:Gem::Specification}
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+  else
+    spec = YAML.load(data)
+  end
+  spec.validate
+  puts spec
+  puts "OK"
+end
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 0
+:minor: 1

data/lib/indifferent-variable-hash.rb

@@ -0,0 +1,49 @@
+$:.unshift File.dirname(__FILE__)
+
+module IndifferentVariableHash
+  attr_accessor :variables
+
+  def variables
+    @variables ||= IndifferentVariableHash::Hash.new
+  end
+
+  def method_missing name, *args
+    begin
+      self.variables.send name, *args
+    rescue Exception => ex
+      super
+    end 
+  end
+
+  # IndifferentVariableHash::Hash extends Hash to be 'indifferent'
+  #
+  # 'Indifferent' has a few different meanings and needs to be better defined.
+  #
+  # This is custom in 2 major ways:
+  #  * All keys will be stringified (so foo[:hi] and foo['hi'] are the same)
+  #  * Sending messages are translated into keys, eg. foo.hi returns foo['hi']
+  #
+  class Hash < ::Hash
+
+    def []= key, value
+      super key.to_s, value
+    end
+
+    def [] key
+      super key.to_s
+    end
+
+    def method_missing name, *args
+      if name.to_s =~ /=$/ # eg. @hash.foo = 'bar'
+        self[$`.to_s] = args.first
+      else
+        if args.empty?
+          self[name.to_s] # eg. @hash.foo
+        else
+          super # anything else ... fall back to super
+        end
+      end
+    end
+  end
+
+end

data/spec/indifferent_variable_hash_spec.rb

@@ -0,0 +1,91 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe IndifferentVariableHash do
+
+  it "obviously, classes and instances shouldn't have these features without including IndifferentVariableHash" do
+    klass    = Class.new
+    instance = klass.new
+
+    lambda { instance.variables }.should raise_error(NoMethodError, /undefined method `variables'/)
+    lambda { instance.foo       }.should raise_error(NoMethodError, /undefined method `foo'/)
+
+    lambda { klass.variables    }.should raise_error(NoMethodError, /undefined method `variables'/)
+    lambda { klass.foo          }.should raise_error(NoMethodError, /undefined method `foo'/)
+  end
+
+  it 'should add a in indifferent hash of variables to instances of a class' do
+    klass    = Class.new { include IndifferentVariableHash }
+    instance = klass.new
+
+    instance.variables.should be_a_kind_of(Hash)
+    instance.foo.should be_nil
+    instance.foo = 'Hello There'
+    instance.foo.should == 'Hello There'
+
+    # klass should *not* have variables, just instances
+    lambda { klass.variables }.should raise_error(NoMethodError, /undefined method `variables'/)
+  end
+
+  it 'should add a in indifferent hash of variables to a class' do
+    klass    = Class.new { extend IndifferentVariableHash }
+    instance = klass.new
+
+    klass.variables.should be_a_kind_of(Hash)
+    klass.foo.should be_nil
+    klass.foo = 'Hello There'
+    klass.foo.should == 'Hello There'
+
+    # instance should *not* have variables, just instances
+    lambda { instance.variables }.should raise_error(NoMethodError, /undefined method `variables'/)
+  end
+
+  it 'should add a in indifferent hash of variables to a class and instances of the same class' do
+    klass    = Class.new { extend IndifferentVariableHash; include IndifferentVariableHash }
+    instance = klass.new
+
+    [ klass, instance ].each do |obj|
+      obj.variables.should be_a_kind_of(Hash)
+      obj.foo.should be_nil
+      obj.foo = 'Hello There'
+      obj.foo.should == 'Hello There'
+    end
+  end
+
+  it 'should be easy[-ish] to give your own custom name for the hash variable' do
+    klass = Class.new { extend IndifferentVariableHash }
+    klass.foo = 'Hello There'
+
+    klass.foo.should == 'Hello There'
+    klass.variables.foo.should == 'Hello There'
+
+    klass.instance_eval { alias config variables } # just add an alias!  nothing custom needed to do this.
+    klass.config.foo.should == 'Hello There'
+    klass.config['foo'].should == 'Hello There'
+    klass.config[:foo].should == 'Hello There'
+  end
+
+  it 'should not make *all* Hashes indifferent' do
+    custom_hash = IndifferentVariableHash::Hash.new
+    custom_hash.foo.should be_nil
+    custom_hash.foo = 'bar'
+    custom_hash.foo.should == 'bar'
+
+    regular_hash = Hash.new
+    lambda { regular_hash.foo }.should raise_error(NoMethodError, /undefined method `foo'/)
+  end
+
+  it "should really be 'indifferent' (shouldn't matter whether a string or a symbol is used)" do
+    custom_hash = IndifferentVariableHash::Hash.new
+    
+    custom_hash.foo = 'bar'
+    custom_hash.foo.should == 'bar'
+    custom_hash['foo'].should == 'bar'
+    custom_hash[:foo].should == 'bar'
+
+    custom_hash[:foo] = 'BAR'
+    custom_hash.foo.should == 'BAR'
+    custom_hash['foo'].should == 'BAR'
+    custom_hash[:foo].should == 'BAR'
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../lib/indifferent-variable-hash'

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: remi-indifferent-variable-hash
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- remi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-03 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: easily add hash-like features to any class / instance
+email: remi@remitaylor.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- VERSION.yml
+- README.markdown
+- lib/indifferent-variable-hash.rb
+- spec/indifferent_variable_hash_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/remi/indifferent-variable-hash
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+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.2.0
+signing_key: 
+specification_version: 2
+summary: easily add hash-like features to any class / instance
+test_files: []
+