RubyGems - order_tree - Versions diffs - 0.0.2 - Mend

order_tree 0.0.2

Files changed (17) hide show

data/.DS_Store +0 -0
data/.gitignore +5 -0
data/.yardoc/checksums +5 -0
data/.yardoc/objects/root.dat +0 -0
data/.yardoc/proxy_types +0 -0
data/Gemfile +4 -0
data/README.md +26 -0
data/Rakefile +39 -0
data/lib/order_tree.rb +6 -0
data/lib/order_tree/order_tree.rb +319 -0
data/lib/order_tree/order_tree_node.rb +66 -0
data/lib/order_tree/unique_proxy.rb +96 -0
data/lib/order_tree/version.rb +3 -0
data/order_tree.gemspec +26 -0
data/spec/order_tree_spec.rb +338 -0
data/spec/spec_helper.rb +35 -0
metadata +110 -0

data/.DS_Store ADDED Viewed

Binary file

data/.gitignore ADDED Viewed

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+report/*
+Gemfile.lock
+pkg/*

data/.yardoc/checksums ADDED Viewed

@@ -0,0 +1,5 @@
+lib/order_tree.rb 1587f76284fef215167a4b0970a1411503f6543f
+lib/order_tree/version.rb 12d621b5c0101d185a48bac5d5ad897d7b83053b
+lib/order_tree/unique_proxy.rb 632e468875c365d94b069f5c7e4d3d10030ccb55
+lib/order_tree/order_tree.rb 3dc2a2a576334be3fe9cd19fe999b310fbfd7ea6
+lib/order_tree/order_store.rb cfef2da2707e61ed0637a48e9a0c1a55d9578b1c

data/.yardoc/objects/root.dat ADDED Viewed

Binary file

data/.yardoc/proxy_types ADDED Viewed

Binary file

data/Gemfile ADDED Viewed

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+# Specify your gem's dependencies in order_tree.gemspec
+gemspec

data/README.md ADDED Viewed

@@ -0,0 +1,26 @@
+#Ordered Tree
+This is a nested hash / unbalance tree structure which iterates over all of
+its available values in insertion order.
+##Like a Normal Hash?
+Exactly like a normal hash.  Althought with a standard Ruby Hash it's impossible to
+know whether or not `hash["a"]["b"]` was inserted before or after `hash["b"]["c"]`
+because each individual Hash maintains it's own insertion order.
+Now you can know.  If you need to.  The main thing you gain with this over an
+Array is the ability to prune or transplant multiple values at the same
+time by cutting on one of the branches.
+##Caveat
+Each value is actually stored in a proxy object which maintains a unique id.
+This is necessary so that if you insert three `4`s into the tree you can tell
+which one came first.  This wouldn't actually be necessary in a C implementation,
+or in one based on WeakRefs, but it works okay here.
+You can generally treat the OrderTree exactly like a nested hash, but be aware
+that the first and last methods (as well as the #each iterator) actually return
+an OrderTreeNode and not the actual object stored at that location.  (You can
+get at it by using #orig on the returned value.

data/Rakefile ADDED Viewed

@@ -0,0 +1,39 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.rspec_opts = "-d"
+end
+RSpec::Core::RakeTask.new(:spec_with_report) do |spec|
+  spec.fail_on_error = false
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.rspec_opts = "--format html --out report/test_report.html"
+end
+task :report do
+  Dir.mkdir "report" unless File.exists? "report"
+  Dir.mkdir "report/profile" unless File.exists? "report/profile"
+  File.open "report/index.html","w" do |f|
+    f.write <<-HTML
+      <html>
+        <body>
+          <h1> Status Report </h1>
+          <a href="coverage/index.html"> Coverage </a>
+          <a href="profile/profile.html"> Speed Profile </a>
+          <a href="test_report.html"> Test Report </a>
+        </body>
+      </html>
+    HTML
+  end
+  ENV["REPORT"] = "1"
+  Rake::Task[:spec_with_report].invoke
+  ENV["REPORT"] = ""
+end
+task :default => :spec

data/lib/order_tree.rb ADDED Viewed

@@ -0,0 +1,6 @@
+require 'order_tree/unique_proxy'
+require 'order_tree/order_tree_node'
+require 'order_tree/order_tree'
+module OrderTree
+end

data/lib/order_tree/order_tree.rb ADDED Viewed

@@ -0,0 +1,319 @@
+require 'delegate'
+module OrderTree
+  # A unbalance tree / nested hash type structure that implements #each and returns
+  # the values in the order in which they were inserted, regardless of depth
+  # It can mostly be treated as a nested hash - but #each will return a #path
+  # to the values it iterates
+  class OrderTree
+    include Enumerable
+    include ProxyOperator
+    class PathNotFound < StandardError; end
+    attr_accessor :first, :root
+    attr_reader :last
+    # Create a new OrderTree
+    # @param [Hash] constructor - a hash literal for the initial values
+    # @param [OrderTree] OrderTree - the root tree object.
+    # @note The order of insertion might not be what you would expect for multi-
+    #   level hash literals. The most deeply nested values will be inserted FIRST.
+    def initialize(constructor = {}, root = nil)
+      @_delegate_hash = {}
+      self.root = root || self
+      constructor.each_with_object(self) do |(k,v),memo|
+        memo[k] = v
+      end
+      self.default = OrderTreeNode.new(nil,self) if self.root
+      _delegate_hash.default = self.default
+    end
+    def last= obj
+      if @last.nil?
+        @first = obj
+        @last = obj
+      else
+        @last = obj
+      end
+    end
+    protected :last=
+    # Set the default value for the tree
+    # This place the default object behind a UniqueProxy. The default
+    # is not remembered within the order
+    # @param [Object] obj
+    def default= obj
+      unless proxy? obj
+        obj = OrderTreeNode.new(obj,self)
+      end
+      @default = obj
+      _delegate_hash.default = @default
+      _delegate_hash.each_value do |v|
+        if v.is_a? OrderTree
+          v.default= obj
+        end
+      end
+    end
+    attr_reader :default
+    # Yields each path, value pair of the OrderTree in the order in which it was
+    # inserted
+    # @return [Enumerator]
+    # @yield [path, value] yields the path (as an array) to a value
+    # @yieldparam [Array] path the path as an array
+    # @yieldparam [Object] value the original object stored in the OrderTree
+    def each_pair
+      return enum_for(:each_pair) unless block_given?
+      self.each do |c|
+        yield c.path, c.orig
+      end
+    end
+    # @return [Array] the results of calling {#each}.to_a
+    def order
+      each_pair.to_a
+    end
+    # @return [Enumerator] collection of OrderTreeNode objects in insertion order
+    def each
+      return enum_for(:each) unless block_given?
+      c = root.first
+      while c
+        yield c
+        c = c.next
+      end
+    end
+    # @return [Enumerator] collection of paths in insertion order
+    def each_path
+      return enum_for(:each_path) unless block_given?
+      self.each do |v|
+        yield v.path
+      end
+    end
+    # @return [Enumerator] collection of leaf values in insertion order
+    def each_leaf
+      return enum_for(:each_leaf) unless block_given?
+      self.each do |v|
+        unless v.is_a? OrderTree
+          yield v.orig
+        end
+      end
+    end
+    # @return [Enumerator] collection of values in insertion order, including subnodes
+    def each_value
+      return enum_for(:each_value) unless block_given?
+      self.each do |v|
+        yield v.orig
+      end
+    end
+    # Finds the first occurence of an object in the tree
+    # @param [Object] val the value to search for this is a O(n) operation
+    # @param [Block] block if both a block and val are passed, the
+    #   block will be evalueated first, then the value
+    # @return [Array, false, true] path to value, false if not found, or true if value == self
+    # @yield [value] use the block to perform more complicated tests
+    # @yieldreturn [Boolean]
+    # @raises [ArgumentError] if neither a val nor block is given.
+    # @note You cannot search for a nil value by passing nil as the value. You must
+    #   pass a block that compares for nil
+    # @note This methods does NOT guarantee that you will recieve the result
+    #   in inserted order
+    def path val = nil, &block
+      begin
+        path! val, &block
+      rescue PathNotFound
+        nil
+      end
+    end
+    # Finds the first occurence of a specific insertion in the tree
+    # @param [OrderTreeNode] val the proxy object to find
+    def strict_path val = nil
+      begin
+        strict_path! val
+      rescue PathNotFound
+        nil
+      end
+    end
+    # Raises an exception if it can't determine the path
+    # @see {#path}
+    def path! val = nil, &block
+      raise ArgumentError, "requires search value or block" if val.nil? and block.nil?
+      __path(val, false, [], &block)
+    end
+    # Raises an exception if it can't find the object
+    # @see {#strict_path}
+    def strict_path! val
+      unless ProxyOperator.proxy? val
+        raise ArgumentError, "OrderTreeNode expected for strict_path"
+      end
+      __path(val, true)
+    end
+    # @private
+    def __path val = nil, strict = false, key_path = [], &block
+      op = strict ? :equal? : :==
+      return true if (yield(val) unless block.nil?) or self.__send__ op, val
+      _delegate_hash.each do |k,v|
+        if (yield v unless block.nil?) or v.__send__ op, val
+          key_path << k
+          break
+        elsif v.respond_to? :__path, true
+          begin
+            v.__path(val, strict, key_path, &block)
+            key_path.unshift(k)
+            break
+          rescue PathNotFound
+            # try the next one
+          end
+        end
+      end
+      raise PathNotFound, "Couldn't find path to #{val} in #{self.to_s}" if key_path.empty?
+      key_path
+    end
+    private :__path
+    # @private
+    # @api Delegate
+    def _delegate_hash
+      @_delegate_hash
+    end
+    private :_delegate_hash
+    def to_s
+      "#<#{self.class}:#{'0x%x' % self.__id__ << 1}>"
+    end
+    def inspect
+      _delegate_hash.inspect
+    end
+    # @param [OrderTree] other
+    # @return [true] if self and other do not share all leaves or were inserted in a different order
+    def != other
+      !(self == other)
+    end
+    # @param [OrderTree] other
+    # @return [true] if self and other share all of their leaves and were inserted in the same order
+    def == other
+      return false if other.class != self.class
+      ov,sv = other.each_value.to_a, self.each_value.to_a
+      t_arr = ov.size > sv.size ? (ov.zip(sv)) : (sv.zip(ov))
+      t_arr.each do |sv, ov|
+        return false if sv.nil? ^ ov.nil?
+        if [ov,sv].map { |v| v.respond_to? :_delegate_hash, true}.all?
+          return false unless ov.send(:_delegate_hash) == sv.send(:_delegate_hash)
+        elsif ov != sv
+          return false
+        end
+      end
+    end
+    # @param [OrderTree] other
+    # @return [true] if self and other contains the same key/path pairs as leaf nodes, regardless of their
+    #   order of insertion
+    def contents_equal? other
+      return false if other.class != self.class
+      ov,sv = other.each_leaf.to_a.sort, self.each_leaf.to_a.sort
+      t_arr = ov.size > sv.size ? (ov.zip(sv)) : (sv.zip(ov))
+      t_arr.each do |sv,ov|
+        return false unless sv == ov
+      end
+    end
+    # Returns the UniqueProxy at path.
+    # @param [Array] path the path to return
+    # @return [OrdeTreeNode] either OrderTreeNode default or the OrderTreeNode at path
+    def at *paths
+      t = self
+      paths.each do |p|
+        if t.respond_to? :at # if it's a branch nodejkeep looking
+          t = (t.__send__ :_delegate_hash)[p]
+        else
+          #other wise resturn the default
+          return self.root.default
+        end
+      end
+      t
+    end
+    # Return the object stored at path
+    # @param [Array] path you may specify the path as either an array, or
+    #   by using the nested hash syntax
+    # @example
+    #    obj = OrderTree.new( :first => { :second => { :third => 3 }})
+    #    obj[:first, :second, :third] #=> 3
+    #    obj[:first][:second][:third] #=> 3
+    def [] *paths
+      t = self.at *paths
+      t.orig
+    end
+    # @private
+    def _find_delegate_hash *paths
+      under = self
+      paths.each do |k|
+        under = under.instance_eval do
+          unless self.respond_to? :_delegate_hash, true
+            raise NoMethodError, "Can't reifiy tree leaf on access to #{paths}"
+          end
+          h = self.send :_delegate_hash
+          if h.has_key? k and k != paths.last
+            h[k]
+          else
+            break h
+          end
+        end
+      end
+      under
+    end
+    private :_find_delegate_hash
+    # Prune branch from the tree
+    # @param [Array] path
+    def delete *paths
+      under = _find_delegate_hash *paths
+      if under.has_key? paths.last
+        under[paths.last].remove
+      end
+    end
+    # Stores the value at path
+    # @param [Array] path
+    # @param [Object] value
+    def []= *paths, value
+      under = _find_delegate_hash *paths
+      if value.kind_of? Hash or value.kind_of? OrderTree
+        value = OrderTree.new(value, @root)
+        value.default= self.root.default
+      end
+      if under.has_key? paths.last # i am overwriting a path
+        under[paths.last].remove
+      end
+      under[paths.last] = OrderTreeNode.new(value, self)
+      under[paths.last].prev = root.last if root.last
+      root.last.next = under[paths.last] if root.last
+      root.last = under[paths.last]
+      #@order.push under[paths.last]
+      #puts "insertion of '#{value}' in #{self.to_s} -> #{@order.to_s} (id #{under[paths.last].unique_id})"
+      value
+    end
+    alias :store :[]=
+  end
+end

data/lib/order_tree/order_tree_node.rb ADDED Viewed

@@ -0,0 +1,66 @@
+module OrderTree
+  class OrderTreeNode < UniqueProxy
+    attr_accessor :next, :prev
+    attr_accessor :tree
+    attr_reader :path
+    def initialize obj, tree
+      super(obj)
+      @tree = tree
+    end
+    def remove
+      prev_node = self.prev
+      next_node = self.next
+      self.next.prev = prev_node if self.next
+      self.prev.next = next_node if self.prev
+      if self.tree.root.first.equal? self
+        self.tree.root.first = self.next
+      end
+      # try this so that the node can remove
+      # itself fromt he tree
+      my_path = self.path
+      self.tree.instance_eval do
+        _delegate_hash.delete my_path.last
+      end
+      @path = nil
+      @tree = nil
+      @next = nil
+      @prev = nil
+      self
+    end
+    def before other
+      (self <=> other) == -1 ? true : false
+    end
+    def after other
+      (self <=> other) == 1 ? true : false
+    end
+    def <=> other
+      if self.equal? other
+        return 0
+      else
+        p, n = self.prev, self.next
+        while p or n
+          return 1 if p.equal? other
+          return -1 if n.equal? other
+          p = p.prev if p
+          n = n.next if n
+        end
+      end
+      raise ::ArgumentError, "Cannot compare #{self} and #{other} because they are not in the same tree"
+    end
+    def path
+      @path || self.path!
+    end
+    def path!
+      @path = self.tree.root.strict_path! self
+    end
+  end
+end

data/lib/order_tree/unique_proxy.rb ADDED Viewed

@@ -0,0 +1,96 @@
+require 'securerandom'
+module OrderTree
+  # Mixin module that provides a proxy convience functions
+  module ProxyOperator
+    #@param [Object] obj object to test
+    #@return [Boolean] is object in fact a proxy?
+    def proxy? obj
+      !!(obj.instance_eval { @is_proxy })
+    rescue false
+    end
+    module_function :proxy?
+    #@param [Object] obj object to proxy
+    #@return [UniqueProxy] create a unique proxy over obj
+    def proxy obj
+      UniqueProxy.new obj
+    rescue false
+    end
+    module_function :proxy
+  end
+  # Simple Proxy for distinguishing between the insertions of two identical
+  # objects in an order tree.  Assign a unique ID to any object passed through
+  # the proxy, so you can always find the same object, even if you move it
+  # around in the tree. It also enables you to tell the differen between two
+  # different insertions of the same singleton object.
+  class UniqueProxy < BasicObject
+    class << self
+      attr_accessor :verbose_inspect
+    end
+    # @param [Object] obj - the proxy target
+    def initialize obj
+      @is_proxy = true
+      @obj = obj
+      @uuid ||= ::SecureRandom.uuid
+    end
+    # @return [String] the unique ID of the proxy
+    def unique_id
+      @uuid
+    end
+    # @return [String] a string describing the proxy if UniqueProxy.verbose_inspect is not false
+    #   otherwise calls #inspect on the proxied object
+    def inspect
+      if UniqueProxy.verbose_inspect
+        "#<#{UniqueProxy}::#{@uuid} => #{@obj.inspect}>"
+      else
+        @obj.inspect
+      end
+    end
+    # @return [String] a eval-able string to create a new proxy over this proxied object
+    def to_s
+      if UniqueProxy.verbose_inspect
+        "proxy(#{@obj.to_s})"
+      else
+        @obj.to_s
+      end
+    end
+    # Is true only if the other object has the same unique_id as self
+    def equal? other
+      (@uuid == other.unique_id) rescue false
+    end
+    # @return [Object] the unproxied target
+    def orig
+      @obj
+    end
+    # Dispatches methods calls to proxy target
+    def method_missing(method, *args, &block)
+      @obj.__send__ method, *args, &block
+    end
+    # @private
+    def !
+      !@obj
+    end
+    # @private
+    def == arg
+      @obj == arg
+    end
+    # @private
+    def != arg
+      @obj != arg
+    end
+  end
+end

data/lib/order_tree/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module OrderTree
+  VERSION = "0.0.2"
+end

data/order_tree.gemspec ADDED Viewed

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "order_tree/version"
+Gem::Specification.new do |s|
+  s.name        = "order_tree"
+  s.version     = OrderTree::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Stephen Prater"]
+  s.email       = ["stephenp@agrussell.com"]
+  s.homepage    = "http://github.com/stephenprater/order_tree"
+  s.summary     = %q{An unbalanced tree / nested hash which remember insertion order}
+  s.description = %q{Use OrderTree when you need both insertion order access and nested hash path style access}
+  s.rubyforge_project = "order_tree"
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('simplecov')
+  s.add_development_dependency('ruby-prof')
+  s.add_development_dependency('ruby-debug19')
+end

data/spec/order_tree_spec.rb ADDED Viewed

@@ -0,0 +1,338 @@
+require 'spec_helper'
+require 'pp'
+require 'order_tree'
+describe OrderTree::UniqueProxy do
+  before :all do
+    Object.send :include, OrderTree::ProxyOperator
+  end
+  it "can tell apart things that are the same" do
+    (4 == 4).should eq true
+    (4.equal? 4).should eq true #because fixnums are really the same object
+    a = OrderTree::UniqueProxy.new(4)
+    b = OrderTree::UniqueProxy.new(4)
+    c = OrderTree::UniqueProxy.new(5)
+    (a == b).should eq true
+    (!c).should eq false
+    (c != a).should eq true
+    (a.equal? b).should eq false
+    (a.orig.equal? b.orig).should eq true
+  end
+  it "can retrieve the unique id" do
+    a = OrderTree::UniqueProxy.new(4)
+    b = OrderTree::UniqueProxy.new(4)
+    a.unique_id.should_not eq b.unique_id
+  end
+  it "can identify a proxy" do
+    a = OrderTree::UniqueProxy.new(5)
+    proxy(5).should eq proxy(5)
+    (proxy(5).equal? proxy(5)).should be_false
+    (proxy? a).should be_true
+    (proxy? 5).should be_false
+  end
+  it "can help you inspect and to_s proxies" do
+    proxy(5).to_s.should eq "5"
+    proxy(5).inspect.should eq "5"
+    OrderTree::UniqueProxy.verbose_inspect = true
+    p = proxy(5)
+    p.inspect.to_s.should match(/#<UniqueProxy:(.*?)\s=>\s5>/)
+    p.to_s.should == "proxy(5)"
+    OrderTree::UniqueProxy.verbose_inspect = false
+    p2 = eval(p.to_s)
+    p2.should eq p
+    (p2.equal? p).should be_false
+  end
+end
+describe OrderTree::OrderTree do
+   before :all do
+     @testhash = {
+      :from => {
+        :a => {
+          :b => 4,
+          :c => 4,
+        }
+      },
+      :to => {
+        :d => 4,
+        :e => 4,
+        :to_to => {
+          :f => 5,
+          :g => 6,
+          :h => 7,
+        }
+      }
+    }
+    @testhash_insertion = {
+      :to => {
+        :d => 4,
+        :e => 4,
+        :to_to => {
+          :f => 5,
+          :g => 6,
+          :h => 7,
+        }
+      },
+      :from => {
+        :a => {
+          :b => 4,
+          :c => 4,
+        }
+      }
+    }
+    @order = [[:from, :a, :b],
+              [:from, :a, :c],
+              [:from, :a],
+              [:from],
+              [:to, :d],
+              [:to, :e],
+              [:to, :to_to, :f],
+              [:to, :to_to, :g],
+              [:to, :to_to, :h],
+              [:to, :to_to],
+              [:to]]
+  end
+  it "initializes with a hash" do
+    ot = OrderTree::OrderTree.new(@testhash)
+    ot2 = OrderTree::OrderTree.new(@testhash_insertion)
+  end
+  it "can retrieve based on path or nest" do
+    ot = OrderTree::OrderTree.new(@testhash)
+    ot2 = OrderTree::OrderTree.new(@testhash_insertion)
+    [ot, ot2].map do |t|
+      t[:from][:a][:c].should eq 4
+      t[:from, :a, :c].should eq 4
+    end
+  end
+  it "can set based on path or nest" do
+    ot = OrderTree::OrderTree.new(@testhash)
+    ot2 = OrderTree::OrderTree.new(@testhash_insertion)
+    [ot, ot2].map do |t|
+      t[:from][:a][:d] = 4
+      t[:from, :a, :d].should eq 4
+      t[:from, :a, :e] = 6
+      t[:from][:a][:e].should eq 6
+    end
+  end
+  it "remember the order" do
+    ot = OrderTree::OrderTree.new(@testhash)
+    ot2 = OrderTree::OrderTree.new(@testhash_insertion)
+    ot.each_path.to_a.should eq @order
+    ot2.each_path.to_a.should_not eq @order
+  end
+  it "does not reify the hash on access" do
+    ot = OrderTree::OrderTree.new
+    lambda do
+      ot[:a, :b, :c] = 4
+    end.should raise_error NoMethodError
+  end
+  it "remembers the order after initialize" do
+    ot = OrderTree::OrderTree.new
+    order_paths = [[:a],
+                   [:a, :a1],
+                   [:a, :a2],
+                   [:b],
+                   [:b, :c],
+                   [:b, :c, :d]]
+    order_paths.map do |v|
+      if [[:a], [:b], [:b, :c]].include? v
+        ot[*v] = {}
+      else
+        ot[*v] = 4
+      end
+    end
+    ot.each_path.to_a.should eq order_paths
+  end
+  it "can retrieve each pair" do
+    ot = OrderTree::OrderTree.new @testhash
+    ot.each_pair.with_index do |(p,v),i|
+      p.should eq @order[i]
+      ot[*p].should eq v
+    end
+  end
+  it "can overwrite nodes" do
+    ot = OrderTree::OrderTree.new @testhash
+    ot[:from, :a, :c] = 'overwritten'
+    new_pairs = ot.each_pair.to_a
+    p,v = new_pairs.last
+    p.should eq [:from, :a, :c]
+    v.should eq 'overwritten'
+    ot[:from, :a, :c] = 'overwritten again'
+    p.should eq [:from, :a, :c]
+    ot[:from, :a, :c].should eq 'overwritten again'
+    new_pairs = ot.each_pair.to_a
+    p,v = new_pairs.first
+    p.should eq [:from, :a, :b]
+    v.should eq 4
+    p,v = new_pairs[3]
+    p.should eq [:to, :d]
+    v.should eq 4
+  end
+  it "does == comparison" do
+    ot = OrderTree::OrderTree.new @testhash
+    ot2 = OrderTree::OrderTree.new @testhash
+    ot.first.should eq ot2.first #because underlying objects are compared
+    (ot == ot2).should be_true #each order and == on the object
+    ot.equal?(ot2).should be_false #we're comparing the proxies here
+    (ot.first.equal? ot2.first).should be_false
+  end
+  it "does != comparison" do
+    ot = OrderTree::OrderTree.new @testhash
+    ot2 = OrderTree::OrderTree.new @testhash_insertion
+    (ot != ot2).should be_true
+  end
+  it "does leaf/node equality with contents_equal?" do
+    ot = OrderTree::OrderTree.new @testhash
+    ot2 = OrderTree::OrderTree.new @testhash_insertion
+    (ot.contents_equal? ot2).should be_true
+  end
+  it "overwriting a key moves it to the end of the order" do
+    ot = OrderTree::OrderTree.new
+    ot[:a] = 4
+    ot[:b] = 4
+    ot.each_path.to_a.should eq [[:a], [:b]]
+    ot[:a] = 5
+    ot.each_path.to_a.should eq [[:b], [:a]]
+  end
+  it "overwriting a nested keys moves to the end of the order" do
+    ot = OrderTree::OrderTree.new( {:a => { :b => 4}, :c => 5})
+    ot.each_path.to_a.should eq [[:a, :b], [:a], [:c]]
+    ot[:a,:b] = 5
+    ot.each_path.to_a.should eq [[:a], [:c], [:a, :b]]
+  end
+  it "does not double proxy the default" do
+    ot = OrderTree::OrderTree.new @testhash
+    (proxy? ot.default).should be_true
+    (proxy? ot[:foobar]).should be_false
+    (proxy? ot[:to, :to_to, :no_key]).should be_false
+  end
+  it "returns a default when the key doesn't exist" do
+    ot = OrderTree::OrderTree.new @testhash
+    ot.default = "foo"
+    ot[:to, :foo].should eq "foo"
+    #copies it to nested levels
+    ot.default = "bar"
+    ot[:to, :foo].should eq "bar"
+    ot[:to, :to_to, :no_key].should eq "bar"
+    # does't matter how deep i look
+    ot[:foo, :bar, :foo, :monkey].should eq "bar"
+  end
+  it "can find the path for value" do
+    ot = OrderTree::OrderTree.new @testhash
+    ot.path(7).should eq [:to, :to_to, :h]
+    ot.path(8).should be_nil
+    lambda do
+      ot.path!(7).should eq [:to, :to_to, :h]
+      ot.path!(8)
+    end.should raise_error OrderTree::OrderTree::PathNotFound
+  end
+  it "can prune the tree" do
+    ot = OrderTree::OrderTree.new @testhash
+    ot.default = "bob"
+    ot.delete :from, :a, :b
+    ot[:from, :a, :b].should eq "bob"
+    to_to = ot.at :to, :to_to
+    to_to.remove
+    ot[:to, :to_to].should eq "bob"
+  end
+  it "can find the path for a node object" do
+    ot = OrderTree::OrderTree.new @testhash
+    lambda do
+      ot.strict_path(7)
+    end.should raise_error ArgumentError
+    seven_node = ot.at *ot.path(7)
+    ot.strict_path(seven_node).should eq [:to, :to_to, :h]
+    seven_node.remove
+    ot.strict_path(seven_node).should be_nil
+    #this is the internal call that it uses - it's just here for completeness
+    lambda do
+      ot.strict_path!(seven_node)
+    end.should raise_error OrderTree::OrderTree::PathNotFound
+  end
+  it "can run enumerable methods which depend on <=>" do
+    ot = OrderTree::OrderTree.new @testhash
+    ot.max.should eq ot.last
+    ot.min.should eq ot.first
+    ot.sort.should eq ot.each_value.to_a
+    # roundabout
+    ot.max.should eq ot[*ot.strict_path!(ot.last)]
+    ot.min.should eq ot[*ot.strict_path!(ot.first)]
+  end
+  it "can tell you about insertion order, natch" do
+    ot = OrderTree::OrderTree.new @testhash
+    ot2 = OrderTree::OrderTree.new @testhash_insertion
+    (ot.at(:from, :a, :c).before(ot.at(:from, :a, :b))).should be_false
+    (ot.at(:from, :a, :b).before(ot.at(:to, :d))).should be_true
+    (ot.at(:from, :a, :c).after(ot.at(:from, :a, :b))).should be_true
+    (ot.at(:to, :e).after(ot.at(:from, :a, :b))).should be_true
+    #this probably is only possible if you're doing this.
+    (ot.at(:from, :a, :b) <=> ot.at(:from, :a, :b)).should eq 0
+  end
+  it "can't compare nodes across trees" do
+    ot = OrderTree::OrderTree.new @testhash
+    ot2 = OrderTree::OrderTree.new @testhash_insertion
+    lambda do
+      ot.at(:from, :a, :c).before(ot2.at(:from, :a, :b))
+    end.should raise_error ArgumentError
+  end
+  it "can run regular enumerable methods" do
+    # i'm not going to try all of these, just the one i know
+    # i didn't define.
+    ot = OrderTree::OrderTree.new @testhash
+    ot.each_cons(3).with_index do |v,idx|
+      v.collect { |e| e.path }.should eq @order[idx..idx+2]
+    end
+  end
+end

data/spec/spec_helper.rb ADDED Viewed

@@ -0,0 +1,35 @@
+if ENV["REPORT"] == "1" then
+  require 'simplecov'
+  require 'ruby-prof'
+  require 'ruby-debug'
+  SimpleCov.start do
+    add_filter "spec.rb"
+    coverage_dir "report/coverage"
+  end
+  RSpec.configure do |config|
+    config.before :suite do |example|
+      STDOUT << '|'
+      RubyProf.start
+    end
+    config.around :each do |example|
+      STDOUT << '.'
+      RubyProf.resume do
+        example.run
+      end
+    end
+    config.after :suite do
+      result = RubyProf.stop
+      result.eliminate_methods!([/RSpec::Matchers#.*?/])
+      printer = RubyProf::MultiPrinter.new(result)
+      printer.print(:path => 'report/profile', :profile => "profile")
+    end
+  end
+end
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}

metadata ADDED Viewed

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: order_tree
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease:
+platform: ruby
+authors:
+- Stephen Prater
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2011-07-25 00:00:00.000000000 -05:00
+default_executable:
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &3691310 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *3691310
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &3691090 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *3691090
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: &3690870 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *3690870
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &3690650 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *3690650
+description: Use OrderTree when you need both insertion order access and nested hash
+  path style access
+email:
+- stephenp@agrussell.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .DS_Store
+- .gitignore
+- .yardoc/checksums
+- .yardoc/objects/root.dat
+- .yardoc/proxy_types
+- Gemfile
+- README.md
+- Rakefile
+- lib/order_tree.rb
+- lib/order_tree/order_tree.rb
+- lib/order_tree/order_tree_node.rb
+- lib/order_tree/unique_proxy.rb
+- lib/order_tree/version.rb
+- order_tree.gemspec
+- spec/order_tree_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/stephenprater/order_tree
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: order_tree
+rubygems_version: 1.5.2
+signing_key:
+specification_version: 3
+summary: An unbalanced tree / nested hash which remember insertion order
+test_files:
+- spec/order_tree_spec.rb
+- spec/spec_helper.rb