awesome_nested_set 1.4.4 → 2.0.0

data/lib/awesome_nested_set/helper.rb

@@ -32,9 +32,9 @@ module CollectiveIdea #:nodoc:
             end.compact
           end
           result
-        end  
-        
+        end
+
       end
-    end  
+    end
   end
 end

data/lib/awesome_nested_set/version.rb

@@ -0,0 +1,3 @@
+module AwesomeNestedSet
+  VERSION = '2.0.0' unless defined?(::AwesomeNestedSet::VERSION)
+end

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: awesome_nested_set
 version: !ruby/object:Gem::Version 
-  hash: 15
   prerelease: 
-  segments: 
-  - 1
-  - 4
-  - 4
-  version: 1.4.4
+  version: 2.0.0
 platform: ruby
 authors: 
 - Brandon Keepers
@@ -27,11 +22,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 1
-        - 1
-        version: "1.1"
+        version: 3.0.0
   type: :runtime
   version_requirements: *id001
 description: An awesome nested set implementation for Active Record
@@ -43,26 +34,13 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
-- .autotest
+- lib/awesome_nested_set/awesome_nested_set.rb
+- lib/awesome_nested_set/helper.rb
+- lib/awesome_nested_set/version.rb
+- lib/awesome_nested_set.rb
 - MIT-LICENSE
 - README.rdoc
-- Rakefile
-- VERSION
-- awesome_nested_set.gemspec
-- init.rb
-- lib/awesome_nested_set.rb
-- lib/awesome_nested_set/helper.rb
-- rails/init.rb
-- test/application.rb
-- test/awesome_nested_set/helper_test.rb
-- test/awesome_nested_set_test.rb
-- test/db/database.yml
-- test/db/schema.rb
-- test/fixtures/categories.yml
-- test/fixtures/category.rb
-- test/fixtures/departments.yml
-- test/fixtures/notes.yml
-- test/test_helper.rb
+- CHANGELOG
 has_rdoc: true
 homepage: http://github.com/collectiveidea/awesome_nested_set
 licenses: []
@@ -80,18 +58,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   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: []
 
@@ -100,14 +72,5 @@ rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: An awesome nested set implementation for Active Record
-test_files: 
-- test/db/database.yml
-- test/fixtures/categories.yml
-- test/fixtures/departments.yml
-- test/fixtures/notes.yml
-- test/application.rb
-- test/awesome_nested_set/helper_test.rb
-- test/awesome_nested_set_test.rb
-- test/db/schema.rb
-- test/fixtures/category.rb
-- test/test_helper.rb
+test_files: []
+

data/.autotest

@@ -1,13 +0,0 @@
-Autotest.add_hook :initialize do |at|
-  at.clear_mappings
-
-  at.add_mapping %r%^lib/(.*)\.rb$% do |_, m|
-    at.files_matching %r%^test/#{m[1]}_test.rb$%
-  end
-
-  at.add_mapping(%r%^test/.*\.rb$%) {|filename, _| filename }
-
-  at.add_mapping %r%^test/fixtures/(.*)s.yml% do |_, _|
-    at.files_matching %r%^test/.*\.rb$%
-  end
-end

data/Rakefile

@@ -1,56 +0,0 @@
-require 'rubygems'
-begin
-  require 'jeweler'
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install jeweler"
-  exit 1
-end
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rcov/rcovtask'
-require "load_multi_rails_rake_tasks" 
-
-Jeweler::Tasks.new do |s|
-  s.name = "awesome_nested_set"
-  s.summary = "An awesome nested set implementation for Active Record"
-  s.description = s.summary
-  s.email = "info@collectiveidea.com"
-  s.homepage = "http://github.com/collectiveidea/awesome_nested_set"
-  s.authors = ["Brandon Keepers", "Daniel Morrison"]
-  s.add_dependency "activerecord", ['>= 1.1']
-  s.has_rdoc = true
-  s.extra_rdoc_files = [ "README.rdoc"]
-  s.rdoc_options = ["--main", "README.rdoc", "--inline-source", "--line-numbers"]
-  s.test_files = Dir['test/**/*.{yml,rb}']
-end
- Jeweler::GemcutterTasks.new
- 
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Test the awesome_nested_set plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs += ['lib', 'test']
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Generate documentation for the awesome_nested_set plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'AwesomeNestedSet'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-namespace :test do
-  desc "just rcov minus html output"
-  Rcov::RcovTask.new(:coverage) do |t|
-    t.libs << 'test'
-    t.test_files = FileList['test/**/*_test.rb']
-    t.output_dir = 'coverage'
-    t.verbose = true
-    t.rcov_opts = %w(--exclude test,/usr/lib/ruby,/Library/Ruby,lib/awesome_nested_set/named_scope.rb --sort coverage)
-  end
-end

data/VERSION

@@ -1 +0,0 @@
-1.4.4

data/awesome_nested_set.gemspec

@@ -1,59 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{awesome_nested_set}
-  s.version = "1.4.4"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Brandon Keepers", "Daniel Morrison"]
-  s.date = %q{2011-05-10}
-  s.description = %q{An awesome nested set implementation for Active Record}
-  s.email = %q{info@collectiveidea.com}
-  s.extra_rdoc_files = [
-    "README.rdoc"
-  ]
-  s.files = [
-    ".autotest",
-    "MIT-LICENSE",
-    "README.rdoc",
-    "Rakefile",
-    "VERSION",
-    "awesome_nested_set.gemspec",
-    "init.rb",
-    "lib/awesome_nested_set.rb",
-    "lib/awesome_nested_set/helper.rb",
-    "rails/init.rb",
-    "test/application.rb",
-    "test/awesome_nested_set/helper_test.rb",
-    "test/awesome_nested_set_test.rb",
-    "test/db/database.yml",
-    "test/db/schema.rb",
-    "test/fixtures/categories.yml",
-    "test/fixtures/category.rb",
-    "test/fixtures/departments.yml",
-    "test/fixtures/notes.yml",
-    "test/test_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/collectiveidea/awesome_nested_set}
-  s.rdoc_options = ["--main", "README.rdoc", "--inline-source", "--line-numbers"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.2}
-  s.summary = %q{An awesome nested set implementation for Active Record}
-  s.test_files = ["test/db/database.yml", "test/fixtures/categories.yml", "test/fixtures/departments.yml", "test/fixtures/notes.yml", "test/application.rb", "test/awesome_nested_set/helper_test.rb", "test/awesome_nested_set_test.rb", "test/db/schema.rb", "test/fixtures/category.rb", "test/test_helper.rb"]
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, [">= 1.1"])
-    else
-      s.add_dependency(%q<activerecord>, [">= 1.1"])
-    end
-  else
-    s.add_dependency(%q<activerecord>, [">= 1.1"])
-  end
-end
-

data/init.rb

@@ -1 +0,0 @@
-require File.dirname(__FILE__) + "/rails/init"  

data/rails/init.rb

@@ -1,12 +0,0 @@
-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/application.rb

@@ -1 +0,0 @@
-# This file is here to satisfy test_help from Rails < 2.3

data/test/awesome_nested_set/helper_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-module CollectiveIdea
-  module Acts #:nodoc:
-    module NestedSet #:nodoc:
-      class AwesomeNestedSetTest < TestCaseClass
-        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

@@ -1,801 +0,0 @@
-require 'test_helper'
-
-class Note < ActiveRecord::Base
-  acts_as_nested_set :scope => [:notable_id, :notable_type]
-end
-class Default < ActiveRecord::Base
-  acts_as_nested_set
-  set_table_name 'categories'
-end
-class ScopedCategory < ActiveRecord::Base
-  acts_as_nested_set :scope => :organization
-  set_table_name 'categories'
-end
-class RenamedColumns < ActiveRecord::Base
-  acts_as_nested_set :parent_column => 'mother_id', :left_column => 'red', :right_column => 'black'
-end
-
-class AwesomeNestedSetTest < TestCaseClass
-
-  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
-    assert_equal 'red', RenamedColumns.left_column_name
-    assert_equal 'red', RenamedColumns.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
-    assert_equal 'black', RenamedColumns.right_column_name
-    assert_equal 'black', RenamedColumns.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
-    assert_equal 'mother_id', RenamedColumns.parent_column_name
-    assert_equal 'mother_id', RenamedColumns.new.parent_column_name
-  end
-  
-  def test_creation_with_altered_column_names
-    assert_nothing_raised do 
-      RenamedColumns.create!()
-    end
-  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_colums_protected_on_initialize
-    c = Category.new(:lft => 1, :rgt => 2)
-    assert_nil c.lft
-    assert_nil c.rgt
-  end
-  
-  def test_scoped_appends_id
-    assert_equal :organization_id, ScopedCategory.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?
-    assert !Category.new.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_order_of_children
-    categories(:child_2).move_left
-    assert_equal categories(:child_2), categories(:top_level).children[0]
-    assert_equal categories(:child_1), categories(:top_level).children[1]
-    assert_equal categories(:child_3), categories(:top_level).children[2]
-  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 = ScopedCategory.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 = ScopedCategory.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 = ScopedCategory.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
-  
-  def test_equal_in_same_scope
-    assert_equal notes(:scope1), notes(:scope1)
-    assert_not_equal notes(:scope1), notes(:child_1)
-  end
-  
-  def test_equal_in_different_scopes
-    assert_not_equal notes(:scope1), notes(:scope2)
-  end
-  
-  def test_delete_does_not_invalidate
-    Category.acts_as_nested_set_options[:dependent] = :delete
-    categories(:child_2).destroy
-    assert Category.valid?
-  end
-
-  def test_destroy_does_not_invalidate
-    Category.acts_as_nested_set_options[:dependent] = :destroy
-    categories(:child_2).destroy
-    assert Category.valid?
-  end
-
-  def test_destroy_multiple_times_does_not_invalidate
-    Category.acts_as_nested_set_options[:dependent] = :destroy
-    categories(:child_2).destroy
-    categories(:child_2).destroy
-    assert Category.valid?
-  end
-  
-  def test_assigning_parent_id_on_create
-    category = Category.create!(:name => "Child", :parent_id => categories(:child_2).id)
-    assert_equal categories(:child_2), category.parent
-    assert_equal categories(:child_2).id, category.parent_id
-    assert_not_nil category.left
-    assert_not_nil category.right
-    assert Category.valid?
-  end
-
-  def test_assigning_parent_on_create
-    category = Category.create!(:name => "Child", :parent => categories(:child_2))
-    assert_equal categories(:child_2), category.parent
-    assert_equal categories(:child_2).id, category.parent_id
-    assert_not_nil category.left
-    assert_not_nil category.right
-    assert Category.valid?
-  end
-
-  def test_assigning_parent_id_to_nil_on_create
-    category = Category.create!(:name => "New Root", :parent_id => nil)
-    assert_nil category.parent
-    assert_nil category.parent_id
-    assert_not_nil category.left
-    assert_not_nil category.right
-    assert Category.valid?
-  end
-
-  def test_assigning_parent_id_on_update
-    category = categories(:child_2_1)
-    category.parent_id = categories(:child_3).id
-    category.save
-    assert_equal categories(:child_3), category.parent
-    assert_equal categories(:child_3).id, category.parent_id
-    assert Category.valid?
-  end
-
-  def test_assigning_parent_on_update
-    category = categories(:child_2_1)
-    category.parent = categories(:child_3)
-    category.save
-    assert_equal categories(:child_3), category.parent
-    assert_equal categories(:child_3).id, category.parent_id
-    assert Category.valid?
-  end
-
-  def test_assigning_parent_id_to_nil_on_update
-    category = categories(:child_2_1)
-    category.parent_id = nil
-    category.save
-    assert_nil category.parent
-    assert_nil category.parent_id
-    assert Category.valid?
-  end
-
-  def test_creating_child_from_parent
-    category = categories(:child_2).children.create!(:name => "Child")
-    assert_equal categories(:child_2), category.parent
-    assert_equal categories(:child_2).id, category.parent_id
-    assert_not_nil category.left
-    assert_not_nil category.right
-    assert Category.valid?
-  end
-
-  def check_structure(entries, structure)
-    structure = structure.dup
-    Category.each_with_level(entries) do |category, level|
-      expected_level, expected_name = structure.shift
-      assert_equal expected_name, category.name, "wrong category"
-      assert_equal expected_level, level, "wrong level for #{category.name}"
-    end
-  end
-
-  def test_each_with_level
-    levels = [
-      [0, "Top Level"],
-      [1, "Child 1"],
-      [1, "Child 2"],
-      [2, "Child 2.1"],
-      [1, "Child 3" ]]
-
-    check_structure(Category.root.self_and_descendants, levels)
-
-    # test some deeper structures
-    category = Category.find_by_name("Child 1")
-    c1 = Category.new(:name => "Child 1.1")
-    c2 = Category.new(:name => "Child 1.1.1")
-    c3 = Category.new(:name => "Child 1.1.1.1")
-    c4 = Category.new(:name => "Child 1.2")
-    [c1, c2, c3, c4].each(&:save!)
-
-    c1.move_to_child_of(category)
-    c2.move_to_child_of(c1)
-    c3.move_to_child_of(c2)
-    c4.move_to_child_of(category)
-
-    levels = [
-      [0, "Top Level"],
-      [1, "Child 1"],
-      [2, "Child 1.1"],
-      [3, "Child 1.1.1"],
-      [4, "Child 1.1.1.1"],
-      [2, "Child 1.2"],
-      [1, "Child 2"],
-      [2, "Child 2.1"],
-      [1, "Child 3" ]]
-
-      check_structure(Category.root.self_and_descendants, levels)
-  end
-  
-  def test_model_with_attr_accessible
-    model = Class.new(ActiveRecord::Base)
-    model.set_table_name 'categories'
-    model.attr_accessible :name
-    assert_nothing_raised do
-      model.acts_as_nested_set
-      model.new(:name => 'foo')
-    end
-  end
-  
-  def test_before_move_callback
-    @called = false
-    Category.before_move do |record|
-      @called = true
-    end
-    categories(:child_2).move_to_root
-    assert @called
-  ensure
-    Category.before_move_callback_chain.pop
-  end
-  
-  def test_before_move_callback_returning_false_stops_move
-    Category.before_move do
-      return false
-    end
-    assert !categories(:child_3).move_to_root
-    assert !categories(:child_3).root?
-  ensure
-    Category.before_move_callback_chain.pop
-  end
-  
-  def test_before_move_callback_returning_false_halts_save
-    Category.before_move do
-      return false
-    end
-    categories(:child_3).parent_id = nil
-    assert !categories(:child_3).save
-  ensure
-    Category.before_move_callback_chain.pop
-  end
-  
-  def test_calls_after_save_when_moving
-    @called = false
-    Category.after_save do
-      @called = true
-    end
-    categories(:child_3).parent = categories(:child_2)
-    assert categories(:child_3).save
-    assert @called
-  ensure
-    Category.after_save_callback_chain.pop
-  end
-end