hashery 1.4.0 → 1.5.0

data/lib/hashery/orderedhash.rb

@@ -1,167 +1 @@
-# = OrderedHash
-#
-# A simple ordered hash implmentation, for users of
-# Ruby 1.8.7 or less.
-#
-# NOTE: As of Ruby 1.9+ this class is not needed, since
-# Ruby 1.9's standard Hash tracks inseration order.
-#
-# This implementation derives from the same class in
-# ActiveSupport library.
-
-class OrderedHash < ::Hash
-  def to_yaml_type
-    "!tag:yaml.org,2002:omap"
-  end
-
-  def to_yaml(opts = {})
-    YAML.quick_emit(self, opts) do |out|
-      out.seq(taguri, to_yaml_style) do |seq|
-        each do |k, v|
-          seq.add(k => v)
-        end
-      end
-    end
-  end
-
-  # Hash is ordered in Ruby 1.9!
-  if RUBY_VERSION < '1.9'
-    def initialize(*args, &block)
-      super
-      @keys = []
-    end
-
-    def self.[](*args)
-      ordered_hash = new
-
-      if (args.length == 1 && args.first.is_a?(Array))
-        args.first.each do |key_value_pair|
-          next unless (key_value_pair.is_a?(Array))
-          ordered_hash[key_value_pair[0]] = key_value_pair[1]
-        end
-
-        return ordered_hash
-      end
-
-      unless (args.size % 2 == 0)
-        raise ArgumentError.new("odd number of arguments for Hash")
-      end
-
-      args.each_with_index do |val, ind|
-        next if (ind % 2 != 0)
-        ordered_hash[val] = args[ind + 1]
-      end
-
-      ordered_hash
-    end
-
-    def initialize_copy(other)
-      super(other)
-      @keys = other.keys
-    end
-
-    def []=(key, value)
-      @keys << key unless key?(key)
-      super(key, value)
-    end
-
-    def delete(key)
-      if has_key? key
-        index = @keys.index(key)
-        @keys.delete_at(index)
-      end
-      super(key)
-    end
-
-    def delete_if
-      super
-      sync_keys!
-      self
-    end
-
-    def reject!
-      super
-      sync_keys!
-      self
-    end
-
-    def reject(&block)
-      dup.reject!(&block)
-    end
-
-    def keys
-      @keys.dup
-    end
-
-    def values
-      @keys.collect{ |key| self[key] }
-    end
-
-    def to_hash
-      self
-    end
-
-    def to_a
-      @keys.map{ |key| [ key, self[key] ] }
-    end
-
-    def each_key
-      @keys.each{ |key| yield(key) }
-    end
-
-    def each_value
-      @keys.each{ |key| yield(self[key]) }
-    end
-
-    def each
-      @keys.each{ |key| yield(key, self[key]) }
-    end
-
-    alias_method :each_pair, :each
-
-    def clear
-      super
-      @keys.clear
-      self
-    end
-
-    def shift
-      k = @keys.first
-      v = delete(k)
-      [k, v]
-    end
-
-    def merge!(other_hash)
-      other_hash.each{ |k,v| self[k] = v }
-      self
-    end
-
-    def merge(other_hash)
-      dup.merge!(other_hash)
-    end
-
-    # When replacing with another hash, the initial order of our
-    # keys must come from the other hash, ordered or not.
-    def replace(other)
-      super
-      @keys = other.keys
-      self
-    end
-
-    def inspect
-      "#<OrderedHash #{super}>"
-    end
-
-    private
-      def sync_keys!
-        @keys.delete_if{ |k| !key?(k) }
-      end
-  end
-end
-
-require 'yaml'
-
-YAML.add_builtin_type("omap") do |type, val|
-  ActiveSupport::OrderedHash[val.map(&:to_a).map(&:first)]
-end
-
+require 'hashery/ordered_hash'

data/lib/hashery/property_hash.rb

@@ -1 +1,97 @@
-require 'hashery/propertyhash'
+# A PropertyHash is the same as a regular Hash except it strictly limits the
+# allowed keys.
+#
+# There are two ways to use it.
+#
+# 1) As an object in itself.
+#
+#   h = PropertyHash.new(:a=>1, :b=>2)
+#   h[:a]        #=> 1
+#   h[:a] = 3
+#   h[:a]        #=> 3
+#
+# But if we try to set key that was not fixed, then we will get an error.
+#
+#   h[:x] = 5    #=> ArgumentError
+# 
+# 2) As a superclass.
+#
+#   class MyPropertyHash < PropertyHash
+#     property :a, :default => 1
+#     property :b, :default => 2
+#   end
+#
+#   h = MyPropertyHash.new
+#   h[:a]        #=> 1
+#   h[:a] = 3
+#   h[:a]        #=> 3
+#
+# Again, if we try to set key that was not fixed, then we will get an error.
+#
+#   h[:x] = 5    #=> ArgumentError
+#
+class PropertyHash < Hash
+
+  #
+  def self.properties
+    @properties ||= (
+      parent = ancestors[1]
+      if parent.respond_to?(:properties)
+        parent.properties
+      else
+        {}
+      end
+    )
+  end
+
+  #
+  def self.property(key, opts={})
+    properties[key] = opts[:default]
+  end
+
+  #
+  def initialize(properties={})
+    super()
+    fixed = self.class.properties.merge(properties)
+    replace(fixed)
+  end
+
+  #
+  def []=(k,v)
+    assert_key!(k)
+    super(k,v)
+  end
+
+  #
+  def update(h)
+    h.keys.each{ |k| assert_key!(k) }
+    super(h)
+  end
+
+  #
+  def merge!(h)
+    h.keys.each{ |k| assert_key!(k) }
+    super(h)
+  end
+
+  #
+  def <<(a)
+    k,v = *a
+    self[k] = v
+  end
+
+  # Add a new acceptable key.
+  # TODO: Should this be supported?
+  def accept_key!(k,v=nil)
+    self[k] = v
+  end
+
+  private
+
+  def assert_key!(key)
+    unless key?(key)
+      raise ArgumentError, "The key '#{key}' is not defined for this FixedHash."
+    end
+  end
+
+end

data/lib/hashery/propertyhash.rb

@@ -1,97 +1 @@
-# A PropertyHash is the same as a regular Hash except it strictly limits the
-# allowed keys.
-#
-# There are two ways to use it.
-#
-# 1) As an object in itself.
-#
-#   h = PropertyHash.new(:a=>1, :b=>2)
-#   h[:a]        #=> 1
-#   h[:a] = 3
-#   h[:a]        #=> 3
-#
-# But if we try to set key that was not fixed, then we will get an error.
-#
-#   h[:x] = 5    #=> ArgumentError
-# 
-# 2) As a superclass.
-#
-#   class MyPropertyHash < PropertyHash
-#     property :a, :default => 1
-#     property :b, :default => 2
-#   end
-#
-#   h = MyPropertyHash.new
-#   h[:a]        #=> 1
-#   h[:a] = 3
-#   h[:a]        #=> 3
-#
-# Again, if we try to set key that was not fixed, then we will get an error.
-#
-#   h[:x] = 5    #=> ArgumentError
-#
-class PropertyHash < Hash
-
-  #
-  def self.properties
-    @properties ||= (
-      parent = ancestors[1]
-      if parent.respond_to?(:properties)
-        parent.properties
-      else
-        {}
-      end
-    )
-  end
-
-  #
-  def self.property(key, opts={})
-    properties[key] = opts[:default]
-  end
-
-  #
-  def initialize(properties={})
-    super()
-    fixed = self.class.properties.merge(properties)
-    replace(fixed)
-  end
-
-  #
-  def []=(k,v)
-    assert_key!(k)
-    super(k,v)
-  end
-
-  #
-  def update(h)
-    h.keys.each{ |k| assert_key!(k) }
-    super(h)
-  end
-
-  #
-  def merge!(h)
-    h.keys.each{ |k| assert_key!(k) }
-    super(h)
-  end
-
-  #
-  def <<(a)
-    k,v = *a
-    self[k] = v
-  end
-
-  # Add a new acceptable key.
-  # TODO: Should this be supported?
-  def accept_key!(k,v=nil)
-    self[k] = v
-  end
-
-  private
-
-  def assert_key!(key)
-    unless key?(key)
-      raise ArgumentError, "The key '#{key}' is not defined for this FixedHash."
-    end
-  end
-
-end
+require 'hashery/property_hash'

data/lib/hashery/query_hash.rb

@@ -1 +1,35 @@
-require 'hashery/queryhash'
+# = 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/queryhash.rb

@@ -1,35 +1 @@
-# = 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
+require 'hashery/query_hash'

data/lib/hashery/stash.rb

@@ -1,181 +1,10 @@
-# Stash is just like Hash, except that all keys are
-# converted to Strings.
-#
-# Note this doesn't yet handle default_proc.
+require 'hashery/keyhash'
 
-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
+Stash = KeyHash
 
 class Hash
-
-  # Convert a Hash to a Stash object.
+  # Convert Hash to Stash.
   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
-