jro_apps/redmine Commit - r9368:f2ec23d80cf4

set_table_name deprecated....

Jean-Philippe Lang -

r9368:f2ec23d80cf4

parent child

Context file:

r9368:f2ec23d80cf4

Collapse all files

lib/plugins/awesome_nested_set/spec/awesome_nested_set_spec.rb +1 -1

              require 'spec_helper'
              describe "AwesomeNestedSet" do
                before(:all) do
                  self.class.fixtures :categories, :departments, :notes, :things, :brokens
                end
                describe "defaults" do
                  it "should have left_column_default" do
                    Default.acts_as_nested_set_options[:left_column].should == 'lft'
                  end
                  it "should have right_column_default" do
                    Default.acts_as_nested_set_options[:right_column].should == 'rgt'
                  end
                  it "should have parent_column_default" do
                    Default.acts_as_nested_set_options[:parent_column].should == 'parent_id'
                  end
                  it "should have scope_default" do
                    Default.acts_as_nested_set_options[:scope].should be_nil
                  end
                  it "should have left_column_name" do
                    Default.left_column_name.should == 'lft'
                    Default.new.left_column_name.should == 'lft'
                    RenamedColumns.left_column_name.should == 'red'
                    RenamedColumns.new.left_column_name.should == 'red'
                  end
                  it "should have right_column_name" do
                    Default.right_column_name.should == 'rgt'
                    Default.new.right_column_name.should == 'rgt'
                    RenamedColumns.right_column_name.should == 'black'
                    RenamedColumns.new.right_column_name.should == 'black'
                  end
                  it "should have parent_column_name" do
                    Default.parent_column_name.should == 'parent_id'
                    Default.new.parent_column_name.should == 'parent_id'
                    RenamedColumns.parent_column_name.should == 'mother_id'
                    RenamedColumns.new.parent_column_name.should == 'mother_id'
                  end
                end
                it "creation_with_altered_column_names" do
                  lambda {
                    RenamedColumns.create!()
                  }.should_not raise_exception
                end
                it "creation when existing record has nil left column" do
                  assert_nothing_raised do
                    Broken.create!
                  end
                end
                it "quoted_left_column_name" do
                  quoted = Default.connection.quote_column_name('lft')
                  Default.quoted_left_column_name.should == quoted
                  Default.new.quoted_left_column_name.should == quoted
                end
                it "quoted_right_column_name" do
                  quoted = Default.connection.quote_column_name('rgt')
                  Default.quoted_right_column_name.should == quoted
                  Default.new.quoted_right_column_name.should == quoted
                end
                it "left_column_protected_from_assignment" do
                  lambda {
                    Category.new.lft = 1
                  }.should raise_exception(ActiveRecord::ActiveRecordError)
                end
                it "right_column_protected_from_assignment" do
                  lambda {
                    Category.new.rgt = 1
                  }.should raise_exception(ActiveRecord::ActiveRecordError)
                end
                it "scoped_appends_id" do
                  ScopedCategory.acts_as_nested_set_options[:scope].should == :organization_id
                end
                it "roots_class_method" do
                  Category.roots.should == Category.find_all_by_parent_id(nil)
                end
                it "root_class_method" do
                  Category.root.should == categories(:top_level)
                end
                it "root" do
                  categories(:child_3).root.should == categories(:top_level)
                end
                it "root?" do
                  categories(:top_level).root?.should be_true
                  categories(:top_level_2).root?.should be_true
                end
                it "leaves_class_method" do
                  Category.find(:all, :conditions => "#{Category.right_column_name} - #{Category.left_column_name} = 1").should == Category.leaves
                  Category.leaves.count.should == 4
                  Category.leaves.should include(categories(:child_1))
                  Category.leaves.should include(categories(:child_2_1))
                  Category.leaves.should include(categories(:child_3))
                  Category.leaves.should include(categories(:top_level_2))
                end
                it "leaf" do
                  categories(:child_1).leaf?.should be_true
                  categories(:child_2_1).leaf?.should be_true
                  categories(:child_3).leaf?.should be_true
                  categories(:top_level_2).leaf?.should be_true
                  categories(:top_level).leaf?.should be_false
                  categories(:child_2).leaf?.should be_false
                  Category.new.leaf?.should be_false
                end
                it "parent" do
                  categories(:child_2_1).parent.should == categories(:child_2)
                end
                it "self_and_ancestors" do
                  child = categories(:child_2_1)
                  self_and_ancestors = [categories(:top_level), categories(:child_2), child]
                  self_and_ancestors.should == child.self_and_ancestors
                end
                it "ancestors" do
                  child = categories(:child_2_1)
                  ancestors = [categories(:top_level), categories(:child_2)]
                  ancestors.should == child.ancestors
                end
                it "self_and_siblings" do
                  child = categories(:child_2)
                  self_and_siblings = [categories(:child_1), child, categories(:child_3)]
                  self_and_siblings.should == child.self_and_siblings
                  lambda do
                    tops = [categories(:top_level), categories(:top_level_2)]
                    assert_equal tops, categories(:top_level).self_and_siblings
                  end.should_not raise_exception
                end
                it "siblings" do
                  child = categories(:child_2)
                  siblings = [categories(:child_1), categories(:child_3)]
                  siblings.should == child.siblings
                end
                it "leaves" do
                  leaves = [categories(:child_1), categories(:child_2_1), categories(:child_3)]
                  categories(:top_level).leaves.should == leaves
                end
                it "level" do
                  categories(:top_level).level.should == 0
                  categories(:child_1).level.should == 1
                  categories(:child_2_1).level.should == 2
                end
                it "has_children?" do
                  categories(:child_2_1).children.empty?.should be_true
                  categories(:child_2).children.empty?.should be_false
                  categories(:top_level).children.empty?.should be_false
                end
                it "self_and_descendents" do
                  parent = categories(:top_level)
                  self_and_descendants = [parent, categories(:child_1), categories(:child_2),
                    categories(:child_2_1), categories(:child_3)]
                  self_and_descendants.should == parent.self_and_descendants
                  self_and_descendants.count.should == parent.self_and_descendants.count
                end
                it "descendents" do
                  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
                  lawyers.children.size.should == 1
                  us.children.size.should == 1
                  lawyers.descendants.size.should == 2
                end
                it "self_and_descendents" do
                  parent = categories(:top_level)
                  descendants = [categories(:child_1), categories(:child_2),
                    categories(:child_2_1), categories(:child_3)]
                  descendants.should == parent.descendants
                end
                it "children" do
                  category = categories(:top_level)
                  category.children.each {|c| category.id.should == c.parent_id }
                end
                it "order_of_children" do
                  categories(:child_2).move_left
                  categories(:child_2).should == categories(:top_level).children[0]
                  categories(:child_1).should == categories(:top_level).children[1]
                  categories(:child_3).should == categories(:top_level).children[2]
                end
                it "is_or_is_ancestor_of?" do
                  categories(:top_level).is_or_is_ancestor_of?(categories(:child_1)).should be_true
                  categories(:top_level).is_or_is_ancestor_of?(categories(:child_2_1)).should be_true
                  categories(:child_2).is_or_is_ancestor_of?(categories(:child_2_1)).should be_true
                  categories(:child_2_1).is_or_is_ancestor_of?(categories(:child_2)).should be_false
                  categories(:child_1).is_or_is_ancestor_of?(categories(:child_2)).should be_false
                  categories(:child_1).is_or_is_ancestor_of?(categories(:child_1)).should be_true
                end
                it "is_ancestor_of?" do
                  categories(:top_level).is_ancestor_of?(categories(:child_1)).should be_true
                  categories(:top_level).is_ancestor_of?(categories(:child_2_1)).should be_true
                  categories(:child_2).is_ancestor_of?(categories(:child_2_1)).should be_true
                  categories(:child_2_1).is_ancestor_of?(categories(:child_2)).should be_false
                  categories(:child_1).is_ancestor_of?(categories(:child_2)).should be_false
                  categories(:child_1).is_ancestor_of?(categories(:child_1)).should be_false
                end
                it "is_or_is_ancestor_of_with_scope" do
                  root = ScopedCategory.root
                  child = root.children.first
                  root.is_or_is_ancestor_of?(child).should be_true
                  child.update_attribute :organization_id, 'different'
                  root.is_or_is_ancestor_of?(child).should be_false
                end
                it "is_or_is_descendant_of?" do
                  categories(:child_1).is_or_is_descendant_of?(categories(:top_level)).should be_true
                  categories(:child_2_1).is_or_is_descendant_of?(categories(:top_level)).should be_true
                  categories(:child_2_1).is_or_is_descendant_of?(categories(:child_2)).should be_true
                  categories(:child_2).is_or_is_descendant_of?(categories(:child_2_1)).should be_false
                  categories(:child_2).is_or_is_descendant_of?(categories(:child_1)).should be_false
                  categories(:child_1).is_or_is_descendant_of?(categories(:child_1)).should be_true
                end
                it "is_descendant_of?" do
                  categories(:child_1).is_descendant_of?(categories(:top_level)).should be_true
                  categories(:child_2_1).is_descendant_of?(categories(:top_level)).should be_true
                  categories(:child_2_1).is_descendant_of?(categories(:child_2)).should be_true
                  categories(:child_2).is_descendant_of?(categories(:child_2_1)).should be_false
                  categories(:child_2).is_descendant_of?(categories(:child_1)).should be_false
                  categories(:child_1).is_descendant_of?(categories(:child_1)).should be_false
                end
                it "is_or_is_descendant_of_with_scope" do
                  root = ScopedCategory.root
                  child = root.children.first
                  child.is_or_is_descendant_of?(root).should be_true
                  child.update_attribute :organization_id, 'different'
                  child.is_or_is_descendant_of?(root).should be_false
                end
                it "same_scope?" do
                  root = ScopedCategory.root
                  child = root.children.first
                  child.same_scope?(root).should be_true
                  child.update_attribute :organization_id, 'different'
                  child.same_scope?(root).should be_false
                end
                it "left_sibling" do
                  categories(:child_1).should == categories(:child_2).left_sibling
                  categories(:child_2).should == categories(:child_3).left_sibling
                end
                it "left_sibling_of_root" do
                  categories(:top_level).left_sibling.should be_nil
                end
                it "left_sibling_without_siblings" do
                  categories(:child_2_1).left_sibling.should be_nil
                end
                it "left_sibling_of_leftmost_node" do
                  categories(:child_1).left_sibling.should be_nil
                end
                it "right_sibling" do
                  categories(:child_3).should == categories(:child_2).right_sibling
                  categories(:child_2).should == categories(:child_1).right_sibling
                end
                it "right_sibling_of_root" do
                  categories(:top_level_2).should == categories(:top_level).right_sibling
                  categories(:top_level_2).right_sibling.should be_nil
                end
                it "right_sibling_without_siblings" do
                  categories(:child_2_1).right_sibling.should be_nil
                end
                it "right_sibling_of_rightmost_node" do
                  categories(:child_3).right_sibling.should be_nil
                end
                it "move_left" do
                  categories(:child_2).move_left
                  categories(:child_2).left_sibling.should be_nil
                  categories(:child_1).should == categories(:child_2).right_sibling
                  Category.valid?.should be_true
                end
                it "move_right" do
                  categories(:child_2).move_right
                  categories(:child_2).right_sibling.should be_nil
                  categories(:child_3).should == categories(:child_2).left_sibling
                  Category.valid?.should be_true
                end
                it "move_to_left_of" do
                  categories(:child_3).move_to_left_of(categories(:child_1))
                  categories(:child_3).left_sibling.should be_nil
                  categories(:child_1).should == categories(:child_3).right_sibling
                  Category.valid?.should be_true
                end
                it "move_to_right_of" do
                  categories(:child_1).move_to_right_of(categories(:child_3))
                  categories(:child_1).right_sibling.should be_nil
                  categories(:child_3).should == categories(:child_1).left_sibling
                  Category.valid?.should be_true
                end
                it "move_to_root" do
                  categories(:child_2).move_to_root
                  categories(:child_2).parent.should be_nil
                  categories(:child_2).level.should == 0
                  categories(:child_2_1).level.should == 1
                  categories(:child_2).left.should == 1
                  categories(:child_2).right.should == 4
                  Category.valid?.should be_true
                end
                it "move_to_child_of" do
                  categories(:child_1).move_to_child_of(categories(:child_3))
                  categories(:child_3).id.should == categories(:child_1).parent_id
                  Category.valid?.should be_true
                end
                it "move_to_child_of_appends_to_end" do
                  child = Category.create! :name => 'New Child'
                  child.move_to_child_of categories(:top_level)
                  child.should == categories(:top_level).children.last
                end
                it "subtree_move_to_child_of" do
                  categories(:child_2).left.should == 4
                  categories(:child_2).right.should == 7
                  categories(:child_1).left.should == 2
                  categories(:child_1).right.should == 3
                  categories(:child_2).move_to_child_of(categories(:child_1))
                  Category.valid?.should be_true
                  categories(:child_1).id.should == categories(:child_2).parent_id
                  categories(:child_2).left.should == 3
                  categories(:child_2).right.should == 6
                  categories(:child_1).left.should == 2
                  categories(:child_1).right.should == 7
                end
                it "slightly_difficult_move_to_child_of" do
                  categories(:top_level_2).left.should == 11
                  categories(:top_level_2).right.should == 12
                  # create a new top-level node and move single-node top-level tree inside it.
                  new_top = Category.create(:name => 'New Top')
                  new_top.left.should == 13
                  new_top.right.should == 14
                  categories(:top_level_2).move_to_child_of(new_top)
                  Category.valid?.should be_true
                  new_top.id.should == categories(:top_level_2).parent_id
                  categories(:top_level_2).left.should == 12
                  categories(:top_level_2).right.should == 13
                  new_top.left.should == 11
                  new_top.right.should == 14
                end
                it "difficult_move_to_child_of" do
                  categories(:top_level).left.should == 1
                  categories(:top_level).right.should == 10
                  categories(:child_2_1).left.should == 5
                  categories(:child_2_1).right.should == 6
                  # 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
                  Category.valid?.should be_true
                  new_top.id.should == categories(:top_level).parent_id
                  categories(:top_level).left.should == 4
                  categories(:top_level).right.should == 13
                  categories(:child_2_1).left.should == 8
                  categories(:child_2_1).right.should == 9
                end
                #rebuild swaps the position of the 2 children when added using move_to_child twice onto same parent
                it "move_to_child_more_than_once_per_parent_rebuild" do
                  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!
                  Category.roots.last.to_text.should == output
                end
                # doing move_to_child twice onto same parent from the furthest right first
                it "move_to_child_more_than_once_per_parent_outside_in" do
                  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!
                  Category.roots.last.to_text.should == output
                end
                it "should be able to rebuild without validating each record" do
                  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
                  root2.name = nil
                  root2.save!(:validate => false)
                  output = Category.roots.last.to_text
                  Category.update_all('lft = null, rgt = null')
                  Category.rebuild!(false)
                  Category.roots.last.to_text.should == output
                end
                it "valid_with_null_lefts" do
                  Category.valid?.should be_true
                  Category.update_all('lft = null')
                  Category.valid?.should be_false
                end
                it "valid_with_null_rights" do
                  Category.valid?.should be_true
                  Category.update_all('rgt = null')
                  Category.valid?.should be_false
                end
                it "valid_with_missing_intermediate_node" do
                  # Even though child_2_1 will still exist, it is a sign of a sloppy delete, not an invalid tree.
                  Category.valid?.should be_true
                  Category.delete(categories(:child_2).id)
                  Category.valid?.should be_true
                end
                it "valid_with_overlapping_and_rights" do
                  Category.valid?.should be_true
                  categories(:top_level_2)['lft'] = 0
                  categories(:top_level_2).save
                  Category.valid?.should be_false
                end
                it "rebuild" do
                  Category.valid?.should be_true
                  before_text = Category.root.to_text
                  Category.update_all('lft = null, rgt = null')
                  Category.rebuild!
                  Category.valid?.should be_true
                  before_text.should == Category.root.to_text
                end
                it "move_possible_for_sibling" do
                  categories(:child_2).move_possible?(categories(:child_1)).should be_true
                end
                it "move_not_possible_to_self" do
                  categories(:top_level).move_possible?(categories(:top_level)).should be_false
                end
                it "move_not_possible_to_parent" do
                  categories(:top_level).descendants.each do |descendant|
                    categories(:top_level).move_possible?(descendant).should be_false
                    descendant.move_possible?(categories(:top_level)).should be_true
                  end
                end
                it "is_or_is_ancestor_of?" do
                  [:child_1, :child_2, :child_2_1, :child_3].each do |c|
                    categories(:top_level).is_or_is_ancestor_of?(categories(c)).should be_true
                  end
                  categories(:top_level).is_or_is_ancestor_of?(categories(:top_level_2)).should be_false
                end
                it "left_and_rights_valid_with_blank_left" do
                  Category.left_and_rights_valid?.should be_true
                  categories(:child_2)[:lft] = nil
                  categories(:child_2).save(:validate => false)
                  Category.left_and_rights_valid?.should be_false
                end
                it "left_and_rights_valid_with_blank_right" do
                  Category.left_and_rights_valid?.should be_true
                  categories(:child_2)[:rgt] = nil
                  categories(:child_2).save(:validate => false)
                  Category.left_and_rights_valid?.should be_false
                end
                it "left_and_rights_valid_with_equal" do
                  Category.left_and_rights_valid?.should be_true
                  categories(:top_level_2)[:lft] = categories(:top_level_2)[:rgt]
                  categories(:top_level_2).save(:validate => false)
                  Category.left_and_rights_valid?.should be_false
                end
                it "left_and_rights_valid_with_left_equal_to_parent" do
                  Category.left_and_rights_valid?.should be_true
                  categories(:child_2)[:lft] = categories(:top_level)[:lft]
                  categories(:child_2).save(:validate => false)
                  Category.left_and_rights_valid?.should be_false
                end
                it "left_and_rights_valid_with_right_equal_to_parent" do
                  Category.left_and_rights_valid?.should be_true
                  categories(:child_2)[:rgt] = categories(:top_level)[:rgt]
                  categories(:child_2).save(:validate => false)
                  Category.left_and_rights_valid?.should be_false
                end
                it "moving_dirty_objects_doesnt_invalidate_tree" do
                  r1 = Category.create :name => "Test 1"
                  r2 = Category.create :name => "Test 2"
                  r3 = Category.create :name => "Test 3"
                  r4 = Category.create :name => "Test 4"
                  nodes = [r1, r2, r3, r4]
                  r2.move_to_child_of(r1)
                  Category.valid?.should be_true
                  r3.move_to_child_of(r1)
                  Category.valid?.should be_true
                  r4.move_to_child_of(r2)
                  Category.valid?.should be_true
                end
                it "multi_scoped_no_duplicates_for_columns?" do
                  lambda {
                    Note.no_duplicates_for_columns?
                  }.should_not raise_exception
                end
                it "multi_scoped_all_roots_valid?" do
                  lambda {
                    Note.all_roots_valid?
                  }.should_not raise_exception
                end
                it "multi_scoped" do
                  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')
                  [note1, note2].should == note1.self_and_siblings
                  [note3].should == note3.self_and_siblings
                end
                it "multi_scoped_rebuild" do
                  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!
                  Note.roots.find_by_body('A').should == root
                  [child1, child2].should == Note.roots.find_by_body('A').children
                end
                it "same_scope_with_multi_scopes" do
                  lambda {
                    notes(:scope1).same_scope?(notes(:child_1))
                  }.should_not raise_exception
                  notes(:scope1).same_scope?(notes(:child_1)).should be_true
                  notes(:child_1).same_scope?(notes(:scope1)).should be_true
                  notes(:scope1).same_scope?(notes(:scope2)).should be_false
                end
                it "quoting_of_multi_scope_column_names" do
                  ["\"notable_id\"", "\"notable_type\""].should == Note.quoted_scope_column_names
                end
                it "equal_in_same_scope" do
                  notes(:scope1).should == notes(:scope1)
                  notes(:scope1).should_not == notes(:child_1)
                end
                it "equal_in_different_scopes" do
                  notes(:scope1).should_not == notes(:scope2)
                end
                it "delete_does_not_invalidate" do
                  Category.acts_as_nested_set_options[:dependent] = :delete
                  categories(:child_2).destroy
                  Category.valid?.should be_true
                end
                it "destroy_does_not_invalidate" do
                  Category.acts_as_nested_set_options[:dependent] = :destroy
                  categories(:child_2).destroy
                  Category.valid?.should be_true
                end
                it "destroy_multiple_times_does_not_invalidate" do
                  Category.acts_as_nested_set_options[:dependent] = :destroy
                  categories(:child_2).destroy
                  categories(:child_2).destroy
                  Category.valid?.should be_true
                end
                it "assigning_parent_id_on_create" do
                  category = Category.create!(:name => "Child", :parent_id => categories(:child_2).id)
                  categories(:child_2).should == category.parent
                  categories(:child_2).id.should == category.parent_id
                  category.left.should_not be_nil
                  category.right.should_not be_nil
                  Category.valid?.should be_true
                end
                it "assigning_parent_on_create" do
                  category = Category.create!(:name => "Child", :parent => categories(:child_2))
                  categories(:child_2).should == category.parent
                  categories(:child_2).id.should == category.parent_id
                  category.left.should_not be_nil
                  category.right.should_not be_nil
                  Category.valid?.should be_true
                end
                it "assigning_parent_id_to_nil_on_create" do
                  category = Category.create!(:name => "New Root", :parent_id => nil)
                  category.parent.should be_nil
                  category.parent_id.should be_nil
                  category.left.should_not be_nil
                  category.right.should_not be_nil
                  Category.valid?.should be_true
                end
                it "assigning_parent_id_on_update" do
                  category = categories(:child_2_1)
                  category.parent_id = categories(:child_3).id
                  category.save
                  category.reload
                  categories(:child_3).reload
                  categories(:child_3).should == category.parent
                  categories(:child_3).id.should == category.parent_id
                  Category.valid?.should be_true
                end
                it "assigning_parent_on_update" do
                  category = categories(:child_2_1)
                  category.parent = categories(:child_3)
                  category.save
                  category.reload
                  categories(:child_3).reload
                  categories(:child_3).should == category.parent
                  categories(:child_3).id.should ==  category.parent_id
                  Category.valid?.should be_true
                end
                it "assigning_parent_id_to_nil_on_update" do
                  category = categories(:child_2_1)
                  category.parent_id = nil
                  category.save
                  category.parent.should be_nil
                  category.parent_id.should be_nil
                  Category.valid?.should be_true
                end
                it "creating_child_from_parent" do
                  category = categories(:child_2).children.create!(:name => "Child")
                  categories(:child_2).should == category.parent
                  categories(:child_2).id.should == category.parent_id
                  category.left.should_not be_nil
                  category.right.should_not be_nil
                  Category.valid?.should be_true
                end
                def check_structure(entries, structure)
                  structure = structure.dup
                  Category.each_with_level(entries) do |category, level|
                    expected_level, expected_name = structure.shift
                    expected_name.should == category.name
                    expected_level.should == level
                  end
                end
                it "each_with_level" do
                  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
                it "should not error on a model with attr_accessible" do
                  model = Class.new(ActiveRecord::Base)
-                 model.set_table_name 'categories'
+                 model.table_name = 'categories'
                  model.attr_accessible :name
                  lambda {
                    model.acts_as_nested_set
                    model.new(:name => 'foo')
                  }.should_not raise_exception
                end
                describe "before_move_callback" do
                  it "should fire the callback" do
                    categories(:child_2).should_receive(:custom_before_move)
                    categories(:child_2).move_to_root
                  end
                  it "should stop move when callback returns false" do
                    Category.test_allows_move = false
                    categories(:child_3).move_to_root.should be_false
                    categories(:child_3).root?.should be_false
                  end
                  it "should not halt save actions" do
                    Category.test_allows_move = false
                    categories(:child_3).parent_id = nil
                    categories(:child_3).save.should be_true
                  end
                end
                describe "counter_cache" do
                  it "should allow use of a counter cache for children" do
                    note1 = things(:parent1)
                    note1.children.count.should == 2
                  end
                  it "should increment the counter cache on create" do
                    note1 = things(:parent1)
                    note1.children.count.should == 2
                    note1[:children_count].should == 2
                    note1.children.create :body => 'Child 3'
                    note1.children.count.should == 3
                    note1.reload
                    note1[:children_count].should == 3
                  end
                  it "should decrement the counter cache on destroy" do
                    note1 = things(:parent1)
                    note1.children.count.should == 2
                    note1[:children_count].should == 2
                    note1.children.last.destroy
                    note1.children.count.should == 1
                    note1.reload
                    note1[:children_count].should == 1
                  end
                end
                describe "association callbacks on children" do
                  it "should call the appropriate callbacks on the children :has_many association " do
                    root = DefaultWithCallbacks.create
                    root.should_not be_new_record
                    child = root.children.build
                    root.before_add.should == child
                    root.after_add.should  == child
                    root.before_remove.should_not == child
                    root.after_remove.should_not  == child
                    child.save.should be_true
                    root.children.delete(child).should be_true
                    root.before_remove.should == child
                    root.after_remove.should  == child
                  end
                end
              end

lib/plugins/awesome_nested_set/spec/support/models.rb +3 -3

              class Note < ActiveRecord::Base
                acts_as_nested_set :scope => [:notable_id, :notable_type]
              end
              class Default < ActiveRecord::Base
-               set_table_name 'categories'
+               self.table_name = 'categories'
                acts_as_nested_set
              end
              class ScopedCategory < ActiveRecord::Base
-               set_table_name 'categories'
+               self.table_name = 'categories'
                acts_as_nested_set :scope => :organization
              end
              class RenamedColumns < ActiveRecord::Base
                acts_as_nested_set :parent_column => 'mother_id', :left_column => 'red', :right_column => 'black'
              end
              class Category < ActiveRecord::Base
                acts_as_nested_set
                validates_presence_of :name
                # Setup a callback that we can switch to true or false per-test
                set_callback :move, :before, :custom_before_move
                cattr_accessor :test_allows_move
                @@test_allows_move = true
                def custom_before_move
                  @@test_allows_move
                end
                def to_s
                  name
                end
                def recurse &block
                  block.call self, lambda{
                    self.children.each do |child|
                      child.recurse &block
                    end
                  }
                end
              end
              class Thing < ActiveRecord::Base
                acts_as_nested_set :counter_cache => 'children_count'
              end
              class DefaultWithCallbacks < ActiveRecord::Base
-               set_table_name 'categories'
+               self.table_name = 'categories'
                attr_accessor :before_add, :after_add, :before_remove, :after_remove
                acts_as_nested_set :before_add => :do_before_add_stuff,
                  :after_add     => :do_after_add_stuff,
                  :before_remove => :do_before_remove_stuff,
                  :after_remove  => :do_after_remove_stuff
                private
                  [ :before_add, :after_add, :before_remove, :after_remove ].each do |hook_name|
                    define_method "do_#{hook_name}_stuff" do |child_node|
                      self.send("#{hook_name}=", child_node)
                    end
                  end
              end
              class Broken < ActiveRecord::Base
                acts_as_nested_set
              end
  No newline at end of file

lib/plugins/awesome_nested_set/test/awesome_nested_set_test.rb +2 -2

              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'
+                 self.table_name = 'categories'
                end
                class Scoped < ActiveRecord::Base
                  acts_as_nested_set :scope => :organization
-                 set_table_name 'categories'
+                 self.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
                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
              end

lib/plugins/classic_pagination/test/fixtures/developer.rb +1 -1

              class Developer < ActiveRecord::Base
                has_and_belongs_to_many :projects
              end
              class DeVeLoPeR < ActiveRecord::Base
-               set_table_name "developers"
+               self.table_name = "developers"
              end

lib/tasks/migrate_from_mantis.rake +16 -16

              # redMine - project management software
              # Copyright (C) 2006-2007  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              desc 'Mantis migration script'
              require 'active_record'
              require 'iconv'
              require 'pp'
              namespace :redmine do
              task :migrate_from_mantis => :environment do
                module MantisMigrate
                    DEFAULT_STATUS = IssueStatus.default
                    assigned_status = IssueStatus.find_by_position(2)
                    resolved_status = IssueStatus.find_by_position(3)
                    feedback_status = IssueStatus.find_by_position(4)
                    closed_status = IssueStatus.find :first, :conditions => { :is_closed => true }
                    STATUS_MAPPING = {10 => DEFAULT_STATUS,  # new
 => feedback_status, # feedback
 => DEFAULT_STATUS,  # acknowledged
 => DEFAULT_STATUS,  # confirmed
 => assigned_status, # assigned
 => resolved_status, # resolved
 => closed_status    # closed
                                      }
                    priorities = IssuePriority.all
                    DEFAULT_PRIORITY = priorities[2]
                    PRIORITY_MAPPING = {10 => priorities[1], # none
 => priorities[1], # low
 => priorities[2], # normal
 => priorities[3], # high
 => priorities[4], # urgent
 => priorities[5]  # immediate
                                        }
                    TRACKER_BUG = Tracker.find_by_position(1)
                    TRACKER_FEATURE = Tracker.find_by_position(2)
                    roles = Role.find(:all, :conditions => {:builtin => 0}, :order => 'position ASC')
                    manager_role = roles[0]
                    developer_role = roles[1]
                    DEFAULT_ROLE = roles.last
                    ROLE_MAPPING = {10 => DEFAULT_ROLE,   # viewer
 => DEFAULT_ROLE,   # reporter
 => DEFAULT_ROLE,   # updater
 => developer_role, # developer
 => manager_role,   # manager
 => manager_role    # administrator
                                    }
                    CUSTOM_FIELD_TYPE_MAPPING = {0 => 'string', # String
 => 'int',    # Numeric
 => 'int',    # Float
 => 'list',   # Enumeration
 => 'string', # Email
 => 'bool',   # Checkbox
 => 'list',   # List
 => 'list',   # Multiselection list
 => 'date',   # Date
                                                 }
                    RELATION_TYPE_MAPPING = {1 => IssueRelation::TYPE_RELATES,    # related to
 => IssueRelation::TYPE_RELATES,    # parent of
 => IssueRelation::TYPE_RELATES,    # child of
 => IssueRelation::TYPE_DUPLICATES, # duplicate of
 => IssueRelation::TYPE_DUPLICATES  # has duplicate
                                             }
                  class MantisUser < ActiveRecord::Base
-                   set_table_name :mantis_user_table
+                   self.table_name = :mantis_user_table
                    def firstname
                      @firstname = realname.blank? ? username : realname.split.first[0..29]
                      @firstname
                    end
                    def lastname
                      @lastname = realname.blank? ? '-' : realname.split[1..-1].join(' ')[0..29]
                      @lastname = '-' if @lastname.blank?
                      @lastname
                    end
                    def email
                      if read_attribute(:email).match(/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i) &&
                           !User.find_by_mail(read_attribute(:email))
                        @email = read_attribute(:email)
                      else
                        @email = "#{username}@foo.bar"
                      end
                    end
                    def username
                      read_attribute(:username)[0..29].gsub(/[^a-zA-Z0-9_\-@\.]/, '-')
                    end
                  end
                  class MantisProject < ActiveRecord::Base
-                   set_table_name :mantis_project_table
+                   self.table_name = :mantis_project_table
                    has_many :versions, :class_name => "MantisVersion", :foreign_key => :project_id
                    has_many :categories, :class_name => "MantisCategory", :foreign_key => :project_id
                    has_many :news, :class_name => "MantisNews", :foreign_key => :project_id
                    has_many :members, :class_name => "MantisProjectUser", :foreign_key => :project_id
                    def identifier
                      read_attribute(:name).gsub(/[^a-z0-9\-]+/, '-').slice(0, Project::IDENTIFIER_MAX_LENGTH)
                    end
                  end
                  class MantisVersion < ActiveRecord::Base
-                   set_table_name :mantis_project_version_table
+                   self.table_name = :mantis_project_version_table
                    def version
                      read_attribute(:version)[0..29]
                    end
                    def description
                      read_attribute(:description)[0..254]
                    end
                  end
                  class MantisCategory < ActiveRecord::Base
-                   set_table_name :mantis_project_category_table
+                   self.table_name = :mantis_project_category_table
                  end
                  class MantisProjectUser < ActiveRecord::Base
-                   set_table_name :mantis_project_user_list_table
+                   self.table_name = :mantis_project_user_list_table
                  end
                  class MantisBug < ActiveRecord::Base
-                   set_table_name :mantis_bug_table
+                   self.table_name = :mantis_bug_table
                    belongs_to :bug_text, :class_name => "MantisBugText", :foreign_key => :bug_text_id
                    has_many :bug_notes, :class_name => "MantisBugNote", :foreign_key => :bug_id
                    has_many :bug_files, :class_name => "MantisBugFile", :foreign_key => :bug_id
                    has_many :bug_monitors, :class_name => "MantisBugMonitor", :foreign_key => :bug_id
                  end
                  class MantisBugText < ActiveRecord::Base
-                   set_table_name :mantis_bug_text_table
+                   self.table_name = :mantis_bug_text_table
                    # Adds Mantis steps_to_reproduce and additional_information fields
                    # to description if any
                    def full_description
                      full_description = description
                      full_description += "\n\n*Steps to reproduce:*\n\n#{steps_to_reproduce}" unless steps_to_reproduce.blank?
                      full_description += "\n\n*Additional information:*\n\n#{additional_information}" unless additional_information.blank?
                      full_description
                    end
                  end
                  class MantisBugNote < ActiveRecord::Base
-                   set_table_name :mantis_bugnote_table
+                   self.table_name = :mantis_bugnote_table
                    belongs_to :bug, :class_name => "MantisBug", :foreign_key => :bug_id
                    belongs_to :bug_note_text, :class_name => "MantisBugNoteText", :foreign_key => :bugnote_text_id
                  end
                  class MantisBugNoteText < ActiveRecord::Base
-                   set_table_name :mantis_bugnote_text_table
+                   self.table_name = :mantis_bugnote_text_table
                  end
                  class MantisBugFile < ActiveRecord::Base
-                   set_table_name :mantis_bug_file_table
+                   self.table_name = :mantis_bug_file_table
                    def size
                      filesize
                    end
                    def original_filename
                      MantisMigrate.encode(filename)
                    end
                    def content_type
                      file_type
                    end
                    def read(*args)
                    	if @read_finished
                    		nil
                    	else
                    		@read_finished = true
                    		content
                    	end
                    end
                  end
                  class MantisBugRelationship < ActiveRecord::Base
-                   set_table_name :mantis_bug_relationship_table
+                   self.table_name = :mantis_bug_relationship_table
                  end
                  class MantisBugMonitor < ActiveRecord::Base
-                   set_table_name :mantis_bug_monitor_table
+                   self.table_name = :mantis_bug_monitor_table
                  end
                  class MantisNews < ActiveRecord::Base
-                   set_table_name :mantis_news_table
+                   self.table_name = :mantis_news_table
                  end
                  class MantisCustomField < ActiveRecord::Base
-                   set_table_name :mantis_custom_field_table
+                   self.table_name = :mantis_custom_field_table
                    set_inheritance_column :none
                    has_many :values, :class_name => "MantisCustomFieldString", :foreign_key => :field_id
                    has_many :projects, :class_name => "MantisCustomFieldProject", :foreign_key => :field_id
                    def format
                      read_attribute :type
                    end
                    def name
                      read_attribute(:name)[0..29]
                    end
                  end
                  class MantisCustomFieldProject < ActiveRecord::Base
-                   set_table_name :mantis_custom_field_project_table
+                   self.table_name = :mantis_custom_field_project_table
                  end
                  class MantisCustomFieldString < ActiveRecord::Base
-                   set_table_name :mantis_custom_field_string_table
+                   self.table_name = :mantis_custom_field_string_table
                  end
                  def self.migrate
                    # Users
                    print "Migrating users"
                    User.delete_all "login <> 'admin'"
                    users_map = {}
                    users_migrated = 0
                    MantisUser.find(:all).each do |user|
                  	u = User.new :firstname => encode(user.firstname),
                  				 :lastname => encode(user.lastname),
                  				 :mail => user.email,
                  				 :last_login_on => user.last_visit
                  	u.login = user.username
                  	u.password = 'mantis'
                  	u.status = User::STATUS_LOCKED if user.enabled != 1
                  	u.admin = true if user.access_level == 90
                  	next unless u.save!
                  	users_migrated += 1
                  	users_map[user.id] = u.id
                  	print '.'
                    end
                    puts
                    # Projects
                    print "Migrating projects"
                    Project.destroy_all
                    projects_map = {}
                    versions_map = {}
                    categories_map = {}
                    MantisProject.find(:all).each do |project|
                  	p = Project.new :name => encode(project.name),
                                      :description => encode(project.description)
                  	p.identifier = project.identifier
                  	next unless p.save
                  	projects_map[project.id] = p.id
                  	p.enabled_module_names = ['issue_tracking', 'news', 'wiki']
                      p.trackers << TRACKER_BUG
                      p.trackers << TRACKER_FEATURE
                  	print '.'
                  	# Project members
                  	project.members.each do |member|
                        m = Member.new :user => User.find_by_id(users_map[member.user_id]),
                  	                   :roles => [ROLE_MAPPING[member.access_level] || DEFAULT_ROLE]
                  	  m.project = p
                  	  m.save
                  	end
                  	# Project versions
                  	project.versions.each do |version|
                        v = Version.new :name => encode(version.version),
                                        :description => encode(version.description),
                                        :effective_date => (version.date_order ? version.date_order.to_date : nil)
                        v.project = p
                        v.save
                        versions_map[version.id] = v.id
                  	end
                  	# Project categories
                  	project.categories.each do |category|
                        g = IssueCategory.new :name => category.category[0,30]
                        g.project = p
                        g.save
                        categories_map[category.category] = g.id
                  	end
                    end
                    puts
                    # Bugs
                    print "Migrating bugs"
                    Issue.destroy_all
                    issues_map = {}
                    keep_bug_ids = (Issue.count == 0)
                    MantisBug.find_each(:batch_size => 200) do |bug|
                      next unless projects_map[bug.project_id] && users_map[bug.reporter_id]
                  	i = Issue.new :project_id => projects_map[bug.project_id],
                                    :subject => encode(bug.summary),
                                    :description => encode(bug.bug_text.full_description),
                                    :priority => PRIORITY_MAPPING[bug.priority] || DEFAULT_PRIORITY,
                                    :created_on => bug.date_submitted,
                                    :updated_on => bug.last_updated
                  	i.author = User.find_by_id(users_map[bug.reporter_id])
                  	i.category = IssueCategory.find_by_project_id_and_name(i.project_id, bug.category[0,30]) unless bug.category.blank?
                  	i.fixed_version = Version.find_by_project_id_and_name(i.project_id, bug.fixed_in_version) unless bug.fixed_in_version.blank?
                  	i.status = STATUS_MAPPING[bug.status] || DEFAULT_STATUS
                  	i.tracker = (bug.severity == 10 ? TRACKER_FEATURE : TRACKER_BUG)
                  	i.id = bug.id if keep_bug_ids
                  	next unless i.save
                  	issues_map[bug.id] = i.id
                  	print '.'
                    STDOUT.flush
                      # Assignee
                      # Redmine checks that the assignee is a project member
                      if (bug.handler_id && users_map[bug.handler_id])
                        i.assigned_to = User.find_by_id(users_map[bug.handler_id])
                        i.save_with_validation(false)
                      end
                  	# Bug notes
                  	bug.bug_notes.each do |note|
                  	  next unless users_map[note.reporter_id]
                        n = Journal.new :notes => encode(note.bug_note_text.note),
                                        :created_on => note.date_submitted
                        n.user = User.find_by_id(users_map[note.reporter_id])
                        n.journalized = i
                        n.save
                  	end
                      # Bug files
                      bug.bug_files.each do |file|
                        a = Attachment.new :created_on => file.date_added
                        a.file = file
                        a.author = User.find :first
                        a.container = i
                        a.save
                      end
                      # Bug monitors
                      bug.bug_monitors.each do |monitor|
                        next unless users_map[monitor.user_id]
                        i.add_watcher(User.find_by_id(users_map[monitor.user_id]))
                      end
                    end
                    # update issue id sequence if needed (postgresql)
                    Issue.connection.reset_pk_sequence!(Issue.table_name) if Issue.connection.respond_to?('reset_pk_sequence!')
                    puts
                    # Bug relationships
                    print "Migrating bug relations"
                    MantisBugRelationship.find(:all).each do |relation|
                      next unless issues_map[relation.source_bug_id] && issues_map[relation.destination_bug_id]
                      r = IssueRelation.new :relation_type => RELATION_TYPE_MAPPING[relation.relationship_type]
                      r.issue_from = Issue.find_by_id(issues_map[relation.source_bug_id])
                      r.issue_to = Issue.find_by_id(issues_map[relation.destination_bug_id])
                      pp r unless r.save
                      print '.'
                      STDOUT.flush
                    end
                    puts
                    # News
                    print "Migrating news"
                    News.destroy_all
                    MantisNews.find(:all, :conditions => 'project_id > 0').each do |news|
                      next unless projects_map[news.project_id]
                      n = News.new :project_id => projects_map[news.project_id],
                                   :title => encode(news.headline[0..59]),
                                   :description => encode(news.body),
                                   :created_on => news.date_posted
                      n.author = User.find_by_id(users_map[news.poster_id])
                      n.save
                      print '.'
                      STDOUT.flush
                    end
                    puts
                    # Custom fields
                    print "Migrating custom fields"
                    IssueCustomField.destroy_all
                    MantisCustomField.find(:all).each do |field|
                      f = IssueCustomField.new :name => field.name[0..29],
                                               :field_format => CUSTOM_FIELD_TYPE_MAPPING[field.format],
                                               :min_length => field.length_min,
                                               :max_length => field.length_max,
                                               :regexp => field.valid_regexp,
                                               :possible_values => field.possible_values.split('|'),
                                               :is_required => field.require_report?
                      next unless f.save
                      print '.'
                      STDOUT.flush
                      # Trackers association
                      f.trackers = Tracker.find :all
                      # Projects association
                      field.projects.each do |project|
                        f.projects << Project.find_by_id(projects_map[project.project_id]) if projects_map[project.project_id]
                      end
                      # Values
                      field.values.each do |value|
                        v = CustomValue.new :custom_field_id => f.id,
                                            :value => value.value
                        v.customized = Issue.find_by_id(issues_map[value.bug_id]) if issues_map[value.bug_id]
                        v.save
                      end unless f.new_record?
                    end
                    puts
                    puts
                    puts "Users:           #{users_migrated}/#{MantisUser.count}"
                    puts "Projects:        #{Project.count}/#{MantisProject.count}"
                    puts "Memberships:     #{Member.count}/#{MantisProjectUser.count}"
                    puts "Versions:        #{Version.count}/#{MantisVersion.count}"
                    puts "Categories:      #{IssueCategory.count}/#{MantisCategory.count}"
                    puts "Bugs:            #{Issue.count}/#{MantisBug.count}"
                    puts "Bug notes:       #{Journal.count}/#{MantisBugNote.count}"
                    puts "Bug files:       #{Attachment.count}/#{MantisBugFile.count}"
                    puts "Bug relations:   #{IssueRelation.count}/#{MantisBugRelationship.count}"
                    puts "Bug monitors:    #{Watcher.count}/#{MantisBugMonitor.count}"
                    puts "News:            #{News.count}/#{MantisNews.count}"
                    puts "Custom fields:   #{IssueCustomField.count}/#{MantisCustomField.count}"
                  end
                  def self.encoding(charset)
                    @ic = Iconv.new('UTF-8', charset)
                  rescue Iconv::InvalidEncoding
                    return false
                  end
                  def self.establish_connection(params)
                    constants.each do |const|
                      klass = const_get(const)
                      next unless klass.respond_to? 'establish_connection'
                      klass.establish_connection params
                    end
                  end
                  def self.encode(text)
                    @ic.iconv text
                  rescue
                    text
                  end
                end
                puts
                if Redmine::DefaultData::Loader.no_data?
                  puts "Redmine configuration need to be loaded before importing data."
                  puts "Please, run this first:"
                  puts
                  puts "  rake redmine:load_default_data RAILS_ENV=\"#{ENV['RAILS_ENV']}\""
                  exit
                end
                puts "WARNING: Your Redmine data will be deleted during this process."
                print "Are you sure you want to continue ? [y/N] "
                STDOUT.flush
                break unless STDIN.gets.match(/^y$/i)
                # Default Mantis database settings
                db_params = {:adapter => 'mysql',
                             :database => 'bugtracker',
                             :host => 'localhost',
                             :username => 'root',
                             :password => '' }
                puts
                puts "Please enter settings for your Mantis database"
                [:adapter, :host, :database, :username, :password].each do |param|
                  print "#{param} [#{db_params[param]}]: "
                  value = STDIN.gets.chomp!
                  db_params[param] = value unless value.blank?
                end
                while true
                  print "encoding [UTF-8]: "
                  STDOUT.flush
                  encoding = STDIN.gets.chomp!
                  encoding = 'UTF-8' if encoding.blank?
                  break if MantisMigrate.encoding encoding
                  puts "Invalid encoding!"
                end
                puts
                # Make sure bugs can refer bugs in other projects
                Setting.cross_project_issue_relations = 1 if Setting.respond_to? 'cross_project_issue_relations'
                # Turn off email notifications
                Setting.notified_events = []
                MantisMigrate.establish_connection db_params
                MantisMigrate.migrate
              end
              end

lib/tasks/migrate_from_trac.rake +9 -9

              # Redmine - project management software
              # Copyright (C) 2006-2011  Jean-Philippe Lang
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require 'active_record'
              require 'iconv'
              require 'pp'
              namespace :redmine do
                desc 'Trac migration script'
                task :migrate_from_trac => :environment do
                  module TracMigrate
                      TICKET_MAP = []
                      DEFAULT_STATUS = IssueStatus.default
                      assigned_status = IssueStatus.find_by_position(2)
                      resolved_status = IssueStatus.find_by_position(3)
                      feedback_status = IssueStatus.find_by_position(4)
                      closed_status = IssueStatus.find :first, :conditions => { :is_closed => true }
                      STATUS_MAPPING = {'new' => DEFAULT_STATUS,
                                        'reopened' => feedback_status,
                                        'assigned' => assigned_status,
                                        'closed' => closed_status
                                        }
                      priorities = IssuePriority.all
                      DEFAULT_PRIORITY = priorities[0]
                      PRIORITY_MAPPING = {'lowest' => priorities[0],
                                          'low' => priorities[0],
                                          'normal' => priorities[1],
                                          'high' => priorities[2],
                                          'highest' => priorities[3],
                                          # ---
                                          'trivial' => priorities[0],
                                          'minor' => priorities[1],
                                          'major' => priorities[2],
                                          'critical' => priorities[3],
                                          'blocker' => priorities[4]
                                          }
                      TRACKER_BUG = Tracker.find_by_position(1)
                      TRACKER_FEATURE = Tracker.find_by_position(2)
                      DEFAULT_TRACKER = TRACKER_BUG
                      TRACKER_MAPPING = {'defect' => TRACKER_BUG,
                                         'enhancement' => TRACKER_FEATURE,
                                         'task' => TRACKER_FEATURE,
                                         'patch' =>TRACKER_FEATURE
                                         }
                      roles = Role.find(:all, :conditions => {:builtin => 0}, :order => 'position ASC')
                      manager_role = roles[0]
                      developer_role = roles[1]
                      DEFAULT_ROLE = roles.last
                      ROLE_MAPPING = {'admin' => manager_role,
                                      'developer' => developer_role
                                      }
                    class ::Time
                      class << self
                        alias :real_now :now
                        def now
                          real_now - @fake_diff.to_i
                        end
                        def fake(time)
                          @fake_diff = real_now - time
                          res = yield
                          @fake_diff = 0
                         res
                        end
                      end
                    end
                    class TracComponent < ActiveRecord::Base
-                     set_table_name :component
+                     self.table_name = :component
                    end
                    class TracMilestone < ActiveRecord::Base
-                     set_table_name :milestone
+                     self.table_name = :milestone
                      # If this attribute is set a milestone has a defined target timepoint
                      def due
                        if read_attribute(:due) && read_attribute(:due) > 0
                          Time.at(read_attribute(:due)).to_date
                        else
                          nil
                        end
                      end
                      # This is the real timepoint at which the milestone has finished.
                      def completed
                        if read_attribute(:completed) && read_attribute(:completed) > 0
                          Time.at(read_attribute(:completed)).to_date
                        else
                          nil
                        end
                      end
                      def description
                        # Attribute is named descr in Trac v0.8.x
                        has_attribute?(:descr) ? read_attribute(:descr) : read_attribute(:description)
                      end
                    end
                    class TracTicketCustom < ActiveRecord::Base
-                     set_table_name :ticket_custom
+                     self.table_name = :ticket_custom
                    end
                    class TracAttachment < ActiveRecord::Base
-                     set_table_name :attachment
+                     self.table_name = :attachment
                      set_inheritance_column :none
                      def time; Time.at(read_attribute(:time)) end
                      def original_filename
                        filename
                      end
                      def content_type
                        ''
                      end
                      def exist?
                        File.file? trac_fullpath
                      end
                      def open
                        File.open("#{trac_fullpath}", 'rb') {|f|
                          @file = f
                          yield self
                        }
                      end
                      def read(*args)
                        @file.read(*args)
                      end
                      def description
                        read_attribute(:description).to_s.slice(0,255)
                      end
                    private
                      def trac_fullpath
                        attachment_type = read_attribute(:type)
                        trac_file = filename.gsub( /[^a-zA-Z0-9\-_\.!~*']/n ) {|x| sprintf('%%%02x', x[0]) }
                        "#{TracMigrate.trac_attachments_directory}/#{attachment_type}/#{id}/#{trac_file}"
                      end
                    end
                    class TracTicket < ActiveRecord::Base
-                     set_table_name :ticket
+                     self.table_name = :ticket
                      set_inheritance_column :none
                      # ticket changes: only migrate status changes and comments
                      has_many :changes, :class_name => "TracTicketChange", :foreign_key => :ticket
                      has_many :attachments, :class_name => "TracAttachment",
                                             :finder_sql => "SELECT DISTINCT attachment.* FROM #{TracMigrate::TracAttachment.table_name}" +
                                                            " WHERE #{TracMigrate::TracAttachment.table_name}.type = 'ticket'" +
                                                            ' AND #{TracMigrate::TracAttachment.table_name}.id = \'#{TracMigrate::TracAttachment.connection.quote_string(id.to_s)}\''
                      has_many :customs, :class_name => "TracTicketCustom", :foreign_key => :ticket
                      def ticket_type
                        read_attribute(:type)
                      end
                      def summary
                        read_attribute(:summary).blank? ? "(no subject)" : read_attribute(:summary)
                      end
                      def description
                        read_attribute(:description).blank? ? summary : read_attribute(:description)
                      end
                      def time; Time.at(read_attribute(:time)) end
                      def changetime; Time.at(read_attribute(:changetime)) end
                    end
                    class TracTicketChange < ActiveRecord::Base
-                     set_table_name :ticket_change
+                     self.table_name = :ticket_change
                      def time; Time.at(read_attribute(:time)) end
                    end
                    TRAC_WIKI_PAGES = %w(InterMapTxt InterTrac InterWiki RecentChanges SandBox TracAccessibility TracAdmin TracBackup TracBrowser TracCgi TracChangeset \
                                         TracEnvironment TracFastCgi TracGuide TracImport TracIni TracInstall TracInterfaceCustomization \
                                         TracLinks TracLogging TracModPython TracNotification TracPermissions TracPlugins TracQuery \
                                         TracReports TracRevisionLog TracRoadmap TracRss TracSearch TracStandalone TracSupport TracSyntaxColoring TracTickets \
                                         TracTicketsCustomFields TracTimeline TracUnicode TracUpgrade TracWiki WikiDeletePage WikiFormatting \
                                         WikiHtml WikiMacros WikiNewPage WikiPageNames WikiProcessors WikiRestructuredText WikiRestructuredTextLinks \
                                         CamelCase TitleIndex)
                    class TracWikiPage < ActiveRecord::Base
-                     set_table_name :wiki
+                     self.table_name = :wiki
                      set_primary_key :name
                      has_many :attachments, :class_name => "TracAttachment",
                                             :finder_sql => "SELECT DISTINCT attachment.* FROM #{TracMigrate::TracAttachment.table_name}" +
                                                    " WHERE #{TracMigrate::TracAttachment.table_name}.type = 'wiki'" +
                                                    ' AND #{TracMigrate::TracAttachment.table_name}.id = \'#{TracMigrate::TracAttachment.connection.quote_string(id.to_s)}\''
                      def self.columns
                        # Hides readonly Trac field to prevent clash with AR readonly? method (Rails 2.0)
                        super.select {|column| column.name.to_s != 'readonly'}
                      end
                      def time; Time.at(read_attribute(:time)) end
                    end
                    class TracPermission < ActiveRecord::Base
-                     set_table_name :permission
+                     self.table_name = :permission
                    end
                    class TracSessionAttribute < ActiveRecord::Base
-                     set_table_name :session_attribute
+                     self.table_name = :session_attribute
                    end
                    def self.find_or_create_user(username, project_member = false)
                      return User.anonymous if username.blank?
                      u = User.find_by_login(username)
                      if !u
                        # Create a new user if not found
                        mail = username[0, User::MAIL_LENGTH_LIMIT]
                        if mail_attr = TracSessionAttribute.find_by_sid_and_name(username, 'email')
                          mail = mail_attr.value
                        end
                        mail = "#{mail}@foo.bar" unless mail.include?("@")
                        name = username
                        if name_attr = TracSessionAttribute.find_by_sid_and_name(username, 'name')
                          name = name_attr.value
                        end
                        name =~ (/(.*)(\s+\w+)?/)
                        fn = $1.strip
                        ln = ($2 || '-').strip
                        u = User.new :mail => mail.gsub(/[^-@a-z0-9\.]/i, '-'),
                                     :firstname => fn[0, limit_for(User, 'firstname')],
                                     :lastname => ln[0, limit_for(User, 'lastname')]
                        u.login = username[0, User::LOGIN_LENGTH_LIMIT].gsub(/[^a-z0-9_\-@\.]/i, '-')
                        u.password = 'trac'
                        u.admin = true if TracPermission.find_by_username_and_action(username, 'admin')
                        # finally, a default user is used if the new user is not valid
                        u = User.find(:first) unless u.save
                      end
                      # Make sure he is a member of the project
                      if project_member && !u.member_of?(@target_project)
                        role = DEFAULT_ROLE
                        if u.admin
                          role = ROLE_MAPPING['admin']
                        elsif TracPermission.find_by_username_and_action(username, 'developer')
                          role = ROLE_MAPPING['developer']
                        end
                        Member.create(:user => u, :project => @target_project, :roles => [role])
                        u.reload
                      end
                      u
                    end
                    # Basic wiki syntax conversion
                    def self.convert_wiki_text(text)
                      # Titles
                      text = text.gsub(/^(\=+)\s(.+)\s(\=+)/) {|s| "\nh#{$1.length}. #{$2}\n"}
                      # External Links
                      text = text.gsub(/\[(http[^\s]+)\s+([^\]]+)\]/) {|s| "\"#{$2}\":#{$1}"}
                      # Ticket links:
                      #      [ticket:234 Text],[ticket:234 This is a test]
                      text = text.gsub(/\[ticket\:([^\ ]+)\ (.+?)\]/, '"\2":/issues/show/\1')
                      #      ticket:1234
                      #      #1 is working cause Redmine uses the same syntax.
                      text = text.gsub(/ticket\:([^\ ]+)/, '#\1')
                      # Milestone links:
                      #      [milestone:"0.1.0 Mercury" Milestone 0.1.0 (Mercury)]
                      #      The text "Milestone 0.1.0 (Mercury)" is not converted,
                      #      cause Redmine's wiki does not support this.
                      text = text.gsub(/\[milestone\:\"([^\"]+)\"\ (.+?)\]/, 'version:"\1"')
                      #      [milestone:"0.1.0 Mercury"]
                      text = text.gsub(/\[milestone\:\"([^\"]+)\"\]/, 'version:"\1"')
                      text = text.gsub(/milestone\:\"([^\"]+)\"/, 'version:"\1"')
                      #      milestone:0.1.0
                      text = text.gsub(/\[milestone\:([^\ ]+)\]/, 'version:\1')
                      text = text.gsub(/milestone\:([^\ ]+)/, 'version:\1')
                      # Internal Links
                      text = text.gsub(/\[\[BR\]\]/, "\n") # This has to go before the rules below
                      text = text.gsub(/\[\"(.+)\".*\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}
                      text = text.gsub(/\[wiki:\"(.+)\".*\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}
                      text = text.gsub(/\[wiki:\"(.+)\".*\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}
                      text = text.gsub(/\[wiki:([^\s\]]+)\]/) {|s| "[[#{$1.delete(',./?;|:')}]]"}
                      text = text.gsub(/\[wiki:([^\s\]]+)\s(.*)\]/) {|s| "[[#{$1.delete(',./?;|:')}|#{$2.delete(',./?;|:')}]]"}
                # Links to pages UsingJustWikiCaps
                text = text.gsub(/([^!]|^)(^| )([A-Z][a-z]+[A-Z][a-zA-Z]+)/, '\\1\\2[[\3]]')
                # Normalize things that were supposed to not be links
                # like !NotALink
                text = text.gsub(/(^| )!([A-Z][A-Za-z]+)/, '\1\2')
                      # Revisions links
                      text = text.gsub(/\[(\d+)\]/, 'r\1')
                      # Ticket number re-writing
                      text = text.gsub(/#(\d+)/) do |s|
                        if $1.length < 10
              #            TICKET_MAP[$1.to_i] ||= $1
                          "\##{TICKET_MAP[$1.to_i] || $1}"
                        else
                          s
                        end
                      end
                      # We would like to convert the Code highlighting too
                      # This will go into the next line.
                      shebang_line = false
                      # Reguar expression for start of code
                      pre_re = /\{\{\{/
                      # Code hightlighing...
                      shebang_re = /^\#\!([a-z]+)/
                      # Regular expression for end of code
                      pre_end_re = /\}\}\}/
                      # Go through the whole text..extract it line by line
                      text = text.gsub(/^(.*)$/) do |line|
                        m_pre = pre_re.match(line)
                        if m_pre
                          line = '<pre>'
                        else
                          m_sl = shebang_re.match(line)
                          if m_sl
                            shebang_line = true
                            line = '<code class="' + m_sl[1] + '">'
                          end
                          m_pre_end = pre_end_re.match(line)
                          if m_pre_end
                            line = '</pre>'
                            if shebang_line
                              line = '</code>' + line
                            end
                          end
                        end
                        line
                      end
                      # Highlighting
                      text = text.gsub(/'''''([^\s])/, '_*\1')
                      text = text.gsub(/([^\s])'''''/, '\1*_')
                      text = text.gsub(/'''/, '*')
                      text = text.gsub(/''/, '_')
                      text = text.gsub(/__/, '+')
                      text = text.gsub(/~~/, '-')
                      text = text.gsub(/`/, '@')
                      text = text.gsub(/,,/, '~')
                      # Lists
                      text = text.gsub(/^([ ]+)\* /) {|s| '*' * $1.length + " "}
                      text
                    end
                    def self.migrate
                      establish_connection
                      # Quick database test
                      TracComponent.count
                      migrated_components = 0
                      migrated_milestones = 0
                      migrated_tickets = 0
                      migrated_custom_values = 0
                      migrated_ticket_attachments = 0
                      migrated_wiki_edits = 0
                      migrated_wiki_attachments = 0
                      #Wiki system initializing...
                      @target_project.wiki.destroy if @target_project.wiki
                      @target_project.reload
                      wiki = Wiki.new(:project => @target_project, :start_page => 'WikiStart')
                      wiki_edit_count = 0
                      # Components
                      print "Migrating components"
                      issues_category_map = {}
                      TracComponent.find(:all).each do |component|
                      print '.'
                      STDOUT.flush
                        c = IssueCategory.new :project => @target_project,
                                              :name => encode(component.name[0, limit_for(IssueCategory, 'name')])
                      next unless c.save
                      issues_category_map[component.name] = c
                      migrated_components += 1
                      end
                      puts
                      # Milestones
                      print "Migrating milestones"
                      version_map = {}
                      TracMilestone.find(:all).each do |milestone|
                        print '.'
                        STDOUT.flush
                        # First we try to find the wiki page...
                        p = wiki.find_or_new_page(milestone.name.to_s)
                        p.content = WikiContent.new(:page => p) if p.new_record?
                        p.content.text = milestone.description.to_s
                        p.content.author = find_or_create_user('trac')
                        p.content.comments = 'Milestone'
                        p.save
                        v = Version.new :project => @target_project,
                                        :name => encode(milestone.name[0, limit_for(Version, 'name')]),
                                        :description => nil,
                                        :wiki_page_title => milestone.name.to_s,
                                        :effective_date => milestone.completed
                        next unless v.save
                        version_map[milestone.name] = v
                        migrated_milestones += 1
                      end
                      puts
                      # Custom fields
                      # TODO: read trac.ini instead
                      print "Migrating custom fields"
                      custom_field_map = {}
                      TracTicketCustom.find_by_sql("SELECT DISTINCT name FROM #{TracTicketCustom.table_name}").each do |field|
                        print '.'
                        STDOUT.flush
                        # Redmine custom field name
                        field_name = encode(field.name[0, limit_for(IssueCustomField, 'name')]).humanize
                        # Find if the custom already exists in Redmine
                        f = IssueCustomField.find_by_name(field_name)
                        # Or create a new one
                        f ||= IssueCustomField.create(:name => encode(field.name[0, limit_for(IssueCustomField, 'name')]).humanize,
                                                      :field_format => 'string')
                        next if f.new_record?
                        f.trackers = Tracker.find(:all)
                        f.projects << @target_project
                        custom_field_map[field.name] = f
                      end
                      puts
                      # Trac 'resolution' field as a Redmine custom field
                      r = IssueCustomField.find(:first, :conditions => { :name => "Resolution" })
                      r = IssueCustomField.new(:name => 'Resolution',
                                               :field_format => 'list',
                                               :is_filter => true) if r.nil?
                      r.trackers = Tracker.find(:all)
                      r.projects << @target_project
                      r.possible_values = (r.possible_values + %w(fixed invalid wontfix duplicate worksforme)).flatten.compact.uniq
                      r.save!
                      custom_field_map['resolution'] = r
                      # Tickets
                      print "Migrating tickets"
                        TracTicket.find_each(:batch_size => 200) do |ticket|
                        print '.'
                        STDOUT.flush
                        i = Issue.new :project => @target_project,
                                        :subject => encode(ticket.summary[0, limit_for(Issue, 'subject')]),
                                        :description => convert_wiki_text(encode(ticket.description)),
                                        :priority => PRIORITY_MAPPING[ticket.priority] || DEFAULT_PRIORITY,
                                        :created_on => ticket.time
                        i.author = find_or_create_user(ticket.reporter)
                        i.category = issues_category_map[ticket.component] unless ticket.component.blank?
                        i.fixed_version = version_map[ticket.milestone] unless ticket.milestone.blank?
                        i.status = STATUS_MAPPING[ticket.status] || DEFAULT_STATUS
                        i.tracker = TRACKER_MAPPING[ticket.ticket_type] || DEFAULT_TRACKER
                        i.id = ticket.id unless Issue.exists?(ticket.id)
                        next unless Time.fake(ticket.changetime) { i.save }
                        TICKET_MAP[ticket.id] = i.id
                        migrated_tickets += 1
                        # Owner
                          unless ticket.owner.blank?
                            i.assigned_to = find_or_create_user(ticket.owner, true)
                            Time.fake(ticket.changetime) { i.save }
                          end
                        # Comments and status/resolution changes
                        ticket.changes.group_by(&:time).each do |time, changeset|
                            status_change = changeset.select {|change| change.field == 'status'}.first
                            resolution_change = changeset.select {|change| change.field == 'resolution'}.first
                            comment_change = changeset.select {|change| change.field == 'comment'}.first
                            n = Journal.new :notes => (comment_change ? convert_wiki_text(encode(comment_change.newvalue)) : ''),
                                            :created_on => time
                            n.user = find_or_create_user(changeset.first.author)
                            n.journalized = i
                            if status_change &&
                                 STATUS_MAPPING[status_change.oldvalue] &&
                                 STATUS_MAPPING[status_change.newvalue] &&
                                 (STATUS_MAPPING[status_change.oldvalue] != STATUS_MAPPING[status_change.newvalue])
                              n.details << JournalDetail.new(:property => 'attr',
                                                             :prop_key => 'status_id',
                                                             :old_value => STATUS_MAPPING[status_change.oldvalue].id,
                                                             :value => STATUS_MAPPING[status_change.newvalue].id)
                            end
                            if resolution_change
                              n.details << JournalDetail.new(:property => 'cf',
                                                             :prop_key => custom_field_map['resolution'].id,
                                                             :old_value => resolution_change.oldvalue,
                                                             :value => resolution_change.newvalue)
                            end
                            n.save unless n.details.empty? && n.notes.blank?
                        end
                        # Attachments
                        ticket.attachments.each do |attachment|
                          next unless attachment.exist?
                            attachment.open {
                              a = Attachment.new :created_on => attachment.time
                              a.file = attachment
                              a.author = find_or_create_user(attachment.author)
                              a.container = i
                              a.description = attachment.description
                              migrated_ticket_attachments += 1 if a.save
                            }
                        end
                        # Custom fields
                        custom_values = ticket.customs.inject({}) do |h, custom|
                          if custom_field = custom_field_map[custom.name]
                            h[custom_field.id] = custom.value
                            migrated_custom_values += 1
                          end
                          h
                        end
                        if custom_field_map['resolution'] && !ticket.resolution.blank?
                          custom_values[custom_field_map['resolution'].id] = ticket.resolution
                        end
                        i.custom_field_values = custom_values
                        i.save_custom_field_values
                      end
                      # update issue id sequence if needed (postgresql)
                      Issue.connection.reset_pk_sequence!(Issue.table_name) if Issue.connection.respond_to?('reset_pk_sequence!')
                      puts
                      # Wiki
                      print "Migrating wiki"
                      if wiki.save
                        TracWikiPage.find(:all, :order => 'name, version').each do |page|
                          # Do not migrate Trac manual wiki pages
                          next if TRAC_WIKI_PAGES.include?(page.name)
                          wiki_edit_count += 1
                          print '.'
                          STDOUT.flush
                          p = wiki.find_or_new_page(page.name)
                          p.content = WikiContent.new(:page => p) if p.new_record?
                          p.content.text = page.text
                          p.content.author = find_or_create_user(page.author) unless page.author.blank? || page.author == 'trac'
                          p.content.comments = page.comment
                          Time.fake(page.time) { p.new_record? ? p.save : p.content.save }
                          next if p.content.new_record?
                          migrated_wiki_edits += 1
                          # Attachments
                          page.attachments.each do |attachment|
                            next unless attachment.exist?
                            next if p.attachments.find_by_filename(attachment.filename.gsub(/^.*(\\|\/)/, '').gsub(/[^\w\.\-]/,'_')) #add only once per page
                            attachment.open {
                              a = Attachment.new :created_on => attachment.time
                              a.file = attachment
                              a.author = find_or_create_user(attachment.author)
                              a.description = attachment.description
                              a.container = p
                              migrated_wiki_attachments += 1 if a.save
                            }
                          end
                        end
                        wiki.reload
                        wiki.pages.each do |page|
                          page.content.text = convert_wiki_text(page.content.text)
                          Time.fake(page.content.updated_on) { page.content.save }
                        end
                      end
                      puts
                      puts
                      puts "Components:      #{migrated_components}/#{TracComponent.count}"
                      puts "Milestones:      #{migrated_milestones}/#{TracMilestone.count}"
                      puts "Tickets:         #{migrated_tickets}/#{TracTicket.count}"
                      puts "Ticket files:    #{migrated_ticket_attachments}/" + TracAttachment.count(:conditions => {:type => 'ticket'}).to_s
                      puts "Custom values:   #{migrated_custom_values}/#{TracTicketCustom.count}"
                      puts "Wiki edits:      #{migrated_wiki_edits}/#{wiki_edit_count}"
                      puts "Wiki files:      #{migrated_wiki_attachments}/" + TracAttachment.count(:conditions => {:type => 'wiki'}).to_s
                    end
                    def self.limit_for(klass, attribute)
                      klass.columns_hash[attribute.to_s].limit
                    end
                    def self.encoding(charset)
                      @ic = Iconv.new('UTF-8', charset)
                    rescue Iconv::InvalidEncoding
                      puts "Invalid encoding!"
                      return false
                    end
                    def self.set_trac_directory(path)
                      @@trac_directory = path
                      raise "This directory doesn't exist!" unless File.directory?(path)
                      raise "#{trac_attachments_directory} doesn't exist!" unless File.directory?(trac_attachments_directory)
                      @@trac_directory
                    rescue Exception => e
                      puts e
                      return false
                    end
                    def self.trac_directory
                      @@trac_directory
                    end
                    def self.set_trac_adapter(adapter)
                      return false if adapter.blank?
                      raise "Unknown adapter: #{adapter}!" unless %w(sqlite sqlite3 mysql postgresql).include?(adapter)
                      # If adapter is sqlite or sqlite3, make sure that trac.db exists
                      raise "#{trac_db_path} doesn't exist!" if %w(sqlite sqlite3).include?(adapter) && !File.exist?(trac_db_path)
                      @@trac_adapter = adapter
                    rescue Exception => e
                      puts e
                      return false
                    end
                    def self.set_trac_db_host(host)
                      return nil if host.blank?
                      @@trac_db_host = host
                    end
                    def self.set_trac_db_port(port)
                      return nil if port.to_i == 0
                      @@trac_db_port = port.to_i
                    end
                    def self.set_trac_db_name(name)
                      return nil if name.blank?
                      @@trac_db_name = name
                    end
                    def self.set_trac_db_username(username)
                      @@trac_db_username = username
                    end
                    def self.set_trac_db_password(password)
                      @@trac_db_password = password
                    end
                    def self.set_trac_db_schema(schema)
                      @@trac_db_schema = schema
                    end
                    mattr_reader :trac_directory, :trac_adapter, :trac_db_host, :trac_db_port, :trac_db_name, :trac_db_schema, :trac_db_username, :trac_db_password
                    def self.trac_db_path; "#{trac_directory}/db/trac.db" end
                    def self.trac_attachments_directory; "#{trac_directory}/attachments" end
                    def self.target_project_identifier(identifier)
                      project = Project.find_by_identifier(identifier)
                      if !project
                        # create the target project
                        project = Project.new :name => identifier.humanize,
                                              :description => ''
                        project.identifier = identifier
                        puts "Unable to create a project with identifier '#{identifier}'!" unless project.save
                        # enable issues and wiki for the created project
                        project.enabled_module_names = ['issue_tracking', 'wiki']
                      else
                        puts
                        puts "This project already exists in your Redmine database."
                        print "Are you sure you want to append data to this project ? [Y/n] "
                        STDOUT.flush
                        exit if STDIN.gets.match(/^n$/i)
                      end
                      project.trackers << TRACKER_BUG unless project.trackers.include?(TRACKER_BUG)
                      project.trackers << TRACKER_FEATURE unless project.trackers.include?(TRACKER_FEATURE)
                      @target_project = project.new_record? ? nil : project
                      @target_project.reload
                    end
                    def self.connection_params
                      if %w(sqlite sqlite3).include?(trac_adapter)
                        {:adapter => trac_adapter,
                         :database => trac_db_path}
                      else
                        {:adapter => trac_adapter,
                         :database => trac_db_name,
                         :host => trac_db_host,
                         :port => trac_db_port,
                         :username => trac_db_username,
                         :password => trac_db_password,
                         :schema_search_path => trac_db_schema
                        }
                      end
                    end
                    def self.establish_connection
                      constants.each do |const|
                        klass = const_get(const)
                        next unless klass.respond_to? 'establish_connection'
                        klass.establish_connection connection_params
                      end
                    end
                  private
                    def self.encode(text)
                      @ic.iconv text
                    rescue
                      text
                    end
                  end
                  puts
                  if Redmine::DefaultData::Loader.no_data?
                    puts "Redmine configuration need to be loaded before importing data."
                    puts "Please, run this first:"
                    puts
                    puts "  rake redmine:load_default_data RAILS_ENV=\"#{ENV['RAILS_ENV']}\""
                    exit
                  end
                  puts "WARNING: a new project will be added to Redmine during this process."
                  print "Are you sure you want to continue ? [y/N] "
                  STDOUT.flush
                  break unless STDIN.gets.match(/^y$/i)
                  puts
                  def prompt(text, options = {}, &block)
                    default = options[:default] || ''
                    while true
                      print "#{text} [#{default}]: "
                      STDOUT.flush
                      value = STDIN.gets.chomp!
                      value = default if value.blank?
                      break if yield value
                    end
                  end
                  DEFAULT_PORTS = {'mysql' => 3306, 'postgresql' => 5432}
                  prompt('Trac directory') {|directory| TracMigrate.set_trac_directory directory.strip}
                  prompt('Trac database adapter (sqlite, sqlite3, mysql, postgresql)', :default => 'sqlite') {|adapter| TracMigrate.set_trac_adapter adapter}
                  unless %w(sqlite sqlite3).include?(TracMigrate.trac_adapter)
                    prompt('Trac database host', :default => 'localhost') {|host| TracMigrate.set_trac_db_host host}
                    prompt('Trac database port', :default => DEFAULT_PORTS[TracMigrate.trac_adapter]) {|port| TracMigrate.set_trac_db_port port}
                    prompt('Trac database name') {|name| TracMigrate.set_trac_db_name name}
                    prompt('Trac database schema', :default => 'public') {|schema| TracMigrate.set_trac_db_schema schema}
                    prompt('Trac database username') {|username| TracMigrate.set_trac_db_username username}
                    prompt('Trac database password') {|password| TracMigrate.set_trac_db_password password}
                  end
                  prompt('Trac database encoding', :default => 'UTF-8') {|encoding| TracMigrate.encoding encoding}
                  prompt('Target project identifier') {|identifier| TracMigrate.target_project_identifier identifier}
                  puts
                  # Turn off email notifications
                  Setting.notified_events = []
                  TracMigrate.migrate
                end
              end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages