hashery 1.4.0 → 1.5.0

data/lib/hashery/open_cascade.rb

@@ -1 +1,99 @@
-require 'hashery/opencascade'
+require 'hashery/open_hash'
+#require 'facets/nullclass'
+
+# = OpenCascade
+#
+# OpenCascade is subclass of OpenHash. It differs in a few
+# significant ways.
+#
+# The main reason this class is labeled "cascade", every internal
+# Hash is transformed into an OpenCascade dynamically upon access.
+# This makes it easy to create "cascading" references.
+#
+#   h = { :x => { :y => { :z => 1 } } }
+#   c = OpenCascade[h]
+#   c.x.y.z  #=> 1
+#
+# As soon as you access a node it automatically becomes an OpenCascade.
+#
+#   c = OpenCascade.new   #=> #<OpenCascade:0x7fac3680ccf0 {}>
+#   c.r                   #=> #<OpenCascade:0x7fac368084c0 {}>
+#   c.a.b                 #=> #<OpenCascade:0x7fac3680a4f0 {}>
+#
+# But if you set a node, then that will be it's value.
+#
+#   c.a.b = 4             #=> 4
+#
+# To query a node without causing the auto-creation of an OpenCasade
+# object, use the ?-mark.
+#
+#   c.a.z?                #=> nil
+#
+# OpenCascade also transforms Hashes within Arrays.
+#
+#  h = { :x=>[ {:a=>1}, {:a=>2} ], :y=>1 }
+#  c = OpenCascade[h]
+#  c.x.first.a.assert == 1
+#  c.x.last.a.assert == 2
+#
+# Finally, you can set a node and get the reciever back using
+# the !-mark.
+#
+#   c = OpenCascade.new   #=> #<OpenCascade:0x7fac3680ccf0 {}>
+#   c.x!(4).y!(3)         #=> #<OpenCascade:0x7fac3680ccf0 {:x=>4, :y=>3}>
+#
+#--
+# Last, when an entry is not found, 'null' is returned rather then 'nil'.
+# This allows for run-on entries withuot error. Eg.
+#
+#   o = OpenCascade.new
+#   o.a.b.c  #=> null
+#
+# Unfortuately this requires an explict test for null? in 'if' conditions.
+#
+#   if o.a.b.c.null?  # true if null
+#   if o.a.b.c.nil?   # true if nil or null
+#   if o.a.b.c.not?   # true if nil or null or false
+#
+# So be sure to take that into account.
+#++
+
+class OpenCascade < OpenHash
+
+  #
+  def method_missing(sym, *args, &blk)
+    type = sym.to_s[-1,1]
+    name = sym.to_s.gsub(/[=!?]$/, '').to_sym
+    case type
+    when '='
+      self[name] = args.first
+    when '!'
+      #@hash.__send__(name, *args, &blk)
+      __send__(name, *args, &blk)
+    when '?'
+      self[name]
+    else
+      if key?(name)
+        self[name] = transform_entry(self[name])
+      else
+        self[name] = OpenCascade.new #self.class.new
+      end
+    end
+  end
+
+  private
+
+    #
+    def transform_entry(entry)
+      case entry
+      when Hash
+        OpenCascade.new(entry) #self.class.new(val)
+      when Array
+        entry.map{ |e| transform_entry(e) }
+      else
+        entry
+      end
+    end
+
+end
+

data/lib/hashery/open_hash.rb

@@ -1 +1,77 @@
-require 'hashery/openhash'
+# = OpenHash
+#
+# OpenHash is very similar to Ruby's own OpenStruct, but it offers some
+# useful advantages in that it is a true Hash object.
+#
+# Because OpenHash is a subclass of Hash, it can do everything a Hash
+# can *unless* a Hash method has been explicity exempted for use
+# as an open read/writer via the #omit! method.
+
+class OpenHash < Hash
+
+  # New OpenHash.
+  def initialize(data={})
+    super()
+    merge!(data)
+  end
+
+  #
+  def <<(x)
+    case x
+    when Hash
+      update(x)
+    when Array
+      x.each_slice(2) do |(k,v)|
+        self[k] = v
+      end
+    end
+  end
+
+  #
+  def respond_to?(name)
+    key?(name.to_sym) || super(name)
+  end
+
+  #
+  def to_h
+    dup
+  end
+
+  #
+  def to_hash
+    dup
+  end
+
+  #
+  def inspect
+    super
+  end
+
+  # Omit specific Hash methods from slot protection.
+  def omit!(*methods)
+    methods.reject!{ |x| x.to_s =~ /^__/ }
+    (class << self; self; end).class_eval{ private *methods }
+  end
+
+  # Route get and set calls.
+  def method_missing(s,*a, &b)
+    type = s.to_s[-1,1]
+    name = s.to_s.sub(/[!?=]$/, '')
+    key  = name.to_sym
+    case type
+    when '='
+      self[key] = a[0]
+    #when '!'
+    #  self[s] = OpenHash.new
+    when '?'
+      key?(key)
+    else
+      if key?(key)
+        self[key]
+      else
+        super(s,*a,&b)
+      end
+    end
+  end
+
+end

data/lib/hashery/opencascade.rb

@@ -1,99 +1 @@
-require 'hashery/openhash'
-#require 'facets/nullclass'
-
-# = OpenCascade
-#
-# OpenCascade is subclass of OpenHash. It differs in a few
-# significant ways.
-#
-# The main reason this class is labeled "cascade", every internal
-# Hash is transformed into an OpenCascade dynamically upon access.
-# This makes it easy to create "cascading" references.
-#
-#   h = { :x => { :y => { :z => 1 } } }
-#   c = OpenCascade[h]
-#   c.x.y.z  #=> 1
-#
-# As soon as you access a node it automatically becomes an OpenCascade.
-#
-#   c = OpenCascade.new   #=> #<OpenCascade:0x7fac3680ccf0 {}>
-#   c.r                   #=> #<OpenCascade:0x7fac368084c0 {}>
-#   c.a.b                 #=> #<OpenCascade:0x7fac3680a4f0 {}>
-#
-# But if you set a node, then that will be it's value.
-#
-#   c.a.b = 4             #=> 4
-#
-# To query a node without causing the auto-creation of an OpenCasade
-# object, use the ?-mark.
-#
-#   c.a.z?                #=> nil
-#
-# OpenCascade also transforms Hashes within Arrays.
-#
-#  h = { :x=>[ {:a=>1}, {:a=>2} ], :y=>1 }
-#  c = OpenCascade[h]
-#  c.x.first.a.assert == 1
-#  c.x.last.a.assert == 2
-#
-# Finally, you can set a node and get the reciever back using
-# the !-mark.
-#
-#   c = OpenCascade.new   #=> #<OpenCascade:0x7fac3680ccf0 {}>
-#   c.x!(4).y!(3)         #=> #<OpenCascade:0x7fac3680ccf0 {:x=>4, :y=>3}>
-#
-#--
-# Last, when an entry is not found, 'null' is returned rather then 'nil'.
-# This allows for run-on entries withuot error. Eg.
-#
-#   o = OpenCascade.new
-#   o.a.b.c  #=> null
-#
-# Unfortuately this requires an explict test for null? in 'if' conditions.
-#
-#   if o.a.b.c.null?  # true if null
-#   if o.a.b.c.nil?   # true if nil or null
-#   if o.a.b.c.not?   # true if nil or null or false
-#
-# So be sure to take that into account.
-#++
-
-class OpenCascade < OpenHash
-
-  #
-  def method_missing(sym, *args, &blk)
-    type = sym.to_s[-1,1]
-    name = sym.to_s.gsub(/[=!?]$/, '').to_sym
-    case type
-    when '='
-      self[name] = args.first
-    when '!'
-      #@hash.__send__(name, *args, &blk)
-      __send__(name, *args, &blk)
-    when '?'
-      self[name]
-    else
-      if key?(name)
-        self[name] = transform_entry(self[name])
-      else
-        self[name] = OpenCascade.new #self.class.new
-      end
-    end
-  end
-
-  private
-
-    #
-    def transform_entry(entry)
-      case entry
-      when Hash
-        OpenCascade.new(entry) #self.class.new(val)
-      when Array
-        entry.map{ |e| transform_entry(e) }
-      else
-        entry
-      end
-    end
-
-end
-
+require 'hashery/open_cascade'

data/lib/hashery/openhash.rb

@@ -1,77 +1 @@
-# = OpenHash
-#
-# OpenHash is very similar to Ruby's own OpenStruct, but it offers some
-# useful advantages in that it is a true Hash object.
-#
-# Because OpenHash is a subclass of Hash, it can do everything a Hash
-# can *unless* a Hash method has been explicity exempted for use
-# as an open read/writer via the #omit! method.
-
-class OpenHash < Hash
-
-  # New OpenHash.
-  def initialize(data={})
-    super()
-    merge!(data)
-  end
-
-  #
-  def <<(x)
-    case x
-    when Hash
-      update(x)
-    when Array
-      x.each_slice(2) do |(k,v)|
-        self[k] = v
-      end
-    end
-  end
-
-  #
-  def respond_to?(name)
-    key?(name.to_sym) || super(name)
-  end
-
-  #
-  def to_h
-    dup
-  end
-
-  #
-  def to_hash
-    dup
-  end
-
-  #
-  def inspect
-    super
-  end
-
-  # Omit specific Hash methods from slot protection.
-  def omit!(*methods)
-    methods.reject!{ |x| x.to_s =~ /^__/ }
-    (class << self; self; end).class_eval{ private *methods }
-  end
-
-  # Route get and set calls.
-  def method_missing(s,*a, &b)
-    type = s.to_s[-1,1]
-    name = s.to_s.sub(/[!?=]$/, '')
-    key  = name.to_sym
-    case type
-    when '='
-      self[key] = a[0]
-    #when '!'
-    #  self[s] = OpenHash.new
-    when '?'
-      key?(key)
-    else
-      if key?(key)
-        self[key]
-      else
-        super(s,*a,&b)
-      end
-    end
-  end
-
-end
+require 'hashery/open_hash'

data/lib/hashery/ordered_hash.rb

@@ -1 +1,168 @@
-require 'hashery/orderedhash'
+# = 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|
+  OrderedHash[val.map(&:to_a).map(&:first)]
+end
+