make_like_a_tree 1.0.3

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,97 @@
+= 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:
+
+* Currently there is no clean way to change the column you scope on
+* 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
+    
+    # Handy for selects and tree text
+    def indented_name
+      ["-" * depth.to_i, name].join
+    end
+  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!
+
+Or just vendorize it, it has a built-in init.rb. You can also use the
+plugin without unpacking it, to do so put the following in the config:
+
+  config.gem "make_like_a_tree"
+  config.after_initialize { Julik::MakeLikeTree.bootstrap! }
+
+== 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,15 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/make_like_a_tree'
+
+# Disable spurious warnings when running tests, ActiveMagic cannot stand -w
+Hoe::RUBY_FLAGS.gsub!(/^-w/, '')
+
+Hoe.spec('make_like_a_tree') do |p|
+  p.version = Julik::MakeLikeTree::VERSION
+  p.developer('Julik Tarkhanov', '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,468 @@
+module Julik
+  module MakeLikeTree
+    class ImpossibleReparent < RuntimeError
+    end
+    
+    VERSION = '1.0.3'
+    DEFAULTS = { 
+      :root_column => "root_id", 
+      :parent_column => "parent_id", 
+      :left_column => "lft", 
+      :right_column => "rgt", 
+      :depth_column => 'depth', 
+      :scope => "(1=1)"
+    }
+    
+    def self.included(base) #:nodoc:
+      super
+      base.extend(ClassMethods)
+    end
+    
+    # Injects the module into ActiveRecord. Can (and should) be used in config.after_initialize
+    # block of the app
+    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 = DEFAULTS.dup.merge(options)
+        
+        if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
+          configuration[:scope] = "#{configuration[:scope]}_id".intern 
+        end
+        
+        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)
+        return false if new_record?
+        
+        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, mini_scopes = [], [], ["(1=0)"]
+        
+          # Exhaust the range starting with the last element, determining the remapped offset
+          # based on the width of remaining sets
+          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.
+            # On every iteration add 1 (the formal increment in a leaf node)
+            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
+            
+             # Optimize - do not move nodes that stay in the same place
+            next if shift.zero?
+
+            case_stmt = "#{left_col_name} >= #{e[left_col_name]} AND #{right_col_name} <= #{e[right_col_name]}"
+            
+            # Scoping our query by the mini-scope will help us avoid a table scan in some situations
+            mini_scopes << case_stmt
+            
+            left_remaps.unshift(
+              "WHEN (#{case_stmt}) THEN (#{left_col_name} + #{shift})"
+            )
+            right_remaps.unshift(
+              "WHEN (#{case_stmt}) THEN (#{right_col_name} + #{shift})"
+            )
+          end
+        
+          # If we are not a root node, scope the changes to our subtree only - this will win us some less writes
+          update_condition = root? ? scope_condition : "#{scope_condition} AND #{root_column} = #{self[root_column]}"
+          update_condition << " AND (#{mini_scopes.join(" OR ")})"
+          
+          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(options = nil)
+        @index_in_parent, @is_root, @is_child, 
+          @old_parent_id, @rerooted, @child_count = nil, nil, nil, nil, nil, nil
+        super(options)
+      end
+      
+      # Returns true is this is a root thread.
+      def root?
+        self[parent_column].to_i.zero?
+      end
+
+      # Returns true is this is a child node. Inverse of root?
+      def child?
+        !root?
+      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
+        
+        transaction do
+          self.save
+          unless self[parent_column].to_i.zero? # will also capture nil
+            # Load the parent
+            parent = self.class.find(self[parent_column])
+            parent.add_child self
+          end
+        end
+        true
+      end
+      
+      # Place the item to the appropriate place as a root item
+      def assign_default_left_and_right(with_space_inside = 0)
+        # Make a self root and assign left and right respectively
+        # even if no children are specified
+        self[root_column] = self.id
+        self[left_col_name], self[right_col_name] = get_left_and_right_for(self, with_space_inside)
+      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)
+        begin
+          add_child!(child)
+        rescue ImpossibleReparent
+          false
+        end
+      end
+      
+      # Tells you if a reparent might be invalid
+      def child_can_be_added?(child)
+        impossible = (child[root_column] == self[root_column] && 
+          child[left_col_name] < self[left_col_name]) && 
+          (child[right_col_name] > self[right_col_name])
+        
+        !impossible
+      end
+      
+      # A noisy version of add_child, will raise an ImpossibleReparent if you try to reparent a node onto its indirect child.
+      # Will return false if either of the records is a new record. Will reload both the parent and the child record
+      def add_child!(child)
+        return false if (new_record? || child.new_record?)
+        raise ImpossibleReparent, "Cannot reparent #{child} onto its child node #{self}" unless child_can_be_added?(child)
+
+        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 (!new_record? && might_have_children?) # shortcut
+        
+        @child_count ||= self.class.scoped(scope_hash_for_branch).count
+      end
+      alias_method :children_count, :child_count
+      
+      # Shortcut to determine if our left and right values allow for possible children.
+      # Note the difference in wording between might_have and has - if this method returns false,
+      # it means you should look no further. If it returns true, you should really examine
+      # the children to be sure
+      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. Any additional
+      # options scope the find call.
+      def full_set(extras = {})
+        [self] + all_children(extras)
+      end
+      alias_method :all_children_and_self, :full_set
+
+      # Returns a set of all of its children and nested children. Any additional
+      # options scope the find call.
+      def all_children(extras = {})
+        return [] unless might_have_children? # optimization shortcut
+        self.class.scoped(scope_hash_for_branch).find(:all, extras)
+      end
+      
+      # Returns scoping options suitable for fetching all children
+      def scope_hash_for_branch
+        {:conditions => conditions_for_all_children, :order => "#{left_col_name} ASC" }
+      end
+      
+      # Returns scopint options suitable for fetching direct children
+      def scope_hash_for_direct_children
+        {:conditions => "#{scope_condition} AND #{parent_column} = #{self.id}", :order => "#{left_col_name} ASC"}
+      end
+      
+      # Get conditions for direct and indirect children of this record
+      def conditions_for_all_children
+        pk = "#{self.class.table_name} WHERE id = #{self.id}"
+        inner_r  = "(SELECT #{root_column}    FROM #{pk})"
+        inner_d  = "(SELECT #{depth_column}   FROM #{pk})"
+        inner_l  = "(SELECT #{left_col_name}  FROM #{pk})"
+        inner_r  = "(SELECT #{right_col_name} FROM #{pk})"
+        inner_rt = "(SELECT #{root_column} FROM #{pk})"
+        
+        "#{scope_condition} AND #{inner_rt} AND " +
+        "#{depth_column} > #{inner_d} AND " +
+        "#{left_col_name} > #{inner_l} AND #{right_col_name} < #{inner_r}"
+      end
+      
+      # Get conditions to find myself and my siblings
+      def conditions_for_self_and_siblings
+        inner_select = "SELECT %s FROM %s WHERE id = %d" % [parent_column, self.class.table_name, id]
+        "#{scope_condition} AND #{parent_column} = (#{inner_select})"
+      end
+      
+      # Get immediate siblings, ordered
+      def siblings(extras = {})
+        scope = {
+          :conditions => "#{conditions_for_self_and_siblings} AND id != #{self.id}", 
+          :order => "#{left_col_name} ASC"
+        }
+        self.class.scoped(scope).find(:all, extras)
+      end
+      
+      # Get myself and siblings, ordered
+      def siblings_and_self(extras = {})
+        scope = {
+          :conditions => "#{conditions_for_self_and_siblings}", 
+          :order => "#{left_col_name} ASC"
+        }
+        self.class.scoped(scope).find(:all, extras)
+      end
+      
+      # Returns a set of only this entry's immediate children, also ordered by position. Any additional
+      # options scope the find call.
+      def direct_children(extras = {})
+        return [] unless might_have_children? # optimize!
+        self.class.scoped(scope_hash_for_direct_children).find(:all, extras)
+      end
+      
+      # Make this item a root node (moves it to the end of the root node list in the same scope)
+      def promote_to_root
+        return false if new_record?
+
+        transaction do
+          my_width = child_count * 2
+        
+          # Use the copy in the DB to infer keys
+          stale = self.class.find(self.id, :select => [left_col_name, right_col_name, root_column, depth_column].join(', '))
+          
+          old_left, old_right, old_root, old_depth = stale[left_col_name], stale[right_col_name], stale[root_column], stale[depth_column]
+          
+          
+          self[parent_column] = 0 # Signal the root node
+          new_left, new_right = get_left_and_right_for(self, my_width)
+          
+          move_by = new_left - old_left
+          move_depth_by = old_depth
+          
+          # 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}"
+          )
+          
+          # update self, assume valid object for speed
+          self.class.update_all(
+            "#{root_column} = #{self.id}, #{depth_column} = 0, #{parent_column} = 0, #{left_col_name} = #{new_left}, #{right_col_name} = #{new_right}",
+            "id = #{self.id}"
+          )
+          
+          # Blow away the memoized counts
+          self.reload
+        end
+        true
+      end
+      
+      
+      private
+      
+      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
+
+      def get_left_and_right_for(item, width)
+        last_root_node = item.class.find(:first, :conditions => "#{item.scope_condition} AND #{item.parent_column} = 0 AND id != #{item.id}",
+          :order => "#{right_col_name} DESC", :limit => 1, :select => [right_col_name]) # spare!
+        offset = last_root_node ? last_root_node[right_col_name] : 0
+        
+        [(offset+1), (offset + width + 2)]
+      end
+      
+      
+    end #InstanceMethods
+  end
+end

data/test/test_ordered_tree.rb

@@ -0,0 +1,474 @@
+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
+
+class NodeTest < Test::Unit::TestCase
+
+  class Node < ActiveRecord::Base
+    set_table_name "nodes"
+    make_like_a_tree :scope => :project
+    def _lr
+      [lft, rgt]
+    end
+  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
+  
+  def setup
+    Node.delete_all
+    super
+  end
+  
+  # Silence!
+  def default_test; end
+end
+
+context "A Node with attributes that change in flight should", NodeTest do
+  specify "return same siblings no matter what parent_id the record has assigned" do
+    node1, node2, node3 = emit_many(3)
+    reload(node1, node2, node3)
+    
+    node1.parent_id = 100
+    node2.parent_id = 300
+    node3.parent_id = 600
+    
+    node1.siblings.should.equal [node2, node3]
+  end
+  
+  specify "should be promoted to root no matter what changes to the attributes are made" do
+    node1, node2, node3 = emit_many(3)
+    node4 = emit :name => "A child", :parent_id => node2.id
+    
+    reload(node4)
+    
+    node4.lft, node4.rgt, node4.depth = 300, 500, 164
+    lambda { node4.promote_to_root}.should.not.raise
+    
+    reload(node4)
+    
+    node4.depth.should.equal 0
+    node4.parent_id.should.equal 0
+    node4._lr.should.equal [9,10]
+  end
+  
+  specify "return same all_children no matter what left and right the record has assigned" do
+    node1, node2, node3 = emit_many(3)
+    children = emit_many(10, :parent_id => node1.id)
+    
+    reload(node1)
+    node1.all_children.should.equal children
+    
+    node1.lft, node1.rgt, node1.depth, node1.root_id = 300, 400, 23, 67
+    
+    node1.all_children.should.equal children
+  end
+end
+
+context "A new Node should", NodeTest do
+  specify "not allow promote_to_root" do
+    Node.new.promote_to_root.should.equal false
+  end
+  
+  specify "not allow move_to" do
+    Node.new.move_to(10).should.equal false
+  end
+  
+  specify "not allow add_child" do
+    Node.new.add_child(Node.new).should.equal false
+  end
+
+  specify "not be accepted for add_child" do
+    emit(:name => "Foo").add_child(Node.new).should.equal false
+    Node.new.add_child(Node.new).should.equal false
+  end
+  
+  specify "identify itself as root if parent is zero or nil" do
+    Node.new.should.be.root
+    Node.new.should.not.be.child
+  end
+  
+  specify "identify itself as a child if parent is not zero" do
+    Node.new(:parent_id => 100).should.be.child
+    Node.new(:parent_id => 100).should.not.be.root
+  end
+end
+
+context "A Node used with OrderedTree should", NodeTest do
+  Node = NodeTest::Node
+  
+  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.child_can_be_added?(child_node).should.blaming("possible move").equal true
+    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 "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 "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 "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)
+    reload(root_node_1, root_node_2)
+    
+    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 "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 "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 "should not allow reparenting an item into its child" do
+    root = emit :name => "foo"
+    child = emit :name => "bar", :parent_id => root.id
+    reload(root, child)
+    
+    child.child_can_be_added?(root).should.blaming("Impossible move").equal false
+    lambda { child.add_child!(root)}.should.raise(Julik::MakeLikeTree::ImpossibleReparent)
+    child.add_child(root).should.equal false
+  end
+  
+  specify "support additional find options via scoped finds on all_children" do
+    root = emit :name => "foo"
+    child = emit :name => "bar", :parent_id => root.id
+    another_child = emit :name => "another", :parent_id => root.id
+    
+    reload(root)
+
+    root.all_children.should.equal [child, another_child]
+    root.all_children(:conditions => {:name => "another"}).should.equal [another_child]
+  end
+  
+  specify "support additional find options via scoped finds on direct_children" do
+    root = emit :name => "foo"
+    anoter_root = emit :name => "another"
+    
+    child = emit :name => "bar", :parent_id => root.id
+    another_child = emit :name => "another", :parent_id => root.id
+    
+    reload(root)
+
+    root.direct_children.should.equal [child, another_child]
+    root.direct_children(:conditions => {:name => "another"}).should.equal [another_child]
+  end
+  
+  specify "support additional find options via scoped finds on full_set" do
+    root = emit :name => "foo"
+    anoter_root = emit :name => "another"
+    child_1 = emit :name => "another",  :parent_id => root.id
+    child_2 = emit :name => "outsider", :parent_id => root.id
+    
+    reload(root)
+    
+    root.full_set(:conditions => {:name => "another"}).should.equal [root, child_1]
+  end
+  
+  specify "support promote_to_root" do
+    a, b = emit_many(2)
+    c = emit(:name => "Subtree", :parent_id => a.id)
+    
+    reload(a, b, c)
+    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
+  
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: make_like_a_tree
+version: !ruby/object:Gem::Version 
+  hash: 17
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 3
+  version: 1.0.3
+platform: ruby
+authors: 
+- Julik Tarkhanov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-22 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 2
+        - 9
+        - 4
+        version: 2.9.4
+  type: :development
+  version_requirements: *id001
+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
+- .gemtest
+has_rdoc: true
+homepage: http://github.com/julik/make_like_a_tree
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: make_like_a_tree
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+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