mcmire-openhash 0.1

data/lib/openhash.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__)+'/openhash/hash_with_indifferent_access'
+require File.dirname(__FILE__)+'/openhash/openhash'

data/lib/openhash/hash_with_indifferent_access.rb

@@ -0,0 +1,120 @@
+# Copied from Rails 2.2 stable
+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
+ 
+  # 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

data/lib/openhash/openhash.rb

@@ -0,0 +1,75 @@
+# Adapted from Ruby Facets
+class OpenHash < HashWithIndifferentAccess
+  def initialize(hash = {})
+    super()
+    update(hash)
+  end
+  
+  def self.[](hash = {})
+    new(hash)
+  end
+  
+  # Route get and set calls.
+  def method_missing(name, *args)
+    name = name.to_s
+    # do nothing if missing method
+    return if name == 'default' && !args.empty?
+    k = name.sub(/[?!=]$/, '')
+    if name =~ /=$/
+      self[k] = args.first
+    elsif args.empty?
+      self[k]
+    else
+      # this should never be called?!
+      super(name, *args)
+    end
+  end
+  
+  def with_indifferent_access
+    self
+  end
+  
+  def dup
+    self.class.new(self)
+  end
+
+end
+
+class Hash
+  def to_openhash
+    hash = self.dup
+    hash.each {|k,v| hash[k] = v.to_openhash if v.is_a?(Hash) }
+    OpenHash.new(hash)
+  end
+end
+
+#oh = OpenHash.new
+#oh.x = 'y'
+#oh.few = 3
+#oh.regz = :sym
+#oh['slimey'] = 'frog'
+#puts "oh.inspect = " + oh.inspect
+#puts "oh.few = #{oh.few}"
+#puts "oh.slimey = #{oh.slimey}"
+#exit
+
+#openhash = OpenHash.new(
+#  :foo => OpenHash.new(
+#    :one => 'awexome',
+#    :two => 'cross',
+#    :three => 'homestar runner'
+#  ),
+#  :bar => OpenHash.new(
+#    :michael => 'jackson',
+#    :citizen => 'kane',
+#    :bread => 'crumbs'
+#  )
+#)
+#puts openhash.foo.inspect
+#openhash.foo.one = 'pretty'
+#puts openhash.foo.inspect
+#exit
+
+#hash = {:y=>{:z=>"foo"}, :x=>"blah"}
+#puts hash.to_openhash.inspect
+#exit

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+name: mcmire-openhash
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Elliot Winkler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-08 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: OpenHash is an alternative to OpenStruct and Ruby Facets' OpenObject. The goal of these libraries is to allow you to access your hash in a more object-oriented syntax, but unlike the others, this library simply uses method_missing.
+email: elliot.winkler@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/openhash.rb
+- lib/openhash/openhash.rb
+- lib/openhash/hash_with_indifferent_access.rb
+has_rdoc: false
+homepage: http://github.com/mcmire/openhash
+licenses: 
+post_install_message: 
+rdoc_options: []
+
+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: Simply access your hash in a more object-oriented syntax
+test_files: []
+