closure_tree 4.2.0 → 4.2.1

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MWJmNzNmNzk4OGM2YmJlYWIzYjdkNTE2Yzk2YjZlNWM1ZDgwMTlhYg==
-  data.tar.gz: !binary |-
-    YjcwMmY4MTcwMTRlZmJmODAwOGViNGMyNzU4NGQ5MGY4ZDU1MjQ5Mg==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    NGRlYjk1MDU4NzdiYzQzNzIzZGQxZTZjMjc1NDA4NzQ0YTAwYTExYTZlM2E4
-    YWM0OTY4NzQ2ZmI4NjA2NDc4MWNjN2RlODIwNTY0ZWMwZGJmNzUwNjk0ZmE3
-    M2NlYmU1MTk5MzViN2ExZmIwYjBmYTU5N2JhMGVmOGE5N2U3NmQ=
-  data.tar.gz: !binary |-
-    NmE0NGFjNmZiMDAwM2U5MTc3Y2E3OWIyMGFiNTEzYWI3MTA1MmRlYWI5MzQw
-    OGMxNGQwODZmY2ZiNzQwZDhmNGUzYTEwNjNkMTZlOTNjZTE5ZTA2NGNhNTg5
-    MTJjMjgxODk1NzdmOWQ1NzhhODA1MWZhYjNlYzUyOGUxNmVlYTk=
+SHA1:
+  metadata.gz: 78c02789c9a49942f41eea1ce0ce205d38f1df9a
+  data.tar.gz: dcad9031af038ee30c9ec61a0f60941c028536f2
+SHA512:
+  metadata.gz: 31034ae207d81917f3e60d69312c80561d21382123be62fb0b753db933f420be6007b5d69438c37b2ecd9800a38310ee184c3f9b570312d7d27cc0adc03971ab
+  data.tar.gz: 2068b5ecf26b41e96cb339a0e14427e6e6baa0527180dce781bd5f10d179662ac8b45b5f9232d5a2413fbf43c72f3a7ee42a0f2f745f95f2851711827b8a1bb3

data/README.md

@@ -8,6 +8,7 @@ and tracking user referrals.
 [![Build Status](https://secure.travis-ci.org/mceachen/closure_tree.png?branch=master)](http://travis-ci.org/mceachen/closure_tree)
 [![Gem Version](https://badge.fury.io/rb/closure_tree.png)](http://rubygems.org/gems/closure_tree)
 [![Code Climate](https://codeclimate.com/github/mceachen/closure_tree.png)](https://codeclimate.com/github/mceachen/closure_tree)
+[![Coverage Status](https://coveralls.io/repos/mceachen/closure_tree/badge.png?branch=master)](https://coveralls.io/r/mceachen/closure_tree?branch=master)
 
 Substantially more efficient than
 [ancestry](https://github.com/stefankroes/ancestry) and
@@ -471,6 +472,10 @@ Parallelism is not tested with Rails 3.0.x nor 3.1.x due to this
 
 ## Change log
 
+### 4.2.1
+
+* Deleting from NumericDeterministicOrdering doesn't create sort order gaps anymore.
+
 ### 4.2.0
 
 * Added ```with_ancestor(*ancestors)```. Thanks for the idea, [Matt](https://github.com/mgornick)!
@@ -479,6 +484,7 @@ Parallelism is not tested with Rails 3.0.x nor 3.1.x due to this
   Thanks for the help, [Judd Blair](https://github.com/juddblair)!
   **Please note that this changes prior behavior—test your code with this new version!**
 * ```ct_advisory_lock``` was moved into the ```_ct``` support class, to reduce model method pollution
+* Moved a bunch of code into more focused piles of module mixins
 
 ### 4.1.0
 

data/lib/closure_tree/hierarchy_maintenance.rb

@@ -52,6 +52,7 @@ module ClosureTree
           SQL
         end
         children.each { |c| c.rebuild! }
+        _ct_reorder_children if _ct.order_is_numeric?
       end
     end
 

data/lib/closure_tree/model.rb

@@ -33,9 +33,6 @@ module ClosureTree
         :foreign_key => "ancestor_id",
         :order => order_by_generations)
 
-      # TODO: FIXME: this collection currently ignores sort_order
-      # (because the quoted_table_named would need to be joined in to get to the order column)
-
       has_many :self_and_descendants, *_ct.has_many_with_order_option(
         :through => :descendant_hierarchies,
         :source => :descendant,
@@ -127,8 +124,25 @@ module ClosureTree
       read_attribute(_ct.parent_column_sym)
     end
 
+    def _ct_quoted_parent_id
+      _ct.quoted_value(_ct_parent_id)
+    end
+
     def _ct_id
       read_attribute(_ct.model_class.primary_key)
     end
+
+    def _ct_quoted_id
+      _ct.quoted_value(_ct_id)
+    end
+
+    def _ct_update_column(column, value)
+      if respond_to?(:update_column)
+        update_column(column, value)
+      else
+        # This will run callbacks, but it's better than failing outright:
+        update_attribute(column, value)
+      end
+    end
   end
 end

data/lib/closure_tree/numeric_deterministic_ordering.rb

@@ -1,8 +1,26 @@
+require 'active_support/concern'
+
 # This module is only included if the order column is an integer.
 module ClosureTree
   module NumericDeterministicOrdering
     extend ActiveSupport::Concern
 
+    included do
+      after_destroy :_ct_reorder_after_destroy
+    end
+
+    def _ct_reorder_after_destroy
+      _ct_reorder_siblings
+    end
+
+    def _ct_reorder_siblings(minimum_sort_order_value = nil, delta = 0)
+      _ct.reorder_with_parent_id(_ct_parent_id, minimum_sort_order_value, delta)
+    end
+
+    def _ct_reorder_children(minimum_sort_order_value = nil, delta = 0)
+      _ct.reorder_with_parent_id(_ct_id, minimum_sort_order_value, delta)
+    end
+
     def self_and_descendants_preordered
       # TODO: raise NotImplementedError if sort_order is not numeric and not null?
       h = _ct.connection.select_one(<<-SQL)
@@ -60,27 +78,41 @@ module ClosureTree
       add_sibling(sibling_node, false)
     end
 
-    def add_sibling(sibling_node, add_after = true)
-      fail "can't add self as sibling" if self == sibling_node
+    def add_sibling(sibling, add_after = true)
+      fail "can't add self as sibling" if self == sibling
       _ct.with_advisory_lock do
-        if self.order_value.nil? || siblings_before.without(sibling_node).empty?
-          update_attribute(:order_value, 0)
+        if self.order_value.nil?
+          # ergh, we don't know where we stand within the siblings, so establish that first:
+          _ct_reorder_siblings
+          reload # < because self.order_value changed
         end
-        sibling_node.parent = self.parent
-        starting_order_value = self.order_value.to_i
-        to_reorder = siblings_after.without(sibling_node).to_a
-        if add_after
-          to_reorder.unshift(sibling_node)
-        else
-          to_reorder.unshift(self)
-          sibling_node.update_attribute(:order_value, starting_order_value)
+        prior_sibling_parent = sibling.parent
+        if prior_sibling_parent == self.parent
+          # We have to adjust the prior siblings by moving sibling out of the way:
+          sibling._ct_update_column(_ct.parent_column_sym, nil)
+          if sibling.order_value && sibling.order_value < self.order_value
+            _ct_reorder_siblings(sibling.order_value, 0)
+            reload # < because self.order_value changed
+          end
         end
-
-        to_reorder.each_with_index do |ea, idx|
-          ea.update_attribute(:order_value, starting_order_value + idx + 1)
+        _ct_move_new_sibling(sibling, add_after)
+        if prior_sibling_parent && prior_sibling_parent != self.parent
+          prior_sibling_parent._ct_reorder_children
         end
-        sibling_node.reload # because the parent may have changed.
+        sibling
+      end
+    end
+
+    def _ct_move_new_sibling(sibling, add_after)
+      _ct_reorder_siblings(self.order_value + 1, 1)
+      if add_after
+        sibling.order_value = self.order_value + 1
+      else
+        sibling.order_value = self.order_value
+        self.order_value += 1
+        self.save!
       end
+      parent.add_child(sibling) # <- this causes sibling to be saved.
     end
   end
 end

data/lib/closure_tree/numeric_order_support.rb

@@ -0,0 +1,63 @@
+module ClosureTree
+  module NumericOrderSupport
+
+    def self.adapter_for_connection(connection)
+      case connection.adapter_name.downcase.to_sym
+        when :postgresql
+          ::ClosureTree::NumericOrderSupport::PostgreSQLAdapter
+        when :mysql, :mysql2
+          ::ClosureTree::NumericOrderSupport::MysqlAdapter
+        else
+          ::ClosureTree::NumericOrderSupport::GenericAdapter
+      end
+    end
+
+    module MysqlAdapter
+      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil, delta = 0)
+        min_where = if minimum_sort_order_value
+          "AND #{quoted_order_column} >= #{minimum_sort_order_value}"
+        else
+          ""
+        end
+        connection.execute "SET @i = 0"
+        connection.execute <<-SQL
+          UPDATE #{quoted_table_name}
+            SET #{quoted_order_column} = (@i := @i + 1) + #{minimum_sort_order_value.to_i + delta - 1}
+          WHERE #{quoted_parent_column_name} = #{quoted_value(parent_id)} #{min_where}
+          ORDER BY #{order_by}
+        SQL
+      end
+    end
+
+    module PostgreSQLAdapter
+      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil, delta = 0)
+        min_where = if minimum_sort_order_value
+          "AND #{quoted_order_column} >= #{minimum_sort_order_value}"
+        else
+          ""
+        end
+        connection.execute <<-SQL
+          UPDATE #{quoted_table_name}
+          SET #{quoted_order_column(false)} = t.seq + #{minimum_sort_order_value.to_i + delta - 1}
+          FROM (
+            SELECT #{quoted_id_column_name} AS id, row_number() OVER(ORDER BY #{order_by}) AS seq
+            FROM #{quoted_table_name}
+            WHERE #{quoted_parent_column_name} = #{quoted_value(parent_id)} #{min_where}) AS t
+          WHERE #{quoted_table_name}.#{quoted_id_column_name} = t.id
+        SQL
+      end
+    end
+
+    module GenericAdapter
+      def reorder_with_parent_id(parent_id, minimum_sort_order_value = nil, delta = 0)
+        scope = model_class.where(parent_column_sym => parent_id)
+        if minimum_sort_order_value
+          scope = scope.where("#{quoted_order_column} >= #{minimum_sort_order_value}")
+        end
+        scope.each_with_index do |ea, idx|
+          ea.update_attribute(order_column_sym, idx + minimum_sort_order_value.to_i + delta)
+        end
+      end
+    end
+  end
+end

data/lib/closure_tree/support.rb

@@ -1,5 +1,6 @@
 require 'closure_tree/support_flags'
 require 'closure_tree/support_attributes'
+require 'closure_tree/numeric_order_support'
 
 module ClosureTree
   class Support
@@ -19,6 +20,9 @@ module ClosureTree
         :with_advisory_lock => true
       }.merge(options)
       raise IllegalArgumentException, "name_column can't be 'path'" if options[:name_column] == 'path'
+      if order_is_numeric?
+        extend NumericOrderSupport.adapter_for_connection(connection)
+      end
     end
 
     def hierarchy_class_for_model
@@ -58,13 +62,13 @@ module ClosureTree
 
     def with_order_option(opts)
       if order_option?
-        opts[:order] = [opts[:order], options[:order]].compact.join(",")
+        opts[:order] = [opts[:order], order_by].compact.join(",")
       end
       opts
     end
 
     def scope_with_order(scope, additional_order_by = nil)
-      order_option? ? scope.order(*([additional_order_by, options[:order]].compact)) : scope
+      order_option? ? scope.order(*([additional_order_by, order_by].compact)) : scope
     end
 
     # lambda-ize the order, but don't apply the default order_option
@@ -78,7 +82,7 @@ module ClosureTree
 
     def has_many_with_order_option(opts)
       if ActiveRecord::VERSION::MAJOR > 3
-        order_options = [opts[:order], options[:order]].compact
+        order_options = [opts[:order], order_by].compact
         [lambda { order(order_options) }, opts.except(:order)]
       else
         [with_order_option(opts)]

data/lib/closure_tree/support_attributes.rb

@@ -1,6 +1,10 @@
+require 'forwardable'
 module ClosureTree
   module SupportAttributes
 
+    extend Forwardable
+    def_delegators :model_class, :connection, :transaction, :table_name
+
     # This is the "topmost" class. This will only potentially not be ct_class if you are using STI.
     def base_class
       options[:base_class]
@@ -10,18 +14,14 @@ module ClosureTree
       @attribute_names ||= model_class.new.attributes.keys - model_class.protected_attributes.to_a
     end
 
-    def connection
-      model_class.connection
-    end
-
-    def table_name
-      model_class.table_name
-    end
-
     def quoted_table_name
       connection.quote_table_name(table_name)
     end
 
+    def quoted_value(value)
+      value.is_a?(Numeric) ? value : quote(value)
+    end
+
     def hierarchy_class_name
       options[:hierarchy_class_name] || model_class.to_s + "Hierarchy"
     end
@@ -69,8 +69,12 @@ module ClosureTree
       connection.quote_column_name name_column
     end
 
+    def order_by
+      options[:order]
+    end
+
     def order_column
-      o = options[:order]
+      o = order_by
       if o.nil?
         nil
       elsif o.is_a?(String)
@@ -94,6 +98,5 @@ module ClosureTree
       prefix = include_table_name ? "#{quoted_table_name}." : ""
       "#{prefix}#{connection.quote_column_name(order_column)}"
     end
-
   end
 end

data/lib/closure_tree/support_flags.rb

@@ -15,7 +15,7 @@ module ClosureTree
     end
 
     def order_option?
-      !options[:order].nil?
+      order_by.present?
     end
 
     def order_is_numeric?

data/lib/closure_tree/version.rb

@@ -1,3 +1,3 @@
 module ClosureTree
-  VERSION = Gem::Version.new("4.2.0") unless defined?(::ClosureTree::VERSION)
+  VERSION = Gem::Version.new("4.2.1") unless defined?(::ClosureTree::VERSION)
 end

data/spec/label_spec.rb

@@ -216,23 +216,29 @@ describe Label do
       @a = EventLabel.new(:name => "a")
       @b = DirectoryLabel.new(:name => "b")
       @c = DateLabel.new(:name => "c")
+      @d = Label.new(:name => "d")
       @parent.children << @a
       @a.append_sibling(@b)
       @b.append_sibling(@c)
+      @c.append_sibling(@d)
     end
 
-    it "when inserted before" do
-      @b.append_sibling(@a)
-      # Have to reload because the sort_order will have changed out from under the references:
-      @b.reload.sort_order.should be < @a.reload.sort_order
-      @a.reload.sort_order.should be < @c.reload.sort_order
+    def children_name_and_order
+      @parent.reload.children.map { |ea| [ea.name, ea.sort_order] }
+    end
+
+    it "sort_orders properly" do
+      children_name_and_order.should == [['a', 0], ['b', 1], ['c', 2], ['d', 3]]
     end
 
     it "when inserted before" do
       @b.append_sibling(@a)
-      # Have to reload because the sort_order will have changed out from under the references:
-      @b.reload.sort_order.should be < @a.reload.sort_order
-      @a.reload.sort_order.should be < @c.reload.sort_order
+      children_name_and_order.should == [['b', 0], ['a', 1], ['c', 2], ['d', 3]]
+    end
+
+    it "when inserted after" do
+      @a.append_sibling(@c)
+      children_name_and_order.should == [['a', 0], ['c', 1], ['b', 2], ['d', 3]]
     end
   end
 
@@ -243,116 +249,100 @@ describe Label do
     c = Label.create(:name => "c")
 
     a.append_sibling(b)
+    a.self_and_siblings.collect(&:name).should == %w(a b)
     root.reload.children.collect(&:name).should == %w(a b)
-    root.reload.children.collect(&:sort_order).should == [0, 1]
+    root.children.collect(&:sort_order).should == [0, 1]
 
     a.prepend_sibling(b)
+    a.self_and_siblings.collect(&:name).should == %w(b a)
     root.reload.children.collect(&:name).should == %w(b a)
-    root.reload.children.collect(&:sort_order).should == [0, 1]
+    root.children.collect(&:sort_order).should == [0, 1]
 
     a.append_sibling(c)
+    a.self_and_siblings.collect(&:name).should == %w(b a c)
     root.reload.children.collect(&:name).should == %w(b a c)
-    root.reload.children.collect(&:sort_order).should == [0, 1, 2]
+    root.children.collect(&:sort_order).should == [0, 1, 2]
 
-    b.append_sibling(c)
+    # We need to reload b because it was updated by a.append_sibling(c)
+    b.reload.append_sibling(c)
     root.reload.children.collect(&:name).should == %w(b c a)
-    root.reload.children.collect(&:sort_order).should == [0, 1, 2]
-  end
+    root.children.collect(&:sort_order).should == [0, 1, 2]
 
-  context "Deterministic siblings sort with custom integer column" do
-    delete_all_labels
-    fixtures :labels
+    # We need to reload a because it was updated by b.append_sibling(c)
+    d = a.reload.append_sibling(Label.new(:name => "d"))
+    d.self_and_siblings.collect(&:name).should == %w(b c a d)
+    d.self_and_siblings.collect(&:sort_order).should == [0, 1, 2, 3]
+  end
 
+  context "#add_sibling" do
     before :each do
-      Label.rebuild!
-    end
-
-    it "orders siblings_before and siblings_after correctly" do
-      labels(:c16).self_and_siblings.to_a.should == [labels(:c16), labels(:c17), labels(:c18), labels(:c19)]
-      labels(:c16).siblings_before.to_a.should == []
-      labels(:c16).siblings_after.to_a.should == [labels(:c17), labels(:c18), labels(:c19)]
-    end
-
-    it "should prepend a node as a sibling of another node" do
-      labels(:c16).prepend_sibling(labels(:c17))
-      labels(:c16).self_and_siblings.to_a.should == [labels(:c17), labels(:c16), labels(:c18), labels(:c19)]
-      labels(:c19).prepend_sibling(labels(:c16))
-      labels(:c16).self_and_siblings.to_a.should == [labels(:c17), labels(:c18), labels(:c16), labels(:c19)]
-      labels(:c16).siblings_before.to_a.should == [labels(:c17), labels(:c18)]
-      labels(:c16).siblings_after.to_a.should == [labels(:c19)]
-    end
-
-    it "should prepend a node as a sibling of another node (!update_all)" do
-      labels(:c16).prepend_sibling(labels(:c17))
-      labels(:c16).self_and_siblings.to_a.should == [labels(:c17), labels(:c16), labels(:c18), labels(:c19)]
-      labels(:c19).reload.prepend_sibling(labels(:c16).reload)
-      labels(:c16).self_and_siblings.to_a.should == [labels(:c17), labels(:c18), labels(:c16), labels(:c19)]
-      labels(:c16).siblings_before.to_a.should == [labels(:c17), labels(:c18)]
-      labels(:c16).siblings_after.to_a.should == [labels(:c19)]
+      Label.delete_all
     end
 
-    it "appends a node as a sibling of another node" do
-      labels(:c19).append_sibling(labels(:c17))
-      labels(:c16).self_and_siblings.to_a.should == [labels(:c16), labels(:c18), labels(:c19), labels(:c17)]
-      labels(:c16).append_sibling(labels(:c19))
-      labels(:c16).self_and_siblings.to_a.should == [labels(:c16), labels(:c19), labels(:c18), labels(:c17)]
-      labels(:c16).siblings_before.to_a.should == []
-      labels(:c16).siblings_after.to_a.should == labels(:c16).siblings.to_a
-    end
-
-    it "should move a node before another node (update_all)" do
-      labels(:c2).ancestry_path.should == %w{a1 b2 c2}
-      labels(:b2).prepend_sibling(labels(:c2))
-      labels(:c2).ancestry_path.should == %w{a1 c2}
-      labels(:c2).self_and_siblings.to_a.should == [labels(:b1), labels(:c2), labels(:b2)]
-      labels(:c2).siblings_before.to_a.should == [labels(:b1)]
-      labels(:c2).siblings_after.to_a.should == [labels(:b2)]
-      labels(:b1).siblings_after.to_a.should == [labels(:c2), labels(:b2)]
-    end
-
-    it "should move a node after another node (update_all)" do
-      labels(:c2).ancestry_path.should == %w{a1 b2 c2}
-      labels(:b2).append_sibling(labels(:c2))
-      labels(:c2).ancestry_path.should == %w{a1 c2}
-      labels(:c2).self_and_siblings.to_a.should == [labels(:b1), labels(:b2), labels(:c2)]
+    it "should move a node before another node which has an uninitialized sort_order" do
+      f = Label.find_or_create_by_path %w(a b c d e fa)
+      f0 = f.prepend_sibling(Label.new(:name => "fb")) # < not alpha sort, so name shouldn't matter
+      f0.ancestry_path.should == %w(a b c d e fb)
+      f.siblings_before.to_a.should == [f0]
+      f0.siblings_before.should be_empty
+      f0.siblings_after.should == [f]
+      f.siblings_after.should be_empty
+      f0.self_and_siblings.should == [f0, f]
+      f.self_and_siblings.should == [f0, f]
+    end
+
+    it "should move a node to another tree" do
+      f1 = Label.find_or_create_by_path %w(a1 b1 c1 d1 e1 f1)
+      f2 = Label.find_or_create_by_path %w(a2 b2 c2 d2 e2 f2)
+      f1.add_sibling(f2)
+      f2.ancestry_path.should == %w(a1 b1 c1 d1 e1 f2)
+      f1.parent.children.should == [f1, f2]
+    end
+
+    it "should reorder old-parent siblings when a node moves to another tree" do
+      f1 = Label.find_or_create_by_path %w(a1 b1 c1 d1 e1 f1)
+      f2 = Label.find_or_create_by_path %w(a2 b2 c2 d2 e2 f2)
+      f3 = f2.prepend_sibling(Label.new(:name => "f3"))
+      f4 = f2.append_sibling(Label.new(:name => "f4"))
+      f1.add_sibling(f2)
+      f1.self_and_siblings.collect(&:sort_order).should == [0, 1]
+      f3.self_and_siblings.collect(&:sort_order).should == [0, 1]
+      f1.self_and_siblings.collect(&:name).should == %w(f1 f2)
+      f3.self_and_siblings.collect(&:name).should == %w(f3 f4)
     end
+  end
 
-    it "should move a node before another node" do
-      labels(:c2).ancestry_path.should == %w{a1 b2 c2}
-      labels(:b2).prepend_sibling(labels(:c2))
-      labels(:c2).ancestry_path.should == %w{a1 c2}
-      labels(:c2).self_and_siblings.to_a.should == [labels(:b1), labels(:c2), labels(:b2)]
+  context "destructive reordering" do
+    before :each do
+      Label.delete_all
+      # to make sure sort_order isn't affected by additional nodes:
+      create_preorder_tree
+      @root = Label.create(:name => "root")
+      @a = @root.children.create!(:name => "a")
+      @b = @a.append_sibling(Label.new(:name => "b"))
+      @c = @b.append_sibling(Label.new(:name => "c"))
+    end
+    context "doesn't create sort order gaps from" do
+      it "from head" do
+        @a.destroy
+        @root.reload.children.should == [@b, @c]
+        @root.children.map { |ea| ea.sort_order }.should == [0, 1]
+      end
+      it "from mid" do
+        @b.destroy
+        @root.reload.children.should == [@a, @c]
+        @root.children.map { |ea| ea.sort_order }.should == [0, 1]
+      end
+      it "from tail" do
+        @c.destroy
+        @root.reload.children.should == [@a, @b]
+        @root.children.map { |ea| ea.sort_order }.should == [0, 1]
+      end
     end
-
-    it "should move a node before another node which has an uninitialized sort_order" do
-      labels(:f3).ancestry_path.should == %w{f3}
-      labels(:e2).children << labels(:f3)
-      labels(:f3).reload.ancestry_path.should == %w{a1 b2 c2 d2 e2 f3}
-      labels(:f3).self_and_siblings.to_a.should == [labels(:f3)]
-      labels(:f3).prepend_sibling labels(:f4)
-      labels(:f3).siblings_before.to_a.should == [labels(:f4)]
-      labels(:f3).self_and_siblings.to_a.should == [labels(:f4), labels(:f3)]
-    end
-
-    it "should move a node after another node which has an uninitialized sort_order" do
-      labels(:f3).ancestry_path.should == %w{f3}
-      labels(:e2).children << labels(:f3)
-      labels(:f3).reload.ancestry_path.should == %w{a1 b2 c2 d2 e2 f3}
-      labels(:f3).self_and_siblings.to_a.should == [labels(:f3)]
-      labels(:f3).append_sibling labels(:f4)
-      labels(:f3).siblings_after.to_a.should == [labels(:f4)]
-      labels(:f3).self_and_siblings.to_a.should == [labels(:f3), labels(:f4)]
-    end
-
-    it "should move a node after another node" do
-      labels(:c2).ancestry_path.should == %w{a1 b2 c2}
-      labels(:b2).append_sibling(labels(:c2))
-      labels(:c2).ancestry_path.should == %w{a1 c2}
-      labels(:c2).self_and_siblings.to_a.should == [labels(:b1), labels(:b2), labels(:c2)]
-      labels(:c2).append_sibling(labels(:e2))
-      labels(:e2).self_and_siblings.to_a.should == [labels(:b1), labels(:b2), labels(:c2), labels(:e2)]
-      labels(:a1).self_and_descendants.collect(&:name).should == %w(a1 b1 b2 c2 e2 d2 c1-six c1-seven c1-eight c1-nine)
-      labels(:a1).leaves.collect(&:name).should =~ %w(b2 e2 d2 c1-six c1-seven c1-eight c1-nine)
+    it "shouldn't fail if all children are destroyed" do
+      roots = Label.roots.to_a
+      roots.each { |ea| ea.children.destroy_all }
+      Label.all.to_a.should =~ roots
     end
   end
 

data/spec/spec_helper.rb

@@ -12,6 +12,8 @@ require 'rspec/rails/adapters'
 require 'rspec/rails/fixture_support'
 require 'closure_tree'
 require 'tmpdir'
+require 'coveralls'
+Coveralls.wear!
 
 #log = Logger.new(STDOUT)
 #log.sev_threshold = Logger::DEBUG

metadata

@@ -1,167 +1,181 @@
 --- !ruby/object:Gem::Specification
 name: closure_tree
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.2.1
 platform: ruby
 authors:
 - Matthew McEachen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-10 00:00:00.000000000 Z
+date: 2013-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: with_advisory_lock
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.0.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.0.6
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: fuubar
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: uuidtools
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Easily and efficiently make your ActiveRecord model support hierarchies
@@ -179,6 +193,7 @@ files:
 - lib/closure_tree/hierarchy_maintenance.rb
 - lib/closure_tree/model.rb
 - lib/closure_tree/numeric_deterministic_ordering.rb
+- lib/closure_tree/numeric_order_support.rb
 - lib/closure_tree/support.rb
 - lib/closure_tree/support_attributes.rb
 - lib/closure_tree/support_flags.rb
@@ -190,7 +205,6 @@ files:
 - spec/cuisine_type_spec.rb
 - spec/db/database.yml
 - spec/db/schema.rb
-- spec/fixtures/labels.yml
 - spec/fixtures/tags.yml
 - spec/label_spec.rb
 - spec/namespace_type_spec.rb
@@ -212,17 +226,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.2
 signing_key: 
 specification_version: 4
 summary: Easily and efficiently make your ActiveRecord model support hierarchies
@@ -230,7 +244,6 @@ test_files:
 - spec/cuisine_type_spec.rb
 - spec/db/database.yml
 - spec/db/schema.rb
-- spec/fixtures/labels.yml
 - spec/fixtures/tags.yml
 - spec/label_spec.rb
 - spec/namespace_type_spec.rb

data/spec/fixtures/labels.yml

@@ -1,55 +0,0 @@
-a1:
-  name: a1
-  sort_order: 1
-
-b1:
-  name: b1
-  parent: a1
-  sort_order: 1
-
-b2:
-  name: b2
-  parent: a1
-  sort_order: 2
-
-# Note that the names are not alphabetically ordered:
-c16:
-  name: c1-six
-  parent: b1
-  sort_order: 6
-
-c17:
-  name: c1-seven
-  parent: b1
-  sort_order: 7
-
-c18:
-  name: c1-eight
-  parent: b1
-  sort_order: 8
-
-c19:
-  name: c1-nine
-  parent: b1
-  sort_order: 9
-
-c2:
-  name: c2
-  parent: b2
-  sort_order: 1
-
-d2:
-  name: d2
-  parent: c2
-  sort_order: 1
-
-e2:
-  name: e2
-  parent: d2
-  sort_order: 1
-
-f3:
-  name: f3
-
-f4:
-  name: f4