hashery 1.0.0

data/lib/hashery/ostructable.rb

@@ -0,0 +1,209 @@
+#--
+# OpenStructable
+#
+# Copyright (c) 2005 Thomas Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+# ==========================================================================
+# Revision History ::
+# --------------------------------------------------------------------------
+# 05.04.28  Trans
+#   - Minor modifications to documentation.
+# ==========================================================================
+#
+# TODO
+# Keep this uptodate with ostruct.rb.
+#
+# TODO Ask Matz
+# See if Matz will accept it into core so we don't have to anymore.
+#
+# TODO Marshalling
+# As with OpenStruct, marshalling is problematic at the moment.
+#
+#++
+
+# OpensStructable is a mixin module which can provide OpenStruct behavior to
+# any class or object. OpenStructable allows extention of data objects
+# with arbitrary attributes.
+#
+# == Usage
+#
+#   require 'ostructable'
+#
+#   class Record
+#     include OpenStructable
+#   end
+#
+#   record = Record.new
+#   record.name    = "John Smith"
+#   record.age     = 70
+#   record.pension = 300
+#
+#   puts record.name     # -> "John Smith"
+#   puts record.address  # -> nil
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+# * Yukihiro Matsumoto
+# * Gavin Sinclair (Documentation)
+#
+module OpenStructable
+
+  def initialize(hash=nil)
+    @__table__ = {}
+    if hash
+      for k,v in hash
+        @__table__[k.to_sym] = v
+        new_ostruct_member(k)
+      end
+    end
+  end
+
+  # duplicate an OpenStruct object members.
+  def initialize_copy(orig)
+    super
+    @__table__ = @__table__.dup
+  end
+
+  def marshal_dump
+    @table
+  end
+  def marshal_load(x)
+    @table = x
+    @table.each_key{|key| new_ostruct_member(key)}
+  end
+
+  def new_ostruct_member(name)
+    unless self.respond_to?(name)
+      self.instance_eval %{
+        def #{name}; @__table__[:#{name}]; end
+        def #{name}=(x); @__table__[:#{name}] = x; end
+      }
+    end
+  end
+
+  #
+  # Generate additional attributes and values.
+  #
+  def update(hash)
+    @__table__ ||= {}
+    if hash
+      for k,v in hash
+        @__table__[k.to_sym] = v
+        new_ostruct_member(k)
+      end
+    end
+  end
+
+  def method_missing(mid, *args) # :nodoc:
+    mname = mid.to_s
+    len = args.length
+    if mname =~ /=$/
+      if len != 1
+        raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
+      end
+      if self.frozen?
+        raise TypeError, "can't modify frozen #{self.class}", caller(1)
+      end
+      mname.chop!
+      @__table__ ||= {}
+      @__table__[mname.intern] = args[0]
+      self.new_ostruct_member(mname)
+    elsif len == 0
+      @__table__ ||= {}
+      @__table__[mid]
+    else
+      raise NoMethodError, "undefined method `#{mname}' for #{self}", caller(1)
+    end
+  end
+
+  #
+  # Remove the named field from the object.
+  #
+  def delete_field(name)
+    @__table__ ||= {}
+    @__table__.delete name.to_sym
+  end
+
+  #
+  # Returns a string containing a detailed summary of the keys and values.
+  #
+  def inspect
+    str = "<#{self.class}"
+    for k,v in (@__table__ ||= {})
+      str << " #{k}=#{v.inspect}"
+    end
+    str << ">"
+  end
+
+  def __table__ # :nodoc:
+    @__table__ ||= {}
+  end
+  protected :__table__
+
+  # Compare this object and +other+ for equality.
+  def ==(other)
+    return false unless(other.kind_of?(OpenStruct))
+    return @__table__ == other.table
+  end
+
+end
+
+=begin
+#
+# It is possibe to implement OpenStruct itself with
+# this OpenStructable module as follows:
+#
+class OpenStruct
+  include OpenStructable
+end
+=end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  # fixture
+
+  class Record
+    include OpenStructable
+  end
+
+  # test
+
+  class TC_OpenStructable < Test::Unit::TestCase
+
+    def test_record
+      record = nil
+      assert_nothing_raised {
+        record = Record.new
+        record.name    = "John Smith"
+        record.age     = 70
+        record.pension = 300
+      }
+      assert_equal( "John Smith", record.name )
+      assert_equal( 70, record.age )
+      assert_equal( nil, record.address )
+    end
+
+  end
+
+=end

data/lib/hashery/queryhash.rb

@@ -0,0 +1,35 @@
+# = QueryHash
+#
+# QueryHash is a similar to OpenHash. Like OpenHash,
+# entries can be assigned via setter methods, but
+# entries can only be looked up via query methods
+# (i.e. methods ending in a ?-mark), hence the name
+# of this class.
+#
+# A QueryHash is not quite as elegant as an OpenHash
+# in that reader methods must end in ?-marks, but
+# it remains fully compatible with Hash regardless
+# of it's settings.
+
+class QueryHash < Hash
+
+  def to_h
+    dup
+  end
+
+  def to_hash
+    dup
+  end
+
+  def method_missing(s,*a,&b)
+    case s.to_s
+    when /\=$/
+      self[s.to_s.chomp('=').to_sym] = a[0]
+    when /\?$/
+      self[s.to_s.chomp('?').to_sym]
+    else
+      super(s,*a,&b)
+    end
+  end
+
+end

data/lib/hashery/stash.rb

@@ -0,0 +1,181 @@
+# Stash is just like Hash, except that all keys are
+# converted to Strings.
+#
+# Note this doesn't yet handle default_proc.
+
+class Stash < Hash
+
+  #
+  def self.[](*hash)
+    s = new
+    super(*hash).each{ |k,v| s[k] = v }
+    s
+  end
+
+  #
+  def [](key)
+    super(convert_key(key))
+  end
+
+  #
+  def []=(key,value)
+    super(convert_key(key), value)
+  end
+
+  #
+  def <<(other)
+    case other
+    when Hash
+      super(other.rekey{ |key| convert_key(key) })
+    when Array
+      self[other[0]] = other[1]
+    else
+      raise ArgumentError
+    end
+  end
+
+  #
+  def fetch(key)
+    super(convert_key(key))
+  end
+
+  #
+  def store(key, value)
+    super(convert_key(key), value)
+  end
+
+  #
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  #
+  def has_key?(key)
+    super(convert_key(key))
+  end
+
+  #
+  def include?(key)
+    super(convert_key(key))
+  end
+
+  #
+  def member?(key)
+    super(convert_key(key))
+  end
+
+
+  # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }.to_stash
+  #   foo.rekey!{ |k| k.upcase }  #=>  { "NAME"=>"Gavin", "WIFE"=>:Lisa }
+  #   foo.inspect                 #=>  { "NAME"=>"Gavin", "WIFE"=>:Lisa }
+  #
+  def rekey!(*args, &block)
+    # for backward comptability (TODO: DEPRECATE?).
+    block = args.pop.to_sym.to_proc if args.size == 1
+    if args.empty?
+      block = lambda{|k| k} unless block
+      keys.each do |k|
+        nk = block[k]
+        self[nk.to_s]=delete(k) #if nk
+      end
+    else
+      raise ArgumentError, "3 for 2" if block
+      to, from = *args
+      self[to] = delete(from) if has_key?(from)
+    end
+    self
+  end
+
+  #
+  def rekey(*args, &block)
+    dup.rekey!(*args, &block)
+  end
+
+  #
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  #
+  def update(other)
+    super(other.rekey{ |key| convert_key(key) })
+  end
+
+  # Same as #update.
+  def merge!(other)
+    super(other.rekey{ |key| convert_key(key) })
+  end
+
+  #
+  def merge(other)
+    super(other.rekey{ |key| convert_key(key) })
+  end
+
+  #
+  def replace(other)
+    super(other.rekey{ |key| convert_key(key) })
+  end
+
+  #
+  def values_at(*keys)
+    super(*keys.map{ |key| convert_key(key) })
+  end
+
+  #
+  def to_hash
+    h = {}
+    each{ |k,v| h[k] = v }
+    h
+  end
+
+  alias_method :to_h, :to_hash
+
+  private
+
+    def convert_key(key)
+      key.to_s
+    end
+
+end
+
+class Hash
+
+  # Convert a Hash to a Stash object.
+  def to_stash
+    Stash[self]
+  end
+
+  # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).
+  #
+  #   foo = { :name=>'Gavin', :wife=>:Lisa }
+  #   foo.rekey!{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #   foo.inspect               #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+  #
+  # This method comes from Ruby Facets.
+
+  def rekey!(*args, &block)
+    # for backward comptability (TODO: DEPRECATE).
+    block = args.pop.to_sym.to_proc if args.size == 1
+    if args.empty?
+      block = lambda{|k| k.to_sym} unless block
+      keys.each do |k|
+        nk = block[k]
+        self[nk]=delete(k) if nk
+      end
+    else
+      raise ArgumentError, "3 for 2" if block
+      to, from = *args
+      self[to] = self.delete(from) if self.has_key?(from)
+    end
+    self
+  end
+
+  # Non-inplace #rekey! method.
+  def rekey(*args, &block)
+    dup.rekey!(*args, &block)
+  end
+
+end
+

data/lib/hashery/statichash.rb

@@ -0,0 +1,48 @@
+# = StaticHash
+#
+# A Hash object which raises an error if any
+# previously-defined key attempts to be set again.
+#
+# == Synopsis
+#
+#   foo = Hash::Static.new
+#   foo['name'] = 'Tom'    #=> 'Tom'
+#   foo['age']  = 30       #=> 30
+#   foo['name'] = 'Bob'
+#
+# _produces_
+#
+#   ArgumentError: Duplicate key for StaticHash -- 'name'
+#
+# == Credit
+#
+# StaticHash has it's orgins in Gavin Kistner's WriteOnceHash
+# class found in his +basiclibrary.rb+ script.
+
+class StaticHash < Hash
+
+  # Set a value for a key. Raises an error if that key already
+  # exists with a different value.
+
+  def []=(key, value)
+    if key?(key) && self[key] != value
+      raise ArgumentError, "Duplicate key for StaticHash -- #{key.inspect}"
+    end
+    super(key, value)
+  end
+
+  #
+  def update(hash)
+    dups = (keys | hash.keys)
+    if dups.empty?
+      super(hash)
+    else
+      raise ArgumentError, "Duplicate key for StaticHash -- #{dups.inspect}"
+    end
+  end
+
+  #
+  alias_method :merge!, :update
+
+end
+