julik-make_like_a_tree 1.0.1

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2009-01-25
+
+* 1 major enhancement
+
+  * duh!
+

data/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+init.rb
+lib/make_like_a_tree.rb
+test/test_ordered_tree.rb

data/README.txt

@@ -0,0 +1,87 @@
+= make_like_a_tree
+
+http://github.com/julik/make_like_a_tree
+
+== DESCRIPTION:
+
+Implement orderable trees in ActiveRecord using the nested set model, with multiple roots and scoping, and most importantly user-defined
+ordering of subtrees. Fetches preordered trees in one go, updates are write-heavy.
+
+This is a substantially butchered-up version/offspring of acts_as_threaded. The main additional perk is the ability
+to reorder nodes, which are always fetched ordered. Example:
+
+  root = Folder.create! :name => "Main folder"
+  subfolder_1 = Folder.create! :name => "Subfolder", :parent_id => root.id
+  subfolder_2 = Folder.create! :name => "Another subfolder", :parent_id => root.id
+  
+  subfolder_2.move_to_top # just like acts_as_list but nestedly awesome
+  root.all_children # => [subfolder_2, subfolder_1]
+
+See the rdocs for examples the method names. It also inherits the awesome properties of acts_as_threaded, namely
+materialized depth, root_id and parent_id values on each object which are updated when nodes get moved.
+
+Thanks to the authors of acts_as_threaded, awesome_nested_set, better_nested_set and all the others for inspiration.
+
+
+== FEATURES/PROBLEMS:
+
+* Use create with parent_id set to the parent id (obvious, but somehow blocked in awesome_nested_set)
+* Ugly SQL
+* The node counts are currently not updated when a node is removed from a subtree and replanted elsewhere, 
+  so you cannot rely on (right-left)/2 to get the child count 
+* You cannot replant a node by assigning a new parent_id, add_child needed instead
+* The table needs to have proper defaults otherwise undefined behavior can happen. Otherwise demons 
+  will fly out of your left nostril and make you rewrite the app in inline PHP.
+
+== SYNOPSIS:
+  
+  class NodeOfThatUbiquitousCms < ActiveRecord::Base
+    make_like_a_tree
+  end
+  
+== REQUIREMENTS:
+
+Use the following migration (attention! dangerous defaults ahead!):
+
+  create_table :nodes do |t|
+    # Bookkeeping for threads
+    t.integer :root_id,          :default => 0,   :null => false
+    t.integer :parent_id,        :default => 0,   :null => false
+    t.integer :depth,            :default => 0,   :null => false
+    t.integer :lft,              :default => 0,   :null => false
+    t.integer :rgt,              :default => 0,   :null => false
+  end
+
+== INSTALL:
+
+Add a bare init file to your app and there:
+
+  require 'make_like_tree'
+  Julik::MakeLikeTree.bootstrap!
+
+That way you can keep the plugin in gems. Or just vendorize it, it has a built-in init.rb
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Julik Tarkhanov <me@julik.nl>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,16 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/make_like_a_tree.rb'
+
+# Disable spurious warnings when running tests, ActiveMagic cannot stand -w
+Hoe::RUBY_FLAGS.replace ENV['RUBY_FLAGS'] || "-I#{%w(lib test).join(File::PATH_SEPARATOR)}" + 
+  (Hoe::RUBY_DEBUG ? " #{RUBY_DEBUG}" : '')
+
+Hoe.new('make_like_a_tree', Julik::MakeLikeTree::VERSION) do |p|
+  # p.rubyforge_name = 'OrderedTreex' # if different than lowercase project name
+  p.developer('Julik', 'me@julik.nl')
+end
+
+# vim: syntax=Ruby

data/init.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/lib/make_like_a_tree'
+Julik::MakeLikeTree.bootstrap!

data/lib/make_like_a_tree.rb

@@ -0,0 +1,378 @@
+module Julik
+  module MakeLikeTree
+    VERSION = '1.0.1'
+    def self.included(base) #:nodoc:
+      super
+      base.extend(ClassMethods)
+    end
+      
+    # Injects the module into ActiveRecord
+    def self.bootstrap!
+      ::ActiveRecord::Base.send :include, self
+    end
+      
+    module ClassMethods
+      # An acts_as_threaded on steroids. Configuration options are:
+      #
+      # * +root_column+ - specifies the column name to use for identifying the root thread, default "root_id"
+      # * +parent_column+ - specifies the column name to use for keeping the position integer, default "parent_id"
+      # * +left_column+ - column name for left boundary data, default "lft"
+      # * +right_column+ - column name for right boundary data, default "rgt"
+      # * +depth+ - column name used to track the depth in the branch, default "depth"
+      # * +scope+ - adds an additional contraint on the threads when searching or updating
+      def make_like_a_tree(options = {})
+        configuration = { :root_column => "root_id", :parent_column => "parent_id", :left_column => "lft", :right_column => "rgt", :depth_column => 'depth', :scope => "(1=1)" }
+        configuration.update(options) if options.is_a?(Hash)
+        configuration[:scope] = "#{configuration[:scope]}_id".intern if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
+
+        if configuration[:scope].is_a?(Symbol)
+          scope_condition_method = %(
+            def scope_condition
+              if #{configuration[:scope].to_s}.nil?
+                "#{configuration[:scope].to_s} IS NULL"
+              else
+                "#{configuration[:scope].to_s} = \#{#{configuration[:scope].to_s}}"
+              end
+            end
+          )
+        else
+          scope_condition_method = "def scope_condition() \"#{configuration[:scope]}\" end"
+        end
+        
+        after_create :apply_parenting_after_create
+        
+       # before_update :register_parent_id_before_update, :unless => :new_record?
+      #  after_update :replant_after_update
+        
+        # TODO: refactor for class << self
+        class_eval <<-EOV
+          include Julik::MakeLikeTree::InstanceMethods
+
+          #{scope_condition_method}
+
+          def root_column() "#{configuration[:root_column]}" end
+          def parent_column() "#{configuration[:parent_column]}" end
+          def left_col_name() "#{configuration[:left_column]}" end
+          def right_col_name() "#{configuration[:right_column]}" end
+          def depth_column() "#{configuration[:depth_column]}" end
+
+        EOV
+      end
+    end
+
+    module InstanceMethods
+      
+      # Move the item to a specific index within the range of it's siblings. Used to reorder lists.
+      # Will cause a cascading update on the neighbouring items and their children, but the update will be scoped
+      def move_to(idx)
+        transaction do 
+          # Take a few shortcuts to avoid extra work
+          cur_idx = index_in_parent
+          return true if (cur_idx == idx)
+        
+          range = siblings_and_self
+          return true if range.length == 1
+        
+          cur_idx = range.index(self)
+          return true if cur_idx == idx
+        
+          # Register starting and ending elements
+          start_left, end_right = range[0][left_col_name], range[-1][right_col_name]
+        
+          old_range = range.dup
+        
+          range.delete_at(cur_idx)
+          range.insert(idx, self)
+          range.compact! # If we inserted something outside of range and created empty slots
+        
+          # Now remap segements
+          left_remaps, right_remaps = [], []
+        
+          # Exhaust the range starting with the last element, determining a remap on the fly
+          while range.any?
+            e = range.pop
+          
+            w = (e[right_col_name] - e[left_col_name])
+
+            # Determine by how many we need to shift the adjacent keys to put this item into place
+            offset_in_range = range.inject(0) do | sum, item_before |
+              sum + item_before[right_col_name] - item_before[left_col_name] + 1
+            end
+            shift = offset_in_range - e[left_col_name] + 1
+            
+            unless shift.zero? # Optimize - do not move nodes that stay in the same place
+              condition_stmt = "#{left_col_name} >= #{e[left_col_name]} AND #{right_col_name} <= #{e[right_col_name]}"
+              value_stmt_left = "#{left_col_name} + #{shift}"
+              value_stmt_right = "#{right_col_name} + #{shift}"
+          
+              left_remaps.unshift(
+                "WHEN (#{condition_stmt}) THEN (#{left_col_name} + #{shift})"
+              )
+              right_remaps.unshift(
+                "WHEN (#{condition_stmt}) THEN (#{right_col_name} + #{shift})"
+              )
+            end
+          end
+        
+          # If we are not a root node, scope the changes to our subtree only - this will win us some less writes
+          update_condition = if root?
+            scope_condition
+          else
+            "#{scope_condition} AND #{root_column} = #{self[root_column]}"
+          end
+          
+          self.class.update_all(
+            "#{left_col_name} = CASE #{left_remaps.join(' ')} ELSE #{left_col_name} END, " + 
+            "#{right_col_name} = CASE #{right_remaps.join(' ')} ELSE #{right_col_name} END ",
+            update_condition
+          )
+        end
+      end
+
+      # Move the record down in the list (uses move_to)
+      def move_up
+        move_to(index_in_parent - 1)
+      end
+      
+      # Move the record up in the list (uses move_to)
+      def move_down
+        move_to(index_in_parent + 1)
+      end
+      
+      # Move the record to top of the list (uses move_to)
+      def move_to_top
+        move_to(0)
+      end
+      
+      # Move the record to the bottom of the list (uses move_to)
+      def move_to_bottom
+        move_to(-1)
+      end
+      
+      # Get the item index in parent. TODO: when the tree is balanced with no orphan counts, just use (rgt-lft)/2
+      def index_in_parent
+        # Fetch the item count of items that have the same root_id and the same parent_id and are lower than me on the indices
+        @index_in_parent ||= self.class.count_by_sql(
+          "SELECT COUNT(id) FROM #{self.class.table_name} WHERE " + 
+          "#{right_col_name} < #{self[left_col_name]} AND  #{parent_column} = #{self[parent_column]}"
+        )
+      end
+      
+      # Override ActiveRecord::Base#reload to blow over all the memoized values
+      def reload(*any_arguments)
+        @index_in_parent, @is_root, @is_child, @old_parent_id, @rerooted = nil, nil, nil, nil, nil
+        super
+      end
+      
+      # Returns true is this is a root thread.
+      def root?
+        @is_root ||= (self[root_column].to_i.zero? ||  (self[root_column] == self.id))
+      end
+
+      # Returns true is this is a child node
+      def child?
+        parent_id = self[parent_column]
+        @is_child ||= (!(parent_id.to_i.zero?) && (self[left_col_name] > 1) && (self[right_col_name] > self[left_col_name]))
+      end
+
+      # Returns true if we have no idea what this is
+      def unknown?
+        !root? && !child?
+      end
+      
+      # Used as an after_create callback to apply the parent_id assignment or create a root node
+      def apply_parenting_after_create
+        reload # Reload to bring in the id
+        assign_default_left_and_right
+        self.save
+        unless self[parent_column].to_i.zero?
+          # Load the parent
+          parent = self.class.find(self[parent_column])
+          parent.add_child self
+        end
+        true
+      end
+      
+      # Place the item to the appropriate place as a root item
+      def assign_default_left_and_right(with_space_inside = 0)
+        
+        # Instead of creating nodes with 0,0 make this a root node BY DEFAULT even if no children are specified
+        self[root_column] = self.id
+        last_root_node = self.class.find(:first, :conditions => "#{scope_condition} AND #{parent_column} = 0 AND id != #{self.id}",
+          :order => "#{right_col_name} DESC", :limit => 1)
+        offset = last_root_node ? last_root_node[right_col_name] : 0
+        
+        self[left_col_name], self[right_col_name] = (offset+1), (offset + with_space_inside + 2)
+      end
+      
+      # Shortcut for self[depth_column]
+      def level
+        self[depth_column]
+      end
+      
+      # Adds a child to this object in the tree.  If this object hasn't been initialized,
+      # it gets set up as a root node.  Otherwise, this method will update all of the
+      # other elements in the tree and shift them to the right, keeping everything
+      # balanced.
+      def add_child(child)
+        child.reload # Pull in the id
+        k = self.class
+        
+        new_left, new_right = determine_range_for_child(child)
+        
+        move_by = new_left - child[left_col_name]
+        move_depth_by = (self[depth_column] + 1) - child[depth_column]
+        
+        child_occupies = (new_right - new_left) + 1
+        
+        transaction do
+          # bring the child and its grandchildren over
+          self.class.update_all( 
+            "#{depth_column} = #{depth_column} + #{move_depth_by}," +
+            "#{root_column} = #{self[root_column]}," +
+            "#{left_col_name} = #{left_col_name} + #{move_by}," +
+            "#{right_col_name} = #{right_col_name} + #{move_by}",
+            "#{scope_condition} AND #{left_col_name} >= #{child[left_col_name]} AND #{right_col_name} <= #{child[right_col_name]}" +
+            " AND #{root_column} = #{child[root_column]} AND #{root_column} != 0"
+          )
+          
+          # update parent_id on child ONLY
+          self.class.update_all(
+            "#{parent_column} = #{self.id}",
+            "id = #{child.id}"
+          )
+          
+          # update myself and upstream to notify we are wider
+          self.class.update_all(
+            "#{right_col_name} = #{right_col_name} + #{child_occupies}",
+            "#{scope_condition} AND #{root_column} = #{self[root_column]} AND (#{depth_column} < #{self[depth_column]} OR id = #{self.id})"
+          )
+          
+          # update items to my right AND downstream of them to notify them we are wider. Will shift root items to the right
+          self.class.update_all(
+            "#{left_col_name} = #{left_col_name} + #{child_occupies}, " +
+            "#{right_col_name} = #{right_col_name} + #{child_occupies}",
+            "#{depth_column} >= #{self[depth_column]} " + 
+            "AND #{left_col_name} > #{self[right_col_name]}"
+          )
+        end
+        [self, child].map{|e| e.reload }
+        true
+      end
+      
+      # Determine lft and rgt for a child item, taking into account the number of child and grandchild nodes it has.
+      # Normally you would not use this directly
+      def determine_range_for_child(child)
+        new_left = begin
+          right_bound_child = self.class.find(:first, 
+            :conditions => "#{scope_condition} AND #{parent_column} = #{self.id} AND id != #{child.id}", :order => "#{right_col_name} DESC")
+          right_bound_child ? (right_bound_child[right_col_name] + 1) : (self[left_col_name] + 1)
+        end
+        new_right = new_left + (child[right_col_name] - child[left_col_name])
+        [new_left, new_right]
+      end
+      
+      # Returns the number of children and grandchildren of this object
+      def child_count
+        return 0 unless might_have_children? # optimization shortcut
+        self.class.count_by_sql("SELECT COUNT(id) FROM #{self.class.table_name} WHERE #{conditions_for_all_children}")
+      end
+      alias_method :children_count, :child_count
+      
+      # Shortcut to determine if our left and right values allow for possible children
+      def might_have_children?
+        (self[right_col_name] - self[left_col_name]) > 1
+      end
+      
+      # Returns a set of itself and all of its nested children
+      def full_set
+        [self] + all_children
+      end
+      alias_method :all_children_and_self, :full_set
+
+      # Returns a set of all of its children and nested children
+      def all_children
+        return [] unless might_have_children? # optimization shortcut
+        self.class.find(:all, :conditions => conditions_for_all_children, :order => "#{left_col_name} ASC")
+      end
+      
+      # Get conditions for direct and indirect children of this record
+      def conditions_for_all_children
+        "#{scope_condition} AND #{root_column} = #{self[root_column]} AND " +
+        "#{depth_column} > #{self[depth_column]} AND " +
+        "#{left_col_name} > #{self[left_col_name]} AND #{right_col_name} < #{self[right_col_name]}"
+      end
+      
+      # Get conditions to find myself and my siblings
+      def conditions_for_self_and_siblings
+        "#{scope_condition} AND #{parent_column} = #{self[parent_column]}"
+      end
+      
+      # Get immediate siblings, ordered
+      def siblings
+        self.class.find(:all, :conditions => "#{conditions_for_self_and_siblings} AND id != #{self.id}", :order => "#{left_col_name} ASC")
+      end
+      
+      # Get myself and siblings, ordered
+      def siblings_and_self
+        self.class.find(:all, :conditions => conditions_for_self_and_siblings, :order => "#{left_col_name} ASC")
+      end
+      
+      # Returns a set of only this entry's immediate children, also ordered by position
+      def direct_children
+        return [] unless might_have_children? # optimize!
+        self.class.find(:all, 
+          :conditions => "#{scope_condition} AND #{parent_column} = #{self.id}",
+          :order => 'lft ASC'
+        )
+      end
+      
+      # Make this item a root node
+      def promote_to_root
+        transaction do
+          my_width = child_count * 2
+        
+          # Stash the values because assign_default_left_and_right reassigns them
+          old_left, old_right, old_root = self[left_col_name], self[right_col_name], self[root_column]
+          self[parent_column] = 0 # Signal the root node
+        
+          assign_default_left_and_right(my_width)
+          
+          move_by = self[left_col_name] - old_left
+          move_depth_by = self[depth_column]
+        
+          # bring the child and its grandchildren over
+          self.class.update_all( 
+            "#{depth_column} = #{depth_column} - #{move_depth_by}," +
+            "#{root_column} = #{self.id}," +
+            "#{left_col_name} = #{left_col_name} + #{move_by}," +
+            "#{right_col_name} = #{right_col_name} + #{move_by}",
+            "#{scope_condition} AND #{left_col_name} >= #{old_left} AND #{right_col_name} <= #{old_right}" +
+            " AND #{root_column} = #{old_root}"
+          )
+          self.reload
+        end
+        true
+      end
+      
+      def register_parent_id_before_update 
+        @old_parent_id = self.class.connection.select_value("SELECT #{parent_column} FROM #{self.class.table_name} WHERE id = #{self.id}")
+        true
+      end
+      
+      def replant_after_update
+        if @old_parent_id.nil? || (@old_parent_id == self[parent_column])
+          return true
+        # If the new parent_id is nil, it means we are promoted to woot node
+        elsif self[parent_column].nil? || self[parent_column].zero?
+          promote_to_root
+        else
+          self.class.find(self[parent_column]).add_child(self)
+        end
+
+        true
+      end
+      
+    end #InstanceMethods
+  end
+end

data/test/test_ordered_tree.rb

@@ -0,0 +1,350 @@
+require 'rubygems'
+require 'active_record'
+require 'active_support'
+require 'test/spec'
+
+require File.dirname(__FILE__) + '/../init'
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :dbfile => ':memory:')
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Schema.define do
+  create_table :nodes, :force => true do |t|
+
+    t.string :name,  :null => false
+    t.integer :project_id
+
+    # Bookkeeping for threads
+    t.integer :root_id,          :default => 0,   :null => false
+    t.integer :parent_id,        :default => 0,   :null => false
+    t.integer :depth,            :maxlength => 5, :default => 0,    :null => false
+    t.integer :lft,              :default => 0,   :null => false
+    t.integer :rgt,              :default => 0,   :null => false
+  end
+  
+  # Anonimous tables for anonimous classes
+  (1..20).each do | i |
+    create_table "an#{i}s", :force => true do # anis!
+    end
+  end
+end
+
+context "A Node used with OrderedTree should" do
+  
+  class Node < ActiveRecord::Base
+    set_table_name "nodes"
+    make_like_a_tree :scope => :project
+    def _lr
+      [lft, rgt]
+    end
+  end
+  
+  before do
+    Node.delete_all
+  end
+  
+  specify "support full_set" do
+    folder1, folder2 = emit(:name => "One"), emit(:name => "Two")
+    three = emit(:name => "subfolder", :parent_id => folder1.id)
+    
+    folder1.all_children_and_self.should.equal folder1.full_set
+  end
+  
+  specify "return a proper scope condition" do
+    Node.new(:project_id => 1).scope_condition.should.equal "project_id = 1"
+    Node.new(:project_id => nil).scope_condition.should.equal "project_id IS NULL"
+  end
+  
+  specify "return a bypass scope condition with no scope" do
+    class An2 < ActiveRecord::Base
+      make_like_a_tree
+    end
+    An2.new.scope_condition.should.equal "(1=1)" 
+  end
+  
+  specify "return a proper left and right column if they have been customized" do
+    class An1 < ActiveRecord::Base
+      make_like_a_tree :left_column => :foo, :right_column => :bar
+    end
+    An1.new.left_col_name.should.equal "foo"
+    An1.new.right_col_name.should.equal "bar"
+  end
+   
+  specify "return a proper depth column if it has been customized" do
+    class An3 < ActiveRecord::Base
+      make_like_a_tree :depth_column => :niveau
+    end
+    An3.new.depth_column.should.equal "niveau"
+  end
+  
+  specify "create root nodes with ordered left and right" do
+    groups = (0...2).map do | idx |
+      emit :name => "Group_#{idx}"
+    end
+    reload(groups)
+    
+    groups[0]._lr.should.equal [1, 2]
+    groups[1]._lr.should.equal [3,4]
+  end
+  
+  specify "create a good child node" do
+    
+    root_node = emit :name => "Mother"
+    child_node = emit :name => "Daughter", :parent_id => root_node.id
+    
+    reload(root_node, child_node)
+    
+    root_node._lr.should.blaming("root node with one subset is 1,4").equal [1, 4]
+    child_node._lr.should.blaming("first in nested range is 2,3").equal [2, 3]
+  end
+  
+  specify "create a number of good child nodes" do
+    
+    root_node = emit :name => "Mother"
+    child_nodes = ["Daughter", "Brother"].map { |n| emit :name => n, :parent_id => root_node.id }
+    
+    reload(root_node, child_nodes)
+    
+    root_node._lr.should.blaming("extended range").equal [1, 6]
+    child_nodes[0]._lr.should.blaming("first in sequence is 2,3").equal [2, 3]
+    child_nodes[1]._lr.should.blaming("second in sequence is 4,5").equal [4, 5]
+    
+    child_nodes.each do | cn |
+      cn.depth.should.blaming("depth increase").equal 1
+      cn.root_id.should.blaming("proper root assignment").equal root_node.id
+      cn.parent_id.should.blaming("parent assignment").equal root_node.id
+    end
+  end
+  
+  specify "properly shift siblings to the right on child assignment to their left neighbour" do
+    root_node = emit :name => "Root one"
+    
+    sub_node = emit :name => "Child 1", :parent_id => root_node.id
+    sub_node_sibling = emit :name => "Child 2", :parent_id => root_node.id
+    
+    reload(sub_node_sibling)
+    sub_node_sibling._lr.should.equal [4,5]
+
+    # Now inject a child into sub_node
+    grandchild = emit :name => "Grandchild via Child 1", :parent_id => sub_node.id
+    
+    reload(sub_node_sibling)
+    sub_node_sibling._lr.should.blaming("shifted right because a child was injected to the left of us").equal [6,7]
+    
+    reload(root_node)
+    root_node._lr.should.blaming("increased range for the grandchild").equal [1,8]
+  end
+  
+  specify "make nodes their own roots" do
+    a, b = %w(a b).map{|n| emit :name => n }
+    a.root_id.should.equal a.id
+    b.root_id.should.equal b.id
+  end
+  
+  specify "properly replant a branch" do
+    root_node_1 = emit :name => "First root"
+    root_node_2 = emit :name => "Second root"
+    root_node_3 = emit :name => "Third root"
+    
+    # Now make a subtree on the third root node
+    child = emit :name => "Child", :parent_id => root_node_3.id
+    grand_child = emit :name => "Grand child", :parent_id => child.id
+    grand_grand_child = emit :name => "Grand grand child", :parent_id => grand_child.id
+    
+    reload(root_node_1, root_node_2, root_node_3, child, grand_child, grand_grand_child)
+    
+    child._lr.should.blaming("the complete branch indices").equal [6,11]
+    root_node_3._lr.should.blaming("inclusive for the child branch").equal [5, 12]
+
+    root_node_1.add_child(child) 
+    
+    reload(root_node_1, root_node_2)
+    
+    root_node_1._lr.should.blaming("branch containment expanded the range").equal [1, 8]
+    root_node_2._lr.should.blaming("shifted right to make room").equal [9, 10]
+  end
+  
+  specify "properly report size after moving a branch from underneath" do
+    root_node_1 = emit :name => "First root"
+    root_node_2 = emit :name => "First root"
+    
+    child = emit :name => "Some child", :parent_id => root_node_2.id
+    
+    root_node_2.reload
+    
+    root_node_2.might_have_children?.should.blaming("might_have_children? is true - our indices are #{root_node_2._lr.inspect}").equal true
+    root_node_2.child_count.should.blaming("only one child available").equal 1
+    
+    # Now replant the child
+    root_node_1.add_child(child)
+
+    root_node_2.child_count.should.blaming("all children removed").be.zero
+    root_node_1.child_count.should.blaming("now has one child").equal 1
+  end
+  
+  specify "properly return siblings" do
+    root_1 = emit :name => "Foo"
+    root_2 = emit :name => "Bar"
+    
+    reload(root_1, root_2)
+    
+    root_1.siblings.should.equal [root_2]
+    root_2.siblings.should.equal [root_1]
+  end
+  
+  specify "properly return siblings and self" do
+    root_1 = emit :name => "Foo"
+    root_2 = emit :name => "Bar"
+    
+    reload(root_1, root_2)
+    
+    root_1.siblings_and_self.should.equal [root_1, root_2]
+    root_2.siblings_and_self.should.equal [root_1, root_2]
+  end
+  
+  specify "provide index_in_parent" do
+    root_nodes  = (0...3).map do | i |
+      emit :name => "Root_#{i}"
+    end
+
+    root_nodes.each_with_index do | rn, i |
+      rn.should.respond_to :index_in_parent
+      rn.index_in_parent.should.blaming("is at index #{i}").equal i
+    end
+  end
+  
+  specify 'do nothing on move when only item in the list' do
+     a = emit :name => "Boo"
+     a.move_to(0).should.equal true
+     a.move_to(200).should.equal true
+  end
+  
+  specify "do nothing if we move from the same position to the same position" do
+    a = emit :name => "Foo"
+    b = emit :name => "Boo"
+    
+    a.move_to(0).should.equal true
+    b.move_to(1).should.equal true
+  end
+  
+  specify "move a root node up" do
+    root_1 = emit :name => "First root"
+    root_2 = emit :name => "Second root"
+    root_2.move_to(0)
+    
+    reload(root_1, root_2)
+    
+    root_1._lr.should.equal [3, 4]
+    root_2._lr.should.equal [1, 2]
+  end
+  
+  specify "reorder including subtrees" do
+    root_1 = emit :name => "First root"
+    root_2 = emit :name => "Second root with children"
+    4.times{ emit :name => "Child of root2", :parent_id => root_2.id }
+    
+    reload(root_2)
+    root_2._lr.should.equal [3, 12]
+    
+    root_2.move_to(0)
+    reload(root_2)
+    
+    root_2._lr.should.blaming("Shifted range").equal [1, 10]
+    root_2.children_count.should.blaming("the same children count").equal 4
+    
+    reload(root_1)
+    root_1._lr.should.blaming("Shifted down").equal [11, 12]
+    root_1.children_count.should.blaming("the same children count").be.zero
+  end
+  
+  specify "support move_up" do
+    root_1, root_2 = emit(:name => "First"), emit(:name => "Second")
+    root_2.should.respond_to :move_up
+    
+    root_2.move_up
+
+    reload(root_1, root_2)
+    root_2._lr.should.equal [1,2]
+  end
+  
+  specify "support move_down" do
+    root_1, root_2 = emit(:name => "First"), emit(:name => "Second")
+
+    root_1.should.respond_to :move_down
+    root_1.move_up
+
+    reload(root_1, root_2)
+    root_2._lr.should.equal [1,2]
+    root_1._lr.should.equal [3,4]
+  end
+
+  specify "support move_to_top" do
+    root_1, root_2, root_3 = emit(:name => "First"), emit(:name => "Second"), emit(:name => "Third")
+
+    root_3.should.respond_to :move_to_top
+    root_3.move_to_top
+    reload(root_1, root_2, root_3)
+    
+    root_3._lr.should.blaming("is now on top").equal [1,2]
+    root_1._lr.should.blaming("is now second").equal [3,4]
+    root_2._lr.should.blaming("is now third").equal [5,6]
+  end
+  
+  specify "support move_to_bottom" do
+    root_1, root_2, root_3, root_4 = (1..4).map{|e| emit :name => "Root_#{e}"}
+    root_1.should.respond_to :move_to_bottom
+    
+    root_1.move_to_bottom
+    reload(root_1, root_2, root_3, root_4)
+    
+    root_2._lr.should.blaming("is now on top").equal [1,2]
+    root_1._lr.should.blaming("is now on the bottom").equal [7,8]
+  end
+
+  specify "support move_to_top for the second item of three" do
+    a, b, c = emit_many(3)
+    b.move_to_top
+    reload(a, b, c)
+    
+    a._lr.should.equal [3, 4]
+    b._lr.should.equal [1, 2]
+    c._lr.should.equal [5, 6]
+  end
+  
+  #specify "support promote_to_root" do
+  def test_promote_to_root
+    a, b = emit_many(2)
+    c = emit(:name => "Subtree", :parent_id => a.id)
+    
+    reload(a, b, c)
+    $l = true
+    c.promote_to_root
+    
+    reload(a, b, c)
+    
+    c.depth.should.blaming("is at top level").equal 0
+    c.root_id.should.blaming("is now self-root").equal c.id
+    c._lr.should.blaming("now promoted to root").equal [7, 8]
+  end
+  
+  specify "support replanting by changing parent_id" do
+    a, b = emit_many(2)
+    sub = emit :name => "Child", :parent_id => a.id
+    sub.update_attributes(:parent_id => b.id)
+
+    reload(a, b, sub)
+    a.all_children.should.blaming("replanted branch from there").not.include( sub)
+    b.all_children.should.blaming("replanted branch here").include( sub)
+  end
+  
+  def emit(attributes = {})
+    Node.create!({:project_id => 1}.merge(attributes))
+  end
+  
+  def emit_many(how_many, extras = {})
+    (1..how_many).map{|i| emit({:name => "Item_#{i}"}.merge(extras)) }
+  end
+
+  def reload(*all)
+    all.flatten.map(&:reload)
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: julik-make_like_a_tree
+version: !ruby/object:Gem::Version 
+  version: 1.0.1
+platform: ruby
+authors: 
+- Julik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-25 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+    version: 
+description: "Implement orderable trees in ActiveRecord using the nested set model, with multiple roots and scoping, and most importantly user-defined ordering of subtrees. Fetches preordered trees in one go, updates are write-heavy.  This is a substantially butchered-up version/offspring of acts_as_threaded. The main additional perk is the ability to reorder nodes, which are always fetched ordered. Example:  root = Folder.create! :name => \"Main folder\" subfolder_1 = Folder.create! :name => \"Subfolder\", :parent_id => root.id subfolder_2 = Folder.create! :name => \"Another subfolder\", :parent_id => root.id  subfolder_2.move_to_top # just like acts_as_list but nestedly awesome root.all_children # => [subfolder_2, subfolder_1]  See the rdocs for examples the method names. It also inherits the awesome properties of acts_as_threaded, namely materialized depth, root_id and parent_id values on each object which are updated when nodes get moved.  Thanks to the authors of acts_as_threaded, awesome_nested_set, better_nested_set and all the others for inspiration."
+email: 
+- me@julik.nl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- init.rb
+- lib/make_like_a_tree.rb
+- test/test_ordered_tree.rb
+has_rdoc: true
+homepage: http://github.com/julik/make_like_a_tree
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: make_like_a_tree
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Implement orderable trees in ActiveRecord using the nested set model, with multiple roots and scoping, and most importantly user-defined ordering of subtrees
+test_files: 
+- test/test_ordered_tree.rb