ggoodale-awesome_nested_set 1.1

data/lib/awesome_nested_set/compatability.rb

@@ -0,0 +1,29 @@
+# Rails <2.x doesn't define #except
+class Hash
+  # Returns a new hash without the given keys.
+  def except(*keys)
+    clone.except!(*keys)
+  end unless method_defined?(:except)
+
+  # Replaces the hash without the given keys.
+  def except!(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+    keys.each { |key| delete(key) }
+    self
+  end unless method_defined?(:except!)
+end
+
+# NamedScope is new to Rails 2.1
+unless defined? ActiveRecord::NamedScope
+  require 'awesome_nested_set/named_scope'
+  ActiveRecord::Base.class_eval do
+    include CollectiveIdea::NamedScope
+  end
+end
+
+# Rails 1.2.x doesn't define #quoted_table_name
+class ActiveRecord::Base
+  def self.quoted_table_name
+    self.connection.quote_column_name(self.table_name)
+  end unless methods.include?('quoted_table_name')
+end

data/lib/awesome_nested_set/helper.rb

@@ -0,0 +1,41 @@
+module CollectiveIdea
+  module Acts #:nodoc:
+    module NestedSet #:nodoc:
+      # This module provides some helpers for the model classes using acts_as_nested_set.
+      # It is included by default in all views. If you need to remove it, edit the last line
+      # of init.rb.
+      #
+      module Helper
+        # Returns options for select.
+        # You can exclude some items from the tree.
+        # You can pass a block receiving an item and returning the string displayed in the select.
+        #
+        # == Params
+        #  * +class_or_item+ - Class name or top level times
+        #  * +mover+ - The item that is being move, used to exlude impossible moves
+        #  * +&block+ - a block that will be used to display: { |item| ... item.name }
+        #
+        # == Usage
+        #
+        #   <%= f.select :parent_id, nested_set_options(Category, @category) {|i|
+        #       "#{'–' * i.level} #{i.name}"
+        #     }) %>
+        #
+        def nested_set_options(class_or_item, mover = nil)
+          class_or_item = class_or_item.roots if class_or_item.is_a?(Class)
+          items = Array(class_or_item)
+          result = []
+          items.each do |root|
+            result += root.self_and_descendants.map do |i|
+              if mover.nil? || mover.new_record? || mover.move_possible?(i)
+                [yield(i), i.id]
+              end
+            end.compact
+          end
+          result
+        end  
+        
+      end
+    end  
+  end
+end

data/lib/awesome_nested_set/named_scope.rb

@@ -0,0 +1,140 @@
+# Taken from Rails 2.1
+module CollectiveIdea
+  module NamedScope
+    # All subclasses of ActiveRecord::Base have two named_scopes:
+    # * <tt>all</tt>, which is similar to a <tt>find(:all)</tt> query, and
+    # * <tt>scoped</tt>, which allows for the creation of anonymous scopes, on the fly:
+    #
+    #   Shirt.scoped(:conditions => {:color => 'red'}).scoped(:include => :washing_instructions)
+    #
+    # These anonymous scopes tend to be useful when procedurally generating complex queries, where passing
+    # intermediate values (scopes) around as first-class objects is convenient.
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        named_scope :scoped, lambda { |scope| scope }
+      end
+    end
+
+    module ClassMethods
+      def scopes
+        read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+      end
+
+      # Adds a class method for retrieving and querying objects. A scope represents a narrowing of a database query,
+      # such as <tt>:conditions => {:color => :red}, :select => 'shirts.*', :include => :washing_instructions</tt>.
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     named_scope :red, :conditions => {:color => 'red'}
+      #     named_scope :dry_clean_only, :joins => :washing_instructions, :conditions => ['washing_instructions.dry_clean_only = ?', true]
+      #   end
+      # 
+      # The above calls to <tt>named_scope</tt> define class methods <tt>Shirt.red</tt> and <tt>Shirt.dry_clean_only</tt>. <tt>Shirt.red</tt>, 
+      # in effect, represents the query <tt>Shirt.find(:all, :conditions => {:color => 'red'})</tt>.
+      #
+      # Unlike Shirt.find(...), however, the object returned by <tt>Shirt.red</tt> is not an Array; it resembles the association object
+      # constructed by a <tt>has_many</tt> declaration. For instance, you can invoke <tt>Shirt.red.find(:first)</tt>, <tt>Shirt.red.count</tt>,
+      # <tt>Shirt.red.find(:all, :conditions => {:size => 'small'})</tt>. Also, just
+      # as with the association objects, name scopes acts like an Array, implementing Enumerable; <tt>Shirt.red.each(&block)</tt>,
+      # <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if Shirt.red really were an Array.
+      #
+      # These named scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are both red and dry clean only.
+      # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt> returns the number of garments
+      # for which these criteria obtain. Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
+      #
+      # All scopes are available as class methods on the ActiveRecord descendent upon which the scopes were defined. But they are also available to
+      # <tt>has_many</tt> associations. If,
+      #
+      #   class Person < ActiveRecord::Base
+      #     has_many :shirts
+      #   end
+      #
+      # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean
+      # only shirts.
+      #
+      # Named scopes can also be procedural.
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     named_scope :colored, lambda { |color|
+      #       { :conditions => { :color => color } }
+      #     }
+      #   end
+      #
+      # In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.
+      #
+      # Named scopes can also have extensions, just as with <tt>has_many</tt> declarations:
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     named_scope :red, :conditions => {:color => 'red'} do
+      #       def dom_id
+      #         'red_shirts'
+      #       end
+      #     end
+      #   end
+      #
+      #
+      # For testing complex named scopes, you can examine the scoping options using the
+      # <tt>proxy_options</tt> method on the proxy itself.
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     named_scope :colored, lambda { |color|
+      #       { :conditions => { :color => color } }
+      #     }
+      #   end
+      #
+      #   expected_options = { :conditions => { :colored => 'red' } }
+      #   assert_equal expected_options, Shirt.colored('red').proxy_options
+      def named_scope(name, options = {}, &block)
+        scopes[name] = lambda do |parent_scope, *args|
+          Scope.new(parent_scope, case options
+            when Hash
+              options
+            when Proc
+              options.call(*args)
+          end, &block)
+        end
+        (class << self; self end).instance_eval do
+          define_method name do |*args|
+            scopes[name].call(self, *args)
+          end
+        end
+      end
+    end
+
+    class Scope
+      attr_reader :proxy_scope, :proxy_options
+      [].methods.each { |m| delegate m, :to => :proxy_found unless m =~ /(^__|^nil\?|^send|class|extend|find|count|sum|average|maximum|minimum|paginate)/ }
+      delegate :scopes, :with_scope, :to => :proxy_scope
+
+      def initialize(proxy_scope, options, &block)
+        [options[:extend]].flatten.each { |extension| extend extension } if options[:extend]
+        extend Module.new(&block) if block_given?
+        @proxy_scope, @proxy_options = proxy_scope, options.except(:extend)
+      end
+
+      def reload
+        load_found; self
+      end
+
+      protected
+      def proxy_found
+        @found || load_found
+      end
+
+      private
+      def method_missing(method, *args, &block)
+        if scopes.include?(method)
+          scopes[method].call(self, *args)
+        else
+          with_scope :find => proxy_options do
+            proxy_scope.send(method, *args, &block)
+          end
+        end
+      end
+
+      def load_found
+        @found = find(:all)
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,13 @@
+require 'awesome_nested_set/compatability'
+require 'awesome_nested_set'
+
+ActiveRecord::Base.class_eval do
+  include CollectiveIdea::Acts::NestedSet
+end
+
+if defined?(ActionView)
+  require 'awesome_nested_set/helper'
+  ActionView::Base.class_eval do
+    include CollectiveIdea::Acts::NestedSet::Helper
+  end
+end

data/test/awesome_nested_set/helper_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+module CollectiveIdea
+  module Acts #:nodoc:
+    module NestedSet #:nodoc:
+      class AwesomeNestedSetTest < Test::Unit::TestCase
+        include Helper
+        fixtures :categories
+        
+        def test_nested_set_options
+          expected = [
+            [" Top Level", 1],
+            ["- Child 1", 2],
+            ['- Child 2', 3],
+            ['-- Child 2.1', 4],
+            ['- Child 3', 5],
+            [" Top Level 2", 6]
+          ]
+          actual = nested_set_options(Category) do |c|
+            "#{'-' * c.level} #{c.name}"
+          end
+          assert_equal expected, actual
+        end
+        
+        def test_nested_set_options_with_mover
+          expected = [
+            [" Top Level", 1],
+            ["- Child 1", 2],
+            ['- Child 3', 5],
+            [" Top Level 2", 6]
+          ]
+          actual = nested_set_options(Category, categories(:child_2)) do |c|
+            "#{'-' * c.level} #{c.name}"
+          end
+          assert_equal expected, actual
+        end
+        
+      end
+    end
+  end
+end

data/test/awesome_nested_set_test.rb

@@ -0,0 +1,594 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Note < ActiveRecord::Base
+  acts_as_nested_set :scope => [:notable_id, :notable_type]
+end
+
+class AwesomeNestedSetTest < Test::Unit::TestCase
+
+  class Default < ActiveRecord::Base
+    acts_as_nested_set
+    set_table_name 'categories'
+  end
+  class Scoped < ActiveRecord::Base
+    acts_as_nested_set :scope => :organization
+    set_table_name 'categories'
+  end
+
+  def test_left_column_default
+    assert_equal 'lft', Default.acts_as_nested_set_options[:left_column]
+  end
+
+  def test_right_column_default
+    assert_equal 'rgt', Default.acts_as_nested_set_options[:right_column]
+  end
+
+  def test_parent_column_default
+    assert_equal 'parent_id', Default.acts_as_nested_set_options[:parent_column]
+  end
+
+  def test_scope_default
+    assert_nil Default.acts_as_nested_set_options[:scope]
+  end
+  
+  def test_left_column_name
+    assert_equal 'lft', Default.left_column_name
+    assert_equal 'lft', Default.new.left_column_name
+  end
+
+  def test_right_column_name
+    assert_equal 'rgt', Default.right_column_name
+    assert_equal 'rgt', Default.new.right_column_name
+  end
+
+  def test_parent_column_name
+    assert_equal 'parent_id', Default.parent_column_name
+    assert_equal 'parent_id', Default.new.parent_column_name
+  end
+  
+  def test_quoted_left_column_name
+    quoted = Default.connection.quote_column_name('lft')
+    assert_equal quoted, Default.quoted_left_column_name
+    assert_equal quoted, Default.new.quoted_left_column_name
+  end
+
+  def test_quoted_right_column_name
+    quoted = Default.connection.quote_column_name('rgt')
+    assert_equal quoted, Default.quoted_right_column_name
+    assert_equal quoted, Default.new.quoted_right_column_name
+  end
+
+  def test_left_column_protected_from_assignment
+    assert_raises(ActiveRecord::ActiveRecordError) { Category.new.lft = 1 }
+  end
+  
+  def test_right_column_protected_from_assignment
+    assert_raises(ActiveRecord::ActiveRecordError) { Category.new.rgt = 1 }
+  end
+  
+  def test_parent_column_protected_from_assignment
+    assert_raises(ActiveRecord::ActiveRecordError) { Category.new.parent_id = 1 }
+  end
+  
+  def test_colums_protected_on_initialize
+    c = Category.new(:lft => 1, :rgt => 2, :parent_id => 3)
+    assert_nil c.lft
+    assert_nil c.rgt
+    assert_nil c.parent_id
+  end
+  
+  def test_scoped_appends_id
+    assert_equal :organization_id, Scoped.acts_as_nested_set_options[:scope]
+  end
+  
+  def test_roots_class_method
+    assert_equal Category.find_all_by_parent_id(nil), Category.roots
+  end
+    
+  def test_root_class_method
+    assert_equal categories(:top_level), Category.root
+  end
+  
+  def test_root
+    assert_equal categories(:top_level), categories(:child_3).root
+  end
+  
+  def test_root?
+    assert categories(:top_level).root?
+    assert categories(:top_level_2).root?
+  end
+  
+  def test_leaves_class_method
+    assert_equal Category.find(:all, :conditions => "#{Category.right_column_name} - #{Category.left_column_name} = 1"), Category.leaves
+    assert_equal Category.leaves.count, 4
+    assert (Category.leaves.include? categories(:child_1))
+    assert (Category.leaves.include? categories(:child_2_1))
+    assert (Category.leaves.include? categories(:child_3))
+    assert (Category.leaves.include? categories(:top_level_2))
+  end
+  
+  def test_leaf
+    assert categories(:child_1).leaf?
+    assert categories(:child_2_1).leaf?
+    assert categories(:child_3).leaf?
+    assert categories(:top_level_2).leaf?
+    
+    assert !categories(:top_level).leaf?
+    assert !categories(:child_2).leaf?
+  end
+    
+  def test_parent
+    assert_equal categories(:child_2), categories(:child_2_1).parent
+  end
+  
+  def test_self_and_ancestors
+    child = categories(:child_2_1)
+    self_and_ancestors = [categories(:top_level), categories(:child_2), child]
+    assert_equal self_and_ancestors, child.self_and_ancestors
+  end
+
+  def test_ancestors
+    child = categories(:child_2_1)
+    ancestors = [categories(:top_level), categories(:child_2)]
+    assert_equal ancestors, child.ancestors
+  end
+  
+  def test_self_and_siblings
+    child = categories(:child_2)
+    self_and_siblings = [categories(:child_1), child, categories(:child_3)]
+    assert_equal self_and_siblings, child.self_and_siblings
+    assert_nothing_raised do
+      tops = [categories(:top_level), categories(:top_level_2)]
+      assert_equal tops, categories(:top_level).self_and_siblings
+    end
+  end
+
+  def test_siblings
+    child = categories(:child_2)
+    siblings = [categories(:child_1), categories(:child_3)]
+    assert_equal siblings, child.siblings
+  end
+  
+  def test_leaves
+    leaves = [categories(:child_1), categories(:child_2_1), categories(:child_3), categories(:top_level_2)]
+    assert categories(:top_level).leaves, leaves
+  end
+  
+  def test_level
+    assert_equal 0, categories(:top_level).level
+    assert_equal 1, categories(:child_1).level
+    assert_equal 2, categories(:child_2_1).level
+  end
+  
+  def test_has_children?
+    assert categories(:child_2_1).children.empty?
+    assert !categories(:child_2).children.empty?
+    assert !categories(:top_level).children.empty?
+  end
+  
+  def test_self_and_descendents
+    parent = categories(:top_level)
+    self_and_descendants = [parent, categories(:child_1), categories(:child_2),
+      categories(:child_2_1), categories(:child_3)]
+    assert_equal self_and_descendants, parent.self_and_descendants
+    assert_equal self_and_descendants, parent.self_and_descendants.count
+  end
+  
+  def test_descendents
+    lawyers = Category.create!(:name => "lawyers")
+    us = Category.create!(:name => "United States")
+    us.move_to_child_of(lawyers)
+    patent = Category.create!(:name => "Patent Law")
+    patent.move_to_child_of(us)
+    lawyers.reload
+
+    assert_equal 1, lawyers.children.size
+    assert_equal 1, us.children.size
+    assert_equal 2, lawyers.descendants.size
+  end
+  
+  def test_self_and_descendents
+    parent = categories(:top_level)
+    descendants = [categories(:child_1), categories(:child_2),
+      categories(:child_2_1), categories(:child_3)]
+    assert_equal descendants, parent.descendants
+  end
+  
+  def test_children
+    category = categories(:top_level)
+    category.children.each {|c| assert_equal category.id, c.parent_id }
+  end
+  
+  def test_is_or_is_ancestor_of?
+    assert categories(:top_level).is_or_is_ancestor_of?(categories(:child_1))
+    assert categories(:top_level).is_or_is_ancestor_of?(categories(:child_2_1))
+    assert categories(:child_2).is_or_is_ancestor_of?(categories(:child_2_1))
+    assert !categories(:child_2_1).is_or_is_ancestor_of?(categories(:child_2))
+    assert !categories(:child_1).is_or_is_ancestor_of?(categories(:child_2))
+    assert categories(:child_1).is_or_is_ancestor_of?(categories(:child_1))
+  end
+  
+  def test_is_ancestor_of?
+    assert categories(:top_level).is_ancestor_of?(categories(:child_1))
+    assert categories(:top_level).is_ancestor_of?(categories(:child_2_1))
+    assert categories(:child_2).is_ancestor_of?(categories(:child_2_1))
+    assert !categories(:child_2_1).is_ancestor_of?(categories(:child_2))
+    assert !categories(:child_1).is_ancestor_of?(categories(:child_2))
+    assert !categories(:child_1).is_ancestor_of?(categories(:child_1))
+  end
+
+  def test_is_or_is_ancestor_of_with_scope
+    root = Scoped.root
+    child = root.children.first
+    assert root.is_or_is_ancestor_of?(child)
+    child.update_attribute :organization_id, 'different'
+    assert !root.is_or_is_ancestor_of?(child)
+  end
+
+  def test_is_or_is_descendant_of?
+    assert categories(:child_1).is_or_is_descendant_of?(categories(:top_level))
+    assert categories(:child_2_1).is_or_is_descendant_of?(categories(:top_level))
+    assert categories(:child_2_1).is_or_is_descendant_of?(categories(:child_2))
+    assert !categories(:child_2).is_or_is_descendant_of?(categories(:child_2_1))
+    assert !categories(:child_2).is_or_is_descendant_of?(categories(:child_1))
+    assert categories(:child_1).is_or_is_descendant_of?(categories(:child_1))
+  end
+  
+  def test_is_descendant_of?
+    assert categories(:child_1).is_descendant_of?(categories(:top_level))
+    assert categories(:child_2_1).is_descendant_of?(categories(:top_level))
+    assert categories(:child_2_1).is_descendant_of?(categories(:child_2))
+    assert !categories(:child_2).is_descendant_of?(categories(:child_2_1))
+    assert !categories(:child_2).is_descendant_of?(categories(:child_1))
+    assert !categories(:child_1).is_descendant_of?(categories(:child_1))
+  end
+  
+  def test_is_or_is_descendant_of_with_scope
+    root = Scoped.root
+    child = root.children.first
+    assert child.is_or_is_descendant_of?(root)
+    child.update_attribute :organization_id, 'different'
+    assert !child.is_or_is_descendant_of?(root)
+  end
+  
+  def test_same_scope?
+    root = Scoped.root
+    child = root.children.first
+    assert child.same_scope?(root)
+    child.update_attribute :organization_id, 'different'
+    assert !child.same_scope?(root)
+  end
+  
+  def test_left_sibling
+    assert_equal categories(:child_1), categories(:child_2).left_sibling
+    assert_equal categories(:child_2), categories(:child_3).left_sibling
+  end
+
+  def test_left_sibling_of_root
+    assert_nil categories(:top_level).left_sibling
+  end
+
+  def test_left_sibling_without_siblings
+    assert_nil categories(:child_2_1).left_sibling
+  end
+
+  def test_left_sibling_of_leftmost_node
+    assert_nil categories(:child_1).left_sibling
+  end
+
+  def test_right_sibling
+    assert_equal categories(:child_3), categories(:child_2).right_sibling
+    assert_equal categories(:child_2), categories(:child_1).right_sibling
+  end
+
+  def test_right_sibling_of_root
+    assert_equal categories(:top_level_2), categories(:top_level).right_sibling
+    assert_nil categories(:top_level_2).right_sibling
+  end
+
+  def test_right_sibling_without_siblings
+    assert_nil categories(:child_2_1).right_sibling
+  end
+
+  def test_right_sibling_of_rightmost_node
+    assert_nil categories(:child_3).right_sibling
+  end
+  
+  def test_move_left
+    categories(:child_2).move_left
+    assert_nil categories(:child_2).left_sibling
+    assert_equal categories(:child_1), categories(:child_2).right_sibling
+    assert Category.valid?
+  end
+
+  def test_move_right
+    categories(:child_2).move_right
+    assert_nil categories(:child_2).right_sibling
+    assert_equal categories(:child_3), categories(:child_2).left_sibling
+    assert Category.valid?
+  end
+
+  def test_move_to_left_of
+    categories(:child_3).move_to_left_of(categories(:child_1))
+    assert_nil categories(:child_3).left_sibling
+    assert_equal categories(:child_1), categories(:child_3).right_sibling
+    assert Category.valid?
+  end
+
+  def test_move_to_right_of
+    categories(:child_1).move_to_right_of(categories(:child_3))
+    assert_nil categories(:child_1).right_sibling
+    assert_equal categories(:child_3), categories(:child_1).left_sibling
+    assert Category.valid?
+  end
+  
+  def test_move_to_root
+    categories(:child_2).move_to_root
+    assert_nil categories(:child_2).parent
+    assert_equal 0, categories(:child_2).level
+    assert_equal 1, categories(:child_2_1).level
+    assert_equal 1, categories(:child_2).left
+    assert_equal 4, categories(:child_2).right
+    assert Category.valid?
+  end
+
+  def test_move_to_child_of
+    categories(:child_1).move_to_child_of(categories(:child_3))
+    assert_equal categories(:child_3).id, categories(:child_1).parent_id
+    assert Category.valid?
+  end
+  
+  def test_move_to_child_of_appends_to_end
+    child = Category.create! :name => 'New Child'
+    child.move_to_child_of categories(:top_level)
+    assert_equal child, categories(:top_level).children.last
+  end
+  
+  def test_subtree_move_to_child_of
+    assert_equal 4, categories(:child_2).left
+    assert_equal 7, categories(:child_2).right
+    
+    assert_equal 2, categories(:child_1).left
+    assert_equal 3, categories(:child_1).right
+    
+    categories(:child_2).move_to_child_of(categories(:child_1))
+    assert Category.valid?
+    assert_equal categories(:child_1).id, categories(:child_2).parent_id
+    
+    assert_equal 3, categories(:child_2).left
+    assert_equal 6, categories(:child_2).right
+    assert_equal 2, categories(:child_1).left
+    assert_equal 7, categories(:child_1).right    
+  end
+  
+  def test_slightly_difficult_move_to_child_of
+    assert_equal 11, categories(:top_level_2).left
+    assert_equal 12, categories(:top_level_2).right
+    
+    # create a new top-level node and move single-node top-level tree inside it.
+    new_top = Category.create(:name => 'New Top')
+    assert_equal 13, new_top.left
+    assert_equal 14, new_top.right
+    
+    categories(:top_level_2).move_to_child_of(new_top)
+    
+    assert Category.valid?
+    assert_equal new_top.id, categories(:top_level_2).parent_id
+    
+    assert_equal 12, categories(:top_level_2).left
+    assert_equal 13, categories(:top_level_2).right
+    assert_equal 11, new_top.left
+    assert_equal 14, new_top.right    
+  end
+  
+  def test_difficult_move_to_child_of
+    assert_equal 1, categories(:top_level).left
+    assert_equal 10, categories(:top_level).right
+    assert_equal 5, categories(:child_2_1).left
+    assert_equal 6, categories(:child_2_1).right
+    
+    # create a new top-level node and move an entire top-level tree inside it.
+    new_top = Category.create(:name => 'New Top')
+    categories(:top_level).move_to_child_of(new_top)
+    categories(:child_2_1).reload
+    assert Category.valid?  
+    assert_equal new_top.id, categories(:top_level).parent_id
+    
+    assert_equal 4, categories(:top_level).left
+    assert_equal 13, categories(:top_level).right
+    assert_equal 8, categories(:child_2_1).left
+    assert_equal 9, categories(:child_2_1).right    
+  end
+
+  #rebuild swaps the position of the 2 children when added using move_to_child twice onto same parent
+  def test_move_to_child_more_than_once_per_parent_rebuild
+    root1 = Category.create(:name => 'Root1')
+    root2 = Category.create(:name => 'Root2')
+    root3 = Category.create(:name => 'Root3')
+    
+    root2.move_to_child_of root1
+    root3.move_to_child_of root1
+      
+    output = Category.roots.last.to_text
+    Category.update_all('lft = null, rgt = null')
+    Category.rebuild!
+    
+    assert_equal Category.roots.last.to_text, output
+  end
+  
+  # doing move_to_child twice onto same parent from the furthest right first
+  def test_move_to_child_more_than_once_per_parent_outside_in
+    node1 = Category.create(:name => 'Node-1')
+    node2 = Category.create(:name => 'Node-2')
+    node3 = Category.create(:name => 'Node-3')
+    
+    node2.move_to_child_of node1
+    node3.move_to_child_of node1
+      
+    output = Category.roots.last.to_text
+    Category.update_all('lft = null, rgt = null')
+    Category.rebuild!
+    
+    assert_equal Category.roots.last.to_text, output
+  end
+
+
+  def test_valid_with_null_lefts
+    assert Category.valid?
+    Category.update_all('lft = null')
+    assert !Category.valid?
+  end
+
+  def test_valid_with_null_rights
+    assert Category.valid?
+    Category.update_all('rgt = null')
+    assert !Category.valid?
+  end
+  
+  def test_valid_with_missing_intermediate_node
+    # Even though child_2_1 will still exist, it is a sign of a sloppy delete, not an invalid tree.
+    assert Category.valid?
+    Category.delete(categories(:child_2).id)
+    assert Category.valid?
+  end
+  
+  def test_valid_with_overlapping_and_rights
+    assert Category.valid?
+    categories(:top_level_2)['lft'] = 0
+    categories(:top_level_2).save
+    assert !Category.valid?
+  end
+  
+  def test_rebuild
+    assert Category.valid?
+    before_text = Category.root.to_text
+    Category.update_all('lft = null, rgt = null')
+    Category.rebuild!
+    assert Category.valid?
+    assert_equal before_text, Category.root.to_text
+  end
+  
+  def test_move_possible_for_sibling
+    assert categories(:child_2).move_possible?(categories(:child_1))
+  end
+  
+  def test_move_not_possible_to_self
+    assert !categories(:top_level).move_possible?(categories(:top_level))
+  end
+  
+  def test_move_not_possible_to_parent
+    categories(:top_level).descendants.each do |descendant|
+      assert !categories(:top_level).move_possible?(descendant)
+      assert descendant.move_possible?(categories(:top_level))
+    end
+  end
+  
+  def test_is_or_is_ancestor_of?
+    [:child_1, :child_2, :child_2_1, :child_3].each do |c|
+      assert categories(:top_level).is_or_is_ancestor_of?(categories(c))
+    end
+    assert !categories(:top_level).is_or_is_ancestor_of?(categories(:top_level_2))
+  end
+  
+  def test_left_and_rights_valid_with_blank_left
+    assert Category.left_and_rights_valid?
+    categories(:child_2)[:lft] = nil
+    categories(:child_2).save(false)
+    assert !Category.left_and_rights_valid?
+  end
+
+  def test_left_and_rights_valid_with_blank_right
+    assert Category.left_and_rights_valid?
+    categories(:child_2)[:rgt] = nil
+    categories(:child_2).save(false)
+    assert !Category.left_and_rights_valid?
+  end
+
+  def test_left_and_rights_valid_with_equal
+    assert Category.left_and_rights_valid?
+    categories(:top_level_2)[:lft] = categories(:top_level_2)[:rgt]
+    categories(:top_level_2).save(false)
+    assert !Category.left_and_rights_valid?
+  end
+
+  def test_left_and_rights_valid_with_left_equal_to_parent
+    assert Category.left_and_rights_valid?
+    categories(:child_2)[:lft] = categories(:top_level)[:lft]
+    categories(:child_2).save(false)
+    assert !Category.left_and_rights_valid?
+  end
+
+  def test_left_and_rights_valid_with_right_equal_to_parent
+    assert Category.left_and_rights_valid?
+    categories(:child_2)[:rgt] = categories(:top_level)[:rgt]
+    categories(:child_2).save(false)
+    assert !Category.left_and_rights_valid?
+  end
+  
+  def test_moving_dirty_objects_doesnt_invalidate_tree
+    r1 = Category.create
+    r2 = Category.create
+    r3 = Category.create
+    r4 = Category.create
+    nodes = [r1, r2, r3, r4]
+    
+    r2.move_to_child_of(r1)
+    assert Category.valid?
+    
+    r3.move_to_child_of(r1)
+    assert Category.valid?
+    
+    r4.move_to_child_of(r2)
+    assert Category.valid?
+  end
+  
+  def test_multi_scoped_no_duplicates_for_columns?
+    assert_nothing_raised do
+      Note.no_duplicates_for_columns?
+    end
+  end
+
+  def test_multi_scoped_all_roots_valid?
+    assert_nothing_raised do
+      Note.all_roots_valid?
+    end
+  end
+
+  def test_multi_scoped
+    note1 = Note.create!(:body => "A", :notable_id => 2, :notable_type => 'Category')
+    note2 = Note.create!(:body => "B", :notable_id => 2, :notable_type => 'Category')
+    note3 = Note.create!(:body => "C", :notable_id => 2, :notable_type => 'Default')
+    
+    assert_equal [note1, note2], note1.self_and_siblings
+    assert_equal [note3], note3.self_and_siblings
+  end
+  
+  def test_multi_scoped_rebuild
+    root = Note.create!(:body => "A", :notable_id => 3, :notable_type => 'Category')
+    child1 = Note.create!(:body => "B", :notable_id => 3, :notable_type => 'Category')
+    child2 = Note.create!(:body => "C", :notable_id => 3, :notable_type => 'Category')
+    
+    child1.move_to_child_of root
+    child2.move_to_child_of root
+          
+    Note.update_all('lft = null, rgt = null')
+    Note.rebuild!
+    
+    assert_equal Note.roots.find_by_body('A'), root
+    assert_equal [child1, child2], Note.roots.find_by_body('A').children
+  end
+  
+  def test_same_scope_with_multi_scopes
+    assert_nothing_raised do
+      notes(:scope1).same_scope?(notes(:child_1))
+    end
+    assert notes(:scope1).same_scope?(notes(:child_1))
+    assert notes(:child_1).same_scope?(notes(:scope1))
+    assert !notes(:scope1).same_scope?(notes(:scope2))
+  end
+  
+  def test_quoting_of_multi_scope_column_names
+    assert_equal ["\"notable_id\"", "\"notable_type\""], Note.quoted_scope_column_names
+  end
+  
+end