jro_apps/redmine Commit - r2302:c9906480d3f2

Merged nested projects branch. Removes limit on subproject nesting (#594)....

Jean-Philippe Lang -

r2302:c9906480d3f2

parent child

Context file:

r2302:c9906480d3f2

Expand all files

db/migrate/104_add_projects_lft_and_rgt.rb created 644 +11 0

			@@ -0,0 +1,11
		1	class AddProjectsLftAndRgt < ActiveRecord::Migration
		2	def self.up
		3	add_column :projects, :lft, :integer
		4	add_column :projects, :rgt, :integer
		5	end
		6
		7	def self.down
		8	remove_column :projects, :lft
		9	remove_column :projects, :rgt
		10	end
		11	end

db/migrate/105_build_projects_tree.rb created 644 +8 0

			@@ -0,0 +1,8
		1	class BuildProjectsTree < ActiveRecord::Migration
		2	def self.up
		3	Project.rebuild!
		4	end
		5
		6	def self.down
		7	end
		8	end

vendor/plugins/awesome_nested_set/MIT-LICENSE created 644 +20 0

			@@ -0,0 +1,20
		1	Copyright (c) 2007 [name of plugin creator]
		2
		3	Permission is hereby granted, free of charge, to any person obtaining
		4	a copy of this software and associated documentation files (the
		5	"Software"), to deal in the Software without restriction, including
		6	without limitation the rights to use, copy, modify, merge, publish,
		7	distribute, sublicense, and/or sell copies of the Software, and to
		8	permit persons to whom the Software is furnished to do so, subject to
		9	the following conditions:
		10
		11	The above copyright notice and this permission notice shall be
		12	included in all copies or substantial portions of the Software.
		13
		14	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
		15	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
		16	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
		17	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
		18	LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
		19	OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
		20	WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/plugins/awesome_nested_set/README.rdoc created 644 +64 0

			@@ -0,0 +1,64
		1	= AwesomeNestedSet
		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 awesomer.
		4
		5	== What makes this so awesome?
		6
		7	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.
		8
		9	== Installation
		10
		11	If you are on Rails 2.1 or later:
		12
		13	script/plugin install git://github.com/collectiveidea/awesome_nested_set.git
		14
		15	== Usage
		16
		17	To make use of awesome_nested_set, your model needs to have 3 fields: lft, rgt, and parent_id:
		18
		19	class CreateCategories < ActiveRecord::Migration
		20	def self.up
		21	create_table :categories do \|t\|
		22	t.string :name
		23	t.integer :parent_id
		24	t.integer :lft
		25	t.integer :rgt
		26	end
		27	end
		28
		29	def self.down
		30	drop_table :categories
		31	end
		32	end
		33
		34	Enable the nested set functionality by declaring acts_as_nested_set on your model
		35
		36	class Category < ActiveRecord::Base
		37	acts_as_nested_set
		38	end
		39
		40	Run `rake rdoc` to generate the API docs and see CollectiveIdea::Acts::NestedSet::SingletonMethods for more info.
		41
		42	== View Helper
		43
		44	The view helper is called #nested_set_options.
		45
		46	Example usage:
		47
		48	<%= f.select :parent_id, nested_set_options(Category, @category) {\|i\| "#{'-' * i.level} #{i.name}" } %>
		49
		50	<%= select_tag 'parent_id', options_for_select(nested_set_options(Category) {\|i\| "#{'-' * i.level} #{i.name}" } ) %>
		51
		52	See CollectiveIdea::Acts::NestedSet::Helper for more information about the helpers.
		53
		54	== References
		55
		56	You can learn more about nested sets at:
		57
		58	http://www.dbmsmag.com/9603d06.html
		59	http://threebit.net/tutorials/nestedset/tutorial1.html
		60	http://api.rubyonrails.com/classes/ActiveRecord/Acts/NestedSet/ClassMethods.html
		61	http://opensource.symetrie.com/trac/better_nested_set/
		62
		63
		64	Copyright (c) 2008 Collective Idea, released under the MIT license No newline at end of file

vendor/plugins/awesome_nested_set/Rakefile created 644 +46 0

			@@ -0,0 +1,46
		1	require 'rake'
		2	require 'rake/testtask'
		3	require 'rake/rdoctask'
		4	require 'rake/gempackagetask'
		5	require 'rcov/rcovtask'
		6	require "load_multi_rails_rake_tasks"
		7
		8	spec = eval(File.read("#{File.dirname(__FILE__)}/awesome_nested_set.gemspec"))
		9	PKG_NAME = spec.name
		10	PKG_VERSION = spec.version
		11
		12	Rake::GemPackageTask.new(spec) do \|pkg\|
		13	pkg.need_zip = true
		14	pkg.need_tar = true
		15	end
		16
		17
		18	desc 'Default: run unit tests.'
		19	task :default => :test
		20
		21	desc 'Test the awesome_nested_set plugin.'
		22	Rake::TestTask.new(:test) do \|t\|
		23	t.libs << 'lib'
		24	t.pattern = 'test/*/_test.rb'
		25	t.verbose = true
		26	end
		27
		28	desc 'Generate documentation for the awesome_nested_set plugin.'
		29	Rake::RDocTask.new(:rdoc) do \|rdoc\|
		30	rdoc.rdoc_dir = 'rdoc'
		31	rdoc.title = 'AwesomeNestedSet'
		32	rdoc.options << '--line-numbers' << '--inline-source'
		33	rdoc.rdoc_files.include('README.rdoc')
		34	rdoc.rdoc_files.include('lib/*/.rb')
		35	end
		36
		37	namespace :test do
		38	desc "just rcov minus html output"
		39	Rcov::RcovTask.new(:coverage) do \|t\|
		40	# t.libs << 'test'
		41	t.test_files = FileList['test/*/_test.rb']
		42	t.output_dir = 'coverage'
		43	t.verbose = true
		44	t.rcov_opts = %w(--exclude test,/usr/lib/ruby,/Library/Ruby,lib/awesome_nested_set/named_scope.rb --sort coverage)
		45	end
		46	end No newline at end of file

vendor/plugins/awesome_nested_set/awesome_nested_set.gemspec created 644 +20 0

			@@ -0,0 +1,20
		1	Gem::Specification.new do \|s\|
		2	s.name = "awesome_nested_set"
		3	s.version = "1.1.1"
		4	s.summary = "An awesome replacement for acts_as_nested_set and better_nested_set."
		5	s.description = s.summary
		6
		7	s.files = %w(init.rb MIT-LICENSE Rakefile README.rdoc lib/awesome_nested_set.rb lib/awesome_nested_set/compatability.rb lib/awesome_nested_set/helper.rb lib/awesome_nested_set/named_scope.rb rails/init.rb test/awesome_nested_set_test.rb test/test_helper.rb test/awesome_nested_set/helper_test.rb test/db/database.yml test/db/schema.rb test/fixtures/categories.yml test/fixtures/category.rb test/fixtures/departments.yml test/fixtures/notes.yml)
		8
		9	s.add_dependency "activerecord", ['>= 1.1']
		10
		11	s.has_rdoc = true
		12	s.extra_rdoc_files = [ "README.rdoc"]
		13	s.rdoc_options = ["--main", "README.rdoc", "--inline-source", "--line-numbers"]
		14
		15	s.test_files = %w(test/awesome_nested_set_test.rb test/test_helper.rb test/awesome_nested_set/helper_test.rb test/db/database.yml test/db/schema.rb test/fixtures/categories.yml test/fixtures/category.rb test/fixtures/departments.yml test/fixtures/notes.yml)
		16	s.require_path = 'lib'
		17	s.author = "Collective Idea"
		18	s.email = "info@collectiveidea.com"
		19	s.homepage = "http://collectiveidea.com"
		20	end

vendor/plugins/awesome_nested_set/init.rb created 644 +1 0

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

vendor/plugins/awesome_nested_set/lib/awesome_nested_set.rb created 644 +547 0

This diff has been collapsed as it changes many lines, (547 lines changed) Show them Hide them
		@@ -0,0 +1,547
	1	module CollectiveIdea #:nodoc:
	2	module Acts #:nodoc:
	3	module NestedSet #:nodoc:
	4	def self.included(base)
	5	base.extend(SingletonMethods)
	6	end
	7
	8	# This acts provides Nested Set functionality. Nested Set is a smart way to implement
	9	# an _ordered_ tree, with the added feature that you can select the children and all of their
	10	# descendants with a single query. The drawback is that insertion or move need some complex
	11	# sql queries. But everything is done here by this module!
	12	#
	13	# Nested sets are appropriate each time you want either an orderd tree (menus,
	14	# commercial categories) or an efficient way of querying big trees (threaded posts).
	15	#
	16	# == API
	17	#
	18	# Methods names are aligned with acts_as_tree as much as possible, to make replacment from one
	19	# by another easier, except for the creation:
	20	#
	21	# in acts_as_tree:
	22	# item.children.create(:name => "child1")
	23	#
	24	# in acts_as_nested_set:
	25	# # adds a new item at the "end" of the tree, i.e. with child.left = max(tree.right)+1
	26	# child = MyClass.new(:name => "child1")
	27	# child.save
	28	# # now move the item to its right place
	29	# child.move_to_child_of my_item
	30	#
	31	# You can pass an id or an object to:
	32	# * <tt>#move_to_child_of</tt>
	33	# * <tt>#move_to_right_of</tt>
	34	# * <tt>#move_to_left_of</tt>
	35	#
	36	module SingletonMethods
	37	# Configuration options are:
	38	#
	39	# * +:parent_column+ - specifies the column name to use for keeping the position integer (default: parent_id)
	40	# * +:left_column+ - column name for left boundry data, default "lft"
	41	# * +:right_column+ - column name for right boundry data, default "rgt"
	42	# * +:scope+ - restricts what is to be considered a list. Given a symbol, it'll attach "_id"
	43	# (if it hasn't been already) and use that as the foreign key restriction. You
	44	# can also pass an array to scope by multiple attributes.
	45	# Example: <tt>acts_as_nested_set :scope => [:notable_id, :notable_type]</tt>
	46	# * +:dependent+ - behavior for cascading destroy. If set to :destroy, all the
	47	# child objects are destroyed alongside this object by calling their destroy
	48	# method. If set to :delete_all (default), all the child objects are deleted
	49	# without calling their destroy method.
	50	#
	51	# See CollectiveIdea::Acts::NestedSet::ClassMethods for a list of class methods and
	52	# CollectiveIdea::Acts::NestedSet::InstanceMethods for a list of instance methods added
	53	# to acts_as_nested_set models
	54	def acts_as_nested_set(options = {})
	55	options = {
	56	:parent_column => 'parent_id',
	57	:left_column => 'lft',
	58	:right_column => 'rgt',
	59	:order => 'id',
	60	:dependent => :delete_all, # or :destroy
	61	}.merge(options)
	62
	63	if options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/
	64	options[:scope] = "#{options[:scope]}_id".intern
	65	end
	66
	67	write_inheritable_attribute :acts_as_nested_set_options, options
	68	class_inheritable_reader :acts_as_nested_set_options
	69
	70	include Comparable
	71	include Columns
	72	include InstanceMethods
	73	extend Columns
	74	extend ClassMethods
	75
	76	# no bulk assignment
	77	attr_protected left_column_name.intern,
	78	right_column_name.intern,
	79	parent_column_name.intern
	80
	81	before_create :set_default_left_and_right
	82	before_destroy :prune_from_tree
	83
	84	# no assignment to structure fields
	85	[left_column_name, right_column_name, parent_column_name].each do \|column\|
	86	module_eval <<-"end_eval", __FILE__, __LINE__
	87	def #{column}=(x)
	88	raise ActiveRecord::ActiveRecordError, "Unauthorized assignment to #{column}: it's an internal field handled by acts_as_nested_set code, use move_to_* methods instead."
	89	end
	90	end_eval
	91	end
	92
	93	named_scope :roots, :conditions => {parent_column_name => nil}, :order => quoted_left_column_name
	94	named_scope :leaves, :conditions => "#{quoted_right_column_name} - #{quoted_left_column_name} = 1", :order => quoted_left_column_name
	95	if self.respond_to?(:define_callbacks)
	96	define_callbacks("before_move", "after_move")
	97	end
	98
	99
	100	end
	101
	102	end
	103
	104	module ClassMethods
	105
	106	# Returns the first root
	107	def root
	108	roots.find(:first)
	109	end
	110
	111	def valid?
	112	left_and_rights_valid? && no_duplicates_for_columns? && all_roots_valid?
	113	end
	114
	115	def left_and_rights_valid?
	116	count(
	117	:joins => "LEFT OUTER JOIN #{quoted_table_name} AS parent ON " +
	118	"#{quoted_table_name}.#{quoted_parent_column_name} = parent.#{primary_key}",
	119	:conditions =>
	120	"#{quoted_table_name}.#{quoted_left_column_name} IS NULL OR " +
	121	"#{quoted_table_name}.#{quoted_right_column_name} IS NULL OR " +
	122	"#{quoted_table_name}.#{quoted_left_column_name} >= " +
	123	"#{quoted_table_name}.#{quoted_right_column_name} OR " +
	124	"(#{quoted_table_name}.#{quoted_parent_column_name} IS NOT NULL AND " +
	125	"(#{quoted_table_name}.#{quoted_left_column_name} <= parent.#{quoted_left_column_name} OR " +
	126	"#{quoted_table_name}.#{quoted_right_column_name} >= parent.#{quoted_right_column_name}))"
	127	) == 0
	128	end
	129
	130	def no_duplicates_for_columns?
	131	scope_string = Array(acts_as_nested_set_options[:scope]).map do \|c\|
	132	connection.quote_column_name(c)
	133	end.push(nil).join(", ")
	134	[quoted_left_column_name, quoted_right_column_name].all? do \|column\|
	135	# No duplicates
	136	find(:first,
	137	:select => "#{scope_string}#{column}, COUNT(#{column})",
	138	:group => "#{scope_string}#{column}
	139	HAVING COUNT(#{column}) > 1").nil?
	140	end
	141	end
	142
	143	# Wrapper for each_root_valid? that can deal with scope.
	144	def all_roots_valid?
	145	if acts_as_nested_set_options[:scope]
	146	roots(:group => scope_column_names).group_by{\|record\| scope_column_names.collect{\|col\| record.send(col.to_sym)}}.all? do \|scope, grouped_roots\|
	147	each_root_valid?(grouped_roots)
	148	end
	149	else
	150	each_root_valid?(roots)
	151	end
	152	end
	153
	154	def each_root_valid?(roots_to_validate)
	155	left = right = 0
	156	roots_to_validate.all? do \|root\|
	157	returning(root.left > left && root.right > right) do
	158	left = root.left
	159	right = root.right
	160	end
	161	end
	162	end
	163
	164	# Rebuilds the left & rights if unset or invalid. Also very useful for converting from acts_as_tree.
	165	def rebuild!
	166	# Don't rebuild a valid tree.
	167	return true if valid?
	168
	169	scope = lambda{}
	170	if acts_as_nested_set_options[:scope]
	171	scope = lambda{\|node\|
	172	scope_column_names.inject(""){\|str, column_name\|
	173	str << "AND #{connection.quote_column_name(column_name)} = #{connection.quote(node.send(column_name.to_sym))} "
	174	}
	175	}
	176	end
	177	indices = {}
	178
	179	set_left_and_rights = lambda do \|node\|
	180	# set left
	181	node[left_column_name] = indices[scope.call(node)] += 1
	182	# find
	183	find(:all, :conditions => ["#{quoted_parent_column_name} = ? #{scope.call(node)}", node], :order => "#{quoted_left_column_name}, #{quoted_right_column_name}, #{acts_as_nested_set_options[:order]}").each{\|n\| set_left_and_rights.call(n) }
	184	# set right
	185	node[right_column_name] = indices[scope.call(node)] += 1
	186	node.save!
	187	end
	188
	189	# Find root node(s)
	190	root_nodes = find(:all, :conditions => "#{quoted_parent_column_name} IS NULL", :order => "#{quoted_left_column_name}, #{quoted_right_column_name}, #{acts_as_nested_set_options[:order]}").each do \|root_node\|
	191	# setup index for this scope
	192	indices[scope.call(root_node)] \|\|= 0
	193	set_left_and_rights.call(root_node)
	194	end
	195	end
	196	end
	197
	198	# Mixed into both classes and instances to provide easy access to the column names
	199	module Columns
	200	def left_column_name
	201	acts_as_nested_set_options[:left_column]
	202	end
	203
	204	def right_column_name
	205	acts_as_nested_set_options[:right_column]
	206	end
	207
	208	def parent_column_name
	209	acts_as_nested_set_options[:parent_column]
	210	end
	211
	212	def scope_column_names
	213	Array(acts_as_nested_set_options[:scope])
	214	end
	215
	216	def quoted_left_column_name
	217	connection.quote_column_name(left_column_name)
	218	end
	219
	220	def quoted_right_column_name
	221	connection.quote_column_name(right_column_name)
	222	end
	223
	224	def quoted_parent_column_name
	225	connection.quote_column_name(parent_column_name)
	226	end
	227
	228	def quoted_scope_column_names
	229	scope_column_names.collect {\|column_name\| connection.quote_column_name(column_name) }
	230	end
	231	end
	232
	233	# 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.
	234	#
	235	# category.self_and_descendants.count
	236	# category.ancestors.find(:all, :conditions => "name like '%foo%'")
	237	module InstanceMethods
	238	# Value of the parent column
	239	def parent_id
	240	self[parent_column_name]
	241	end
	242
	243	# Value of the left column
	244	def left
	245	self[left_column_name]
	246	end
	247
	248	# Value of the right column
	249	def right
	250	self[right_column_name]
	251	end
	252
	253	# Returns true if this is a root node.
	254	def root?
	255	parent_id.nil?
	256	end
	257
	258	def leaf?
	259	right - left == 1
	260	end
	261
	262	# Returns true is this is a child node
	263	def child?
	264	!parent_id.nil?
	265	end
	266
	267	# order by left column
	268	def <=>(x)
	269	left <=> x.left
	270	end
	271
	272	# Redefine to act like active record
	273	def ==(comparison_object)
	274	comparison_object.equal?(self) \|\|
	275	(comparison_object.instance_of?(self.class) &&
	276	comparison_object.id == id &&
	277	!comparison_object.new_record?)
	278	end
	279
	280	# Returns root
	281	def root
	282	self_and_ancestors.find(:first)
	283	end
	284
	285	# Returns the immediate parent
	286	def parent
	287	nested_set_scope.find_by_id(parent_id) if parent_id
	288	end
	289
	290	# Returns the array of all parents and self
	291	def self_and_ancestors
	292	nested_set_scope.scoped :conditions => [
	293	"#{self.class.table_name}.#{quoted_left_column_name} <= ? AND #{self.class.table_name}.#{quoted_right_column_name} >= ?", left, right
	294	]
	295	end
	296
	297	# Returns an array of all parents
	298	def ancestors
	299	without_self self_and_ancestors
	300	end
	301
	302	# Returns the array of all children of the parent, including self
	303	def self_and_siblings
	304	nested_set_scope.scoped :conditions => {parent_column_name => parent_id}
	305	end
	306
	307	# Returns the array of all children of the parent, except self
	308	def siblings
	309	without_self self_and_siblings
	310	end
	311
	312	# Returns a set of all of its nested children which do not have children
	313	def leaves
	314	descendants.scoped :conditions => "#{self.class.table_name}.#{quoted_right_column_name} - #{self.class.table_name}.#{quoted_left_column_name} = 1"
	315	end
	316
	317	# Returns the level of this object in the tree
	318	# root level is 0
	319	def level
	320	parent_id.nil? ? 0 : ancestors.count
	321	end
	322
	323	# Returns a set of itself and all of its nested children
	324	def self_and_descendants
	325	nested_set_scope.scoped :conditions => [
	326	"#{self.class.table_name}.#{quoted_left_column_name} >= ? AND #{self.class.table_name}.#{quoted_right_column_name} <= ?", left, right
	327	]
	328	end
	329
	330	# Returns a set of all of its children and nested children
	331	def descendants
	332	without_self self_and_descendants
	333	end
	334
	335	# Returns a set of only this entry's immediate children
	336	def children
	337	nested_set_scope.scoped :conditions => {parent_column_name => self}
	338	end
	339
	340	def is_descendant_of?(other)
	341	other.left < self.left && self.left < other.right && same_scope?(other)
	342	end
	343
	344	def is_or_is_descendant_of?(other)
	345	other.left <= self.left && self.left < other.right && same_scope?(other)
	346	end
	347
	348	def is_ancestor_of?(other)
	349	self.left < other.left && other.left < self.right && same_scope?(other)
	350	end
	351
	352	def is_or_is_ancestor_of?(other)
	353	self.left <= other.left && other.left < self.right && same_scope?(other)
	354	end
	355
	356	# Check if other model is in the same scope
	357	def same_scope?(other)
	358	Array(acts_as_nested_set_options[:scope]).all? do \|attr\|
	359	self.send(attr) == other.send(attr)
	360	end
	361	end
	362
	363	# Find the first sibling to the left
	364	def left_sibling
	365	siblings.find(:first, :conditions => ["#{self.class.table_name}.#{quoted_left_column_name} < ?", left],
	366	:order => "#{self.class.table_name}.#{quoted_left_column_name} DESC")
	367	end
	368
	369	# Find the first sibling to the right
	370	def right_sibling
	371	siblings.find(:first, :conditions => ["#{self.class.table_name}.#{quoted_left_column_name} > ?", left])
	372	end
	373
	374	# Shorthand method for finding the left sibling and moving to the left of it.
	375	def move_left
	376	move_to_left_of left_sibling
	377	end
	378
	379	# Shorthand method for finding the right sibling and moving to the right of it.
	380	def move_right
	381	move_to_right_of right_sibling
	382	end
	383
	384	# Move the node to the left of another node (you can pass id only)
	385	def move_to_left_of(node)
	386	move_to node, :left
	387	end
	388
	389	# Move the node to the left of another node (you can pass id only)
	390	def move_to_right_of(node)
	391	move_to node, :right
	392	end
	393
	394	# Move the node to the child of another node (you can pass id only)
	395	def move_to_child_of(node)
	396	move_to node, :child
	397	end
	398
	399	# Move the node to root nodes
	400	def move_to_root
	401	move_to nil, :root
	402	end
	403
	404	def move_possible?(target)
	405	self != target && # Can't target self
	406	same_scope?(target) && # can't be in different scopes
	407	# !(left..right).include?(target.left..target.right) # this needs tested more
	408	# detect impossible move
	409	!((left <= target.left && right >= target.left) or (left <= target.right && right >= target.right))
	410	end
	411
	412	def to_text
	413	self_and_descendants.map do \|node\|
	414	"#{''(node.level+1)} #{node.id} #{node.to_s} (#{node.parent_id}, #{node.left}, #{node.right})"
	415	end.join("\n")
	416	end
	417
	418	protected
	419
	420	def without_self(scope)
	421	scope.scoped :conditions => ["#{self.class.table_name}.#{self.class.primary_key} != ?", self]
	422	end
	423
	424	# All nested set queries should use this nested_set_scope, which performs finds on
	425	# the base ActiveRecord class, using the :scope declared in the acts_as_nested_set
	426	# declaration.
	427	def nested_set_scope
	428	options = {:order => quoted_left_column_name}
	429	scopes = Array(acts_as_nested_set_options[:scope])
	430	options[:conditions] = scopes.inject({}) do \|conditions,attr\|
	431	conditions.merge attr => self[attr]
	432	end unless scopes.empty?
	433	self.class.base_class.scoped options
	434	end
	435
	436	# on creation, set automatically lft and rgt to the end of the tree
	437	def set_default_left_and_right
	438	maxright = nested_set_scope.maximum(right_column_name) \|\| 0
	439	# adds the new node to the right of all existing nodes
	440	self[left_column_name] = maxright + 1
	441	self[right_column_name] = maxright + 2
	442	end
	443
	444	# Prunes a branch off of the tree, shifting all of the elements on the right
	445	# back to the left so the counts still work.
	446	def prune_from_tree
	447	return if right.nil? \|\| left.nil?
	448	diff = right - left + 1
	449
	450	delete_method = acts_as_nested_set_options[:dependent] == :destroy ?
	451	:destroy_all : :delete_all
	452
	453	self.class.base_class.transaction do
	454	nested_set_scope.send(delete_method,
	455	["#{quoted_left_column_name} > ? AND #{quoted_right_column_name} < ?",
	456	left, right]
	457	)
	458	nested_set_scope.update_all(
	459	["#{quoted_left_column_name} = (#{quoted_left_column_name} - ?)", diff],
	460	["#{quoted_left_column_name} >= ?", right]
	461	)
	462	nested_set_scope.update_all(
	463	["#{quoted_right_column_name} = (#{quoted_right_column_name} - ?)", diff],
	464	["#{quoted_right_column_name} >= ?", right]
	465	)
	466	end
	467	end
	468
	469	# reload left, right, and parent
	470	def reload_nested_set
	471	reload(:select => "#{quoted_left_column_name}, " +
	472	"#{quoted_right_column_name}, #{quoted_parent_column_name}")
	473	end
	474
	475	def move_to(target, position)
	476	raise ActiveRecord::ActiveRecordError, "You cannot move a new node" if self.new_record?
	477	return if callback(:before_move) == false
	478	transaction do
	479	if target.is_a? self.class.base_class
	480	target.reload_nested_set
	481	elsif position != :root
	482	# load object if node is not an object
	483	target = nested_set_scope.find(target)
	484	end
	485	self.reload_nested_set
	486
	487	unless position == :root \|\| move_possible?(target)
	488	raise ActiveRecord::ActiveRecordError, "Impossible move, target node cannot be inside moved tree."
	489	end
	490
	491	bound = case position
	492	when :child; target[right_column_name]
	493	when :left; target[left_column_name]
	494	when :right; target[right_column_name] + 1
	495	when :root; 1
	496	else raise ActiveRecord::ActiveRecordError, "Position should be :child, :left, :right or :root ('#{position}' received)."
	497	end
	498
	499	if bound > self[right_column_name]
	500	bound = bound - 1
	501	other_bound = self[right_column_name] + 1
	502	else
	503	other_bound = self[left_column_name] - 1
	504	end
	505
	506	# there would be no change
	507	return if bound == self[right_column_name] \|\| bound == self[left_column_name]
	508
	509	# we have defined the boundaries of two non-overlapping intervals,
	510	# so sorting puts both the intervals and their boundaries in order
	511	a, b, c, d = [self[left_column_name], self[right_column_name], bound, other_bound].sort
	512
	513	new_parent = case position
	514	when :child; target.id
	515	when :root; nil
	516	else target[parent_column_name]
	517	end
	518
	519	self.class.base_class.update_all([
	520	"#{quoted_left_column_name} = CASE " +
	521	"WHEN #{quoted_left_column_name} BETWEEN :a AND :b " +
	522	"THEN #{quoted_left_column_name} + :d - :b " +
	523	"WHEN #{quoted_left_column_name} BETWEEN :c AND :d " +
	524	"THEN #{quoted_left_column_name} + :a - :c " +
	525	"ELSE #{quoted_left_column_name} END, " +
	526	"#{quoted_right_column_name} = CASE " +
	527	"WHEN #{quoted_right_column_name} BETWEEN :a AND :b " +
	528	"THEN #{quoted_right_column_name} + :d - :b " +
	529	"WHEN #{quoted_right_column_name} BETWEEN :c AND :d " +
	530	"THEN #{quoted_right_column_name} + :a - :c " +
	531	"ELSE #{quoted_right_column_name} END, " +
	532	"#{quoted_parent_column_name} = CASE " +
	533	"WHEN #{self.class.base_class.primary_key} = :id THEN :new_parent " +
	534	"ELSE #{quoted_parent_column_name} END",
	535	{:a => a, :b => b, :c => c, :d => d, :id => self.id, :new_parent => new_parent}
	536	], nested_set_scope.proxy_options[:conditions])
	537	end
	538	target.reload_nested_set if target
	539	self.reload_nested_set
	540	callback(:after_move)
	541	end
	542
	543	end
	544
	545	end
	546	end
	547	end

vendor/plugins/awesome_nested_set/lib/awesome_nested_set/compatability.rb created 644 +29 0

			@@ -0,0 +1,29
		1	# Rails <2.x doesn't define #except
		2	class Hash #:nodoc:
		3	# Returns a new hash without the given keys.
		4	def except(*keys)
		5	clone.except!(*keys)
		6	end unless method_defined?(:except)
		7
		8	# Replaces the hash without the given keys.
		9	def except!(*keys)
		10	keys.map! { \|key\| convert_key(key) } if respond_to?(:convert_key)
		11	keys.each { \|key\| delete(key) }
		12	self
		13	end unless method_defined?(:except!)
		14	end
		15
		16	# NamedScope is new to Rails 2.1
		17	unless defined? ActiveRecord::NamedScope
		18	require 'awesome_nested_set/named_scope'
		19	ActiveRecord::Base.class_eval do
		20	include CollectiveIdea::NamedScope
		21	end
		22	end
		23
		24	# Rails 1.2.x doesn't define #quoted_table_name
		25	class ActiveRecord::Base #:nodoc:
		26	def self.quoted_table_name
		27	self.connection.quote_column_name(self.table_name)
		28	end unless methods.include?('quoted_table_name')
		29	end No newline at end of file

vendor/plugins/awesome_nested_set/lib/awesome_nested_set/helper.rb created 644 +40 0

			@@ -0,0 +1,40
		1	module CollectiveIdea #:nodoc:
		2	module Acts #:nodoc:
		3	module NestedSet #:nodoc:
		4	# This module provides some helpers for the model classes using acts_as_nested_set.
		5	# It is included by default in all views.
		6	#
		7	module Helper
		8	# Returns options for select.
		9	# You can exclude some items from the tree.
		10	# You can pass a block receiving an item and returning the string displayed in the select.
		11	#
		12	# == Params
		13	# * +class_or_item+ - Class name or top level times
		14	# * +mover+ - The item that is being move, used to exlude impossible moves
		15	# * +&block+ - a block that will be used to display: { \|item\| ... item.name }
		16	#
		17	# == Usage
		18	#
		19	# <%= f.select :parent_id, nested_set_options(Category, @category) {\|i\|
		20	# "#{'–' * i.level} #{i.name}"
		21	# }) %>
		22	#
		23	def nested_set_options(class_or_item, mover = nil)
		24	class_or_item = class_or_item.roots if class_or_item.is_a?(Class)
		25	items = Array(class_or_item)
		26	result = []
		27	items.each do \|root\|
		28	result += root.self_and_descendants.map do \|i\|
		29	if mover.nil? \|\| mover.new_record? \|\| mover.move_possible?(i)
		30	[yield(i), i.id]
		31	end
		32	end.compact
		33	end
		34	result
		35	end
		36
		37	end
		38	end
		39	end
		40	end No newline at end of file

vendor/plugins/awesome_nested_set/lib/awesome_nested_set/named_scope.rb created 644 +140 0

			@@ -0,0 +1,140
		1	# Taken from Rails 2.1
		2	module CollectiveIdea #:nodoc:
		3	module NamedScope #:nodoc:
		4	# All subclasses of ActiveRecord::Base have two named_scopes:
		5	# * <tt>all</tt>, which is similar to a <tt>find(:all)</tt> query, and
		6	# * <tt>scoped</tt>, which allows for the creation of anonymous scopes, on the fly:
		7	#
		8	# Shirt.scoped(:conditions => {:color => 'red'}).scoped(:include => :washing_instructions)
		9	#
		10	# These anonymous scopes tend to be useful when procedurally generating complex queries, where passing
		11	# intermediate values (scopes) around as first-class objects is convenient.
		12	def self.included(base)
		13	base.class_eval do
		14	extend ClassMethods
		15	named_scope :scoped, lambda { \|scope\| scope }
		16	end
		17	end
		18
		19	module ClassMethods #:nodoc:
		20	def scopes
		21	read_inheritable_attribute(:scopes) \|\| write_inheritable_attribute(:scopes, {})
		22	end
		23
		24	# Adds a class method for retrieving and querying objects. A scope represents a narrowing of a database query,
		25	# such as <tt>:conditions => {:color => :red}, :select => 'shirts.*', :include => :washing_instructions</tt>.
		26	#
		27	# class Shirt < ActiveRecord::Base
		28	# named_scope :red, :conditions => {:color => 'red'}
		29	# named_scope :dry_clean_only, :joins => :washing_instructions, :conditions => ['washing_instructions.dry_clean_only = ?', true]
		30	# end
		31	#
		32	# The above calls to <tt>named_scope</tt> define class methods <tt>Shirt.red</tt> and <tt>Shirt.dry_clean_only</tt>. <tt>Shirt.red</tt>,
		33	# in effect, represents the query <tt>Shirt.find(:all, :conditions => {:color => 'red'})</tt>.
		34	#
		35	# Unlike Shirt.find(...), however, the object returned by <tt>Shirt.red</tt> is not an Array; it resembles the association object
		36	# constructed by a <tt>has_many</tt> declaration. For instance, you can invoke <tt>Shirt.red.find(:first)</tt>, <tt>Shirt.red.count</tt>,
		37	# <tt>Shirt.red.find(:all, :conditions => {:size => 'small'})</tt>. Also, just
		38	# as with the association objects, name scopes acts like an Array, implementing Enumerable; <tt>Shirt.red.each(&block)</tt>,
		39	# <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if Shirt.red really were an Array.
		40	#
		41	# These named scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are both red and dry clean only.
		42	# Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt> returns the number of garments
		43	# for which these criteria obtain. Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
		44	#
		45	# All scopes are available as class methods on the ActiveRecord descendent upon which the scopes were defined. But they are also available to
		46	# <tt>has_many</tt> associations. If,
		47	#
		48	# class Person < ActiveRecord::Base
		49	# has_many :shirts
		50	# end
		51	#
		52	# then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean
		53	# only shirts.
		54	#
		55	# Named scopes can also be procedural.
		56	#
		57	# class Shirt < ActiveRecord::Base
		58	# named_scope :colored, lambda { \|color\|
		59	# { :conditions => { :color => color } }
		60	# }
		61	# end
		62	#
		63	# In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.
		64	#
		65	# Named scopes can also have extensions, just as with <tt>has_many</tt> declarations:
		66	#
		67	# class Shirt < ActiveRecord::Base
		68	# named_scope :red, :conditions => {:color => 'red'} do
		69	# def dom_id
		70	# 'red_shirts'
		71	# end
		72	# end
		73	# end
		74	#
		75	#
		76	# For testing complex named scopes, you can examine the scoping options using the
		77	# <tt>proxy_options</tt> method on the proxy itself.
		78	#
		79	# class Shirt < ActiveRecord::Base
		80	# named_scope :colored, lambda { \|color\|
		81	# { :conditions => { :color => color } }
		82	# }
		83	# end
		84	#
		85	# expected_options = { :conditions => { :colored => 'red' } }
		86	# assert_equal expected_options, Shirt.colored('red').proxy_options
		87	def named_scope(name, options = {}, &block)
		88	scopes[name] = lambda do \|parent_scope, *args\|
		89	Scope.new(parent_scope, case options
		90	when Hash
		91	options
		92	when Proc
		93	options.call(*args)
		94	end, &block)
		95	end
		96	(class << self; self end).instance_eval do
		97	define_method name do \|*args\|
		98	scopes[name].call(self, *args)
		99	end
		100	end
		101	end
		102	end
		103
		104	class Scope #:nodoc:
		105	attr_reader :proxy_scope, :proxy_options
		106	[].methods.each { \|m\| delegate m, :to => :proxy_found unless m =~ /(^__\|^nil\?\|^send\|class\|extend\|find\|count\|sum\|average\|maximum\|minimum\|paginate)/ }
		107	delegate :scopes, :with_scope, :to => :proxy_scope
		108
		109	def initialize(proxy_scope, options, &block)
		110	[options[:extend]].flatten.each { \|extension\| extend extension } if options[:extend]
		111	extend Module.new(&block) if block_given?
		112	@proxy_scope, @proxy_options = proxy_scope, options.except(:extend)
		113	end
		114
		115	def reload
		116	load_found; self
		117	end
		118
		119	protected
		120	def proxy_found
		121	@found \|\| load_found
		122	end
		123
		124	private
		125	def method_missing(method, *args, &block)
		126	if scopes.include?(method)
		127	scopes[method].call(self, *args)
		128	else
		129	with_scope :find => proxy_options do
		130	proxy_scope.send(method, *args, &block)
		131	end
		132	end
		133	end
		134
		135	def load_found
		136	@found = find(:all)
		137	end
		138	end
		139	end
		140	end No newline at end of file

vendor/plugins/awesome_nested_set/rails/init.rb created 644 +13 0

			@@ -0,0 +1,13
		1	require 'awesome_nested_set/compatability'
		2	require 'awesome_nested_set'
		3
		4	ActiveRecord::Base.class_eval do
		5	include CollectiveIdea::Acts::NestedSet
		6	end
		7
		8	if defined?(ActionView)
		9	require 'awesome_nested_set/helper'
		10	ActionView::Base.class_eval do
		11	include CollectiveIdea::Acts::NestedSet::Helper
		12	end
		13	end No newline at end of file

vendor/plugins/awesome_nested_set/test/awesome_nested_set/helper_test.rb created 644 +41 0

			@@ -0,0 +1,41
		1	require File.dirname(__FILE__) + '/../test_helper'
		2
		3	module CollectiveIdea
		4	module Acts #:nodoc:
		5	module NestedSet #:nodoc:
		6	class AwesomeNestedSetTest < Test::Unit::TestCase
		7	include Helper
		8	fixtures :categories
		9
		10	def test_nested_set_options
		11	expected = [
		12	[" Top Level", 1],
		13	["- Child 1", 2],
		14	['- Child 2', 3],
		15	['-- Child 2.1', 4],
		16	['- Child 3', 5],
		17	[" Top Level 2", 6]
		18	]
		19	actual = nested_set_options(Category) do \|c\|
		20	"#{'-' * c.level} #{c.name}"
		21	end
		22	assert_equal expected, actual
		23	end
		24
		25	def test_nested_set_options_with_mover
		26	expected = [
		27	[" Top Level", 1],
		28	["- Child 1", 2],
		29	['- Child 3', 5],
		30	[" Top Level 2", 6]
		31	]
		32	actual = nested_set_options(Category, categories(:child_2)) do \|c\|
		33	"#{'-' * c.level} #{c.name}"
		34	end
		35	assert_equal expected, actual
		36	end
		37
		38	end
		39	end
		40	end
		41	end No newline at end of file

vendor/plugins/awesome_nested_set/test/awesome_nested_set_test.rb created 644 +603 0

This diff has been collapsed as it changes many lines, (603 lines changed) Show them Hide them
		@@ -0,0 +1,603
	1	require File.dirname(__FILE__) + '/test_helper'
	2
	3	class Note < ActiveRecord::Base
	4	acts_as_nested_set :scope => [:notable_id, :notable_type]
	5	end
	6
	7	class AwesomeNestedSetTest < Test::Unit::TestCase
	8
	9	class Default < ActiveRecord::Base
	10	acts_as_nested_set
	11	set_table_name 'categories'
	12	end
	13	class Scoped < ActiveRecord::Base
	14	acts_as_nested_set :scope => :organization
	15	set_table_name 'categories'
	16	end
	17
	18	def test_left_column_default
	19	assert_equal 'lft', Default.acts_as_nested_set_options[:left_column]
	20	end
	21
	22	def test_right_column_default
	23	assert_equal 'rgt', Default.acts_as_nested_set_options[:right_column]
	24	end
	25
	26	def test_parent_column_default
	27	assert_equal 'parent_id', Default.acts_as_nested_set_options[:parent_column]
	28	end
	29
	30	def test_scope_default
	31	assert_nil Default.acts_as_nested_set_options[:scope]
	32	end
	33
	34	def test_left_column_name
	35	assert_equal 'lft', Default.left_column_name
	36	assert_equal 'lft', Default.new.left_column_name
	37	end
	38
	39	def test_right_column_name
	40	assert_equal 'rgt', Default.right_column_name
	41	assert_equal 'rgt', Default.new.right_column_name
	42	end
	43
	44	def test_parent_column_name
	45	assert_equal 'parent_id', Default.parent_column_name
	46	assert_equal 'parent_id', Default.new.parent_column_name
	47	end
	48
	49	def test_quoted_left_column_name
	50	quoted = Default.connection.quote_column_name('lft')
	51	assert_equal quoted, Default.quoted_left_column_name
	52	assert_equal quoted, Default.new.quoted_left_column_name
	53	end
	54
	55	def test_quoted_right_column_name
	56	quoted = Default.connection.quote_column_name('rgt')
	57	assert_equal quoted, Default.quoted_right_column_name
	58	assert_equal quoted, Default.new.quoted_right_column_name
	59	end
	60
	61	def test_left_column_protected_from_assignment
	62	assert_raises(ActiveRecord::ActiveRecordError) { Category.new.lft = 1 }
	63	end
	64
	65	def test_right_column_protected_from_assignment
	66	assert_raises(ActiveRecord::ActiveRecordError) { Category.new.rgt = 1 }
	67	end
	68
	69	def test_parent_column_protected_from_assignment
	70	assert_raises(ActiveRecord::ActiveRecordError) { Category.new.parent_id = 1 }
	71	end
	72
	73	def test_colums_protected_on_initialize
	74	c = Category.new(:lft => 1, :rgt => 2, :parent_id => 3)
	75	assert_nil c.lft
	76	assert_nil c.rgt
	77	assert_nil c.parent_id
	78	end
	79
	80	def test_scoped_appends_id
	81	assert_equal :organization_id, Scoped.acts_as_nested_set_options[:scope]
	82	end
	83
	84	def test_roots_class_method
	85	assert_equal Category.find_all_by_parent_id(nil), Category.roots
	86	end
	87
	88	def test_root_class_method
	89	assert_equal categories(:top_level), Category.root
	90	end
	91
	92	def test_root
	93	assert_equal categories(:top_level), categories(:child_3).root
	94	end
	95
	96	def test_root?
	97	assert categories(:top_level).root?
	98	assert categories(:top_level_2).root?
	99	end
	100
	101	def test_leaves_class_method
	102	assert_equal Category.find(:all, :conditions => "#{Category.right_column_name} - #{Category.left_column_name} = 1"), Category.leaves
	103	assert_equal Category.leaves.count, 4
	104	assert (Category.leaves.include? categories(:child_1))
	105	assert (Category.leaves.include? categories(:child_2_1))
	106	assert (Category.leaves.include? categories(:child_3))
	107	assert (Category.leaves.include? categories(:top_level_2))
	108	end
	109
	110	def test_leaf
	111	assert categories(:child_1).leaf?
	112	assert categories(:child_2_1).leaf?
	113	assert categories(:child_3).leaf?
	114	assert categories(:top_level_2).leaf?
	115
	116	assert !categories(:top_level).leaf?
	117	assert !categories(:child_2).leaf?
	118	end
	119
	120	def test_parent
	121	assert_equal categories(:child_2), categories(:child_2_1).parent
	122	end
	123
	124	def test_self_and_ancestors
	125	child = categories(:child_2_1)
	126	self_and_ancestors = [categories(:top_level), categories(:child_2), child]
	127	assert_equal self_and_ancestors, child.self_and_ancestors
	128	end
	129
	130	def test_ancestors
	131	child = categories(:child_2_1)
	132	ancestors = [categories(:top_level), categories(:child_2)]
	133	assert_equal ancestors, child.ancestors
	134	end
	135
	136	def test_self_and_siblings
	137	child = categories(:child_2)
	138	self_and_siblings = [categories(:child_1), child, categories(:child_3)]
	139	assert_equal self_and_siblings, child.self_and_siblings
	140	assert_nothing_raised do
	141	tops = [categories(:top_level), categories(:top_level_2)]
	142	assert_equal tops, categories(:top_level).self_and_siblings
	143	end
	144	end
	145
	146	def test_siblings
	147	child = categories(:child_2)
	148	siblings = [categories(:child_1), categories(:child_3)]
	149	assert_equal siblings, child.siblings
	150	end
	151
	152	def test_leaves
	153	leaves = [categories(:child_1), categories(:child_2_1), categories(:child_3), categories(:top_level_2)]
	154	assert categories(:top_level).leaves, leaves
	155	end
	156
	157	def test_level
	158	assert_equal 0, categories(:top_level).level
	159	assert_equal 1, categories(:child_1).level
	160	assert_equal 2, categories(:child_2_1).level
	161	end
	162
	163	def test_has_children?
	164	assert categories(:child_2_1).children.empty?
	165	assert !categories(:child_2).children.empty?
	166	assert !categories(:top_level).children.empty?
	167	end
	168
	169	def test_self_and_descendents
	170	parent = categories(:top_level)
	171	self_and_descendants = [parent, categories(:child_1), categories(:child_2),
	172	categories(:child_2_1), categories(:child_3)]
	173	assert_equal self_and_descendants, parent.self_and_descendants
	174	assert_equal self_and_descendants, parent.self_and_descendants.count
	175	end
	176
	177	def test_descendents
	178	lawyers = Category.create!(:name => "lawyers")
	179	us = Category.create!(:name => "United States")
	180	us.move_to_child_of(lawyers)
	181	patent = Category.create!(:name => "Patent Law")
	182	patent.move_to_child_of(us)
	183	lawyers.reload
	184
	185	assert_equal 1, lawyers.children.size
	186	assert_equal 1, us.children.size
	187	assert_equal 2, lawyers.descendants.size
	188	end
	189
	190	def test_self_and_descendents
	191	parent = categories(:top_level)
	192	descendants = [categories(:child_1), categories(:child_2),
	193	categories(:child_2_1), categories(:child_3)]
	194	assert_equal descendants, parent.descendants
	195	end
	196
	197	def test_children
	198	category = categories(:top_level)
	199	category.children.each {\|c\| assert_equal category.id, c.parent_id }
	200	end
	201
	202	def test_is_or_is_ancestor_of?
	203	assert categories(:top_level).is_or_is_ancestor_of?(categories(:child_1))
	204	assert categories(:top_level).is_or_is_ancestor_of?(categories(:child_2_1))
	205	assert categories(:child_2).is_or_is_ancestor_of?(categories(:child_2_1))
	206	assert !categories(:child_2_1).is_or_is_ancestor_of?(categories(:child_2))
	207	assert !categories(:child_1).is_or_is_ancestor_of?(categories(:child_2))
	208	assert categories(:child_1).is_or_is_ancestor_of?(categories(:child_1))
	209	end
	210
	211	def test_is_ancestor_of?
	212	assert categories(:top_level).is_ancestor_of?(categories(:child_1))
	213	assert categories(:top_level).is_ancestor_of?(categories(:child_2_1))
	214	assert categories(:child_2).is_ancestor_of?(categories(:child_2_1))
	215	assert !categories(:child_2_1).is_ancestor_of?(categories(:child_2))
	216	assert !categories(:child_1).is_ancestor_of?(categories(:child_2))
	217	assert !categories(:child_1).is_ancestor_of?(categories(:child_1))
	218	end
	219
	220	def test_is_or_is_ancestor_of_with_scope
	221	root = Scoped.root
	222	child = root.children.first
	223	assert root.is_or_is_ancestor_of?(child)
	224	child.update_attribute :organization_id, 'different'
	225	assert !root.is_or_is_ancestor_of?(child)
	226	end
	227
	228	def test_is_or_is_descendant_of?
	229	assert categories(:child_1).is_or_is_descendant_of?(categories(:top_level))
	230	assert categories(:child_2_1).is_or_is_descendant_of?(categories(:top_level))
	231	assert categories(:child_2_1).is_or_is_descendant_of?(categories(:child_2))
	232	assert !categories(:child_2).is_or_is_descendant_of?(categories(:child_2_1))
	233	assert !categories(:child_2).is_or_is_descendant_of?(categories(:child_1))
	234	assert categories(:child_1).is_or_is_descendant_of?(categories(:child_1))
	235	end
	236
	237	def test_is_descendant_of?
	238	assert categories(:child_1).is_descendant_of?(categories(:top_level))
	239	assert categories(:child_2_1).is_descendant_of?(categories(:top_level))
	240	assert categories(:child_2_1).is_descendant_of?(categories(:child_2))
	241	assert !categories(:child_2).is_descendant_of?(categories(:child_2_1))
	242	assert !categories(:child_2).is_descendant_of?(categories(:child_1))
	243	assert !categories(:child_1).is_descendant_of?(categories(:child_1))
	244	end
	245
	246	def test_is_or_is_descendant_of_with_scope
	247	root = Scoped.root
	248	child = root.children.first
	249	assert child.is_or_is_descendant_of?(root)
	250	child.update_attribute :organization_id, 'different'
	251	assert !child.is_or_is_descendant_of?(root)
	252	end
	253
	254	def test_same_scope?
	255	root = Scoped.root
	256	child = root.children.first
	257	assert child.same_scope?(root)
	258	child.update_attribute :organization_id, 'different'
	259	assert !child.same_scope?(root)
	260	end
	261
	262	def test_left_sibling
	263	assert_equal categories(:child_1), categories(:child_2).left_sibling
	264	assert_equal categories(:child_2), categories(:child_3).left_sibling
	265	end
	266
	267	def test_left_sibling_of_root
	268	assert_nil categories(:top_level).left_sibling
	269	end
	270
	271	def test_left_sibling_without_siblings
	272	assert_nil categories(:child_2_1).left_sibling
	273	end
	274
	275	def test_left_sibling_of_leftmost_node
	276	assert_nil categories(:child_1).left_sibling
	277	end
	278
	279	def test_right_sibling
	280	assert_equal categories(:child_3), categories(:child_2).right_sibling
	281	assert_equal categories(:child_2), categories(:child_1).right_sibling
	282	end
	283
	284	def test_right_sibling_of_root
	285	assert_equal categories(:top_level_2), categories(:top_level).right_sibling
	286	assert_nil categories(:top_level_2).right_sibling
	287	end
	288
	289	def test_right_sibling_without_siblings
	290	assert_nil categories(:child_2_1).right_sibling
	291	end
	292
	293	def test_right_sibling_of_rightmost_node
	294	assert_nil categories(:child_3).right_sibling
	295	end
	296
	297	def test_move_left
	298	categories(:child_2).move_left
	299	assert_nil categories(:child_2).left_sibling
	300	assert_equal categories(:child_1), categories(:child_2).right_sibling
	301	assert Category.valid?
	302	end
	303
	304	def test_move_right
	305	categories(:child_2).move_right
	306	assert_nil categories(:child_2).right_sibling
	307	assert_equal categories(:child_3), categories(:child_2).left_sibling
	308	assert Category.valid?
	309	end
	310
	311	def test_move_to_left_of
	312	categories(:child_3).move_to_left_of(categories(:child_1))
	313	assert_nil categories(:child_3).left_sibling
	314	assert_equal categories(:child_1), categories(:child_3).right_sibling
	315	assert Category.valid?
	316	end
	317
	318	def test_move_to_right_of
	319	categories(:child_1).move_to_right_of(categories(:child_3))
	320	assert_nil categories(:child_1).right_sibling
	321	assert_equal categories(:child_3), categories(:child_1).left_sibling
	322	assert Category.valid?
	323	end
	324
	325	def test_move_to_root
	326	categories(:child_2).move_to_root
	327	assert_nil categories(:child_2).parent
	328	assert_equal 0, categories(:child_2).level
	329	assert_equal 1, categories(:child_2_1).level
	330	assert_equal 1, categories(:child_2).left
	331	assert_equal 4, categories(:child_2).right
	332	assert Category.valid?
	333	end
	334
	335	def test_move_to_child_of
	336	categories(:child_1).move_to_child_of(categories(:child_3))
	337	assert_equal categories(:child_3).id, categories(:child_1).parent_id
	338	assert Category.valid?
	339	end
	340
	341	def test_move_to_child_of_appends_to_end
	342	child = Category.create! :name => 'New Child'
	343	child.move_to_child_of categories(:top_level)
	344	assert_equal child, categories(:top_level).children.last
	345	end
	346
	347	def test_subtree_move_to_child_of
	348	assert_equal 4, categories(:child_2).left
	349	assert_equal 7, categories(:child_2).right
	350
	351	assert_equal 2, categories(:child_1).left
	352	assert_equal 3, categories(:child_1).right
	353
	354	categories(:child_2).move_to_child_of(categories(:child_1))
	355	assert Category.valid?
	356	assert_equal categories(:child_1).id, categories(:child_2).parent_id
	357
	358	assert_equal 3, categories(:child_2).left
	359	assert_equal 6, categories(:child_2).right
	360	assert_equal 2, categories(:child_1).left
	361	assert_equal 7, categories(:child_1).right
	362	end
	363
	364	def test_slightly_difficult_move_to_child_of
	365	assert_equal 11, categories(:top_level_2).left
	366	assert_equal 12, categories(:top_level_2).right
	367
	368	# create a new top-level node and move single-node top-level tree inside it.
	369	new_top = Category.create(:name => 'New Top')
	370	assert_equal 13, new_top.left
	371	assert_equal 14, new_top.right
	372
	373	categories(:top_level_2).move_to_child_of(new_top)
	374
	375	assert Category.valid?
	376	assert_equal new_top.id, categories(:top_level_2).parent_id
	377
	378	assert_equal 12, categories(:top_level_2).left
	379	assert_equal 13, categories(:top_level_2).right
	380	assert_equal 11, new_top.left
	381	assert_equal 14, new_top.right
	382	end
	383
	384	def test_difficult_move_to_child_of
	385	assert_equal 1, categories(:top_level).left
	386	assert_equal 10, categories(:top_level).right
	387	assert_equal 5, categories(:child_2_1).left
	388	assert_equal 6, categories(:child_2_1).right
	389
	390	# create a new top-level node and move an entire top-level tree inside it.
	391	new_top = Category.create(:name => 'New Top')
	392	categories(:top_level).move_to_child_of(new_top)
	393	categories(:child_2_1).reload
	394	assert Category.valid?
	395	assert_equal new_top.id, categories(:top_level).parent_id
	396
	397	assert_equal 4, categories(:top_level).left
	398	assert_equal 13, categories(:top_level).right
	399	assert_equal 8, categories(:child_2_1).left
	400	assert_equal 9, categories(:child_2_1).right
	401	end
	402
	403	#rebuild swaps the position of the 2 children when added using move_to_child twice onto same parent
	404	def test_move_to_child_more_than_once_per_parent_rebuild
	405	root1 = Category.create(:name => 'Root1')
	406	root2 = Category.create(:name => 'Root2')
	407	root3 = Category.create(:name => 'Root3')
	408
	409	root2.move_to_child_of root1
	410	root3.move_to_child_of root1
	411
	412	output = Category.roots.last.to_text
	413	Category.update_all('lft = null, rgt = null')
	414	Category.rebuild!
	415
	416	assert_equal Category.roots.last.to_text, output
	417	end
	418
	419	# doing move_to_child twice onto same parent from the furthest right first
	420	def test_move_to_child_more_than_once_per_parent_outside_in
	421	node1 = Category.create(:name => 'Node-1')
	422	node2 = Category.create(:name => 'Node-2')
	423	node3 = Category.create(:name => 'Node-3')
	424
	425	node2.move_to_child_of node1
	426	node3.move_to_child_of node1
	427
	428	output = Category.roots.last.to_text
	429	Category.update_all('lft = null, rgt = null')
	430	Category.rebuild!
	431
	432	assert_equal Category.roots.last.to_text, output
	433	end
	434
	435
	436	def test_valid_with_null_lefts
	437	assert Category.valid?
	438	Category.update_all('lft = null')
	439	assert !Category.valid?
	440	end
	441
	442	def test_valid_with_null_rights
	443	assert Category.valid?
	444	Category.update_all('rgt = null')
	445	assert !Category.valid?
	446	end
	447
	448	def test_valid_with_missing_intermediate_node
	449	# Even though child_2_1 will still exist, it is a sign of a sloppy delete, not an invalid tree.
	450	assert Category.valid?
	451	Category.delete(categories(:child_2).id)
	452	assert Category.valid?
	453	end
	454
	455	def test_valid_with_overlapping_and_rights
	456	assert Category.valid?
	457	categories(:top_level_2)['lft'] = 0
	458	categories(:top_level_2).save
	459	assert !Category.valid?
	460	end
	461
	462	def test_rebuild
	463	assert Category.valid?
	464	before_text = Category.root.to_text
	465	Category.update_all('lft = null, rgt = null')
	466	Category.rebuild!
	467	assert Category.valid?
	468	assert_equal before_text, Category.root.to_text
	469	end
	470
	471	def test_move_possible_for_sibling
	472	assert categories(:child_2).move_possible?(categories(:child_1))
	473	end
	474
	475	def test_move_not_possible_to_self
	476	assert !categories(:top_level).move_possible?(categories(:top_level))
	477	end
	478
	479	def test_move_not_possible_to_parent
	480	categories(:top_level).descendants.each do \|descendant\|
	481	assert !categories(:top_level).move_possible?(descendant)
	482	assert descendant.move_possible?(categories(:top_level))
	483	end
	484	end
	485
	486	def test_is_or_is_ancestor_of?
	487	[:child_1, :child_2, :child_2_1, :child_3].each do \|c\|
	488	assert categories(:top_level).is_or_is_ancestor_of?(categories(c))
	489	end
	490	assert !categories(:top_level).is_or_is_ancestor_of?(categories(:top_level_2))
	491	end
	492
	493	def test_left_and_rights_valid_with_blank_left
	494	assert Category.left_and_rights_valid?
	495	categories(:child_2)[:lft] = nil
	496	categories(:child_2).save(false)
	497	assert !Category.left_and_rights_valid?
	498	end
	499
	500	def test_left_and_rights_valid_with_blank_right
	501	assert Category.left_and_rights_valid?
	502	categories(:child_2)[:rgt] = nil
	503	categories(:child_2).save(false)
	504	assert !Category.left_and_rights_valid?
	505	end
	506
	507	def test_left_and_rights_valid_with_equal
	508	assert Category.left_and_rights_valid?
	509	categories(:top_level_2)[:lft] = categories(:top_level_2)[:rgt]
	510	categories(:top_level_2).save(false)
	511	assert !Category.left_and_rights_valid?
	512	end
	513
	514	def test_left_and_rights_valid_with_left_equal_to_parent
	515	assert Category.left_and_rights_valid?
	516	categories(:child_2)[:lft] = categories(:top_level)[:lft]
	517	categories(:child_2).save(false)
	518	assert !Category.left_and_rights_valid?
	519	end
	520
	521	def test_left_and_rights_valid_with_right_equal_to_parent
	522	assert Category.left_and_rights_valid?
	523	categories(:child_2)[:rgt] = categories(:top_level)[:rgt]
	524	categories(:child_2).save(false)
	525	assert !Category.left_and_rights_valid?
	526	end
	527
	528	def test_moving_dirty_objects_doesnt_invalidate_tree
	529	r1 = Category.create
	530	r2 = Category.create
	531	r3 = Category.create
	532	r4 = Category.create
	533	nodes = [r1, r2, r3, r4]
	534
	535	r2.move_to_child_of(r1)
	536	assert Category.valid?
	537
	538	r3.move_to_child_of(r1)
	539	assert Category.valid?
	540
	541	r4.move_to_child_of(r2)
	542	assert Category.valid?
	543	end
	544
	545	def test_multi_scoped_no_duplicates_for_columns?
	546	assert_nothing_raised do
	547	Note.no_duplicates_for_columns?
	548	end
	549	end
	550
	551	def test_multi_scoped_all_roots_valid?
	552	assert_nothing_raised do
	553	Note.all_roots_valid?
	554	end
	555	end
	556
	557	def test_multi_scoped
	558	note1 = Note.create!(:body => "A", :notable_id => 2, :notable_type => 'Category')
	559	note2 = Note.create!(:body => "B", :notable_id => 2, :notable_type => 'Category')
	560	note3 = Note.create!(:body => "C", :notable_id => 2, :notable_type => 'Default')
	561
	562	assert_equal [note1, note2], note1.self_and_siblings
	563	assert_equal [note3], note3.self_and_siblings
	564	end
	565
	566	def test_multi_scoped_rebuild
	567	root = Note.create!(:body => "A", :notable_id => 3, :notable_type => 'Category')
	568	child1 = Note.create!(:body => "B", :notable_id => 3, :notable_type => 'Category')
	569	child2 = Note.create!(:body => "C", :notable_id => 3, :notable_type => 'Category')
	570
	571	child1.move_to_child_of root
	572	child2.move_to_child_of root
	573
	574	Note.update_all('lft = null, rgt = null')
	575	Note.rebuild!
	576
	577	assert_equal Note.roots.find_by_body('A'), root
	578	assert_equal [child1, child2], Note.roots.find_by_body('A').children
	579	end
	580
	581	def test_same_scope_with_multi_scopes
	582	assert_nothing_raised do
	583	notes(:scope1).same_scope?(notes(:child_1))
	584	end
	585	assert notes(:scope1).same_scope?(notes(:child_1))
	586	assert notes(:child_1).same_scope?(notes(:scope1))
	587	assert !notes(:scope1).same_scope?(notes(:scope2))
	588	end
	589
	590	def test_quoting_of_multi_scope_column_names
	591	assert_equal ["\"notable_id\"", "\"notable_type\""], Note.quoted_scope_column_names
	592	end
	593
	594	def test_equal_in_same_scope
	595	assert_equal notes(:scope1), notes(:scope1)
	596	assert_not_equal notes(:scope1), notes(:child_1)
	597	end
	598
	599	def test_equal_in_different_scopes
	600	assert_not_equal notes(:scope1), notes(:scope2)
	601	end
	602
	603	end

vendor/plugins/awesome_nested_set/test/db/database.yml created 644 +18 0

			@@ -0,0 +1,18
		1	sqlite3:
		2	adapter: sqlite3
		3	dbfile: awesome_nested_set.sqlite3.db
		4	sqlite3mem:
		5	:adapter: sqlite3
		6	:dbfile: ":memory:"
		7	postgresql:
		8	:adapter: postgresql
		9	:username: postgres
		10	:password: postgres
		11	:database: awesome_nested_set_plugin_test
		12	:min_messages: ERROR
		13	mysql:
		14	:adapter: mysql
		15	:host: localhost
		16	:username: root
		17	:password:
		18	:database: awesome_nested_set_plugin_test No newline at end of file

vendor/plugins/awesome_nested_set/test/db/schema.rb created 644 +23 0

			@@ -0,0 +1,23
		1	ActiveRecord::Schema.define(:version => 0) do
		2
		3	create_table :categories, :force => true do \|t\|
		4	t.column :name, :string
		5	t.column :parent_id, :integer
		6	t.column :lft, :integer
		7	t.column :rgt, :integer
		8	t.column :organization_id, :integer
		9	end
		10
		11	create_table :departments, :force => true do \|t\|
		12	t.column :name, :string
		13	end
		14
		15	create_table :notes, :force => true do \|t\|
		16	t.column :body, :text
		17	t.column :parent_id, :integer
		18	t.column :lft, :integer
		19	t.column :rgt, :integer
		20	t.column :notable_id, :integer
		21	t.column :notable_type, :string
		22	end
		23	end

vendor/plugins/awesome_nested_set/test/fixtures/categories.yml created 644 +34 0

			@@ -0,0 +1,34
		1	top_level:
		2	id: 1
		3	name: Top Level
		4	lft: 1
		5	rgt: 10
		6	child_1:
		7	id: 2
		8	name: Child 1
		9	parent_id: 1
		10	lft: 2
		11	rgt: 3
		12	child_2:
		13	id: 3
		14	name: Child 2
		15	parent_id: 1
		16	lft: 4
		17	rgt: 7
		18	child_2_1:
		19	id: 4
		20	name: Child 2.1
		21	parent_id: 3
		22	lft: 5
		23	rgt: 6
		24	child_3:
		25	id: 5
		26	name: Child 3
		27	parent_id: 1
		28	lft: 8
		29	rgt: 9
		30	top_level_2:
		31	id: 6
		32	name: Top Level 2
		33	lft: 11
		34	rgt: 12

vendor/plugins/awesome_nested_set/test/fixtures/category.rb created 644 +15 0

			@@ -0,0 +1,15
		1	class Category < ActiveRecord::Base
		2	acts_as_nested_set
		3
		4	def to_s
		5	name
		6	end
		7
		8	def recurse &block
		9	block.call self, lambda{
		10	self.children.each do \|child\|
		11	child.recurse &block
		12	end
		13	}
		14	end
		15	end No newline at end of file

vendor/plugins/awesome_nested_set/test/fixtures/departments.yml created 644 +3 0

			@@ -0,0 +1,3
		1	top:
		2	id: 1
		3	name: Top No newline at end of file

vendor/plugins/awesome_nested_set/test/fixtures/notes.yml created 644 +38 0

			@@ -0,0 +1,38
		1	scope1:
		2	id: 1
		3	body: Top Level
		4	lft: 1
		5	rgt: 10
		6	notable_id: 1
		7	notable_type: Category
		8	child_1:
		9	id: 2
		10	body: Child 1
		11	parent_id: 1
		12	lft: 2
		13	rgt: 3
		14	notable_id: 1
		15	notable_type: Category
		16	child_2:
		17	id: 3
		18	body: Child 2
		19	parent_id: 1
		20	lft: 4
		21	rgt: 7
		22	notable_id: 1
		23	notable_type: Category
		24	child_3:
		25	id: 4
		26	body: Child 3
		27	parent_id: 1
		28	lft: 8
		29	rgt: 9
		30	notable_id: 1
		31	notable_type: Category
		32	scope2:
		33	id: 5
		34	body: Top Level 2
		35	lft: 1
		36	rgt: 2
		37	notable_id: 1
		38	notable_type: Departments

vendor/plugins/awesome_nested_set/test/test_helper.rb created 644 +31 0

			@@ -0,0 +1,31
		1	$:.unshift(File.dirname(__FILE__) + '/../lib')
		2	plugin_test_dir = File.dirname(__FILE__)
		3
		4	require 'rubygems'
		5	require 'test/unit'
		6	require 'multi_rails_init'
		7	# gem 'activerecord', '>= 2.0'
		8	require 'active_record'
		9	require 'action_controller'
		10	require 'action_view'
		11	require 'active_record/fixtures'
		12
		13	require plugin_test_dir + '/../init.rb'
		14
		15	ActiveRecord::Base.logger = Logger.new(plugin_test_dir + "/debug.log")
		16
		17	ActiveRecord::Base.configurations = YAML::load(IO.read(plugin_test_dir + "/db/database.yml"))
		18	ActiveRecord::Base.establish_connection(ENV["DB"] \|\| "sqlite3mem")
		19	ActiveRecord::Migration.verbose = false
		20	load(File.join(plugin_test_dir, "db", "schema.rb"))
		21
		22	Dir["#{plugin_test_dir}/fixtures/*.rb"].each {\|file\| require file }
		23
		24
		25	class Test::Unit::TestCase #:nodoc:
		26	self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
		27	self.use_transactional_fixtures = true
		28	self.use_instantiated_fixtures = false
		29
		30	fixtures :categories, :notes, :departments
		31	end No newline at end of file

app/controllers/admin_controller.rb +2 -11

                end
                def projects
-                 sort_init 'name', 'asc'
-                 sort_update %w(name is_public created_on)
                  @status = params[:status] ? params[:status].to_i : 1
                  c = ARCondition.new(@status == 0 ? "status <> 0" : ["status = ?", @status])
                    c << ["LOWER(identifier) LIKE ? OR LOWER(name) LIKE ?", name, name]
                  end
-                 @project_count = Project.count(:conditions => c.conditions)
-                 @project_pages = Paginator.new self, @project_count,
-             								per_page_option,
-             								params['page']
-                 @projects = Project.find :all, :order => sort_clause,
-                                     :conditions => c.conditions,
-             						:limit  =>  @project_pages.items_per_page,
-             						:offset =>  @project_pages.current.offset
+                 @projects = Project.find :all, :order => 'lft',
+                                                :conditions => c.conditions
                  render :action => "projects", :layout => false if request.xhr?
                end

app/controllers/projects_controller.rb +8 -14

                # Lists visible projects
                def index
-                 projects = Project.find :all,
-                                         :conditions => Project.visible_by(User.current),
-                                         :include => :parent
                  respond_to do |format|
                    format.html {
-                     @project_tree = projects.group_by {|p| p.parent || p}
-                     @project_tree.keys.each {|p| @project_tree[p] -= [p]}
+                     @projects = Project.visible.find(:all, :order => 'lft')
                    }
                    format.atom {
-                     render_feed(projects.sort_by(&:created_on).reverse.slice(0, Setting.feeds_limit.to_i),
-                                               :title => "#{Setting.app_title}: #{l(:label_project_latest)}")
+                     projects = Project.visible.find(:all, :order => 'created_on DESC',
+                                                           :limit => Setting.feeds_limit.to_i)
+                     render_feed(projects, :title => "#{Setting.app_title}: #{l(:label_project_latest)}")
                    }
                  end
                end
                def add
                  @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
                  @trackers = Tracker.all
-                 @root_projects = Project.find(:all,
-                                               :conditions => "parent_id IS NULL AND status = #{Project::STATUS_ACTIVE}",
-                                               :order => 'name')
                  @project = Project.new(params[:project])
                  if request.get?
                    @project.identifier = Project.next_identifier if Setting.sequential_project_identifiers?
                  else
                    @project.enabled_module_names = params[:enabled_modules]
                    if @project.save
+                     @project.set_parent!(params[:project]['parent_id']) if User.current.admin? && params[:project].has_key?('parent_id')
                      flash[:notice] = l(:notice_successful_create)
                      redirect_to :controller => 'admin', :action => 'projects'
              	  end
                  end
                  @members_by_role = @project.members.find(:all, :include => [:user, :role], :order => 'position').group_by {|m| m.role}
-                 @subprojects = @project.children.find(:all, :conditions => Project.visible_by(User.current))
+                 @subprojects = @project.children.visible
+                 @ancestors = @project.ancestors.visible
                  @news = @project.news.find(:all, :limit => 5, :include => [ :author, :project ], :order => "#{News.table_name}.created_on DESC")
                  @trackers = @project.rolled_up_trackers
                end
                def settings
-                 @root_projects = Project.find(:all,
-                                               :conditions => ["parent_id IS NULL AND status = #{Project::STATUS_ACTIVE} AND id <> ?", @project.id],
-                                               :order => 'name')
                  @issue_custom_fields = IssueCustomField.find(:all, :order => "#{CustomField.table_name}.position")
                  @issue_category ||= IssueCategory.new
                  @member ||= @project.members.new
                  if request.post?
                    @project.attributes = params[:project]
                    if @project.save
+                     @project.set_parent!(params[:project]['parent_id']) if User.current.admin? && params[:project].has_key?('parent_id')
                      flash[:notice] = l(:notice_successful_update)
                      redirect_to :action => 'settings', :id => @project
                    else

app/controllers/reports_controller.rb +4 -4

                    render :template => "reports/issue_report_details"
                  when "subproject"
                    @field = "project_id"
-                   @rows = @project.active_children
+                   @rows = @project.descendants.active
                    @data = issues_by_subproject
                    @report_title = l(:field_subproject)
                    render :template => "reports/issue_report_details"
                    @categories = @project.issue_categories
                    @assignees = @project.members.collect { |m| m.user }
                    @authors = @project.members.collect { |m| m.user }
-                   @subprojects = @project.active_children
+                   @subprojects = @project.descendants.active
                    issues_by_tracker
                    issues_by_version
                    issues_by_priority
                                                                #{Issue.table_name} i, #{IssueStatus.table_name} s
                                                              where
                                                                i.status_id=s.id
-                                                               and i.project_id IN (#{@project.active_children.collect{|p| p.id}.join(',')})
-                                                             group by s.id, s.is_closed, i.project_id") if @project.active_children.any?
+                                                               and i.project_id IN (#{@project.descendants.active.collect{|p| p.id}.join(',')})
+                                                             group by s.id, s.is_closed, i.project_id") if @project.descendants.active.any?
                  @issues_by_subproject ||= []
                end
              end

app/controllers/search_controller.rb +1 -1

                    when 'my_projects'
                      User.current.memberships.collect(&:project)
                    when 'subprojects'
-                     @project ? ([ @project ] + @project.active_children) : nil
+                     @project ? (@project.self_and_descendants.active) : nil
                    else
                      @project
                    end

app/controllers/users_controller.rb +1 -1

                  end
                  @auth_sources = AuthSource.find(:all)
                  @roles = Role.find_all_givable
-                 @projects = Project.find(:all, :order => 'name', :conditions => "status=#{Project::STATUS_ACTIVE}") - @user.projects
+                 @projects = Project.active.find(:all, :order => 'lft')
                  @membership ||= Member.new
                  @memberships = @user.memberships
                end

app/helpers/admin_helper.rb +8 0

                  options_for_select([[l(:label_all), ''],
                                      [l(:status_active), 1]], selected)
                end
+               def css_project_classes(project)
+                 s = 'project'
+                 s << ' root' if project.root?
+                 s << ' child' if project.child?
+                 s << (project.leaf? ? ' leaf' : ' parent')
+                 s
+               end
              end

app/helpers/application_helper.rb +39 0

		@@ -157,6 +157,45 module ApplicationHelper
157	157	s
158	158	end
159	159
	160	# Renders the project quick-jump box
	161	def render_project_jump_box
	162	# Retrieve them now to avoid a COUNT query
	163	projects = User.current.projects.all
	164	if projects.any?
	165	s = '<select onchange="if (this.value != \'\') { window.location = this.value; }">' +
	166	"<option selected='selected'>#{ l(:label_jump_to_a_project) }</option>" +
	167	'<option disabled="disabled">---</option>'
	168	s << project_tree_options_for_select(projects) do \|p\|
	169	{ :value => url_for(:controller => 'projects', :action => 'show', :id => p) }
	170	end
	171	s << '</select>'
	172	s
	173	end
	174	end
	175
	176	def project_tree_options_for_select(projects, options = {})
	177	s = ''
	178	project_tree(projects) do \|project, level\|
	179	name_prefix = (level > 0 ? (' ' * 2 * level + '» ') : '')
	180	tag_options = {:value => project.id, :selected => ((project == options[:selected]) ? 'selected' : nil)}
	181	tag_options.merge!(yield(project)) if block_given?
	182	s << content_tag('option', name_prefix + h(project), tag_options)
	183	end
	184	s
	185	end
	186
	187	# Yields the given block for each project with its level in the tree
	188	def project_tree(projects, &block)
	189	ancestors = []
	190	projects.sort_by(&:lft).each do \|project\|
	191	while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
	192	ancestors.pop
	193	end
	194	yield project, ancestors.size
	195	ancestors << project
	196	end
	197	end
	198
160	199	# Truncates and returns the string as a single line
161	200	def truncate_single_line(string, *args)
162	201	truncate(string, *args).gsub(%r{[\r\n]+}m, ' ')

app/helpers/projects_helper.rb +35 0

		@@ -33,4 +33,39 module ProjectsHelper
33	33	]
34	34	tabs.select {\|tab\| User.current.allowed_to?(tab[:action], @project)}
35	35	end
	36
	37	def parent_project_select_tag(project)
	38	options = '<option></option>' + project_tree_options_for_select(project.possible_parents, :selected => project.parent)
	39	content_tag('select', options, :name => 'project[parent_id]')
	40	end
	41
	42	# Renders a tree of projects as a nested set of unordered lists
	43	# The given collection may be a subset of the whole project tree
	44	# (eg. some intermediate nodes are private and can not be seen)
	45	def render_project_hierarchy(projects)
	46	s = ''
	47	if projects.any?
	48	ancestors = []
	49	projects.each do \|project\|
	50	if (ancestors.empty? \|\| project.is_descendant_of?(ancestors.last))
	51	s << "<ul class='projects #{ ancestors.empty? ? 'root' : nil}'>\n"
	52	else
	53	ancestors.pop
	54	s << "</li>"
	55	while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
	56	ancestors.pop
	57	s << "</ul></li>\n"
	58	end
	59	end
	60	classes = (ancestors.empty? ? 'root' : 'child')
	61	s << "<li class='#{classes}'><div class='#{classes}'>" +
	62	link_to(h(project), {:controller => 'projects', :action => 'show', :id => project}, :class => "project #{User.current.member_of?(project) ? 'my-project' : nil}")
	63	s << "<div class='wiki description'>#{textilizable(project.short_description, :project => project)}</div>" unless project.description.blank?
	64	s << "</div>\n"
	65	ancestors << project
	66	end
	67	s << ("</li></ul>\n" * ancestors.size)
	68	end
	69	s
	70	end
36	71	end

app/helpers/search_helper.rb +1 -1

                def project_select_tag
                  options = [[l(:label_project_all), 'all']]
                  options << [l(:label_my_projects), 'my_projects'] unless User.current.memberships.empty?
-                 options << [l(:label_and_its_subprojects, @project.name), 'subprojects'] unless @project.nil? || @project.active_children.empty?
+                 options << [l(:label_and_its_subprojects, @project.name), 'subprojects'] unless @project.nil? || @project.descendants.active.empty?
                  options << [@project.name, ''] unless @project.nil?
                  select_tag('scope', options_for_select(options, params[:scope].to_s)) if options.size > 1
                end

app/helpers/users_helper.rb +3 -8

                end
                # Options for the new membership projects combo-box
-               def projects_options_for_select(projects)
+               def options_for_membership_project_select(user, projects)
                  options = content_tag('option', "--- #{l(:actionview_instancetag_blank_option)} ---")
-                 projects_by_root = projects.group_by(&:root)
-                 projects_by_root.keys.sort.each do |root|
-                   options << content_tag('option', h(root.name), :value => root.id, :disabled => (!projects.include?(root)))
-                   projects_by_root[root].sort.each do |project|
-                     next if project == root
-                     options << content_tag('option', '&#187; ' + h(project.name), :value => project.id)
-                   end
+                 options << project_tree_options_for_select(projects) do |p|
+                   {:disabled => (user.projects.include?(p))}
                  end
                  options
                end

app/models/project.rb +53 -11

                                        :join_table => "#{table_name_prefix}custom_fields_projects#{table_name_suffix}",
                                        :association_foreign_key => 'custom_field_id'
-               acts_as_tree :order => "name", :counter_cache => true
+               acts_as_nested_set :order => 'name', :dependent => :destroy
                acts_as_attachable :view_permission => :view_files,
                                   :delete_permission => :manage_files
                before_destroy :delete_all_members
                named_scope :has_module, lambda { |mod| { :conditions => ["#{Project.table_name}.id IN (SELECT em.project_id FROM #{EnabledModule.table_name} em WHERE em.name=?)", mod.to_s] } }
+               named_scope :active, { :conditions => "#{Project.table_name}.status = #{STATUS_ACTIVE}"}
+               named_scope :visible, lambda { { :conditions => Project.visible_by(User.current) } }
                def identifier=(identifier)
                  super unless identifier_frozen?
                def issues_with_subprojects(include_subprojects=false)
                  conditions = nil
                  if include_subprojects
-                   ids = [id] + child_ids
+                   ids = [id] + descendants.collect(&:id)
                    conditions = ["#{Project.table_name}.id IN (#{ids.join(',')}) AND #{Project.visible_by}"]
                  end
                  conditions ||= ["#{Project.table_name}.id = ?", id]
                  end
                  if options[:project]
                    project_statement = "#{Project.table_name}.id = #{options[:project].id}"
-                   project_statement << " OR #{Project.table_name}.parent_id = #{options[:project].id}" if options[:with_subprojects]
+                   project_statement << " OR (#{Project.table_name}.lft > #{options[:project].lft} AND #{Project.table_name}.rgt < #{options[:project].rgt})" if options[:with_subprojects]
                    base_statement = "(#{project_statement}) AND (#{base_statement})"
                  end
                  if user.admin?
                def project_condition(with_subprojects)
                  cond = "#{Project.table_name}.id = #{id}"
-                 cond = "(#{cond} OR #{Project.table_name}.parent_id = #{id})" if with_subprojects
+                 cond = "(#{cond} OR (#{Project.table_name}.lft > #{lft} AND #{Project.table_name}.rgt < #{rgt}))" if with_subprojects
                  cond
                end
                  self.status == STATUS_ACTIVE
                end
+               # Archives the project and its descendants recursively
                def archive
                  # Archive subprojects if any
                  children.each do |subproject|
                  update_attribute :status, STATUS_ARCHIVED
                end
+               # Unarchives the project
+               # All its ancestors must be active
                def unarchive
-                 return false if parent && !parent.active?
+                 return false if ancestors.detect {|a| !a.active?}
                  update_attribute :status, STATUS_ACTIVE
                end
-               def active_children
-                 children.select {|child| child.active?}
+               # Returns an array of projects the project can be moved to
+               def possible_parents
+                 @possible_parents ||= (Project.active.find(:all) - self_and_descendants)
+               end
+               # Sets the parent of the project
+               # Argument can be either a Project, a String, a Fixnum or nil
+               def set_parent!(p)
+                 unless p.nil? || p.is_a?(Project)
+                   if p.to_s.blank?
+                     p = nil
+                   else
+                     p = Project.find_by_id(p)
+                     return false unless p
+                   end
+                 end
+                 if p == parent && !p.nil?
+                   # Nothing to do
+                   true
+                 elsif p.nil? || (p.active? && move_possible?(p))
+                   # Insert the project so that target's children or root projects stay alphabetically sorted
+                   sibs = (p.nil? ? self.class.roots : p.children)
+                   to_be_inserted_before = sibs.detect {|c| c.name.to_s.downcase > name.to_s.downcase }
+                   if to_be_inserted_before
+                     move_to_left_of(to_be_inserted_before)
+                   elsif p.nil?
+                     if sibs.empty?
+                       # move_to_root adds the project in first (ie. left) position
+                       move_to_root
+                     else
+                       move_to_right_of(sibs.last) unless self == sibs.last
+                     end
+                   else
+                     # move_to_child_of adds the project in last (ie.right) position
+                     move_to_child_of(p)
+                   end
+                   true
+                 else
+                   # Can not move to the given target
+                   false
+                 end
                end
                # Returns an array of the trackers used by the project and its sub projects
                  @rolled_up_trackers ||=
                    Tracker.find(:all, :include => :projects,
                                       :select => "DISTINCT #{Tracker.table_name}.*",
-                                      :conditions => ["#{Project.table_name}.id = ? OR #{Project.table_name}.parent_id = ?", id, id],
+                                      :conditions => ["#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ?", lft, rgt],
                                       :order => "#{Tracker.table_name}.position")
                end
                # Returns a short description of the projects (first lines)
                def short_description(length = 255)
-                 description.gsub(/^(.{#{length}}[^\n]*).*$/m, '\1').strip if description
+                 description.gsub(/^(.{#{length}}[^\n\r]*).*$/m, '\1...').strip if description
                end
                def allows_to?(action)
              protected
                def validate
-                 errors.add(parent_id, " must be a root project") if parent and parent.parent
-                 errors.add_to_base("A project with subprojects can't be a subproject") if parent and children.size > 0
                  errors.add(:identifier, :activerecord_error_invalid) if !identifier.blank? && identifier.match(/^\d*$/)
                end

app/models/query.rb +5 -5

                    unless @project.versions.empty?
                      @available_filters["fixed_version_id"] = { :type => :list_optional, :order => 7, :values => @project.versions.sort.collect{|s| [s.name, s.id.to_s] } }
                    end
-                   unless @project.active_children.empty?
-                     @available_filters["subproject_id"] = { :type => :list_subprojects, :order => 13, :values => @project.active_children.collect{|s| [s.name, s.id.to_s] } }
+                   unless @project.descendants.active.empty?
+                     @available_filters["subproject_id"] = { :type => :list_subprojects, :order => 13, :values => @project.descendants.visible.collect{|s| [s.name, s.id.to_s] } }
                    end
                    add_custom_fields_filters(@project.all_issue_custom_fields)
                  else
                def project_statement
                  project_clauses = []
-                 if project && !@project.active_children.empty?
+                 if project && !@project.descendants.active.empty?
                    ids = [project.id]
                    if has_filter?("subproject_id")
                      case operator_for("subproject_id")
                        # main project only
                      else
                        # all subprojects
-                       ids += project.child_ids
+                       ids += project.descendants.collect(&:id)
                      end
                    elsif Setting.display_subprojects_issues?
-                     ids += project.child_ids
+                     ids += project.descendants.collect(&:id)
                    end
                    project_clauses << "#{Project.table_name}.id IN (%s)" % ids.join(',')
                  elsif project

app/views/admin/projects.rhtml +8 -12

              <table class="list">
                <thead><tr>
-             	<%= sort_header_tag('name', :caption => l(:label_project)) %>
+             	<th><%=l(:label_project)%></th>
              	<th><%=l(:field_description)%></th>
-             	<th><%=l(:label_subproject_plural)%></th>
-             	<%= sort_header_tag('is_public', :caption => l(:field_is_public), :default_order => 'desc') %>
-             	<%= sort_header_tag('created_on', :caption => l(:field_created_on), :default_order => 'desc') %>
+             	<th><%=l(:field_is_public)%></th>
+             	<th><%=l(:field_created_on)%></th>
                  <th></th>
                  <th></th>
                </tr></thead>
                <tbody>
              <% for project in @projects %>
-               <tr class="<%= cycle("odd", "even") %>">
-             	<td><%= project.active? ? link_to(h(project.name), :controller => 'projects', :action => 'settings', :id => project) : h(project.name) %>
-             	<td><%= textilizable project.short_description, :project => project %>
-             	<td align="center"><%= project.children.size %>
-             	<td align="center"><%= image_tag 'true.png' if project.is_public? %>
-             	<td align="center"><%= format_date(project.created_on) %>
+               <tr class="<%= cycle("odd", "even") %> <%= css_project_classes(project) %>">
+             	<td class="name" style="padding-left: <%= project.level %>em;"><%= project.active? ? link_to(h(project.name), :controller => 'projects', :action => 'settings', :id => project) : h(project.name) %></td>
+             	<td><%= textilizable project.short_description, :project => project %></td>
+             	<td align="center"><%= image_tag 'true.png' if project.is_public? %></td>
+             	<td align="center"><%= format_date(project.created_on) %></td>
                <td align="center" style="width:10%">
                  <small>
                  <%= link_to(l(:button_archive), { :controller => 'projects', :action => 'archive', :id => project }, :confirm => l(:text_are_you_sure), :method => :post, :class => 'icon icon-lock') if project.active? %>
                </tbody>
              </table>
-             <p class="pagination"><%= pagination_links_full @project_pages, @project_count %></p>
              <% html_title(l(:label_project_plural)) -%>

app/views/layouts/base.rhtml +1 -1

                      <%= link_to l(:label_search), {:controller => 'search', :action => 'index', :id => @project}, :accesskey => accesskey(:search) %>:
                      <%= text_field_tag 'q', @question, :size => 20, :class => 'small', :accesskey => accesskey(:quick_search) %>
                      <% end %>
-                     <%= render :partial => 'layouts/project_selector' if User.current.memberships.any? %>
+                     <%= render_project_jump_box %>
                  </div>
                  <h1><%= h(@project && !@project.new_record? ? @project.name : Setting.app_title) %></h1>

app/views/projects/_form.rhtml +2 -2

              <!--[form:project]-->
              <p><%= f.text_field :name, :required => true %><br /><em><%= l(:text_caracters_maximum, 30) %></em></p>
-             <% if User.current.admin? and !@root_projects.empty? %>
-                 <p><%= f.select :parent_id, (@root_projects.collect {|p| [p.name, p.id]}), { :include_blank => true } %></p>
+             <% if User.current.admin? && !@project.possible_parents.empty? %>
+                 <p><label><%= l(:field_parent) %></label><%= parent_project_select_tag(@project) %></p>
              <% end %>
              <p><%= f.text_area :description, :rows => 5, :class => 'wiki-edit' %></p>

app/views/projects/activity.rhtml +1 -1

              <p><% @activity.event_types.each do |t| %>
              <label><%= check_box_tag "show_#{t}", 1, @activity.scope.include?(t) %> <%= l("label_#{t.singularize}_plural")%></label><br />
              <% end %></p>
-             <% if @project && @project.active_children.any? %>
+             <% if @project && @project.descendants.active.any? %>
                  <p><label><%= check_box_tag 'with_subprojects', 1, @with_subprojects %> <%=l(:label_subproject_plural)%></label></p>
                  <%= hidden_field_tag 'with_subprojects', 0 %>
              <% end %>

app/views/projects/destroy.rhtml +2 -2

              <p><strong><%=h @project_to_destroy %></strong><br />
              <%=l(:text_project_destroy_confirmation)%>
-             <% if @project_to_destroy.children.any? %>
-             <br /><%= l(:text_subprojects_destroy_warning, content_tag('strong', h(@project_to_destroy.children.sort.collect{|p| p.to_s}.join(', ')))) %>
+             <% if @project_to_destroy.descendants.any? %>
+             <br /><%= l(:text_subprojects_destroy_warning, content_tag('strong', h(@project_to_destroy.descendants.collect{|p| p.to_s}.join(', ')))) %>
              <% end %>
              </p>
              <p>

app/views/projects/index.rhtml +2 -11

              <h2><%=l(:label_project_plural)%></h2>
-             <% @project_tree.keys.sort.each do |project| %>
-             <h3><%= link_to h(project.name), {:action => 'show', :id => project}, :class => (User.current.member_of?(project) ? "icon icon-fav" : "") %></h3>
-             <%= textilizable(project.short_description, :project => project) %>
-             <% if @project_tree[project].any? %>
-                 <p><%= l(:label_subproject_plural) %>:
-                 <%= @project_tree[project].sort.collect {|subproject|
-                    link_to(h(subproject.name), {:action => 'show', :id => subproject}, :class => (User.current.member_of?(subproject) ? "icon icon-fav" : ""))}.join(', ') %></p>
-             <% end %>
-             <% end %>
+             <%= render_project_hierarchy(@projects)%>
              <% if User.current.logged? %>
              <p style="text-align:right;">
-             <span class="icon icon-fav"><%= l(:label_my_projects) %></span>
+             <span class="my-project"><%= l(:label_my_projects) %></span>
              </p>
              <% end %>

app/views/projects/show.rhtml +5 -3

              	<ul>
              	<% unless @project.homepage.blank? %><li><%=l(:field_homepage)%>: <%= link_to(h(@project.homepage), @project.homepage) %></li><% end %>
-                 <% if @subprojects.any? %>
-              	<li><%=l(:label_subproject_plural)%>: <%= @subprojects.collect{|p| link_to(h(p.name), :action => 'show', :id => p)}.join(", ") %></li>
+              	<li><%=l(:label_subproject_plural)%>:
+             	    <%= @subprojects.collect{|p| link_to(h(p), :action => 'show', :id => p)}.join(", ") %></li>
-                 <% end %>
-             	<% if @project.parent %>
-             	<li><%=l(:field_parent)%>: <%= link_to h(@project.parent.name), :controller => 'projects', :action => 'show', :id => @project.parent %></li>
+             	<% if @ancestors.any? %>
+             	<li><%=l(:field_parent)%>:
+             		  <%= @ancestors.collect {|p| link_to(h(p), :action => 'show', :id => p)}.join(" &#187; ") %></li>
              	<% end %>
              	<% @project.custom_values.each do |custom_value| %>
              	<% if !custom_value.value.empty? %>

app/views/users/_memberships.rhtml +1 -1

              <p>
              <label><%=l(:label_project_new)%></label><br/>
              <% form_tag({ :action => 'edit_membership', :id => @user }) do %>
-             <%= select_tag 'membership[project_id]', projects_options_for_select(@projects) %>
+             <%= select_tag 'membership[project_id]', options_for_membership_project_select(@user, @projects) %>
              <%= l(:label_role) %>:
              <%= select_tag 'membership[role_id]', options_from_collection_for_select(@roles, "id", "name") %>
              <%= submit_tag l(:button_add) %>

public/stylesheets/application.css +12 0

              table.list td.id { width: 2%; text-align: center;}
              table.list td.checkbox { width: 15px; padding: 0px;}
+             tr.project td.name a { padding-left: 16px; white-space:nowrap; }
+             tr.project.parent td.name a { background: url('../images/bullet_toggle_minus.png') no-repeat; }
              tr.issue { text-align: center; white-space: nowrap; }
              tr.issue td.subject, tr.issue td.category, td.assigned_to { white-space: normal; }
              tr.issue td.subject { text-align: left; }
              form#issue-form .attributes p { padding-top: 1px; padding-bottom: 2px; }
              form#issue-form .attributes select { min-width: 30%; }
+             ul.projects { margin: 0; padding-left: 1em; }
+             ul.projects.root { margin: 0;  padding: 0; }
+             ul.projects ul { border-left: 3px solid #e0e0e0; }
+             ul.projects li { list-style-type:none; }
+             ul.projects li.root { margin-bottom: 1em; }
+             ul.projects li.child { margin-top: 1em;}
+             ul.projects div.root a.project { font-family: "Trebuchet MS", Verdana, sans-serif; font-weight: bold; font-size: 16px; margin: 0 0 10px 0; }
+             .my-project { padding-left: 18px; background: url(../images/fav.png) no-repeat 0 50%; }
              ul.properties {padding:0; font-size: 0.9em; color: #777;}
              ul.properties li {list-style-type:none;}
              ul.properties li span {font-style:italic;}

test/fixtures/projects.yml +24 -1

                is_public: true
                identifier: ecookbook
                parent_id:
+               lft: 1
+               rgt: 10
              projects_002:
                created_on: 2006-07-19 19:14:19 +02:00
                name: OnlineStore
                is_public: false
                identifier: onlinestore
                parent_id:
+               lft: 11
+               rgt: 12
              projects_003:
                created_on: 2006-07-19 19:15:21 +02:00
                name: eCookbook Subproject 1
                is_public: true
                identifier: subproject1
                parent_id: 1
+               lft: 6
+               rgt: 7
              projects_004:
                created_on: 2006-07-19 19:15:51 +02:00
                name: eCookbook Subproject 2
                is_public: true
                identifier: subproject2
                parent_id: 1
+               lft: 8
+               rgt: 9
              projects_005:
                created_on: 2006-07-19 19:15:51 +02:00
                name: Private child of eCookbook
                description: This is a private subproject of a public project
                homepage: ""
                is_public: false
-               identifier: private_child
+               identifier: private-child
                parent_id: 1
+               lft: 2
+               rgt: 5
+             projects_006:
+               created_on: 2006-07-19 19:15:51 +02:00
+               name: Child of private child
+               updated_on: 2006-07-19 19:17:07 +02:00
+               projects_count: 0
+               id: 6
+               description: This is a public subproject of a private project
+               homepage: ""
+               is_public: true
+               identifier: project6
+               parent_id: 5
+               lft: 3
+               rgt: 4
   No newline at end of file

test/functional/projects_controller_test.rb +12 -5

                  get :index
                  assert_response :success
                  assert_template 'index'
-                 assert_not_nil assigns(:project_tree)
-                 # Root project as hash key
-                 assert assigns(:project_tree).keys.include?(Project.find(1))
-                 # Subproject in corresponding value
-                 assert assigns(:project_tree)[Project.find(1)].include?(Project.find(3))
+                 assert_not_nil assigns(:projects)
+                 assert_tag :ul, :child => {:tag => 'li',
+                                            :descendant => {:tag => 'a', :content => 'eCookbook'},
+                                            :child => { :tag => 'ul',
+                                                        :descendant => { :tag => 'a',
+                                                                         :content => 'Child of private child'
+                                                                        }
+                                                       }
+                                            }
+                 assert_no_tag :a, :content => /Private child of eCookbook/
                end
                def test_index_atom

test/unit/project_test.rb +83 -16

                  assert_equal "activerecord_error_blank", @ecookbook.errors.on(:name)
                end
-               def test_public_projects
-                 public_projects = Project.find(:all, :conditions => ["is_public=?", true])
-                 assert_equal 3, public_projects.length
-                 assert_equal true, public_projects[0].is_public?
-               end
                def test_archive
                  user = @ecookbook.members.first.user
                  @ecookbook.archive
                  assert !user.projects.include?(@ecookbook)
                  # Subproject are also archived
                  assert !@ecookbook.children.empty?
-                 assert @ecookbook.active_children.empty?
+                 assert @ecookbook.descendants.active.empty?
                end
                def test_unarchive
                  assert Board.find(:all, :conditions => ['project_id = ?', @ecookbook.id]).empty?
                end
-               def test_subproject_ok
+               def test_move_an_orphan_project_to_a_root_project
                  sub = Project.find(2)
-                 sub.parent = @ecookbook
-                 assert sub.save
+                 sub.set_parent! @ecookbook
                  assert_equal @ecookbook.id, sub.parent.id
                  @ecookbook.reload
                  assert_equal 4, @ecookbook.children.size
                end
-               def test_subproject_invalid
+               def test_move_an_orphan_project_to_a_subproject
                  sub = Project.find(2)
-                 sub.parent = @ecookbook_sub1
-                 assert !sub.save
+                 assert sub.set_parent!(@ecookbook_sub1)
                end
-               def test_subproject_invalid_2
+               def test_move_a_root_project_to_a_project
                  sub = @ecookbook
-                 sub.parent = Project.find(2)
-                 assert !sub.save
+                 assert sub.set_parent!(Project.find(2))
+               end
+               def test_should_not_move_a_project_to_its_children
+                 sub = @ecookbook
+                 assert !(sub.set_parent!(Project.find(3)))
+               end
+               def test_set_parent_should_add_roots_in_alphabetical_order
+                 ProjectCustomField.delete_all
+                 Project.delete_all
+                 Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(nil)
+                 Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(nil)
+                 Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(nil)
+                 Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(nil)
+                 assert_equal 4, Project.count
+                 assert_equal Project.all.sort_by(&:name), Project.all.sort_by(&:lft)
+               end
+               def test_set_parent_should_add_children_in_alphabetical_order
+                 ProjectCustomField.delete_all
+                 parent = Project.create!(:name => 'Parent', :identifier => 'parent')
+                 Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(parent)
+                 Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(parent)
+                 Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(parent)
+                 Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(parent)
+                 parent.reload
+                 assert_equal 4, parent.children.size
+                 assert_equal parent.children.sort_by(&:name), parent.children
+               end
+               def test_rebuild_should_sort_children_alphabetically
+                 ProjectCustomField.delete_all
+                 parent = Project.create!(:name => 'Parent', :identifier => 'parent')
+                 Project.create!(:name => 'Project C', :identifier => 'project-c').move_to_child_of(parent)
+                 Project.create!(:name => 'Project B', :identifier => 'project-b').move_to_child_of(parent)
+                 Project.create!(:name => 'Project D', :identifier => 'project-d').move_to_child_of(parent)
+                 Project.create!(:name => 'Project A', :identifier => 'project-a').move_to_child_of(parent)
+                 Project.update_all("lft = NULL, rgt = NULL")
+                 Project.rebuild!
+                 parent.reload
+                 assert_equal 4, parent.children.size
+                 assert_equal parent.children.sort_by(&:name), parent.children
+               end
+               def test_parent
+                 p = Project.find(6).parent
+                 assert p.is_a?(Project)
+                 assert_equal 5, p.id
+               end
+               def test_ancestors
+                 a = Project.find(6).ancestors
+                 assert a.first.is_a?(Project)
+                 assert_equal [1, 5], a.collect(&:id)
+               end
+               def test_root
+                 r = Project.find(6).root
+                 assert r.is_a?(Project)
+                 assert_equal 1, r.id
+               end
+               def test_children
+                 c = Project.find(1).children
+                 assert c.first.is_a?(Project)
+                 assert_equal [5, 3, 4], c.collect(&:id)
+               end
+               def test_descendants
+                 d = Project.find(1).descendants
+                 assert d.first.is_a?(Project)
+                 assert_equal [5, 6, 3, 4], d.collect(&:id)
                end
                def test_rolled_up_trackers

app/views/layouts/_project_selector.rhtml removed 0 -12

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