jro_apps/redmine Commit - r12868:43e84c6c1070

awesome_nested_set: import git 2-1-stable branch revision 606847769 (#6579)...

Toshi MARUYAMA -

r12868:43e84c6c1070

parent child

Context file:

r12868:43e84c6c1070

Expand all files

lib/plugins/awesome_nested_set/CONTRIBUTING.md created 644 +14 0

@@ -0,0 +1,14
	1	# Contributing to AwesomeNestedSet
	2
	3	If you find what you might think is a bug:
	4
	5	1. Check the [GitHub issue tracker](https://github.com/collectiveidea/awesome_nested_set/issues/) to see if anyone else has had the same issue.
	6	2. If you don't see anything, create an issue with information on how to reproduce it.
	7
	8	If you want to contribute an enhancement or a fix:
	9
	10	1. Fork [the project on GitHub](https://github.com/collectiveidea/awesome_nested_set)
	11	2. Make your changes with tests.
	12	3. Commit the changes without making changes to the [Rakefile](Rakefile) or any other files that aren't related to your enhancement or fix.
	13	4. Write an entry in the [CHANGELOG](CHANGELOG)
	14	5. Send a pull request.

lib/plugins/awesome_nested_set/lib/awesome_nested_set/columns.rb created 644 +68 0

@@ -0,0 +1,68
	1	# Mixed into both classes and instances to provide easy access to the column names
	2	module CollectiveIdea #:nodoc:
	3	module Acts #:nodoc:
	4	module NestedSet #:nodoc:
	5	module Columns
	6	def left_column_name
	7	acts_as_nested_set_options[:left_column]
	8	end
	9
	10	def right_column_name
	11	acts_as_nested_set_options[:right_column]
	12	end
	13
	14	def depth_column_name
	15	acts_as_nested_set_options[:depth_column]
	16	end
	17
	18	def parent_column_name
	19	acts_as_nested_set_options[:parent_column]
	20	end
	21
	22	def order_column
	23	acts_as_nested_set_options[:order_column] \|\| left_column_name
	24	end
	25
	26	def scope_column_names
	27	Array(acts_as_nested_set_options[:scope])
	28	end
	29
	30	def quoted_left_column_name
	31	connection.quote_column_name(left_column_name)
	32	end
	33
	34	def quoted_right_column_name
	35	connection.quote_column_name(right_column_name)
	36	end
	37
	38	def quoted_depth_column_name
	39	connection.quote_column_name(depth_column_name)
	40	end
	41
	42	def quoted_parent_column_name
	43	connection.quote_column_name(parent_column_name)
	44	end
	45
	46	def quoted_scope_column_names
	47	scope_column_names.collect {\|column_name\| connection.quote_column_name(column_name) }
	48	end
	49
	50	def quoted_order_column_name
	51	connection.quote_column_name(order_column)
	52	end
	53
	54	def quoted_left_column_full_name
	55	"#{quoted_table_name}.#{quoted_left_column_name}"
	56	end
	57
	58	def quoted_right_column_full_name
	59	"#{quoted_table_name}.#{quoted_right_column_name}"
	60	end
	61
	62	def quoted_parent_column_full_name
	63	"#{quoted_table_name}.#{quoted_parent_column_name}"
	64	end
	65	end
	66	end
	67	end
	68	end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/iterator.rb created 644 +29 0

@@ -0,0 +1,29
	1	module CollectiveIdea #:nodoc:
	2	module Acts #:nodoc:
	3	module NestedSet #:nodoc:
	4	class Iterator
	5	attr_reader :objects
	6
	7	def initialize(objects)
	8	@objects = objects
	9	end
	10
	11	def each_with_level
	12	path = [nil]
	13	objects.each do \|o\|
	14	if o.parent_id != path.last
	15	# we are on a new level, did we descend or ascend?
	16	if path.include?(o.parent_id)
	17	# remove wrong tailing paths elements
	18	path.pop while path.last != o.parent_id
	19	else
	20	path << o.parent_id
	21	end
	22	end
	23	yield(o, path.length - 1)
	24	end
	25	end
	26	end
	27	end
	28	end
	29	end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/model.rb created 644 +212 0

@@ -0,0 +1,212
	1	require 'awesome_nested_set/model/prunable'
	2	require 'awesome_nested_set/model/movable'
	3	require 'awesome_nested_set/model/transactable'
	4	require 'awesome_nested_set/model/relatable'
	5	require 'awesome_nested_set/model/rebuildable'
	6	require 'awesome_nested_set/model/validatable'
	7	require 'awesome_nested_set/iterator'
	8
	9	module CollectiveIdea #:nodoc:
	10	module Acts #:nodoc:
	11	module NestedSet #:nodoc:
	12
	13	module Model
	14	extend ActiveSupport::Concern
	15
	16	included do
	17	delegate :quoted_table_name, :arel_table, :to => self
	18	extend Validatable
	19	extend Rebuildable
	20	include Movable
	21	include Prunable
	22	include Relatable
	23	include Transactable
	24	end
	25
	26	module ClassMethods
	27	def associate_parents(objects)
	28	return objects unless objects.all? {\|o\| o.respond_to?(:association)}
	29
	30	id_indexed = objects.index_by(&:id)
	31	objects.each do \|object\|
	32	association = object.association(:parent)
	33	parent = id_indexed[object.parent_id]
	34
	35	if !association.loaded? && parent
	36	association.target = parent
	37	association.set_inverse_instance(parent)
	38	end
	39	end
	40	end
	41
	42	def children_of(parent_id)
	43	where arel_table[parent_column_name].eq(parent_id)
	44	end
	45
	46	# Iterates over tree elements and determines the current level in the tree.
	47	# Only accepts default ordering, odering by an other column than lft
	48	# does not work. This method is much more efficent than calling level
	49	# because it doesn't require any additional database queries.
	50	#
	51	# Example:
	52	# Category.each_with_level(Category.root.self_and_descendants) do \|o, level\|
	53	#
	54	def each_with_level(objects, &block)
	55	Iterator.new(objects).each_with_level(&block)
	56	end
	57
	58	def leaves
	59	nested_set_scope.where "#{quoted_right_column_full_name} - #{quoted_left_column_full_name} = 1"
	60	end
	61
	62	def left_of(node)
	63	where arel_table[left_column_name].lt(node)
	64	end
	65
	66	def left_of_right_side(node)
	67	where arel_table[right_column_name].lteq(node)
	68	end
	69
	70	def right_of(node)
	71	where arel_table[left_column_name].gteq(node)
	72	end
	73
	74	def nested_set_scope(options = {})
	75	options = {:order => quoted_order_column_name}.merge(options)
	76
	77	order(options.delete(:order)).scoped options
	78	end
	79
	80	def primary_key_scope(id)
	81	where arel_table[primary_key].eq(id)
	82	end
	83
	84	def root
	85	roots.first
	86	end
	87
	88	def roots
	89	nested_set_scope.children_of nil
	90	end
	91	end # end class methods
	92
	93	# Any instance method that returns a collection makes use of Rails 2.1's named_scope (which is bundled for Rails 2.0), so it can be treated as a finder.
	94	#
	95	# category.self_and_descendants.count
	96	# category.ancestors.find(:all, :conditions => "name like '%foo%'")
	97	# Value of the parent column
	98	def parent_id(target = self)
	99	target[parent_column_name]
	100	end
	101
	102	# Value of the left column
	103	def left(target = self)
	104	target[left_column_name]
	105	end
	106
	107	# Value of the right column
	108	def right(target = self)
	109	target[right_column_name]
	110	end
	111
	112	# Returns true if this is a root node.
	113	def root?
	114	parent_id.nil?
	115	end
	116
	117	# Returns true is this is a child node
	118	def child?
	119	!root?
	120	end
	121
	122	# Returns true if this is the end of a branch.
	123	def leaf?
	124	persisted? && right.to_i - left.to_i == 1
	125	end
	126
	127	# All nested set queries should use this nested_set_scope, which
	128	# performs finds on the base ActiveRecord class, using the :scope
	129	# declared in the acts_as_nested_set declaration.
	130	def nested_set_scope(options = {})
	131	if (scopes = Array(acts_as_nested_set_options[:scope])).any?
	132	options[:conditions] = scopes.inject({}) do \|conditions,attr\|
	133	conditions.merge attr => self[attr]
	134	end
	135	end
	136
	137	self.class.nested_set_scope options
	138	end
	139
	140	def to_text
	141	self_and_descendants.map do \|node\|
	142	"#{''(node.level+1)} #{node.id} #{node.to_s} (#{node.parent_id}, #{node.left}, #{node.right})"
	143	end.join("\n")
	144	end
	145
	146	protected
	147
	148	def without_self(scope)
	149	return scope if new_record?
	150	scope.where(["#{self.class.quoted_table_name}.#{self.class.primary_key} != ?", self])
	151	end
	152
	153	def store_new_parent
	154	@move_to_new_parent_id = send("#{parent_column_name}_changed?") ? parent_id : false
	155	true # force callback to return true
	156	end
	157
	158	def has_depth_column?
	159	nested_set_scope.column_names.map(&:to_s).include?(depth_column_name.to_s)
	160	end
	161
	162	def right_most_node
	163	@right_most_node \|\|= self.class.base_class.unscoped.nested_set_scope(
	164	:order => "#{quoted_right_column_full_name} desc"
	165	).first
	166	end
	167
	168	def right_most_bound
	169	@right_most_bound \|\|= begin
	170	return 0 if right_most_node.nil?
	171
	172	right_most_node.lock!
	173	right_most_node[right_column_name] \|\| 0
	174	end
	175	end
	176
	177	def set_depth!
	178	return unless has_depth_column?
	179
	180	in_tenacious_transaction do
	181	reload
	182	nested_set_scope.primary_key_scope(id).
	183	update_all(["#{quoted_depth_column_name} = ?", level])
	184	end
	185	self[depth_column_name] = self.level
	186	end
	187
	188	def set_default_left_and_right
	189	# adds the new node to the right of all existing nodes
	190	self[left_column_name] = right_most_bound + 1
	191	self[right_column_name] = right_most_bound + 2
	192	end
	193
	194	# reload left, right, and parent
	195	def reload_nested_set
	196	reload(
	197	:select => "#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, #{quoted_parent_column_full_name}",
	198	:lock => true
	199	)
	200	end
	201
	202	def reload_target(target)
	203	if target.is_a? self.class.base_class
	204	target.reload
	205	else
	206	nested_set_scope.find(target)
	207	end
	208	end
	209	end
	210	end
	211	end
	212	end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/model/movable.rb created 644 +137 0

@@ -0,0 +1,137
	1	require 'awesome_nested_set/move'
	2
	3	module CollectiveIdea #:nodoc:
	4	module Acts #:nodoc:
	5	module NestedSet #:nodoc:
	6	module Model
	7	module Movable
	8
	9	def move_possible?(target)
	10	self != target && # Can't target self
	11	same_scope?(target) && # can't be in different scopes
	12	# detect impossible move
	13	within_bounds?(target.left, target.left) &&
	14	within_bounds?(target.right, target.right)
	15	end
	16
	17	# Shorthand method for finding the left sibling and moving to the left of it.
	18	def move_left
	19	move_to_left_of left_sibling
	20	end
	21
	22	# Shorthand method for finding the right sibling and moving to the right of it.
	23	def move_right
	24	move_to_right_of right_sibling
	25	end
	26
	27	# Move the node to the left of another node
	28	def move_to_left_of(node)
	29	move_to node, :left
	30	end
	31
	32	# Move the node to the left of another node
	33	def move_to_right_of(node)
	34	move_to node, :right
	35	end
	36
	37	# Move the node to the child of another node
	38	def move_to_child_of(node)
	39	move_to node, :child
	40	end
	41
	42	# Move the node to the child of another node with specify index
	43	def move_to_child_with_index(node, index)
	44	if node.children.empty?
	45	move_to_child_of(node)
	46	elsif node.children.count == index
	47	move_to_right_of(node.children.last)
	48	else
	49	move_to_left_of(node.children[index])
	50	end
	51	end
	52
	53	# Move the node to root nodes
	54	def move_to_root
	55	move_to_right_of(root)
	56	end
	57
	58	# Order children in a nested set by an attribute
	59	# Can order by any attribute class that uses the Comparable mixin, for example a string or integer
	60	# Usage example when sorting categories alphabetically: @new_category.move_to_ordered_child_of(@root, "name")
	61	def move_to_ordered_child_of(parent, order_attribute, ascending = true)
	62	self.move_to_root and return unless parent
	63
	64	left_neighbor = find_left_neighbor(parent, order_attribute, ascending)
	65	self.move_to_child_of(parent)
	66
	67	return unless parent.children.many?
	68
	69	if left_neighbor
	70	self.move_to_right_of(left_neighbor)
	71	else # Self is the left most node.
	72	self.move_to_left_of(parent.children[0])
	73	end
	74	end
	75
	76	# Find the node immediately to the left of this node.
	77	def find_left_neighbor(parent, order_attribute, ascending)
	78	left = nil
	79	parent.children.each do \|n\|
	80	if ascending
	81	left = n if n.send(order_attribute) < self.send(order_attribute)
	82	else
	83	left = n if n.send(order_attribute) > self.send(order_attribute)
	84	end
	85	end
	86	left
	87	end
	88
	89	def move_to(target, position)
	90	prevent_unpersisted_move
	91
	92	run_callbacks :move do
	93	in_tenacious_transaction do
	94	target = reload_target(target)
	95	self.reload_nested_set
	96
	97	Move.new(target, position, self).move
	98	end
	99	after_move_to(target, position)
	100	end
	101	end
	102
	103	protected
	104
	105	def after_move_to(target, position)
	106	target.reload_nested_set if target
	107	self.set_depth!
	108	self.descendants.each(&:save)
	109	self.reload_nested_set
	110	end
	111
	112	def move_to_new_parent
	113	if @move_to_new_parent_id.nil?
	114	move_to_root
	115	elsif @move_to_new_parent_id
	116	move_to_child_of(@move_to_new_parent_id)
	117	end
	118	end
	119
	120	def out_of_bounds?(left_bound, right_bound)
	121	left <= left_bound && right >= right_bound
	122	end
	123
	124	def prevent_unpersisted_move
	125	if self.new_record?
	126	raise ActiveRecord::ActiveRecordError, "You cannot move a new node"
	127	end
	128	end
	129
	130	def within_bounds?(left_bound, right_bound)
	131	!out_of_bounds?(left_bound, right_bound)
	132	end
	133	end
	134	end
	135	end
	136	end
	137	end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/model/prunable.rb created 644 +58 0

@@ -0,0 +1,58
	1	module CollectiveIdea #:nodoc:
	2	module Acts #:nodoc:
	3	module NestedSet #:nodoc:
	4	module Model
	5	module Prunable
	6
	7	# Prunes a branch off of the tree, shifting all of the elements on the right
	8	# back to the left so the counts still work.
	9	def destroy_descendants
	10	return if right.nil? \|\| left.nil? \|\| skip_before_destroy
	11
	12	in_tenacious_transaction do
	13	reload_nested_set
	14	# select the rows in the model that extend past the deletion point and apply a lock
	15	nested_set_scope.right_of(left).select(id).lock(true)
	16
	17	destroy_or_delete_descendants
	18
	19	# update lefts and rights for remaining nodes
	20	update_siblings_for_remaining_nodes
	21
	22	# Don't allow multiple calls to destroy to corrupt the set
	23	self.skip_before_destroy = true
	24	end
	25	end
	26
	27	def destroy_or_delete_descendants
	28	if acts_as_nested_set_options[:dependent] == :destroy
	29	descendants.each do \|model\|
	30	model.skip_before_destroy = true
	31	model.destroy
	32	end
	33	else
	34	descendants.delete_all
	35	end
	36	end
	37
	38	def update_siblings_for_remaining_nodes
	39	update_siblings(:left)
	40	update_siblings(:right)
	41	end
	42
	43	def update_siblings(direction)
	44	full_column_name = send("quoted_#{direction}_column_full_name")
	45	column_name = send("quoted_#{direction}_column_name")
	46
	47	nested_set_scope.where(["#{full_column_name} > ?", right]).
	48	update_all(["#{column_name} = (#{column_name} - ?)", diff])
	49	end
	50
	51	def diff
	52	right - left + 1
	53	end
	54	end
	55	end
	56	end
	57	end
	58	end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/model/rebuildable.rb created 644 +41 0

@@ -0,0 +1,41
	1	require 'awesome_nested_set/tree'
	2
	3	module CollectiveIdea
	4	module Acts
	5	module NestedSet
	6	module Model
	7	module Rebuildable
	8
	9
	10	# Rebuilds the left & rights if unset or invalid.
	11	# Also very useful for converting from acts_as_tree.
	12	def rebuild!(validate_nodes = true)
	13	# default_scope with order may break database queries so we do all operation without scope
	14	unscoped do
	15	Tree.new(self, validate_nodes).rebuild!
	16	end
	17	end
	18
	19	private
	20	def scope_for_rebuild
	21	scope = proc {}
	22
	23	if acts_as_nested_set_options[:scope]
	24	scope = proc {\|node\|
	25	scope_column_names.inject("") {\|str, column_name\|
	26	str << "AND #{connection.quote_column_name(column_name)} = #{connection.quote(node.send(column_name))} "
	27	}
	28	}
	29	end
	30	scope
	31	end
	32
	33	def order_for_rebuild
	34	"#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, #{primary_key}"
	35	end
	36	end
	37
	38	end
	39	end
	40	end
	41	end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/model/relatable.rb created 644 +121 0

@@ -0,0 +1,121
	1	module CollectiveIdea
	2	module Acts
	3	module NestedSet
	4	module Model
	5	module Relatable
	6
	7	# Returns an collection of all parents
	8	def ancestors
	9	without_self self_and_ancestors
	10	end
	11
	12	# Returns the collection of all parents and self
	13	def self_and_ancestors
	14	nested_set_scope.
	15	where(arel_table[left_column_name].lteq(left)).
	16	where(arel_table[right_column_name].gteq(right))
	17	end
	18
	19	# Returns the collection of all children of the parent, except self
	20	def siblings
	21	without_self self_and_siblings
	22	end
	23
	24	# Returns the collection of all children of the parent, including self
	25	def self_and_siblings
	26	nested_set_scope.children_of parent_id
	27	end
	28
	29	# Returns a set of all of its nested children which do not have children
	30	def leaves
	31	descendants.where(
	32	"#{quoted_right_column_full_name} - #{quoted_left_column_full_name} = 1"
	33	)
	34	end
	35
	36	# Returns the level of this object in the tree
	37	# root level is 0
	38	def level
	39	parent_id.nil? ? 0 : compute_level
	40	end
	41
	42	# Returns a collection including all of its children and nested children
	43	def descendants
	44	without_self self_and_descendants
	45	end
	46
	47	# Returns a collection including itself and all of its nested children
	48	def self_and_descendants
	49	# using _left_ for both sides here lets us benefit from an index on that column if one exists
	50	nested_set_scope.right_of(left).left_of(right)
	51	end
	52
	53	def is_descendant_of?(other)
	54	within_node?(other, self) && same_scope?(other)
	55	end
	56
	57	def is_or_is_descendant_of?(other)
	58	(other == self \|\| within_node?(other, self)) && same_scope?(other)
	59	end
	60
	61	def is_ancestor_of?(other)
	62	within_node?(self, other) && same_scope?(other)
	63	end
	64
	65	def is_or_is_ancestor_of?(other)
	66	(self == other \|\| within_node?(self, other)) && same_scope?(other)
	67	end
	68
	69	# Check if other model is in the same scope
	70	def same_scope?(other)
	71	Array(acts_as_nested_set_options[:scope]).all? do \|attr\|
	72	self.send(attr) == other.send(attr)
	73	end
	74	end
	75
	76	# Find the first sibling to the left
	77	def left_sibling
	78	siblings.left_of(left).last
	79	end
	80
	81	# Find the first sibling to the right
	82	def right_sibling
	83	siblings.right_of(left).first
	84	end
	85
	86	def root
	87	return self_and_ancestors.children_of(nil).first if persisted?
	88
	89	if parent_id && current_parent = nested_set_scope.find(parent_id)
	90	current_parent.root
	91	else
	92	self
	93	end
	94	end
	95
	96	protected
	97
	98	def compute_level
	99	node, nesting = determine_depth
	100
	101	node == self ? ancestors.count : node.level + nesting
	102	end
	103
	104	def determine_depth(node = self, nesting = 0)
	105	while (association = node.association(:parent)).loaded? && association.target
	106	nesting += 1
	107	node = node.parent
	108	end if node.respond_to?(:association)
	109
	110	[node, nesting]
	111	end
	112
	113	def within_node?(node, within)
	114	node.left < within.left && within.left < node.right
	115	end
	116
	117	end
	118	end
	119	end
	120	end
	121	end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/model/transactable.rb created 644 +27 0

@@ -0,0 +1,27
	1	module CollectiveIdea #:nodoc:
	2	module Acts #:nodoc:
	3	module NestedSet #:nodoc:
	4	module Model
	5	module Transactable
	6
	7	protected
	8	def in_tenacious_transaction(&block)
	9	retry_count = 0
	10	begin
	11	transaction(&block)
	12	rescue ActiveRecord::StatementInvalid => error
	13	raise unless connection.open_transactions.zero?
	14	raise unless error.message =~ /Deadlock found when trying to get lock\|Lock wait timeout exceeded/
	15	raise unless retry_count < 10
	16	retry_count += 1
	17	logger.info "Deadlock detected on retry #{retry_count}, restarting transaction"
	18	sleep(rand(retry_count)*0.1) # Aloha protocol
	19	retry
	20	end
	21	end
	22
	23	end
	24	end
	25	end
	26	end
	27	end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/model/validatable.rb created 644 +69 0

@@ -0,0 +1,69
	1	require 'awesome_nested_set/set_validator'
	2
	3	module CollectiveIdea
	4	module Acts
	5	module NestedSet
	6	module Model
	7	module Validatable
	8
	9	def valid?
	10	left_and_rights_valid? && no_duplicates_for_columns? && all_roots_valid?
	11	end
	12
	13	def left_and_rights_valid?
	14	SetValidator.new(self).valid?
	15	end
	16
	17	def no_duplicates_for_columns?
	18	[quoted_left_column_full_name, quoted_right_column_full_name].all? do \|column\|
	19	# No duplicates
	20	select("#{scope_string}#{column}, COUNT(#{column})").
	21	group("#{scope_string}#{column}").
	22	having("COUNT(#{column}) > 1").
	23	first.nil?
	24	end
	25	end
	26
	27	# Wrapper for each_root_valid? that can deal with scope.
	28	def all_roots_valid?
	29	if acts_as_nested_set_options[:scope]
	30	all_roots_valid_by_scope?(roots)
	31	else
	32	each_root_valid?(roots)
	33	end
	34	end
	35
	36	def all_roots_valid_by_scope?(roots_to_validate)
	37	roots_grouped_by_scope(roots_to_validate).all? do \|scope, grouped_roots\|
	38	each_root_valid?(grouped_roots)
	39	end
	40	end
	41
	42	def each_root_valid?(roots_to_validate)
	43	left = right = 0
	44	roots_to_validate.all? do \|root\|
	45	(root.left > left && root.right > right).tap do
	46	left = root.left
	47	right = root.right
	48	end
	49	end
	50	end
	51
	52	private
	53	def roots_grouped_by_scope(roots_to_group)
	54	roots_to_group.group_by {\|record\|
	55	scope_column_names.collect {\|col\| record.send(col) }
	56	}
	57	end
	58
	59	def scope_string
	60	Array(acts_as_nested_set_options[:scope]).map do \|c\|
	61	connection.quote_column_name(c)
	62	end.push(nil).join(", ")
	63	end
	64
	65	end
	66	end
	67	end
	68	end
	69	end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/move.rb created 644 +117 0

@@ -0,0 +1,117
	1	module CollectiveIdea #:nodoc:
	2	module Acts #:nodoc:
	3	module NestedSet #:nodoc:
	4	class Move
	5	attr_reader :target, :position, :instance
	6
	7	def initialize(target, position, instance)
	8	@target = target
	9	@position = position
	10	@instance = instance
	11	end
	12
	13	def move
	14	prevent_impossible_move
	15
	16	bound, other_bound = get_boundaries
	17
	18	# there would be no change
	19	return if bound == right \|\| bound == left
	20
	21	# we have defined the boundaries of two non-overlapping intervals,
	22	# so sorting puts both the intervals and their boundaries in order
	23	a, b, c, d = [left, right, bound, other_bound].sort
	24
	25	lock_nodes_between! a, d
	26
	27	nested_set_scope.where(where_statement(a, d)).
	28	update_all(conditions(a, b, c, d))
	29	end
	30
	31	private
	32
	33	delegate :left, :right, :left_column_name, :right_column_name,
	34	:quoted_left_column_name, :quoted_right_column_name,
	35	:quoted_parent_column_name, :parent_column_name, :nested_set_scope,
	36	:to => :instance
	37
	38	delegate :arel_table, :class, :to => :instance, :prefix => true
	39	delegate :base_class, :to => :instance_class, :prefix => :instance
	40
	41	def where_statement(left_bound, right_bound)
	42	instance_arel_table[left_column_name].in(left_bound..right_bound).
	43	or(instance_arel_table[right_column_name].in(left_bound..right_bound))
	44	end
	45
	46	def conditions(a, b, c, d)
	47	[
	48	case_condition_for_direction(:quoted_left_column_name) +
	49	case_condition_for_direction(:quoted_right_column_name) +
	50	case_condition_for_parent,
	51	{:a => a, :b => b, :c => c, :d => d, :id => instance.id, :new_parent => new_parent}
	52	]
	53	end
	54
	55	def case_condition_for_direction(column_name)
	56	column = send(column_name)
	57	"#{column} = CASE " +
	58	"WHEN #{column} BETWEEN :a AND :b " +
	59	"THEN #{column} + :d - :b " +
	60	"WHEN #{column} BETWEEN :c AND :d " +
	61	"THEN #{column} + :a - :c " +
	62	"ELSE #{column} END, "
	63	end
	64
	65	def case_condition_for_parent
	66	"#{quoted_parent_column_name} = CASE " +
	67	"WHEN #{instance_base_class.primary_key} = :id THEN :new_parent " +
	68	"ELSE #{quoted_parent_column_name} END"
	69	end
	70
	71	def lock_nodes_between!(left_bound, right_bound)
	72	# select the rows in the model between a and d, and apply a lock
	73	instance_base_class.right_of(left_bound).left_of_right_side(right_bound).
	74	select(:id).lock(true)
	75	end
	76
	77	def root
	78	position == :root
	79	end
	80
	81	def new_parent
	82	case position
	83	when :child
	84	target.id
	85	else
	86	target[parent_column_name]
	87	end
	88	end
	89
	90	def get_boundaries
	91	if (bound = target_bound) > right
	92	bound -= 1
	93	other_bound = right + 1
	94	else
	95	other_bound = left - 1
	96	end
	97	[bound, other_bound]
	98	end
	99
	100	def prevent_impossible_move
	101	if !root && !instance.move_possible?(target)
	102	raise ActiveRecord::ActiveRecordError, "Impossible move, target node cannot be inside moved tree."
	103	end
	104	end
	105
	106	def target_bound
	107	case position
	108	when :child; right(target)
	109	when :left; left(target)
	110	when :right; right(target) + 1
	111	else raise ActiveRecord::ActiveRecordError, "Position should be :child, :left, :right or :root ('#{position}' received)."
	112	end
	113	end
	114	end
	115	end
	116	end
	117	end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/set_validator.rb created 644 +63 0

@@ -0,0 +1,63
	1	module CollectiveIdea #:nodoc:
	2	module Acts #:nodoc:
	3	module NestedSet #:nodoc:
	4	class SetValidator
	5
	6	def initialize(model)
	7	@model = model
	8	@scope = model.scoped
	9	@parent = arel_table.alias('parent')
	10	end
	11
	12	def valid?
	13	query.count == 0
	14	end
	15
	16	private
	17
	18	attr_reader :model, :parent
	19	attr_accessor :scope
	20
	21	delegate :parent_column_name, :primary_key, :left_column_name, :right_column_name, :arel_table,
	22	:quoted_table_name, :quoted_parent_column_full_name, :quoted_left_column_full_name, :quoted_right_column_full_name, :quoted_left_column_name, :quoted_right_column_name,
	23	:to => :model
	24
	25	def query
	26	join_scope
	27	filter_scope
	28	end
	29
	30	def join_scope
	31	join_arel = arel_table.join(parent, Arel::Nodes::OuterJoin).on(parent[primary_key].eq(arel_table[parent_column_name]))
	32	self.scope = scope.joins(join_arel.join_sql)
	33	end
	34
	35	def filter_scope
	36	self.scope = scope.where(
	37	bound_is_null(left_column_name).
	38	or(bound_is_null(right_column_name)).
	39	or(left_bound_greater_than_right).
	40	or(parent_not_null.and(bounds_outside_parent))
	41	)
	42	end
	43
	44	def bound_is_null(column_name)
	45	arel_table[column_name].eq(nil)
	46	end
	47
	48	def left_bound_greater_than_right
	49	arel_table[left_column_name].gteq(arel_table[right_column_name])
	50	end
	51
	52	def parent_not_null
	53	arel_table[parent_column_name].not_eq(nil)
	54	end
	55
	56	def bounds_outside_parent
	57	arel_table[left_column_name].lteq(parent[left_column_name]).or(arel_table[right_column_name].gteq(parent[right_column_name]))
	58	end
	59
	60	end
	61	end
	62	end
	63	end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/tree.rb created 644 +63 0

@@ -0,0 +1,63
	1	module CollectiveIdea #:nodoc:
	2	module Acts #:nodoc:
	3	module NestedSet #:nodoc:
	4	class Tree
	5	attr_reader :model, :validate_nodes
	6	attr_accessor :indices
	7
	8	delegate :left_column_name, :right_column_name, :quoted_parent_column_full_name,
	9	:order_for_rebuild, :scope_for_rebuild,
	10	:to => :model
	11
	12	def initialize(model, validate_nodes)
	13	@model = model
	14	@validate_nodes = validate_nodes
	15	@indices = {}
	16	end
	17
	18	def rebuild!
	19	# Don't rebuild a valid tree.
	20	return true if model.valid?
	21
	22	root_nodes.each do \|root_node\|
	23	# setup index for this scope
	24	indices[scope_for_rebuild.call(root_node)] \|\|= 0
	25	set_left_and_rights(root_node)
	26	end
	27	end
	28
	29	private
	30
	31	def increment_indice!(node)
	32	indices[scope_for_rebuild.call(node)] += 1
	33	end
	34
	35	def set_left_and_rights(node)
	36	set_left!(node)
	37	# find
	38	node_children(node).each { \|n\| set_left_and_rights(n) }
	39	set_right!(node)
	40
	41	node.save!(:validate => validate_nodes)
	42	end
	43
	44	def node_children(node)
	45	model.where(["#{quoted_parent_column_full_name} = ? #{scope_for_rebuild.call(node)}", node]).
	46	order(order_for_rebuild)
	47	end
	48
	49	def root_nodes
	50	model.where("#{quoted_parent_column_full_name} IS NULL").order(order_for_rebuild)
	51	end
	52
	53	def set_left!(node)
	54	node[left_column_name] = increment_indice!(node)
	55	end
	56
	57	def set_right!(node)
	58	node[right_column_name] = increment_indice!(node)
	59	end
	60	end
	61	end
	62	end
	63	end

lib/plugins/awesome_nested_set/.travis.yml +1 -4

             language: ruby
-            notifications:
-              email:
-                - parndt@gmail.com
             script: bundle exec rspec spec
             env:
               - DB=sqlite3
               - DB=sqlite3mem
               - DB=postgresql
               - DB=mysql
             rvm:
               - 2.0.0
               - 1.9.3
-              - 1.8.7
               - rbx-19mode
               - jruby-19mode
+              - 1.8.7
               - rbx-18mode
               - jruby-18mode
             gemfile:
               - gemfiles/Gemfile.rails-3.0.rb
               - gemfiles/Gemfile.rails-3.1.rb
               - gemfiles/Gemfile.rails-3.2.rb

lib/plugins/awesome_nested_set/Gemfile +4 -3

-            gem 'combustion', :github => 'pat/combustion'
+            gem 'combustion', :github => 'pat/combustion', :branch => 'master'
             source 'https://rubygems.org'
             gemspec :path => File.expand_path('../', __FILE__)
             platforms :jruby do
               gem 'activerecord-jdbcsqlite3-adapter'
               gem 'activerecord-jdbcmysql-adapter'
+              gem 'jdbc-mysql'
               gem 'activerecord-jdbcpostgresql-adapter'
               gem 'jruby-openssl'
             end
             platforms :ruby do
               gem 'sqlite3'
               gem 'mysql2', (MYSQL2_VERSION if defined? MYSQL2_VERSION)
               gem 'pg'
             end
             RAILS_VERSION = nil unless defined? RAILS_VERSION
             gem 'railties', RAILS_VERSION
             gem 'activerecord', RAILS_VERSION
             gem 'actionpack', RAILS_VERSION
             # Add Oracle Adapters
             # gem 'ruby-oci8'
             # gem 'activerecord-oracle_enhanced-adapter'
             # Debuggers
-            # gem 'pry'
+            gem 'pry'
-            # gem 'pry-nav'
+            gem 'pry-nav'

lib/plugins/awesome_nested_set/README.md ~~lib/plugins/awesome_nested_set/README.rdoc~~ renamed +105 -95

@@ -1,153 +1,163
1	= AwesomeNestedSet	1	# AwesomeNestedSet
2		2
3	Awesome Nested Set is an implementation of the nested set pattern for ActiveRecord models. ~~It is replacement for acts_as_nested_set and BetterNestedSet, but more awesome.~~	3	Awesome Nested Set is an implementation of the nested set pattern for ActiveRecord models.
		4	It is a replacement for acts_as_nested_set and BetterNestedSet, but more awesome.
4		5
5	Version 2 supports Rails 3. Gem versions prior to 2.0 support Rails 2.	6	Version 2 supports Rails 3. Gem versions prior to 2.0 support Rails 2.
6		7
7	== What makes this so awesome?	8	## What makes this so awesome?
8		9
9	This is a new implementation of nested set based off of BetterNestedSet that fixes some bugs, removes tons of duplication, adds a few useful methods, and adds STI support.	10	This is a new implementation of nested set based off of BetterNestedSet that fixes some bugs, removes tons of duplication, adds a few useful methods, and adds STI support.
10		11
11	== Installation	12	[![Code Climate](https://codeclimate.com/github/collectiveidea/awesome_nested_set.png)](https://codeclimate.com/github/collectiveidea/awesome_nested_set)
12		13
13	Add to your Gemfile:	14	## Installation
14		15
15	gem 'awesome_nested_set'	16	Add to your Gemfile:
16		17
17	== Usage	18	```ruby
		19	gem 'awesome_nested_set'
		20	```
18		21
19	To make use of awesome_nested_set, your model needs to have 3 fields: lft, rgt, and parent_id.	22	## Usage
20	You can also have an optional field: depth:
21		23
22	class CreateCategories < ActiveRecord::Migration	24	To make use of `awesome_nested_set`, your model needs to have 3 fields:
23	def self.up	25	`lft`, `rgt`, and `parent_id`. The names of these fields are configurable.
24	create_table :categories do \|t\|	26	You can also have an optional field, `depth`:
25	t.string :name
26	t.integer :parent_id
27	t.integer :lft
28	t.integer :rgt
29	t.integer :depth # this is optional.
30	end
31	end
32		27
33	def self.down	28	```ruby
34	drop_table :categories	29	class CreateCategories < ActiveRecord::Migration
		30	def self.up
		31	create_table :categories do \|t\|
		32	t.string :name
		33	t.integer :parent_id
		34	t.integer :lft
		35	t.integer :rgt
		36	t.integer :depth # this is optional.
35	end	37	end
36	end	38	end
37		39
38	Enable the nested set functionality by declaring acts_as_nested_set on your model	40	def self.down
39		41	drop_table :categories
40	class Category < ActiveRecord::Base
41	acts_as_nested_set
42	end	42	end
		43	end
		44	```
43		45
44	Run `rake rdoc` to generate the API docs and see CollectiveIdea::Acts::NestedSet for more info.	46	Enable the nested set functionality by declaring `acts_as_nested_set` on your model
45		47
46	== Callbacks	48	```ruby
		49	class Category < ActiveRecord::Base
		50	acts_as_nested_set
		51	end
		52	```
47		53
48	There are three callbacks called when moving a node. `before_move`, `after_move` and `around_move`.	54	Run `rake rdoc` to generate the API docs and see [CollectiveIdea::Acts::NestedSet](lib/awesome_nested_set/awesome_nested_set.rb) for more information.
49		55
50	class Category < ActiveRecord::Base	56	## Callbacks
51	acts_as_nested_set
52		57
53	after_move :rebuild_slug	58	There are three callbacks called when moving a node:
54	around_move :da_fancy_things_around	59	`before_move`, `after_move` and `around_move`.
55		60
56	private	61	```ruby
57		62	class Category < ActiveRecord::Base
58	def rebuild_slug	63	acts_as_nested_set
59	# do whatever
60	end
61		64
62	def da_fancy_things_around	65	after_move :rebuild_slug
63	# do something...	66	around_move :da_fancy_things_around
64	yield # actually moves	67
65	# do something else...	68	private
66	end	69
		70	def rebuild_slug
		71	# do whatever
67	end	72	end
68		73
		74	def da_fancy_things_around
		75	# do something...
		76	yield # actually moves
		77	# do something else...
		78	end
		79	end
		80	```
		81
69	Beside this there are also hooks to act on the newly added or removed children.	82	Beside this there are also hooks to act on the newly added or removed children.
70		83
71	class Category < ActiveRecord::Base	84	```ruby
72	acts_as_nested_set :before_add => :do_before_add_stuff,	85	class Category < ActiveRecord::Base
73	:after_add => :do_after_add_stuff,	86	acts_as_nested_set :before_add => :do_before_add_stuff,
74	~~:before_remove => :do_before_remove~~_stuff,	87	:after_add => :do_after_add_stuff,
75	~~:after~~_remove => :do_~~after~~_remove_stuff	88	:before_remove => :do_before_remove_stuff,
		89	:after_remove => :do_after_remove_stuff
76		90
77	private	91	private
78		92
79	def do_before_add_stuff(child_node)	93	def do_before_add_stuff(child_node)
80	# do whatever with the child	94	# do whatever with the child
81	end	95	end
82
83	def do_after_add_stuff(child_node)
84	# do whatever with the child
85	end
86		96
87	def do_~~before_remove~~_stuff(child_node)	97	def do_after_add_stuff(child_node)
88	# do whatever with the child	98	# do whatever with the child
89	end	99	end
90		100
91	def do_~~after~~_remove_stuff(child_node)	101	def do_before_remove_stuff(child_node)
92	# do whatever with the child	102	# do whatever with the child
93	end
94	end	103	end
95		104
		105	def do_after_remove_stuff(child_node)
		106	# do whatever with the child
		107	end
		108	end
		109	```
96		110
97	== Protecting attributes from mass assignment	111	## Protecting attributes from mass assignment
98		112
99	It's generally best to "white list" the attributes that can be used in mass assignment:	113	It's generally best to "whitelist" the attributes that can be used in mass assignment:
100		114
101	class Category < ActiveRecord::Base	115	```ruby
102	acts_as_nested_set	116	class Category < ActiveRecord::Base
103	attr_accessible :name, :parent_id	117	acts_as_nested_set
104	end	118	attr_accessible :name, :parent_id
		119	end
		120	```
105		121
106	If for some reason that is not possible, you will probably want to protect the lft and rgt attributes:	122	If for some reason that is not possible, you will probably want to protect the `lft` and `rgt` attributes:
107		123
108	class Category < ActiveRecord::Base	124	```ruby
109	acts_as_nested_set	125	class Category < ActiveRecord::Base
110	attr_protected :lft, :rgt	126	acts_as_nested_set
111	end	127	attr_protected :lft, :rgt
		128	end
		129	```
112		130
113	== Conversion from other trees	131	## Conversion from other trees
114		132
115	Coming from acts_as_tree or another system where you only have a parent_id? No problem. Simply add the lft & rgt fields as above, and then run	133	Coming from acts_as_tree or another system where you only have a parent_id? No problem. Simply add the lft & rgt fields as above, and then run:
116		134
117	Category.rebuild!	135	```ruby
		136	Category.rebuild!
		137	```
118		138
119	Your tree will be converted to a valid nested set. Awesome!	139	Your tree will be converted to a valid nested set. Awesome!
120		140
121	== View Helper	141	## View Helper
122		142
123	The view helper is called #nested_set_options.	143	The view helper is called #nested_set_options.
124		144
125	Example usage:	145	Example usage:
126		146
127	<%= f.select :parent_id, nested_set_options(Category, @category) {\|i\| "#{'-' * i.level} #{i.name}" } %>	147	```erb
		148	<%= f.select :parent_id, nested_set_options(Category, @category) {\|i\| "#{'-' * i.level} #{i.name}" } %>
128		149
129	<%= select_tag 'parent_id', options_for_select(nested_set_options(Category) {\|i\| "#{'-' * i.level} #{i.name}" } ) %>	150	<%= select_tag 'parent_id', options_for_select(nested_set_options(Category) {\|i\| "#{'-' * i.level} #{i.name}" } ) %>
		151	```
130		152
131	See CollectiveIdea::Acts::NestedSet::Helper for more information about the helpers.	153	See [CollectiveIdea::Acts::NestedSet::Helper](lib/awesome_nested_set/helper.rb) for more information about the helpers.
132		154
133	== References	155	## References
134		156
135	You can learn more about nested sets at: http://threebit.net/tutorials/nestedset/tutorial1.html	157	You can learn more about nested sets at: http://threebit.net/tutorials/nestedset/tutorial1.html
136		158
137	== How to contribute	159	## How to contribute
138
139	If you find what you might think is a bug:
140
141	1. Check the GitHub issue tracker to see if anyone else has had the same issue.
142	https://github.com/collectiveidea/awesome_nested_set/issues/
143	2. If you don't see anything, create an issue with information on how to reproduce it.
144
145	If you want to contribute an enhancement or a fix:
146		160
147	1. Fork the project on GitHub.	161	Please see the ['Contributing' document](CONTRIBUTING.md).
148	https://github.com/collectiveidea/awesome_nested_set/
149	2. Make your changes with tests.
150	3. Commit the changes without making changes to the Rakefile, VERSION, or any other files that aren't related to your enhancement or fix
151	4. Send a pull request.
152		162
153	Copyright ©2008 Collective Idea, released under the MIT license	163	Copyright © 2008 - 2013 Collective Idea, released under the MIT license

lib/plugins/awesome_nested_set/awesome_nested_set.gemspec +3 -3

             # -*- encoding: utf-8 -*-
             require File.expand_path('../lib/awesome_nested_set/version', __FILE__)
             Gem::Specification.new do |s|
               s.name = %q{awesome_nested_set}
               s.version = ::AwesomeNestedSet::VERSION
               s.authors = ["Brandon Keepers", "Daniel Morrison", "Philip Arndt"]
               s.description = %q{An awesome nested set implementation for Active Record}
               s.email = %q{info@collectiveidea.com}
-              s.extra_rdoc_files = %w[README.rdoc]
+              s.files = Dir.glob("lib/**/*") + %w(MIT-LICENSE README.md CHANGELOG)
-              s.files = Dir.glob("lib/**/*") + %w(MIT-LICENSE README.rdoc CHANGELOG)
               s.homepage = %q{http://github.com/collectiveidea/awesome_nested_set}
-              s.rdoc_options = ["--main", "README.rdoc", "--inline-source", "--line-numbers"]
+              s.rdoc_options = ["--inline-source", "--line-numbers"]
               s.require_paths = ["lib"]
               s.rubygems_version = %q{1.3.6}
               s.summary = %q{An awesome nested set implementation for Active Record}
               s.license = %q{MIT}
               s.add_runtime_dependency 'activerecord', '>= 3.0.0'
               s.add_development_dependency 'rspec-rails', '~> 2.12'
               s.add_development_dependency 'rake', '~> 10'
               s.add_development_dependency 'combustion', '>= 0.3.3'
+              s.add_development_dependency 'database_cleaner'
             end

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

             require 'awesome_nested_set/awesome_nested_set'
             require 'active_record'
             ActiveRecord::Base.send :extend, CollectiveIdea::Acts::NestedSet
             if defined?(ActionView)
               require 'awesome_nested_set/helper'
               ActionView::Base.send :include, CollectiveIdea::Acts::NestedSet::Helper
-            end
  No newline at end of file
+            end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/awesome_nested_set.rb +58 -697

This diff has been collapsed as it changes many lines, (755 lines changed) Show them Hide them
	@@ -1,772 +1,133
			1	require 'awesome_nested_set/columns'
			2	require 'awesome_nested_set/model'
			3
	1	module CollectiveIdea #:nodoc:	4	module CollectiveIdea #:nodoc:
	2	module Acts #:nodoc:	5	module Acts #:nodoc:
	3	module NestedSet #:nodoc:	6	module NestedSet #:nodoc:
	4		7
	5	# This acts provides Nested Set functionality. Nested Set is a smart way to implement	8	# This acts provides Nested Set functionality. Nested Set is a smart way to implement
	6	# an _ordered_ tree, with the added feature that you can select the children and all of their	9	# an _ordered_ tree, with the added feature that you can select the children and all of their
	7	# descendants with a single query. The drawback is that insertion or move need some complex	10	# descendants with a single query. The drawback is that insertion or move need some complex
	8	# sql queries. But everything is done here by this module!	11	# sql queries. But everything is done here by this module!
	9	#	12	#
	10	# Nested sets are appropriate each time you want either an orderd tree (menus,	13	# Nested sets are appropriate each time you want either an orderd tree (menus,
	11	# commercial categories) or an efficient way of querying big trees (threaded posts).	14	# commercial categories) or an efficient way of querying big trees (threaded posts).
	12	#	15	#
	13	# == API	16	# == API
	14	#	17	#
	15	# Methods names are aligned with acts_as_tree as much as possible to make replacment from one	18	# Methods names are aligned with acts_as_tree as much as possible to make replacment from one
	16	# by another easier.	19	# by another easier.
	17	#	20	#
	18	# item.children.create(:name => "child1")	21	# item.children.create(:name => "child1")
	19	#	22	#
	20		23
	21	# Configuration options are:	24	# Configuration options are:
	22	#	25	#
	23	# * +:parent_column+ - specifies the column name to use for keeping the position integer (default: parent_id)	26	# * +:parent_column+ - specifies the column name to use for keeping the position integer (default: parent_id)
	24	# * +:left_column+ - column name for left boundry data, default "lft"	27	# * +:left_column+ - column name for left boundry data, default "lft"
	25	# * +:right_column+ - column name for right boundry data, default "rgt"	28	# * +:right_column+ - column name for right boundry data, default "rgt"
	26	# * +:depth_column+ - column name for the depth data, default "depth"	29	# * +:depth_column+ - column name for the depth data, default "depth"
	27	# * +:scope+ - restricts what is to be considered a list. Given a symbol, it'll attach "_id"	30	# * +:scope+ - restricts what is to be considered a list. Given a symbol, it'll attach "_id"
	28	# (if it hasn't been already) and use that as the foreign key restriction. You	31	# (if it hasn't been already) and use that as the foreign key restriction. You
	29	# can also pass an array to scope by multiple attributes.	32	# can also pass an array to scope by multiple attributes.
	30	# Example: <tt>acts_as_nested_set :scope => [:notable_id, :notable_type]</tt>	33	# Example: <tt>acts_as_nested_set :scope => [:notable_id, :notable_type]</tt>
	31	# * +:dependent+ - behavior for cascading destroy. If set to :destroy, all the	34	# * +:dependent+ - behavior for cascading destroy. If set to :destroy, all the
	32	# child objects are destroyed alongside this object by calling their destroy	35	# child objects are destroyed alongside this object by calling their destroy
	33	# method. If set to :delete_all (default), all the child objects are deleted	36	# method. If set to :delete_all (default), all the child objects are deleted
	34	# without calling their destroy method.	37	# without calling their destroy method.
	35	# * +:counter_cache+ adds a counter cache for the number of children.	38	# * +:counter_cache+ adds a counter cache for the number of children.
	36	# defaults to false.	39	# defaults to false.
	37	# Example: <tt>acts_as_nested_set :counter_cache => :children_count</tt>	40	# Example: <tt>acts_as_nested_set :counter_cache => :children_count</tt>
	38	# * +:order_column+ on which column to do sorting, by default it is the left_column_name	41	# * +:order_column+ on which column to do sorting, by default it is the left_column_name
	39	# Example: <tt>acts_as_nested_set :order_column => :position</tt>	42	# Example: <tt>acts_as_nested_set :order_column => :position</tt>
	40	#	43	#
	41	# See CollectiveIdea::Acts::NestedSet::Model::ClassMethods for a list of class methods and	44	# See CollectiveIdea::Acts::NestedSet::Model::ClassMethods for a list of class methods and
	42	# CollectiveIdea::Acts::NestedSet::Model for a list of instance methods added	45	# CollectiveIdea::Acts::NestedSet::Model for a list of instance methods added
	43	# to acts_as_nested_set models	46	# to acts_as_nested_set models
	44	def acts_as_nested_set(options = {})	47	def acts_as_nested_set(options = {})
	45	options = {	48	acts_as_nested_set_parse_options! options
	46	:parent_column => 'parent_id',
	47	:left_column => 'lft',
	48	:right_column => 'rgt',
	49	:depth_column => 'depth',
	50	:dependent => :delete_all, # or :destroy
	51	:polymorphic => false,
	52	:counter_cache => false
	53	}.merge(options)
	54
	55	if options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/
	56	options[:scope] = "#{options[:scope]}_id".intern
	57	end
	58
	59	class_attribute :acts_as_nested_set_options
	60	self.acts_as_nested_set_options = options
	61		49
	62	include CollectiveIdea::Acts::NestedSet::Model	50	include Model
	63	include Columns	51	include Columns
	64	extend Columns	52	extend Columns
	65		53
	66	belongs_to :parent, :class_name => self.base_class.to_s,	54	acts_as_nested_set_relate_parent!
	67	:foreign_key => parent_column_name,	55	acts_as_nested_set_relate_children!
	68	:counter_cache => options[:counter_cache],
	69	:inverse_of => (:children unless options[:polymorphic]),
	70	:polymorphic => options[:polymorphic]
	71
	72	has_many_children_options = {
	73	:class_name => self.base_class.to_s,
	74	:foreign_key => parent_column_name,
	75	:order => order_column,
	76	:inverse_of => (:parent unless options[:polymorphic]),
	77	}
	78
	79	# Add callbacks, if they were supplied.. otherwise, we don't want them.
	80	[:before_add, :after_add, :before_remove, :after_remove].each do \|ar_callback\|
	81	has_many_children_options.update(ar_callback => options[ar_callback]) if options[ar_callback]
	82	end
	83
	84	has_many :children, has_many_children_options
	85		56
	86	attr_accessor :skip_before_destroy	57	attr_accessor :skip_before_destroy
	87		58
			59	acts_as_nested_set_prevent_assignment_to_reserved_columns!
			60	acts_as_nested_set_define_callbacks!
			61	end
			62
			63	private
			64	def acts_as_nested_set_define_callbacks!
			65	# on creation, set automatically lft and rgt to the end of the tree
	88	before_create :set_default_left_and_right	66	before_create :set_default_left_and_right
	89	before_save :store_new_parent	67	before_save :store_new_parent
	90	after_save :move_to_new_parent, :set_depth!	68	after_save :move_to_new_parent, :set_depth!
	91	before_destroy :destroy_descendants	69	before_destroy :destroy_descendants
	92		70
	93	# no assignment to structure fields
	94	[left_column_name, right_column_name, depth_column_name].each do \|column\|
	95	module_eval <<-"end_eval", __FILE__, __LINE__
	96	def #{column}=(x)
	97	raise ActiveRecord::ActiveRecordError, "Unauthorized assignment to #{column}: it's an internal field handled by acts_as_nested_set code, use move_to_* methods instead."
	98	end
	99	end_eval
	100	end
	101
	102	define_model_callbacks :move	71	define_model_callbacks :move
	103	end	72	end
	104		73
	105	module Model	74	def acts_as_nested_set_relate_children!
	106	extend ActiveSupport::Concern	75	has_many_children_options = {
	107		76	:class_name => self.base_class.to_s,
	108	included do	77	:foreign_key => parent_column_name,
	109	delegate :quoted_table_name, :to => self	78	:order => quoted_order_column_name,
	110	end	79	:inverse_of => (:parent unless acts_as_nested_set_options[:polymorphic]),
	111		80	}
	112	module ClassMethods
	113	# Returns the first root
	114	def root
	115	roots.first
	116	end
	117
	118	def roots
	119	where(parent_column_name => nil).order(quoted_left_column_full_name)
	120	end
	121
	122	def leaves
	123	where("#{quoted_right_column_full_name} - #{quoted_left_column_full_name} = 1").order(quoted_left_column_full_name)
	124	end
	125
	126	def valid?
	127	left_and_rights_valid? && no_duplicates_for_columns? && all_roots_valid?
	128	end
	129
	130	def left_and_rights_valid?
	131	## AS clause not supported in Oracle in FROM clause for aliasing table name
	132	joins("LEFT OUTER JOIN #{quoted_table_name}" +
	133	(connection.adapter_name.match(/Oracle/).nil? ? " AS " : " ") +
	134	"parent ON " +
	135	"#{quoted_parent_column_full_name} = parent.#{primary_key}").
	136	where(
	137	"#{quoted_left_column_full_name} IS NULL OR " +
	138	"#{quoted_right_column_full_name} IS NULL OR " +
	139	"#{quoted_left_column_full_name} >= " +
	140	"#{quoted_right_column_full_name} OR " +
	141	"(#{quoted_parent_column_full_name} IS NOT NULL AND " +
	142	"(#{quoted_left_column_full_name} <= parent.#{quoted_left_column_name} OR " +
	143	"#{quoted_right_column_full_name} >= parent.#{quoted_right_column_name}))"
	144	).count == 0
	145	end
	146
	147	def no_duplicates_for_columns?
	148	scope_string = Array(acts_as_nested_set_options[:scope]).map do \|c\|
	149	connection.quote_column_name(c)
	150	end.push(nil).join(", ")
	151	[quoted_left_column_full_name, quoted_right_column_full_name].all? do \|column\|
	152	# No duplicates
	153	select("#{scope_string}#{column}, COUNT(#{column})").
	154	group("#{scope_string}#{column}").
	155	having("COUNT(#{column}) > 1").
	156	first.nil?
	157	end
	158	end
	159
	160	# Wrapper for each_root_valid? that can deal with scope.
	161	def all_roots_valid?
	162	if acts_as_nested_set_options[:scope]
	163	roots.group_by {\|record\| scope_column_names.collect {\|col\| record.send(col.to_sym) } }.all? do \|scope, grouped_roots\|
	164	each_root_valid?(grouped_roots)
	165	end
	166	else
	167	each_root_valid?(roots)
	168	end
	169	end
	170
	171	def each_root_valid?(roots_to_validate)
	172	left = right = 0
	173	roots_to_validate.all? do \|root\|
	174	(root.left > left && root.right > right).tap do
	175	left = root.left
	176	right = root.right
	177	end
	178	end
	179	end
	180
	181	# Rebuilds the left & rights if unset or invalid.
	182	# Also very useful for converting from acts_as_tree.
	183	def rebuild!(validate_nodes = true)
	184	# default_scope with order may break database queries so we do all operation without scope
	185	unscoped do
	186	# Don't rebuild a valid tree.
	187	return true if valid?
	188
	189	scope = lambda{\|node\|}
	190	if acts_as_nested_set_options[:scope]
	191	scope = lambda{\|node\|
	192	scope_column_names.inject(""){\|str, column_name\|
	193	str << "AND #{connection.quote_column_name(column_name)} = #{connection.quote(node.send(column_name.to_sym))} "
	194	}
	195	}
	196	end
	197	indices = {}
	198
	199	set_left_and_rights = lambda do \|node\|
	200	# set left
	201	node[left_column_name] = indices[scope.call(node)] += 1
	202	# find
	203	where(["#{quoted_parent_column_full_name} = ? #{scope.call(node)}", node]).order("#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, id").each{\|n\| set_left_and_rights.call(n) }
	204	# set right
	205	node[right_column_name] = indices[scope.call(node)] += 1
	206	node.save!(:validate => validate_nodes)
	207	end
	208
	209	# Find root node(s)
	210	root_nodes = where("#{quoted_parent_column_full_name} IS NULL").order("#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, id").each do \|root_node\|
	211	# setup index for this scope
	212	indices[scope.call(root_node)] \|\|= 0
	213	set_left_and_rights.call(root_node)
	214	end
	215	end
	216	end
	217
	218	# Iterates over tree elements and determines the current level in the tree.
	219	# Only accepts default ordering, odering by an other column than lft
	220	# does not work. This method is much more efficent than calling level
	221	# because it doesn't require any additional database queries.
	222	#
	223	# Example:
	224	# Category.each_with_level(Category.root.self_and_descendants) do \|o, level\|
	225	#
	226	def each_with_level(objects)
	227	path = [nil]
	228	objects.each do \|o\|
	229	if o.parent_id != path.last
	230	# we are on a new level, did we descend or ascend?
	231	if path.include?(o.parent_id)
	232	# remove wrong wrong tailing paths elements
	233	path.pop while path.last != o.parent_id
	234	else
	235	path << o.parent_id
	236	end
	237	end
	238	yield(o, path.length - 1)
	239	end
	240	end
	241
	242	# Same as each_with_level - Accepts a string as a second argument to sort the list
	243	# Example:
	244	# Category.each_with_level(Category.root.self_and_descendants, :sort_by_this_column) do \|o, level\|
	245	def sorted_each_with_level(objects, order)
	246	path = [nil]
	247	children = []
	248	objects.each do \|o\|
	249	children << o if o.leaf?
	250	if o.parent_id != path.last
	251	if !children.empty? && !o.leaf?
	252	children.sort_by! &order
	253	children.each { \|c\| yield(c, path.length-1) }
	254	children = []
	255	end
	256	# we are on a new level, did we decent or ascent?
	257	if path.include?(o.parent_id)
	258	# remove wrong wrong tailing paths elements
	259	path.pop while path.last != o.parent_id
	260	else
	261	path << o.parent_id
	262	end
	263	end
	264	yield(o,path.length-1) if !o.leaf?
	265	end
	266	if !children.empty?
	267	children.sort_by! &order
	268	children.each { \|c\| yield(c, path.length-1) }
	269	end
	270	end
	271
	272	def associate_parents(objects)
	273	if objects.all?{\|o\| o.respond_to?(:association)}
	274	id_indexed = objects.index_by(&:id)
	275	objects.each do \|object\|
	276	if !(association = object.association(:parent)).loaded? && (parent = id_indexed[object.parent_id])
	277	association.target = parent
	278	association.set_inverse_instance(parent)
	279	end
	280	end
	281	else
	282	objects
	283	end
	284	end
	285	end
	286
	287	# Any instance method that returns a collection makes use of Rails 2.1's named_scope (which is bundled for Rails 2.0), so it can be treated as a finder.
	288	#
	289	# category.self_and_descendants.count
	290	# category.ancestors.find(:all, :conditions => "name like '%foo%'")
	291	# Value of the parent column
	292	def parent_id
	293	self[parent_column_name]
	294	end
	295
	296	# Value of the left column
	297	def left
	298	self[left_column_name]
	299	end
	300
	301	# Value of the right column
	302	def right
	303	self[right_column_name]
	304	end
	305
	306	# Returns true if this is a root node.
	307	def root?
	308	parent_id.nil?
	309	end
	310
	311	# Returns true if this is the end of a branch.
	312	def leaf?
	313	persisted? && right.to_i - left.to_i == 1
	314	end
	315
	316	# Returns true is this is a child node
	317	def child?
	318	!root?
	319	end
	320
	321	# Returns root
	322	def root
	323	if persisted?
	324	self_and_ancestors.where(parent_column_name => nil).first
	325	else
	326	if parent_id && current_parent = nested_set_scope.find(parent_id)
	327	current_parent.root
	328	else
	329	self
	330	end
	331	end
	332	end
	333
	334	# Returns the array of all parents and self
	335	def self_and_ancestors
	336	nested_set_scope.where([
	337	"#{quoted_left_column_full_name} <= ? AND #{quoted_right_column_full_name} >= ?", left, right
	338	])
	339	end
	340
	341	# Returns an array of all parents
	342	def ancestors
	343	without_self self_and_ancestors
	344	end
	345
	346	# Returns the array of all children of the parent, including self
	347	def self_and_siblings
	348	nested_set_scope.where(parent_column_name => parent_id)
	349	end
	350
	351	# Returns the array of all children of the parent, except self
	352	def siblings
	353	without_self self_and_siblings
	354	end
	355
	356	# Returns a set of all of its nested children which do not have children
	357	def leaves
	358	descendants.where("#{quoted_right_column_full_name} - #{quoted_left_column_full_name} = 1")
	359	end
	360
	361	# Returns the level of this object in the tree
	362	# root level is 0
	363	def level
	364	parent_id.nil? ? 0 : compute_level
	365	end
	366
	367	# Returns a set of itself and all of its nested children
	368	def self_and_descendants
	369	nested_set_scope.where([
	370	"#{quoted_left_column_full_name} >= ? AND #{quoted_left_column_full_name} < ?", left, right
	371	# using _left_ for both sides here lets us benefit from an index on that column if one exists
	372	])
	373	end
	374
	375	# Returns a set of all of its children and nested children
	376	def descendants
	377	without_self self_and_descendants
	378	end
	379
	380	def is_descendant_of?(other)
	381	other.left < self.left && self.left < other.right && same_scope?(other)
	382	end
	383
	384	def is_or_is_descendant_of?(other)
	385	other.left <= self.left && self.left < other.right && same_scope?(other)
	386	end
	387
	388	def is_ancestor_of?(other)
	389	self.left < other.left && other.left < self.right && same_scope?(other)
	390	end
	391
	392	def is_or_is_ancestor_of?(other)
	393	self.left <= other.left && other.left < self.right && same_scope?(other)
	394	end
	395
	396	# Check if other model is in the same scope
	397	def same_scope?(other)
	398	Array(acts_as_nested_set_options[:scope]).all? do \|attr\|
	399	self.send(attr) == other.send(attr)
	400	end
	401	end
	402
	403	# Find the first sibling to the left
	404	def left_sibling
	405	siblings.where(["#{quoted_left_column_full_name} < ?", left]).
	406	order("#{quoted_left_column_full_name} DESC").last
	407	end
	408
	409	# Find the first sibling to the right
	410	def right_sibling
	411	siblings.where(["#{quoted_left_column_full_name} > ?", left]).first
	412	end
	413
	414	# Shorthand method for finding the left sibling and moving to the left of it.
	415	def move_left
	416	move_to_left_of left_sibling
	417	end
	418
	419	# Shorthand method for finding the right sibling and moving to the right of it.
	420	def move_right
	421	move_to_right_of right_sibling
	422	end
	423
	424	# Move the node to the left of another node (you can pass id only)
	425	def move_to_left_of(node)
	426	move_to node, :left
	427	end
	428
	429	# Move the node to the left of another node (you can pass id only)
	430	def move_to_right_of(node)
	431	move_to node, :right
	432	end
	433
	434	# Move the node to the child of another node (you can pass id only)
	435	def move_to_child_of(node)
	436	move_to node, :child
	437	end
	438
	439	# Move the node to the child of another node with specify index (you can pass id only)
	440	def move_to_child_with_index(node, index)
	441	if node.children.empty?
	442	move_to_child_of(node)
	443	elsif node.children.count == index
	444	move_to_right_of(node.children.last)
	445	else
	446	move_to_left_of(node.children[index])
	447	end
	448	end
	449
	450	# Move the node to root nodes
	451	def move_to_root
	452	move_to nil, :root
	453	end
	454
	455	# Order children in a nested set by an attribute
	456	# Can order by any attribute class that uses the Comparable mixin, for example a string or integer
	457	# Usage example when sorting categories alphabetically: @new_category.move_to_ordered_child_of(@root, "name")
	458	def move_to_ordered_child_of(parent, order_attribute, ascending = true)
	459	self.move_to_root and return unless parent
	460	left = nil # This is needed, at least for the tests.
	461	parent.children.each do \|n\| # Find the node immediately to the left of this node.
	462	if ascending
	463	left = n if n.send(order_attribute) < self.send(order_attribute)
	464	else
	465	left = n if n.send(order_attribute) > self.send(order_attribute)
	466	end
	467	end
	468	self.move_to_child_of(parent)
	469	return unless parent.children.count > 1 # Only need to order if there are multiple children.
	470	if left # Self has a left neighbor.
	471	self.move_to_right_of(left)
	472	else # Self is the left most node.
	473	self.move_to_left_of(parent.children[0])
	474	end
	475	end
	476
	477	def move_possible?(target)
	478	self != target && # Can't target self
	479	same_scope?(target) && # can't be in different scopes
	480	# !(left..right).include?(target.left..target.right) # this needs tested more
	481	# detect impossible move
	482	!((left <= target.left && right >= target.left) or (left <= target.right && right >= target.right))
	483	end
	484
	485	def to_text
	486	self_and_descendants.map do \|node\|
	487	"#{''(node.level+1)} #{node.id} #{node.to_s} (#{node.parent_id}, #{node.left}, #{node.right})"
	488	end.join("\n")
	489	end
	490
	491	protected
	492	def compute_level
	493	node, nesting = self, 0
	494	while (association = node.association(:parent)).loaded? && association.target
	495	nesting += 1
	496	node = node.parent
	497	end if node.respond_to? :association
	498	node == self ? ancestors.count : node.level + nesting
	499	end
	500
	501	def without_self(scope)
	502	scope.where(["#{self.class.quoted_table_name}.#{self.class.primary_key} != ?", self])
	503	end
	504
	505	# All nested set queries should use this nested_set_scope, which performs finds on
	506	# the base ActiveRecord class, using the :scope declared in the acts_as_nested_set
	507	# declaration.
	508	def nested_set_scope(options = {})
	509	options = {:order => quoted_left_column_full_name}.merge(options)
	510	scopes = Array(acts_as_nested_set_options[:scope])
	511	options[:conditions] = scopes.inject({}) do \|conditions,attr\|
	512	conditions.merge attr => self[attr]
	513	end unless scopes.empty?
	514	self.class.base_class.unscoped.scoped options
	515	end
	516
	517	def store_new_parent
	518	@move_to_new_parent_id = send("#{parent_column_name}_changed?") ? parent_id : false
	519	true # force callback to return true
	520	end
	521
	522	def move_to_new_parent
	523	if @move_to_new_parent_id.nil?
	524	move_to_root
	525	elsif @move_to_new_parent_id
	526	move_to_child_of(@move_to_new_parent_id)
	527	end
	528	end
	529
	530	def set_depth!
	531	if nested_set_scope.column_names.map(&:to_s).include?(depth_column_name.to_s)
	532	in_tenacious_transaction do
	533	reload
	534
	535	nested_set_scope.where(:id => id).update_all(["#{quoted_depth_column_name} = ?", level])
	536	end
	537	self[depth_column_name.to_sym] = self.level
	538	end
	539	end
	540
	541	def right_most_bound
	542	right_most_node =
	543	self.class.base_class.unscoped.
	544	order("#{quoted_right_column_full_name} desc").limit(1).lock(true).first
	545	right_most_node ? (right_most_node[right_column_name] \|\| 0) : 0
	546	end
	547
	548	# on creation, set automatically lft and rgt to the end of the tree
	549	def set_default_left_and_right
	550	# adds the new node to the right of all existing nodes
	551	self[left_column_name] = right_most_bound + 1
	552	self[right_column_name] = right_most_bound + 2
	553	end
	554
	555	def in_tenacious_transaction(&block)
	556	retry_count = 0
	557	begin
	558	transaction(&block)
	559	rescue ActiveRecord::StatementInvalid => error
	560	raise unless connection.open_transactions.zero?
	561	raise unless error.message =~ /Deadlock found when trying to get lock\|Lock wait timeout exceeded/
	562	raise unless retry_count < 10
	563	retry_count += 1
	564	logger.info "Deadlock detected on retry #{retry_count}, restarting transaction"
	565	sleep(rand(retry_count)*0.1) # Aloha protocol
	566	retry
	567	end
	568	end
	569
	570	# Prunes a branch off of the tree, shifting all of the elements on the right
	571	# back to the left so the counts still work.
	572	def destroy_descendants
	573	return if right.nil? \|\| left.nil? \|\| skip_before_destroy
	574
	575	in_tenacious_transaction do
	576	reload_nested_set
	577	# select the rows in the model that extend past the deletion point and apply a lock
	578	nested_set_scope.where(["#{quoted_left_column_full_name} >= ?", left]).
	579	select(id).lock(true)
	580
	581	if acts_as_nested_set_options[:dependent] == :destroy
	582	descendants.each do \|model\|
	583	model.skip_before_destroy = true
	584	model.destroy
	585	end
	586	else
	587	nested_set_scope.where(["#{quoted_left_column_name} > ? AND #{quoted_right_column_name} < ?", left, right]).
	588	delete_all
	589	end
	590
	591	# update lefts and rights for remaining nodes
	592	diff = right - left + 1
	593	nested_set_scope.where(["#{quoted_left_column_full_name} > ?", right]).update_all(
	594	["#{quoted_left_column_name} = (#{quoted_left_column_name} - ?)", diff]
	595	)
	596
	597	nested_set_scope.where(["#{quoted_right_column_full_name} > ?", right]).update_all(
	598	["#{quoted_right_column_name} = (#{quoted_right_column_name} - ?)", diff]
	599	)
	600
	601	# Don't allow multiple calls to destroy to corrupt the set
	602	self.skip_before_destroy = true
	603	end
	604	end
	605
	606	# reload left, right, and parent
	607	def reload_nested_set
	608	reload(
	609	:select => "#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, #{quoted_parent_column_full_name}",
	610	:lock => true
	611	)
	612	end
	613
	614	def move_to(target, position)
	615	raise ActiveRecord::ActiveRecordError, "You cannot move a new node" if self.new_record?
	616	run_callbacks :move do
	617	in_tenacious_transaction do
	618	if target.is_a? self.class.base_class
	619	target.reload_nested_set
	620	elsif position != :root
	621	# load object if node is not an object
	622	target = nested_set_scope.find(target)
	623	end
	624	self.reload_nested_set
	625
	626	unless position == :root \|\| move_possible?(target)
	627	raise ActiveRecord::ActiveRecordError, "Impossible move, target node cannot be inside moved tree."
	628	end
	629
	630	bound = case position
	631	when :child; target[right_column_name]
	632	when :left; target[left_column_name]
	633	when :right; target[right_column_name] + 1
	634	when :root; 1
	635	else raise ActiveRecord::ActiveRecordError, "Position should be :child, :left, :right or :root ('#{position}' received)."
	636	end
	637
	638	if bound > self[right_column_name]
	639	bound = bound - 1
	640	other_bound = self[right_column_name] + 1
	641	else
	642	other_bound = self[left_column_name] - 1
	643	end
	644
	645	# there would be no change
	646	return if bound == self[right_column_name] \|\| bound == self[left_column_name]
	647
	648	# we have defined the boundaries of two non-overlapping intervals,
	649	# so sorting puts both the intervals and their boundaries in order
	650	a, b, c, d = [self[left_column_name], self[right_column_name], bound, other_bound].sort
	651
	652	# select the rows in the model between a and d, and apply a lock
	653	self.class.base_class.select('id').lock(true).where(
	654	["#{quoted_left_column_full_name} >= :a and #{quoted_right_column_full_name} <= :d", {:a => a, :d => d}]
	655	)
	656
	657	new_parent = case position
	658	when :child; target.id
	659	when :root; nil
	660	else target[parent_column_name]
	661	end
	662
	663	where_statement = ["not (#{quoted_left_column_name} = CASE " +
	664	"WHEN #{quoted_left_column_name} BETWEEN :a AND :b " +
	665	"THEN #{quoted_left_column_name} + :d - :b " +
	666	"WHEN #{quoted_left_column_name} BETWEEN :c AND :d " +
	667	"THEN #{quoted_left_column_name} + :a - :c " +
	668	"ELSE #{quoted_left_column_name} END AND " +
	669	"#{quoted_right_column_name} = CASE " +
	670	"WHEN #{quoted_right_column_name} BETWEEN :a AND :b " +
	671	"THEN #{quoted_right_column_name} + :d - :b " +
	672	"WHEN #{quoted_right_column_name} BETWEEN :c AND :d " +
	673	"THEN #{quoted_right_column_name} + :a - :c " +
	674	"ELSE #{quoted_right_column_name} END AND " +
	675	"#{quoted_parent_column_name} = CASE " +
	676	"WHEN #{self.class.base_class.primary_key} = :id THEN :new_parent " +
	677	"ELSE #{quoted_parent_column_name} END)" ,
	678	{:a => a, :b => b, :c => c, :d => d, :id => self.id, :new_parent => new_parent} ]
	679
	680
	681
	682		81
	683	self.nested_set_scope.where(*where_statement).update_all([	82	# Add callbacks, if they were supplied.. otherwise, we don't want them.
	684	"#{quoted_left_column_name} = CASE " +	83	[:before_add, :after_add, :before_remove, :after_remove].each do \|ar_callback\|
	685	"WHEN #{quoted_left_column_name} BETWEEN :a AND :b " +	84	has_many_children_options.update(ar_callback => acts_as_nested_set_options[ar_callback]) if acts_as_nested_set_options[ar_callback]
	686	"THEN #{quoted_left_column_name} + :d - :b " +
	687	"WHEN #{quoted_left_column_name} BETWEEN :c AND :d " +
	688	"THEN #{quoted_left_column_name} + :a - :c " +
	689	"ELSE #{quoted_left_column_name} END, " +
	690	"#{quoted_right_column_name} = CASE " +
	691	"WHEN #{quoted_right_column_name} BETWEEN :a AND :b " +
	692	"THEN #{quoted_right_column_name} + :d - :b " +
	693	"WHEN #{quoted_right_column_name} BETWEEN :c AND :d " +
	694	"THEN #{quoted_right_column_name} + :a - :c " +
	695	"ELSE #{quoted_right_column_name} END, " +
	696	"#{quoted_parent_column_name} = CASE " +
	697	"WHEN #{self.class.base_class.primary_key} = :id THEN :new_parent " +
	698	"ELSE #{quoted_parent_column_name} END",
	699	{:a => a, :b => b, :c => c, :d => d, :id => self.id, :new_parent => new_parent}
	700	])
	701	end
	702	target.reload_nested_set if target
	703	self.set_depth!
	704	self.descendants.each(&:save)
	705	self.reload_nested_set
	706	end
	707	end	85	end
	708		86
			87	has_many :children, has_many_children_options
	709	end	88	end
	710		89
	711	# Mixed into both classes and instances to provide easy access to the column names	90	def acts_as_nested_set_relate_parent!
	712	module Columns	91	belongs_to :parent, :class_name => self.base_class.to_s,
	713	def left_column_name	92	:foreign_key => parent_column_name,
	714	acts_as_nested_set_options[:~~left_~~column]	93	:counter_cache => acts_as_nested_set_options[:counter_cache],
	715	end	94	:inverse_of => (:children unless acts_as_nested_set_options[:polymorphic]),
	716		95	:polymorphic => acts_as_nested_set_options[:polymorphic]
	717	def right_column_name	96	end
	718	acts_as_nested_set_options[:right_column]
	719	end
	720
	721	def depth_column_name
	722	acts_as_nested_set_options[:depth_column]
	723	end
	724
	725	def parent_column_name
	726	acts_as_nested_set_options[:parent_column]
	727	end
	728
	729	def order_column
	730	acts_as_nested_set_options[:order_column] \|\| left_column_name
	731	end
	732
	733	def scope_column_names
	734	Array(acts_as_nested_set_options[:scope])
	735	end
	736
	737	def quoted_left_column_name
	738	connection.quote_column_name(left_column_name)
	739	end
	740
	741	def quoted_right_column_name
	742	connection.quote_column_name(right_column_name)
	743	end
	744
	745	def quoted_depth_column_name
	746	connection.quote_column_name(depth_column_name)
	747	end
	748		97
	749	def quoted_parent_column_name	98	def acts_as_nested_set_default_options
	750	connection.quote_column_name(parent_column_name)	99	{
	751	end	100	:parent_column => 'parent_id',
			101	:left_column => 'lft',
			102	:right_column => 'rgt',
			103	:depth_column => 'depth',
			104	:dependent => :delete_all, # or :destroy
			105	:polymorphic => false,
			106	:counter_cache => false
			107	}.freeze
			108	end
	752		109
	753	def quoted_scope_column_names	110	def acts_as_nested_set_parse_options!(options)
	754	scope_column_names.collect {\|column_name\| connection.quote_column_name(column_name) }	111	options = acts_as_nested_set_default_options.merge(options)
	755	end
	756		112
	757	def quoted_left_column_full_name	113	if options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/
	758	"#{quoted_table_name}.#{quoted_left_column_name}"	114	options[:scope] = "#{options[:scope]}_id".intern
	759	end	115	end
	760		116
	761	def quoted_right_column_full_name	117	class_attribute :acts_as_nested_set_options
	762	"#{quoted_table_name}.#{quoted_right_column_name}"	118	self.acts_as_nested_set_options = options
	763	end	119	end
	764		120
	765	def quoted_parent_column_full_name	121	def acts_as_nested_set_prevent_assignment_to_reserved_columns!
	766	"#{quoted_table_name}.#{quoted_parent_column_name}"	122	# no assignment to structure fields
			123	[left_column_name, right_column_name, depth_column_name].each do \|column\|
			124	module_eval <<-"end_eval", __FILE__, __LINE__
			125	def #{column}=(x)
			126	raise ActiveRecord::ActiveRecordError, "Unauthorized assignment to #{column}: it's an internal field handled by acts_as_nested_set code, use move_to_* methods instead."
			127	end
			128	end_eval
	767	end	129	end
	768	end	130	end
	769
	770	end	131	end
	771	end	132	end
	772	end	133	end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/helper.rb 0 -45

             # -*- coding: utf-8 -*-
             module CollectiveIdea #:nodoc:
               module Acts #:nodoc:
                 module NestedSet #:nodoc:
                   # This module provides some helpers for the model classes using acts_as_nested_set.
                   # It is included by default in all views.
                   #
                   module Helper
                     # Returns options for select.
                     # You can exclude some items from the tree.
                     # You can pass a block receiving an item and returning the string displayed in the select.
                     #
                     # == Params
                     #  * +class_or_item+ - Class name or top level times
                     #  * +mover+ - The item that is being move, used to exlude impossible moves
                     #  * +&block+ - a block that will be used to display: { |item| ... item.name }
                     #
                     # == Usage
                     #
                     #   <%= f.select :parent_id, nested_set_options(Category, @category) {|i|
                     #       "#{'–' * i.level} #{i.name}"
                     #     }) %>
                     #
                     def nested_set_options(class_or_item, mover = nil)
                       if class_or_item.is_a? Array
                         items = class_or_item.reject { |e| !e.root? }
                       else
                         class_or_item = class_or_item.roots if class_or_item.respond_to?(:scoped)
                         items = Array(class_or_item)
                       end
                       result = []
                       items.each do |root|
                         result += root.class.associate_parents(root.self_and_descendants).map do |i|
                           if mover.nil? || mover.new_record? || mover.move_possible?(i)
                             [yield(i), i.id]
                           end
                         end.compact
                       end
                       result
                     end
-                    # Returns options for select as nested_set_options, sorted by an specific column
-                    # It requires passing a string with the name of the column to sort the set with
-                    # You can exclude some items from the tree.
-                    # You can pass a block receiving an item and returning the string displayed in the select.
-                    # == Params
-                    #  * +class_or_item+ - Class name or top level times
-                    #  * +:column+ - Column to sort the set (this will sort each children for all root elements)
-                    #  * +mover+ - The item that is being move, used to exlude impossible moves
-                    #  * +&block+ - a block that will be used to display: { |item| ... item.name }
-                    # == Usage
-                    #   <%= f.select :parent_id, nested_set_options(Category, :sort_by_this_column,  @category) {|i|
-                    #       "#{'–' * i.level} #{i.name}"
-                    #     }) %>
-                    def sorted_nested_set_options(class_or_item, order, mover = nil)
-                      if class_or_item.is_a? Array
-                        items = class_or_item.reject { |e| !e.root? }
-                      else
-                        class_or_item = class_or_item.roots if class_or_item.is_a?(Class)
-                        items = Array(class_or_item)
-                      end
-                      result = []
-                      children = []
-                      items.each do |root|
-                        root.class.associate_parents(root.self_and_descendants).map do |i|
-                          if mover.nil? || mover.new_record? || mover.move_possible?(i)
-                            if !i.leaf?
-                              children.sort_by! &order
-                              children.each { |c| result << [yield(c), c.id] }
-                              children = []
-                              result << [yield(i), i.id]
-                            else
-                              children << i
-                             end
-                          end
-                        end.compact
-                      end
-                      children.sort_by! &order
-                      children.each { |c| result << [yield(c), c.id] }
-                      result
-                    end
                   end
                 end
               end
             end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/version.rb +1 -1

             module AwesomeNestedSet
-              VERSION = '2.1.6' unless defined?(::AwesomeNestedSet::VERSION)
+              VERSION = '2.1.7' unless defined?(::AwesomeNestedSet::VERSION)
             end

lib/plugins/awesome_nested_set/spec/awesome_nested_set/helper_spec.rb +8 -2

             require 'spec_helper'
             require 'awesome_nested_set/helper'
             describe "Helper" do
               include CollectiveIdea::Acts::NestedSet::Helper
               before(:all) do
                 self.class.fixtures :categories
               end
               describe "nested_set_options" do
                 it "test_nested_set_options" do
                   expected = [
                     [" Top Level", 1],
                     ["- Child 1", 2],
                     ['- Child 2', 3],
                     ['-- Child 2.1', 4],
                     ['- Child 3', 5],
                     [" Top Level 2", 6]
                   ]
                   actual = nested_set_options(Category.scoped) do |c|
                     "#{'-' * c.level} #{c.name}"
                   end
                   actual.should == expected
                 end
                 it "test_nested_set_options_with_mover" do
                   expected = [
                     [" Top Level", 1],
                     ["- Child 1", 2],
                     ['- Child 3', 5],
                     [" Top Level 2", 6]
                   ]
                   actual = nested_set_options(Category.scoped, categories(:child_2)) do |c|
                     "#{'-' * c.level} #{c.name}"
                   end
                   actual.should == expected
                 end
                 it "test_nested_set_options_with_class_as_argument" do
                   expected = [
                     [" Top Level", 1],
                     ["- Child 1", 2],
                     ['- Child 2', 3],
                     ['-- Child 2.1', 4],
                     ['- Child 3', 5],
                     [" Top Level 2", 6]
                   ]
                   actual = nested_set_options(Category) do |c|
                     "#{'-' * c.level} #{c.name}"
                   end
                   actual.should == expected
                 end
                 it "test_nested_set_options_with_class_as_argument_with_mover" do
                   expected = [
                     [" Top Level", 1],
                     ["- Child 1", 2],
                     ['- Child 3', 5],
                     [" Top Level 2", 6]
                   ]
                   actual = nested_set_options(Category, categories(:child_2)) do |c|
                     "#{'-' * c.level} #{c.name}"
                   end
                   actual.should == expected
                 end
                 it "test_nested_set_options_with_array_as_argument_without_mover" do
                   expected = [
                     [" Top Level", 1],
                     ["- Child 1", 2],
                     ['- Child 2', 3],
                     ['-- Child 2.1', 4],
                     ['- Child 3', 5],
                     [" Top Level 2", 6]
                   ]
                   actual = nested_set_options(Category.all) do |c|
                     "#{'-' * c.level} #{c.name}"
                   end
-                  actual.should == expected
+                  actual.length.should == expected.length
+                  expected.flatten.each do |node|
+                    actual.flatten.should include(node)
+                  end
                 end
                 it "test_nested_set_options_with_array_as_argument_with_mover" do
                   expected = [
                     [" Top Level", 1],
                     ["- Child 1", 2],
                     ['- Child 3', 5],
                     [" Top Level 2", 6]
                   ]
                   actual = nested_set_options(Category.all, categories(:child_2)) do |c|
                     "#{'-' * c.level} #{c.name}"
                   end
-                  actual.should == expected
+                  actual.length.should == expected.length
+                  expected.flatten.each do |node|
+                    actual.flatten.should include(node)
+                  end
                 end
               end
             end

lib/plugins/awesome_nested_set/spec/awesome_nested_set_spec.rb +18 -8

             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 "has a depth_column_name" do
                   Default.depth_column_name.should == 'depth'
                   Default.new.depth_column_name.should == 'depth'
                   RenamedColumns.depth_column_name.should == 'pitch'
                   RenamedColumns.depth_column_name.should == 'pitch'
                 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 "quoted_depth_column_name" do
                 quoted = Default.connection.quote_column_name('depth')
                 Default.quoted_depth_column_name.should == quoted
                 Default.new.quoted_depth_column_name.should == quoted
               end
+              it "quoted_order_column_name" do
+                quoted = Default.connection.quote_column_name('lft')
+                Default.quoted_order_column_name.should == quoted
+                Default.new.quoted_order_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 "depth_column_protected_from_assignment" do
                 lambda {
                   Category.new.depth = 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)
+                found_by_us = Category.where(:parent_id => nil).to_a
+                found_by_roots = Category.roots.to_a
+                found_by_us.length.should == found_by_roots.length
+                found_by_us.each do |root|
+                  found_by_roots.should include(root)
+                end
               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 when not persisted and parent_column_name value is self" do
                 new_category = Category.new
                 new_category.root.should == new_category
               end
               it "root when not persisted and parent_column_name value is set" do
                 last_category = Category.last
                 Category.new(Default.parent_column_name => last_category.id).root.should == last_category.root
               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
+                child.self_and_ancestors.should == 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
               describe "level" do
                 it "returns the correct level" do
                   categories(:top_level).level.should == 0
                   categories(:child_1).level.should == 1
                   categories(:child_2_1).level.should == 2
                 end
                 context "given parent associations are loaded" do
                   it "returns the correct level" do
                     child = categories(:child_1)
                     if child.respond_to?(:association)
                       child.association(:parent).load_target
                       child.parent.association(:parent).load_target
                       child.level.should == 1
                     else
                       pending 'associations not used where child#association is not a method'
                     end
                   end
                 end
               end
               describe "depth" do
                 let(:lawyers) { Category.create!(:name => "lawyers") }
                 let(:us) { Category.create!(:name => "United States") }
                 let(:new_york) { Category.create!(:name => "New York") }
                 let(:patent) { Category.create!(:name => "Patent Law") }
                 before(:each) do
                   # lawyers > us > new_york > patent
                   us.move_to_child_of(lawyers)
                   new_york.move_to_child_of(us)
                   patent.move_to_child_of(new_york)
                   [lawyers, us, new_york, patent].each(&:reload)
                 end
                 it "updates depth when moved into child position" do
                   lawyers.depth.should == 0
                   us.depth.should == 1
                   new_york.depth.should == 2
                   patent.depth.should == 3
                 end
                 it "updates depth of all descendants when parent is moved" do
                   # lawyers
                   # us > new_york > patent
                   us.move_to_right_of(lawyers)
                   [lawyers, us, new_york, patent].each(&:reload)
                   us.depth.should == 0
                   new_york.depth.should == 1
                   patent.depth.should == 2
                 end
               end
               it "depth is magic and does not apply when column is missing" do
                 lambda { NoDepth.create!(:name => "shallow") }.should_not raise_error
                 lambda { NoDepth.first.save }.should_not raise_error
                 lambda { NoDepth.rebuild! }.should_not raise_error
                 NoDepth.method_defined?(:depth).should be_false
                 NoDepth.first.respond_to?(:depth).should be_false
               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_descendants" 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 "descendants" 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_descendants" 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).left.should == 7
-                categories(:child_2).right.should == 4
+                categories(:child_2).right.should == 10
                 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
               describe "#move_to_child_with_index" do
                 it "move to a node without child" do
                   categories(:child_1).move_to_child_with_index(categories(:child_3), 0)
                   categories(:child_3).id.should == categories(:child_1).parent_id
                   categories(:child_1).left.should == 7
                   categories(:child_1).right.should == 8
                   categories(:child_3).left.should == 6
                   categories(:child_3).right.should == 9
                   Category.valid?.should be_true
                 end
                 it "move to a node to the left child" do
                   categories(:child_1).move_to_child_with_index(categories(:child_2), 0)
                   categories(:child_1).parent_id.should == categories(:child_2).id
                   categories(:child_2_1).left.should == 5
                   categories(:child_2_1).right.should == 6
                   categories(:child_1).left.should == 3
                   categories(:child_1).right.should == 4
                   categories(:child_2).reload
                   categories(:child_2).left.should == 2
                   categories(:child_2).right.should == 7
                 end
                 it "move to a node to the right child" do
                   categories(:child_1).move_to_child_with_index(categories(:child_2), 1)
                   categories(:child_1).parent_id.should == categories(:child_2).id
                   categories(:child_2_1).left.should == 3
                   categories(:child_2_1).right.should == 4
                   categories(:child_1).left.should == 5
                   categories(:child_1).right.should == 6
                   categories(:child_2).reload
                   categories(:child_2).left.should == 2
                   categories(:child_2).right.should == 7
                 end
               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_move_to_ordered_child" do
                 node1 = Category.create(:name => 'Node-1')
                 node2 = Category.create(:name => 'Node-2')
                 node3 = Category.create(:name => 'Node-3')
                 node2.move_to_ordered_child_of(node1, "name")
                 assert_equal node1, node2.parent
                 assert_equal 1, node1.children.count
                 node3.move_to_ordered_child_of(node1, "name", true) # acending
                 assert_equal node1, node3.parent
                 assert_equal 2, node1.children.count
                 assert_equal node2.name, node1.children[0].name
                 assert_equal node3.name, node1.children[1].name
                 node3.move_to_ordered_child_of(node1, "name", false) # decending
                 node1.reload
                 assert_equal node1, node3.parent
                 assert_equal 2, node1.children.count
                 assert_equal node3.name, node1.children[0].name
                 assert_equal node2.name, node1.children[1].name
               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
                 ## Proper Array Assignment for different DBs as per their quoting column behavior
-                if Note.connection.adapter_name.match(/Oracle/)
+                if Note.connection.adapter_name.match(/oracle/i)
                   expected_quoted_scope_column_names = ["\"NOTABLE_ID\"", "\"NOTABLE_TYPE\""]
-                elsif Note.connection.adapter_name.match(/Mysql/)
+                elsif Note.connection.adapter_name.match(/mysql/i)
                   expected_quoted_scope_column_names = ["`notable_id`", "`notable_type`"]
                 else
                   expected_quoted_scope_column_names = ["\"notable_id\"", "\"notable_type\""]
                 end
-                expected_quoted_scope_column_names.should == Note.quoted_scope_column_names
+                Note.quoted_scope_column_names.should == expected_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.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
               describe 'rebuilding tree with a default scope ordering' do
                 it "doesn't throw exception" do
                   expect { Position.rebuild! }.not_to raise_error
                 end
               end
               describe 'creating roots with a default scope ordering' do
                 it "assigns rgt and lft correctly" do
                   alpha = Order.create(:name => 'Alpha')
                   gamma = Order.create(:name => 'Gamma')
                   omega = Order.create(:name => 'Omega')
                   alpha.lft.should == 1
                   alpha.rgt.should == 2
                   gamma.lft.should == 3
                   gamma.rgt.should == 4
                   omega.lft.should == 5
                   omega.rgt.should == 6
                 end
               end
               describe 'moving node from one scoped tree to another' do
                 xit "moves single node correctly" do
                   root1 = Note.create!(:body => "A-1", :notable_id => 4, :notable_type => 'Category')
                   child1_1 = Note.create!(:body => "B-1", :notable_id => 4, :notable_type => 'Category')
                   child1_2 = Note.create!(:body => "C-1", :notable_id => 4, :notable_type => 'Category')
                   child1_1.move_to_child_of root1
                   child1_2.move_to_child_of root1
                   root2 = Note.create!(:body => "A-2", :notable_id => 5, :notable_type => 'Category')
                   child2_1 = Note.create!(:body => "B-2", :notable_id => 5, :notable_type => 'Category')
                   child2_2 = Note.create!(:body => "C-2", :notable_id => 5, :notable_type => 'Category')
                   child2_1.move_to_child_of root2
                   child2_2.move_to_child_of root2
                   child1_1.update_attributes!(:notable_id => 5)
                   child1_1.move_to_child_of root2
                   root1.children.should == [child1_2]
                   root2.children.should == [child2_1, child2_2, child1_1]
                   Note.valid?.should == true
                 end
                 xit "moves node with children correctly" do
                   root1 = Note.create!(:body => "A-1", :notable_id => 4, :notable_type => 'Category')
                   child1_1 = Note.create!(:body => "B-1", :notable_id => 4, :notable_type => 'Category')
                   child1_2 = Note.create!(:body => "C-1", :notable_id => 4, :notable_type => 'Category')
                   child1_1.move_to_child_of root1
                   child1_2.move_to_child_of child1_1
                   root2 = Note.create!(:body => "A-2", :notable_id => 5, :notable_type => 'Category')
                   child2_1 = Note.create!(:body => "B-2", :notable_id => 5, :notable_type => 'Category')
                   child2_2 = Note.create!(:body => "C-2", :notable_id => 5, :notable_type => 'Category')
                   child2_1.move_to_child_of root2
                   child2_2.move_to_child_of root2
                   child1_1.update_attributes!(:notable_id => 5)
                   child1_1.move_to_child_of root2
                   root1.children.should == []
                   root2.children.should == [child2_1, child2_2, child1_1]
                   child1_1.children should == [child1_2]
                   root2.siblings.should == [child2_1, child2_2, child1_1, child1_2]
                   Note.valid?.should == true
                 end
               end
               describe 'specifying custom sort column' do
                 it "should sort by the default sort column" do
                   Category.order_column.should == 'lft'
                 end
                 it "should sort by custom sort column" do
                   OrderedCategory.acts_as_nested_set_options[:order_column].should == 'name'
                   OrderedCategory.order_column.should == 'name'
                 end
               end
             end

lib/plugins/awesome_nested_set/spec/spec_helper.rb +2 0

             plugin_test_dir = File.dirname(__FILE__)
             require 'rubygems'
             require 'bundler/setup'
+            require 'pry'
             require 'logger'
             require 'active_record'
             ActiveRecord::Base.logger = Logger.new(plugin_test_dir + "/debug.log")
             require 'yaml'
             require 'erb'
             ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read(plugin_test_dir + "/db/database.yml")).result)
             ActiveRecord::Base.establish_connection(ENV["DB"] ||= "sqlite3mem")
             ActiveRecord::Migration.verbose = false
             require 'combustion/database'
             Combustion::Database.create_database(ActiveRecord::Base.configurations[ENV["DB"]])
             load(File.join(plugin_test_dir, "db", "schema.rb"))
             require 'awesome_nested_set'
             require 'support/models'
             require 'action_controller'
             require 'rspec/rails'
+            require 'database_cleaner'
             RSpec.configure do |config|
               config.fixture_path = "#{plugin_test_dir}/fixtures"
               config.use_transactional_fixtures = true
               config.after(:suite) do
                 unless /sqlite/ === ENV['DB']
                   Combustion::Database.drop_database(ActiveRecord::Base.configurations[ENV['DB']])
                 end
               end
             end

lib/plugins/awesome_nested_set/init.rb removed 0 -1

NO CONTENT: file was removed

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