closure_tree 3.1.0 → 3.2.0

data/README.md

@@ -1,20 +1,22 @@
 # Closure Tree [![Build Status](https://secure.travis-ci.org/mceachen/closure_tree.png?branch=master)](http://travis-ci.org/mceachen/closure_tree)
 
 Closure Tree is a mostly-API-compatible replacement for the
-acts_as_tree and awesome_nested_set gems, but with much better
-mutation performance thanks to the Closure Tree storage algorithm,
-as well as support for polymorphism within the hierarchy.
+[ancestry](https://github.com/stefankroes/ancestry),
+[acts_as_tree](https://github.com/amerine/acts_as_tree) and
+[awesome_nested_set](https://github.com/collectiveidea/awesome_nested_set/) gems, giving you:
+
+* Much better mutation performance thanks to the Closure Tree storage algorithm
+* Very efficient select performance (again, thanks to Closure Tree)
+* Efficient subtree selects
+* Support for polymorphism [STI](#sti) within the hierarchy
+* ```find_or_create_by_path``` for [building out hierarchies quickly and conveniently](#find_or_create_by_path)
+* Support for [deterministic ordering](#deterministic-ordering) of children
+* Excellent [test coverage](#testing) in a variety of environments
 
 See [Bill Karwin](http://karwin.blogspot.com/)'s excellent
 [Models for hierarchical data presentation](http://www.slideshare.net/billkarwin/models-for-hierarchical-data)
 for a description of different tree storage algorithms.
 
-Closure tree is [tested under every combination](https://secure.travis-ci.org/mceachen/closure_tree.png?branch=master) of
-
-* Ruby 1.8.7 and Ruby 1.9.3
-* The latest Rails 3.0, 3.1, and 3.2 branches, and
-* Using MySQL, Postgresql, and SQLite.
-
 ## Installation
 
 Note that closure_tree only supports Rails 3.0 and later, and has test coverage for MySQL, PostgreSQL, and SQLite.
@@ -26,6 +28,7 @@ Note that closure_tree only supports Rails 3.0 and later, and has test coverage
 3.  Add ```acts_as_tree``` to your hierarchical model(s) (see the <em>Available options</em> section below for details).
 
 4.  Add a migration to add a ```parent_id``` column to the model you want to act_as_tree.
+    You may want to also [add a column for deterministic ordering of children](#sort_order), but that's optional.
 
     ```ruby
     class AddParentIdToTag < ActiveRecord::Migration
@@ -102,15 +105,15 @@ Then:
 
 ```ruby
 puts grandparent.self_and_descendants.collect{ |t| t.name }.join(" > ")
-"grandparent > parent > child"
+=> "grandparent > parent > child"
 
 child.ancestry_path
-["grandparent", "parent", "child"]
+=> ["grandparent", "parent", "child"]
 ```
 
 ### find_or_create_by_path
 
-We can do all the node creation and add_child calls from the prior section with one method call:
+We can do all the node creation and add_child calls with one method call:
 
   ```ruby
   child = Tag.find_or_create_by_path(["grandparent", "parent", "child"])
@@ -130,8 +133,20 @@ This will pass the attribute hash of ```{:name => "home", :tag_type => "File"}``
 ```Tag.find_or_create_by_name``` if the root directory doesn't exist (and
 ```{:name => "chuck", :tag_type => "File"}``` if the second-level tag doesn't exist, and so on).
 
-### Available options
-<a id="options" />
+### Moving nodes around the tree
+
+Nodes can be moved around to other parents, and closure_tree moves the node's descendancy to the new parent for you:
+
+```ruby
+d = Tag.find_or_create_by_path %w(a b c d)
+h = Tag.find_or_create_by_path %w(e f g h)
+e = h.root
+d.add_child(e) # "d.children << e" would work too, of course
+h.ancestry_path
+=> ["a", "b", "c", "d", "e", "f", "g", "h"]
+```
+
+### <a id="options"></a>Available options
 
 When you include ```acts_as_tree``` in your model, you can provide a hash to override the following defaults:
 
@@ -142,6 +157,7 @@ When you include ```acts_as_tree``` in your model, you can provide a hash to ove
     * ```:delete_all``` will delete all descendant nodes (which circumvents the destroy hooks)
     * ```:destroy``` will destroy all descendant nodes (which runs the destroy hooks on each child node)
 * ```:name_column``` used by #```find_or_create_by_path```, #```find_by_path```, and ```ancestry_path``` instance methods. This is primarily useful if the model only has one required field (like a "tag").
+* ```:order``` used to set up [deterministic ordering](#deterministic-ordering)
 
 ## Accessing Data
 
@@ -157,24 +173,24 @@ When you include ```acts_as_tree``` in your model, you can provide a hash to ove
 * ```tag.root?``` returns true if this is a root node
 * ```tag.child?``` returns true if this is a child node. It has a parent.
 * ```tag.leaf?``` returns true if this is a leaf node. It has no children.
-* ```tag.leaves``` returns an array of all the nodes in self_and_descendants that are leaves.
-* ```tag.level``` returns the level, or "generation", for this node in the tree. A root node == 0.
+* ```tag.leaves``` is scoped to all leaf nodes in self_and_descendants.
+* ```tag.depth``` returns the depth, or "generation", for this node in the tree. A root node will have a value of 0.
 * ```tag.parent``` returns the node's immediate parent. Root nodes will return nil.
-* ```tag.children``` returns an array of immediate children (just those nodes whose parent is the current node).
-* ```tag.ancestors``` returns an array of [ parent, grandparent, great grandparent, … ]. Note that the size of this array will always equal ```tag.level```.
-* ```tag.self_and_ancestors``` returns an array of self, parent, grandparent, great grandparent, etc.
-* ```tag.siblings``` returns an array of brothers and sisters (all at that level), excluding self.
-* ```tag.self_and_siblings``` returns an array of brothers and sisters (all at that level), including self.
-* ```tag.descendants``` returns an array of all children, childrens' children, etc., excluding self.
-* ```tag.self_and_descendants``` returns an array of all children, childrens' children, etc., including self.
+* ```tag.children``` is a ```has_many``` of immediate children (just those nodes whose parent is the current node).
+* ```tag.ancestors``` is a ordered scope of [ parent, grandparent, great grandparent, … ]. Note that the size of this array will always equal ```tag.depth```.
+* ```tag.self_and_ancestors``` returns a scope containing self, parent, grandparent, great grandparent, etc.
+* ```tag.siblings``` returns a scope containing all nodes with the same parent as ```tag```, excluding self.
+* ```tag.self_and_siblings``` returns a scope containing all nodes with the same parent as ```tag```, including self.
+* ```tag.descendants``` returns a scope of all children, childrens' children, etc., excluding self ordered by depth.
+* ```tag.self_and_descendants``` returns a scope of all children, childrens' children, etc., including self, ordered by depth.
 * ```tag.destroy``` will destroy a node and do <em>something</em> to its children, which is determined by the ```:dependent``` option passed to ```acts_as_tree```.
 
-## Polymorphic hierarchies
+## <a id="sti"></a>Polymorphic hierarchies with STI
 
-Polymorphic models are supported:
+Polymorphic models using single table inheritance (STI) are supported:
 
 1. Create a db migration that adds a String ```type``` column to your model
-2. Subclass the model class. You only need to add acts_as_tree to your base class.
+2. Subclass the model class. You only need to add ```acts_as_tree``` to your base class:
 
 ```ruby
 class Tag < ActiveRecord::Base
@@ -185,8 +201,91 @@ class WhereTag < Tag ; end
 class WhatTag < Tag ; end
 ```
 
+## Deterministic ordering
+
+By default, children will be ordered by your database engine, which may not be what you want.
+
+If you want to order children alphabetically, and your model has a ```name``` column, you'd do this:
+
+```ruby
+class Tag < ActiveRecord::Base
+  acts_as_tree :order => 'name'
+end
+```
+
+If you want a specific order, add a new integer column to your model in a migration:
+
+```ruby
+t.integer :sort_order
+```
+
+and in your model:
+
+```ruby
+class OrderedTag < ActiveRecord::Base
+  acts_as_tree :order => 'sort_order'
+end
+```
+
+When you enable ```order```, you'll also have the following new methods injected into your model:
+
+* ```tag.siblings_before``` is a scope containing all nodes with the same parent as ```tag```,
+  whose sort order column is less than ```self```. These will be ordered properly, so the ```last```
+  element in scope will be the sibling immediately before ```self```
+* ```tag.siblings_after``` is a scope containing all nodes with the same parent as ```tag```,
+  whose sort order column is more than ```self```. These will be ordered properly, so the ```first```
+  element in scope will be the sibling immediately "after" ```self```
+
+If your ```order``` column is an integer attribute, you'll also have these:
+
+* ```tag.add_sibling_before(sibling_node)``` which will
+  1. move ```tag``` to the same parent as ```sibling_node```,
+  2. decrement the sort_order values of the nodes before the ```sibling_node``` by one, and
+  3. set ```tag```'s order column to 1 less than the ```sibling_node```'s value.
+
+* ```tag.add_sibling_after(sibling_node)``` which will
+  1. move ```tag``` to the same parent as ```sibling_node```,
+  2. increment the sort_order values of the nodes after the ```sibling_node``` by one, and
+  3. set ```tag```'s order column to 1 more than the ```sibling_node```'s value.
+
+```ruby
+root = OrderedTag.create(:name => "root")
+a = OrderedTag.create(:name => "a", :parent => "root")
+b = OrderedTag.create(:name => "b")
+c = OrderedTag.create(:name => "c")
+
+a.append_sibling(b)
+root.children.collect(&:name)
+=> ["a", "b"]
+
+a.prepend_sibling(b)
+root.children.collect(&:name)
+=> ["b", "a"]
+
+a.append_sibling(c)
+root.children.collect(&:name)
+=> ["a", "c", "b"]
+
+b.append_sibling(c)
+root.children.collect(&:name)
+=> ["a", "b", "c"]
+```
+
+## Testing
+
+Closure tree is [tested under every combination](https://secure.travis-ci.org/mceachen/closure_tree.png?branch=master) of
+
+* Ruby 1.8.7 and Ruby 1.9.3
+* The latest Rails 3.0, 3.1, and 3.2 branches, and
+* MySQL, PostgreSQL, and SQLite.
+
+
 ## Change log
 
+### 3.2.0
+
+* Added support for deterministic ordering of nodes.
+
 ### 3.1.0
 
 * Switched to using ```has_many :though``` rather than ```has_and_belongs_to_many```

data/lib/closure_tree/acts_as_tree.rb

@@ -31,21 +31,27 @@ module ClosureTree
         alias :eql? :==
       RUBY
 
+      unless order_option.nil?
+        include ClosureTree::DeterministicOrdering
+        include ClosureTree::DeterministicNumericOrdering if order_is_numeric
+      end
+
       include ClosureTree::Model
 
-      validate :acts_as_tree_validate
-      before_save :acts_as_tree_before_save
-      after_save :acts_as_tree_after_save
-      before_destroy :acts_as_tree_before_destroy
+      validate :ct_validate
+      before_save :ct_before_save
+      after_save :ct_after_save
+      before_destroy :ct_before_destroy
 
       belongs_to :parent,
         :class_name => ct_class.to_s,
         :foreign_key => parent_column_name
 
-      has_many :children,
+      has_many :children, with_order_option(
         :class_name => ct_class.to_s,
-        :foreign_key => parent_column_name,
-        :dependent => closure_tree_options[:dependent]
+          :foreign_key => parent_column_name,
+          :dependent => closure_tree_options[:dependent]
+      )
 
       has_many :ancestor_hierarchies,
         :class_name => hierarchy_class_name,
@@ -63,19 +69,26 @@ module ClosureTree
         :foreign_key => "ancestor_id",
         :order => "generations asc",
         :dependent => :destroy
+      # 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,
         :through => :descendant_hierarchies,
         :source => :descendant,
-        :order => "generations asc"
+        :order => append_order("generations asc")
 
-      scope :roots, where(parent_column_name => nil)
+      def self.roots
+        where(parent_column_name => nil)
+      end
 
-      scope :leaves, where(" #{quoted_table_name}.#{primary_key} IN
+      def self.leaves
+        s = where("#{quoted_table_name}.#{primary_key} IN
         (SELECT ancestor_id
          FROM #{quoted_hierarchy_table_name}
          GROUP BY 1
          HAVING MAX(generations) = 0)")
+        order_option ? s.order(order_option) : s
+      end
     end
   end
 
@@ -84,7 +97,7 @@ module ClosureTree
 
     # Returns true if this node has no parents.
     def root?
-      _parent_id.nil?
+      ct_parent_id.nil?
     end
 
     # Returns true if this node has a parent, and is not a root.
@@ -113,10 +126,12 @@ module ClosureTree
       )
     end
 
-    def level
+    def depth
       ancestors.size
     end
 
+    alias :level :depth
+
     def ancestors
       without_self(self_and_ancestors)
     end
@@ -133,7 +148,8 @@ module ClosureTree
     end
 
     def self_and_siblings
-      self.class.scoped.where(:parent_id => parent)
+      s = self.class.scoped.where(:parent_id => parent)
+      quoted_order_column ? s.order(quoted_order_column) : s
     end
 
     def siblings
@@ -177,7 +193,7 @@ module ClosureTree
 
     protected
 
-    def acts_as_tree_validate
+    def ct_validate
       if changes[parent_column_name] &&
         parent.present? &&
         parent.self_and_ancestors.include?(self)
@@ -185,12 +201,12 @@ module ClosureTree
       end
     end
 
-    def acts_as_tree_before_save
+    def ct_before_save
       @was_new_record = new_record?
       true # don't cancel the save
     end
 
-    def acts_as_tree_after_save
+    def ct_after_save
       rebuild! if changes[parent_column_name] || @was_new_record
     end
 
@@ -203,13 +219,13 @@ module ClosureTree
             (ancestor_id, descendant_id, generations)
           SELECT x.ancestor_id, #{id}, x.generations + 1
           FROM #{quoted_hierarchy_table_name} x
-          WHERE x.descendant_id = #{self._parent_id}
+          WHERE x.descendant_id = #{self.ct_parent_id}
         SQL
       end
       children.each { |c| c.rebuild! }
     end
 
-    def acts_as_tree_before_destroy
+    def ct_before_destroy
       delete_hierarchy_references
       if closure_tree_options[:dependent] == :nullify
         children.each { |c| c.rebuild! }
@@ -236,10 +252,13 @@ module ClosureTree
       scope.where(["#{quoted_table_name}.#{self.class.primary_key} != ?", self])
     end
 
-    def _parent_id
+    def ct_parent_id
       send(parent_column_name)
     end
 
+    # TODO: _parent_id will be removed in the next major version
+    alias :_parent_id :ct_parent_id
+
     module ClassMethods
 
       # Returns an arbitrary node that has no parents.
@@ -315,6 +334,24 @@ module ClosureTree
       connection.quote_column_name parent_column_name
     end
 
+    def order_option
+      closure_tree_options[:order]
+    end
+
+    def with_order_option(options)
+      order_option ? options.merge(:order => order_option) : options
+    end
+
+    def append_order(order_by)
+      order_option ? "#{order_by}, #{order_option}" : order_by
+    end
+
+    def order_is_numeric
+      return false unless order_option
+      c = ct_class.columns_hash[order_option]
+      c && c.type == :integer
+    end
+
     def ct_class
       (self.is_a?(Class) ? self : self.class)
     end
@@ -339,4 +376,78 @@ module ClosureTree
       connection.quote_column_name ct_table_name
     end
   end
+
+  module DeterministicOrdering
+    def order_column
+      o = order_option
+      o.split(' ', 2).first if o
+    end
+
+    def require_order_column
+      raise ":order value, '#{order_option}', isn't a column" if order_column.nil?
+    end
+
+    def order_column_sym
+      require_order_column
+      order_column.to_sym
+    end
+
+    def order_value
+      send(order_column_sym)
+    end
+
+    def order_value=(new_order_value)
+      require_order_column
+      send("#{order_column}=".to_sym, new_order_value)
+    end
+
+    def quoted_order_column(include_table_name = true)
+      require_order_column
+      prefix = include_table_name ? "#{quoted_table_name}." : ""
+      "#{prefix}#{connection.quote_column_name(order_column)}"
+    end
+
+    def siblings_before
+      siblings.where(["#{quoted_order_column} < ?", order_value])
+    end
+
+    def siblings_after
+      siblings.where(["#{quoted_order_column} > ?", order_value])
+    end
+  end
+
+  # This module is only included if the order column is an integer.
+  module DeterministicNumericOrdering
+    def append_sibling(sibling_node, use_update_all = true)
+      add_sibling(sibling_node, use_update_all, true)
+    end
+
+    def prepend_sibling(sibling_node, use_update_all = true)
+      add_sibling(sibling_node, use_update_all, false)
+    end
+
+    def add_sibling(sibling_node, use_update_all = true, add_after = true)
+      fail "can't add self as sibling" if self == sibling_node
+      sibling_node.order_value = self.order_value.to_i + (add_after ? 1 : -1)
+      # We need to incr the before_siblings to make room for sibling_node:
+      if use_update_all
+        col = quoted_order_column(false)
+        ct_class.update_all(
+          ["#{col} = #{col} #{add_after ? '+' : '-'} 1", "updated_at = now()"],
+            ["#{quoted_parent_column_name} = ? AND #{col} #{add_after ? '>=' : '<='} ?",
+              ct_parent_id,
+              sibling_node.order_value])
+      else
+        last_value = sibling_node.order_value.to_i
+        (add_after ? siblings_after : siblings_before.reverse).each do |ea|
+          last_value += (add_after ? 1 : -1)
+          ea.order_value = last_value
+          ea.save!
+        end
+      end
+      sibling_node.parent = self.parent
+      sibling_node.save!
+      sibling_node.reload
+    end
+  end
 end

data/lib/closure_tree/version.rb

@@ -1,3 +1,3 @@
 module ClosureTree
-  VERSION = "3.1.0" unless defined?(::ClosureTree::VERSION)
+  VERSION = "3.2.0" unless defined?(::ClosureTree::VERSION)
 end

data/spec/db/schema.rb

@@ -5,6 +5,7 @@ ActiveRecord::Schema.define(:version => 0) do
     t.string   "name"
     t.string   "title"
     t.integer  "parent_id"
+    t.integer  "sort_order"
     t.datetime "created_at"
     t.datetime "updated_at"
   end
@@ -41,6 +42,7 @@ ActiveRecord::Schema.define(:version => 0) do
   create_table "labels", :force => true do |t|
     t.string   "name"
     t.string   "type"
+    t.integer  "sort_order"
     t.integer  "parent_id"
   end
 

data/spec/fixtures/labels.yml

@@ -0,0 +1,51 @@
+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
+
+

data/spec/fixtures/tags.yml

@@ -78,10 +78,12 @@ b2:
 c1a:
   name: c1a
   parent: b1
+  sort_order: 2
 
 c1b:
   name: c1b
   parent: b1
+  sort_order: 1
 
 c2:
   name: c2
@@ -93,4 +95,4 @@ d2:
 
 e2:
   name: e2
-  parent: d2
+  parent: d2

data/spec/label_spec.rb

@@ -15,8 +15,8 @@ describe Label do
       c.parent.name.should == "parent"
     end
   end
-  context "DateLabel" do
 
+  context "DateLabel" do
     it "should find or create by path" do
       date = DateLabel.find_or_create_by_path(%w{2011 November 23})
       date.ancestry_path.should == %w{2011 November 23}
@@ -44,7 +44,7 @@ describe Label do
     it "should support mixed type ancestors" do
       [Label, DateLabel, DirectoryLabel, EventLabel].permutation do |classes|
         nuke_db
-        classes.each{|c|c.all.should(be_empty, "class #{c} wasn't cleaned out") }
+        classes.each { |c| c.all.should(be_empty, "class #{c} wasn't cleaned out") }
         names = ('A'..'Z').to_a.first(classes.size)
         instances = classes.collect { |clazz| clazz.new(:name => names.shift) }
         a = instances.first
@@ -64,4 +64,81 @@ describe Label do
       end
     end
   end
+
+  context "Deterministic siblings sort with custom integer column" do
+    nuke_db
+    fixtures :labels
+
+    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), false)
+      labels(:c16).self_and_siblings.to_a.should == [labels(:c17), labels(:c16), labels(:c18), labels(:c19)]
+      labels(:c19).reload.prepend_sibling(labels(:c16).reload, false)
+      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 "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)]
+    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), false)
+      labels(:c2).ancestry_path.should == %w{a1 c2}
+      labels(:c2).self_and_siblings.to_a.should == [labels(:b1), labels(:c2), labels(:b2)]
+    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), false)
+      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), false)
+      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(d2 b2 e2 c1-six c1-seven c1-eight c1-nine)
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -14,7 +14,12 @@ require 'action_controller' # rspec-rails needs this :(
 
 require 'closure_tree'
 
-ActiveRecord::Base.logger = Logger.new(plugin_test_dir + "/debug.log")
+log = Logger.new(plugin_test_dir + "/debug.log")
+log.sev_threshold = Logger::DEBUG
+log.datetime_format = "%Y-%m-%d %H:%M:%S"
+log.formatter = Logger::Formatter.new
+
+ActiveRecord::Base.logger = log
 
 require 'yaml'
 require 'erb'

data/spec/support/models.rb

@@ -1,5 +1,5 @@
 class Tag < ActiveRecord::Base
-  acts_as_tree :dependent => :destroy
+  acts_as_tree :dependent => :destroy, :order => "name"
   before_destroy :add_destroyed_tag
   attr_accessible :name
 
@@ -29,7 +29,7 @@ class User < ActiveRecord::Base
 end
 
 class Label < ActiveRecord::Base
-  acts_as_tree
+  acts_as_tree :order => "sort_order"
   attr_accessible :name
 
   def to_s

data/spec/tag_spec.rb

@@ -76,7 +76,7 @@ shared_examples_for Tag do
       end
 
       it "should create all tags" do
-        Tag.all.should =~ [@root, @mid, @leaf]
+        Tag.all.should == [@root, @mid, @leaf]
       end
 
       it "should return a root and leaf without middle tag" do
@@ -96,11 +96,11 @@ shared_examples_for Tag do
         @leaf.reload.children.should be_empty
       end
 
-      it "should support reparenting" do
+      it "should support re-parenting" do
         @root.children << @leaf
-        Tag.leaves.should =~ [@leaf, @mid]
+        Tag.leaves.should == [@leaf, @mid]
       end
-      
+
       it "cleans up hierarchy references for leaves" do
         @leaf.destroy
         TagHierarchy.find_all_by_ancestor_id(@leaf.id).should be_empty
@@ -194,7 +194,7 @@ shared_examples_for Tag do
         child.add_child(parent) # this should fail
         parent.valid?.should be_false
         child.reload.children.should be_empty
-        parent.reload.children.should =~ [child]
+        parent.reload.children.should == [child]
       end
 
       it "should move non-leaves" do
@@ -254,6 +254,23 @@ shared_examples_for Tag do
         tags(:b1).siblings.to_a.should =~ [tags(:b2)]
         tags(:a1).siblings.to_a.should =~ (Tag.roots.to_a - [tags(:a1)])
         tags(:a1).self_and_siblings.to_a.should =~ Tag.roots.to_a
+
+        # must be ordered
+        tags(:indoor).siblings.to_a.should == [tags(:home), tags(:museum), tags(:outdoor), tags(:united_states)]
+        tags(:indoor).self_and_siblings.to_a.should == [tags(:home), tags(:indoor), tags(:museum), tags(:outdoor), tags(:united_states)]
+      end
+
+      it "assembles siblings before correctly" do
+        tags(:home).siblings_before.to_a.should == []
+        tags(:indoor).siblings_before.to_a.should == [tags(:home)]
+        tags(:outdoor).siblings_before.to_a.should == [tags(:home), tags(:indoor), tags(:museum)]
+        tags(:united_states).siblings_before.to_a.should == [tags(:home), tags(:indoor), tags(:museum), tags(:outdoor)]
+      end
+
+      it "assembles siblings after correctly" do
+        tags(:indoor).siblings_after.to_a.should == [tags(:museum), tags(:outdoor), tags(:united_states)]
+        tags(:outdoor).siblings_after.to_a.should == [tags(:united_states)]
+        tags(:united_states).siblings_after.to_a.should == []
       end
 
       it "assembles ancestors" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: closure_tree
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-09 00:00:00.000000000 Z
+date: 2012-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -172,6 +172,7 @@ files:
 - README.md
 - spec/db/database.yml
 - spec/db/schema.rb
+- spec/fixtures/labels.yml
 - spec/fixtures/tags.yml
 - spec/label_spec.rb
 - spec/spec_helper.rb
@@ -192,7 +193,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1583374080415694998
+      hash: -1361799512496949037
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -201,7 +202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1583374080415694998
+      hash: -1361799512496949037
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.21
@@ -211,6 +212,7 @@ summary: Hierarchies for ActiveRecord models using a Closure Tree storage algori
 test_files:
 - spec/db/database.yml
 - spec/db/schema.rb
+- spec/fixtures/labels.yml
 - spec/fixtures/tags.yml
 - spec/label_spec.rb
 - spec/spec_helper.rb