order_tree 0.0.3 → 0.0.4

data/lib/order_tree/order_tree.rb

@@ -20,7 +20,7 @@ module OrderTree
     # @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) 
+    def initialize(constructor = {}, root = nil)
       @_delegate_hash = {}
       self.root = root || self 
       constructor.each_with_object(self) do |(k,v),memo|
@@ -68,7 +68,7 @@ module OrderTree
     def each_pair
       return enum_for(:each_pair) unless block_given?
       self.each do |c|
-        yield c.path, c.orig 
+        yield c.path.dup, c.orig 
       end
     end
 
@@ -91,7 +91,7 @@ module OrderTree
     def each_path 
       return enum_for(:each_path) unless block_given?
       self.each do |v|
-        yield v.path
+        yield v.path.dup
       end
     end
     
@@ -197,6 +197,10 @@ module OrderTree
       _delegate_hash.inspect
     end
 
+    def pretty_print(pp)
+      _delegate_hash.pretty_print(pp)
+    end
+
     # @param [OrderTree] other
     # @return [true] if self and other do not share all leaves or were inserted in a different order
     def != other
@@ -258,7 +262,24 @@ module OrderTree
       t = self.at *paths
       t.orig
     end
-
+    
+    # Returns true if the given path points to a non-default object
+    # @param [Array] path to check for
+    # @return [Boolean] true if path is not the default object
+    def has_path? *paths
+      t = self
+      penum = paths.each
+      loop do
+        current_path = penum.next
+        dh = t.__send__ :_delegate_hash
+        return false unless dh.has_key? current_path
+        t = dh[current_path]
+      end
+      true
+    rescue NoMethodError => e
+      return false if e.name == :_delegate_hash
+    end
+    alias :has_key? :has_path?
 
     # @private
     def _find_delegate_hash *paths
@@ -280,12 +301,37 @@ module OrderTree
     end
     private :_find_delegate_hash
 
+    def _insert_ordered_node branch, path, value
+      if branch.has_key? path # i am overwriting a path
+        branch[path].remove
+      end
+      branch[path] = OrderTreeNode.new(value, self)
+      branch[path].prev = root.last if root.last
+      root.last.next = branch[path] if root.last
+      root.last = branch[path]
+    end
+    private :_insert_ordered_node
+
     # 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
+      branch = _find_delegate_hash *paths
+      if branch.has_key? paths.last
+        branch[paths.last].remove
+      end
+    end
+    
+    # The nodes of immediate branches under path 
+    # @param [Array] path
+    # @return [Enumerator] enumeration of the nodes under the reciever, in order
+    def branches *path
+      return enum_for(:branches, *path) unless block_given?
+      self.each_pair do |k,v|
+        if k.slice(0, path.size) == path
+          sub_key = k - k.slice(0,path.size)
+          v = proxy?(v) ? v.deproxy : v
+          yield sub_key[0], v unless sub_key.size != 1
+        end
       end
     end
 
@@ -293,27 +339,23 @@ module OrderTree
     # @param [Array] path
     # @param [Object] value
     def []= *paths, value
-      under = _find_delegate_hash *paths
-      
-      if value.kind_of? Hash or value.kind_of? OrderTree
+      branch = _find_delegate_hash *paths
+     
+      if value.kind_of? Hash or value.kind_of? OrderTree and not @no_expand_hash
         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})"
+      _insert_ordered_node branch, paths.last, value
+      value
+    end
+    
+    # Stores the value at path without expanding value into an OrderTree if it is a hash
+    # @param [Array] path
+    # @param [Object] value
+    def store *paths, value
+      branch = _find_delegate_hash *paths
+      _insert_ordered_node branch, paths.last, value
       value
     end
-    alias :store :[]=
   end
 end

data/lib/order_tree/order_tree_node.rb

@@ -44,6 +44,15 @@ module OrderTree
       self
     end
 
+    def deproxy
+      orig = self.orig.respond_to?(:dup) ? self.orig.dup : self.orig
+      if orig.respond_to? :each 
+        orig.each.map! { |i| proxy?(i) ? i.deproxy : i }
+      end
+      orig
+    end
+        
+
     def before other
       (self <=> other) == -1 ? true : false
     end

data/lib/order_tree/unique_proxy.rb

@@ -72,6 +72,10 @@ module OrderTree
       @obj
     end
     
+    def deproxy
+      @obj
+    end
+    
     # Dispatches methods calls to proxy target
     def method_missing(method, *args, &block)
       @obj.__send__ method, *args, &block
@@ -84,6 +88,7 @@ module OrderTree
     
     # @private
     def == arg
+      return true if @obj.nil? and arg.nil?
       @obj == arg
     end
     

data/lib/order_tree/version.rb

@@ -1,3 +1,3 @@
 module OrderTree
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/order_tree_spec.rb

@@ -22,6 +22,11 @@ describe OrderTree::UniqueProxy do
     (a.orig.equal? b.orig).should eq true
   end
 
+  it "unique proxy over nil should be == to itself" do
+    #proxy objects over nil do not respond correctly to "should"
+    (proxy(nil) == proxy(nil)).should be_true
+  end
+
   it "can retrieve the unique id" do
     a = OrderTree::UniqueProxy.new(4)
     b = OrderTree::UniqueProxy.new(4)
@@ -115,6 +120,14 @@ describe OrderTree::OrderTree do
     end
   end
 
+  it "can tell you whether a path exists" do
+    ot = OrderTree::OrderTree.new(@testhash)
+    (ot.has_key? :from, :a, :c).should be_true
+    (ot.has_key? :from, :to, :c).should be_false
+    (ot.has_key? :from).should be_true
+    (ot.has_key? :from, :a, :c, :d).should be_false
+  end
+
   it "can set based on path or nest" do
     ot = OrderTree::OrderTree.new(@testhash)
     ot2 = OrderTree::OrderTree.new(@testhash_insertion)
@@ -126,6 +139,23 @@ describe OrderTree::OrderTree do
     end
   end
 
+  it "can store hashes without expanding them by accessing the underlying hash" do
+    ot = OrderTree::OrderTree.new({:first => "a"})
+    ot[:first] = {:a => 2}
+    ot.min.path.should eq [:first, :a] #this is important later!
+
+    ot.max.path.should eq [:first] #because it will reinsier :first as an order_tree
+    ot[:first][:b] = 3
+    ot.max.path.should eq [:first, :b] #because first is an OrderTree 
+    lambda { ot[:first, :c, :d] = 3 }.should raise_error NoMethodError # because it can't reifiy tree leaves on create
+    ot[:first, :c] = { :d => 3}
+    ot.max.path.should eq [:first, :c]
+    ot.max.prev.path.should eq [:first, :c, :d] #because a hash was added with tree access
+    ot.store(:first, :c, { :e => 5})
+    ot.max.prev.path.should eq [:first,:c ,:d]
+    (ot[*ot.max.prev.path] == ot.default.orig).should be_true
+  end
+
   it "remember the order" do
     ot = OrderTree::OrderTree.new(@testhash)
     ot2 = OrderTree::OrderTree.new(@testhash_insertion)
@@ -211,6 +241,7 @@ describe OrderTree::OrderTree do
     ot.each_path.to_a.first.should eq second_path
   end
 
+
   it "does == comparison" do
     ot = OrderTree::OrderTree.new @testhash
     ot2 = OrderTree::OrderTree.new @testhash
@@ -296,6 +327,15 @@ describe OrderTree::OrderTree do
     ot[:to, :to_to].should eq "bob"
   end
 
+  it "can get the branches for node" do
+    ot = OrderTree::OrderTree.new @testhash
+    ot.branches(:from, :a).to_a.should eq [[:b,4], [:c,4]]
+    # it actually returns the ordertree (as it should) and not the underlying
+    # has, but for the sake of simplicity comare the string representations
+    ot.branches(:from).to_a.to_s.should eq "[[:a, {:b=>4, :c=>4}]]"
+    ot.branches.to_a.to_s.should eq "[[:from, {:a=>{:b=>4, :c=>4}}], [:to, {:d=>4, :e=>4, :to_to=>{:f=>5, :g=>6, :h=>7}}]]"
+  end
+
   it "can find the path for a node object" do
     ot = OrderTree::OrderTree.new @testhash
     lambda do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: order_tree
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-26 00:00:00.000000000 -05:00
+date: 2011-10-03 00:00:00.000000000 -05:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &3691050 !ruby/object:Gem::Requirement
+  requirement: &10085620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *3691050
+  version_requirements: *10085620
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &3690830 !ruby/object:Gem::Requirement
+  requirement: &10085410 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *3690830
+  version_requirements: *10085410
 - !ruby/object:Gem::Dependency
   name: ruby-prof
-  requirement: &3690610 !ruby/object:Gem::Requirement
+  requirement: &10085200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +44,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *3690610
+  version_requirements: *10085200
 - !ruby/object:Gem::Dependency
   name: ruby-debug19
-  requirement: &3690400 !ruby/object:Gem::Requirement
+  requirement: &10084990 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,7 +55,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *3690400
+  version_requirements: *10084990
 description: Use OrderTree when you need both insertion order access and nested hash
   path style access
 email: