RubyGems - order_tree - Versions diffs - 0.0.2 - Mend

order_tree 0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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