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

             # redMine - project management software
             # Copyright (C) 2006  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class AdminController < ApplicationController
               before_filter :require_admin
               helper :sort
               include SortHelper
               def index
                 @no_configuration_data = Redmine::DefaultData::Loader::no_data?
               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])
                 unless params[:name].blank?
                   name = "%#{params[:name].strip.downcase}%"
                   c << ["LOWER(identifier) LIKE ? OR LOWER(name) LIKE ?", name, name]
                 end
-                @project_count = Project.count(:conditions => c.conditions)
+                @projects = Project.find :all, :order => 'lft',
-                @project_pages = Paginator.new self, @project_count,
+                                               :conditions => c.conditions
-            								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
                 render :action => "projects", :layout => false if request.xhr?
               end
               def plugins
                 @plugins = Redmine::Plugin.all
               end
               # Loads the default configuration
               # (roles, trackers, statuses, workflow, enumerations)
               def default_configuration
                 if request.post?
                   begin
                     Redmine::DefaultData::Loader::load(params[:lang])
                     flash[:notice] = l(:notice_default_data_loaded)
                   rescue Exception => e
                     flash[:error] = l(:error_can_t_load_default_data, e.message)
                   end
                 end
                 redirect_to :action => 'index'
               end
               def test_email
                 raise_delivery_errors = ActionMailer::Base.raise_delivery_errors
                 # Force ActionMailer to raise delivery errors so we can catch it
                 ActionMailer::Base.raise_delivery_errors = true
                 begin
                   @test = Mailer.deliver_test(User.current)
                   flash[:notice] = l(:notice_email_sent, User.current.mail)
                 rescue Exception => e
                   flash[:error] = l(:notice_email_error, e.message)
                 end
                 ActionMailer::Base.raise_delivery_errors = raise_delivery_errors
                 redirect_to :controller => 'settings', :action => 'edit', :tab => 'notifications'
               end
               def info
                 @db_adapter_name = ActiveRecord::Base.connection.adapter_name
                 @flags = {
                   :default_admin_changed => User.find(:first, :conditions => ["login=? and hashed_password=?", 'admin', User.hash_password('admin')]).nil?,
                   :file_repository_writable => File.writable?(Attachment.storage_path),
                   :plugin_assets_writable => File.writable?(Engines.public_directory),
                   :rmagick_available => Object.const_defined?(:Magick)
                 }
               end
             end

app/controllers/projects_controller.rb +8 -14

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class ProjectsController < ApplicationController
               menu_item :overview
               menu_item :activity, :only => :activity
               menu_item :roadmap, :only => :roadmap
               menu_item :files, :only => [:list_files, :add_file]
               menu_item :settings, :only => :settings
               menu_item :issues, :only => [:changelog]
               before_filter :find_project, :except => [ :index, :list, :add, :activity ]
               before_filter :find_optional_project, :only => :activity
               before_filter :authorize, :except => [ :index, :list, :add, :archive, :unarchive, :destroy, :activity ]
               before_filter :require_admin, :only => [ :add, :archive, :unarchive, :destroy ]
               accept_key_auth :activity
               helper :sort
               include SortHelper
               helper :custom_fields
               include CustomFieldsHelper
               helper :issues
               helper IssuesHelper
               helper :queries
               include QueriesHelper
               helper :repositories
               include RepositoriesHelper
               include ProjectsHelper
               # 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}
+                    @projects = Project.visible.find(:all, :order => 'lft')
-                    @project_tree.keys.each {|p| @project_tree[p] -= [p]}
                   }
                   format.atom {
-                    render_feed(projects.sort_by(&:created_on).reverse.slice(0, Setting.feeds_limit.to_i),
+                    projects = Project.visible.find(:all, :order => 'created_on DESC',
-                                              :title => "#{Setting.app_title}: #{l(:label_project_latest)}")
+                                                          :limit => Setting.feeds_limit.to_i)
+                    render_feed(projects, :title => "#{Setting.app_title}: #{l(:label_project_latest)}")
                   }
                 end
               end
               # Add a new project
               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?
                   @project.trackers = Tracker.all
                   @project.is_public = Setting.default_projects_public?
                   @project.enabled_module_names = Redmine::AccessControl.available_project_modules
                 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
               end
               # Show @project
               def show
                 if params[:jump]
                   # try to redirect to the requested menu item
                   redirect_to_project_menu_item(@project, params[:jump]) && return
                 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
                 cond = @project.project_condition(Setting.display_subprojects_issues?)
                 Issue.visible_by(User.current) do
                   @open_issues_by_tracker = Issue.count(:group => :tracker,
                                                         :include => [:project, :status, :tracker],
                                                         :conditions => ["(#{cond}) AND #{IssueStatus.table_name}.is_closed=?", false])
                   @total_issues_by_tracker = Issue.count(:group => :tracker,
                                                         :include => [:project, :status, :tracker],
                                                         :conditions => cond)
                 end
                 TimeEntry.visible_by(User.current) do
                   @total_hours = TimeEntry.sum(:hours,
                                                :include => :project,
                                                :conditions => cond).to_f
                 end
                 @key = User.current.rss_key
               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
                 @trackers = Tracker.all
                 @repository ||= @project.repository
                 @wiki ||= @project.wiki
               end
               # Edit @project
               def edit
                 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
                     settings
                     render :action => 'settings'
                   end
                 end
               end
               def modules
                 @project.enabled_module_names = params[:enabled_modules]
                 redirect_to :action => 'settings', :id => @project, :tab => 'modules'
               end
               def archive
                 @project.archive if request.post? && @project.active?
                 redirect_to :controller => 'admin', :action => 'projects'
               end
               def unarchive
                 @project.unarchive if request.post? && !@project.active?
                 redirect_to :controller => 'admin', :action => 'projects'
               end
               # Delete @project
               def destroy
                 @project_to_destroy = @project
                 if request.post? and params[:confirm]
                   @project_to_destroy.destroy
                   redirect_to :controller => 'admin', :action => 'projects'
                 end
                 # hide project in layout
                 @project = nil
               end
               # Add a new issue category to @project
               def add_issue_category
                 @category = @project.issue_categories.build(params[:category])
                 if request.post? and @category.save
               	  respond_to do |format|
                     format.html do
                       flash[:notice] = l(:notice_successful_create)
                       redirect_to :action => 'settings', :tab => 'categories', :id => @project
                     end
                     format.js do
                       # IE doesn't support the replace_html rjs method for select box options
                       render(:update) {|page| page.replace "issue_category_id",
                         content_tag('select', '<option></option>' + options_from_collection_for_select(@project.issue_categories, 'id', 'name', @category.id), :id => 'issue_category_id', :name => 'issue[category_id]')
                       }
                     end
                   end
                 end
               end
               # Add a new version to @project
               def add_version
               	@version = @project.versions.build(params[:version])
               	if request.post? and @version.save
               	  flash[:notice] = l(:notice_successful_create)
                   redirect_to :action => 'settings', :tab => 'versions', :id => @project
               	end
               end
               def add_file
                 if request.post?
                   container = (params[:version_id].blank? ? @project : @project.versions.find_by_id(params[:version_id]))
                   attachments = attach_files(container, params[:attachments])
                   if !attachments.empty? && Setting.notified_events.include?('file_added')
                     Mailer.deliver_attachments_added(attachments)
                   end
                   redirect_to :controller => 'projects', :action => 'list_files', :id => @project
                   return
                 end
                 @versions = @project.versions.sort
               end
               def list_files
                 sort_init 'filename', 'asc'
                 sort_update 'filename' => "#{Attachment.table_name}.filename",
                             'created_on' => "#{Attachment.table_name}.created_on",
                             'size' => "#{Attachment.table_name}.filesize",
                             'downloads' => "#{Attachment.table_name}.downloads"
                 @containers = [ Project.find(@project.id, :include => :attachments, :order => sort_clause)]
                 @containers += @project.versions.find(:all, :include => :attachments, :order => sort_clause).sort.reverse
                 render :layout => !request.xhr?
               end
               # Show changelog for @project
               def changelog
                 @trackers = @project.trackers.find(:all, :conditions => ["is_in_chlog=?", true], :order => 'position')
                 retrieve_selected_tracker_ids(@trackers)
                 @versions = @project.versions.sort
               end
               def roadmap
                 @trackers = @project.trackers.find(:all, :conditions => ["is_in_roadmap=?", true])
                 retrieve_selected_tracker_ids(@trackers)
                 @versions = @project.versions.sort
                 @versions = @versions.select {|v| !v.completed? } unless params[:completed]
               end
               def activity
                 @days = Setting.activity_days_default.to_i
                 if params[:from]
                   begin; @date_to = params[:from].to_date + 1; rescue; end
                 end
                 @date_to ||= Date.today + 1
                 @date_from = @date_to - @days
                 @with_subprojects = params[:with_subprojects].nil? ? Setting.display_subprojects_issues? : (params[:with_subprojects] == '1')
                 @author = (params[:user_id].blank? ? nil : User.active.find(params[:user_id]))
                 @activity = Redmine::Activity::Fetcher.new(User.current, :project => @project,
                                                                          :with_subprojects => @with_subprojects,
                                                                          :author => @author)
                 @activity.scope_select {|t| !params["show_#{t}"].nil?}
                 @activity.scope = (@author.nil? ? :default : :all) if @activity.scope.empty?
                 events = @activity.events(@date_from, @date_to)
                 respond_to do |format|
                   format.html {
                     @events_by_day = events.group_by(&:event_date)
                     render :layout => false if request.xhr?
                   }
                   format.atom {
                     title = l(:label_activity)
                     if @author
                       title = @author.name
                     elsif @activity.scope.size == 1
                       title = l("label_#{@activity.scope.first.singularize}_plural")
                     end
                     render_feed(events, :title => "#{@project || Setting.app_title}: #{title}")
                   }
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             private
               # Find project of id params[:id]
               # if not found, redirect to project list
               # Used as a before_filter
               def find_project
                 @project = Project.find(params[:id])
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def find_optional_project
                 return true unless params[:id]
                 @project = Project.find(params[:id])
                 authorize
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def retrieve_selected_tracker_ids(selectable_trackers)
                 if ids = params[:tracker_ids]
                   @selected_tracker_ids = (ids.is_a? Array) ? ids.collect { |id| id.to_i.to_s } : ids.split('/').collect { |id| id.to_i.to_s }
                 else
                   @selected_tracker_ids = selectable_trackers.collect {|t| t.id.to_s }
                 end
               end
             end

app/controllers/reports_controller.rb +4 -4

             # redMine - project management software
             # Copyright (C) 2006  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class ReportsController < ApplicationController
               menu_item :issues
               before_filter :find_project, :authorize
               def issue_report
                 @statuses = IssueStatus.find(:all, :order => 'position')
                 case params[:detail]
                 when "tracker"
                   @field = "tracker_id"
                   @rows = @project.trackers
                   @data = issues_by_tracker
                   @report_title = l(:field_tracker)
                   render :template => "reports/issue_report_details"
                 when "version"
                   @field = "fixed_version_id"
                   @rows = @project.versions.sort
                   @data = issues_by_version
                   @report_title = l(:field_version)
                   render :template => "reports/issue_report_details"
                 when "priority"
                   @field = "priority_id"
                   @rows = Enumeration::get_values('IPRI')
                   @data = issues_by_priority
                   @report_title = l(:field_priority)
                   render :template => "reports/issue_report_details"
                 when "category"
                   @field = "category_id"
                   @rows = @project.issue_categories
                   @data = issues_by_category
                   @report_title = l(:field_category)
                   render :template => "reports/issue_report_details"
                 when "assigned_to"
                   @field = "assigned_to_id"
                   @rows = @project.members.collect { |m| m.user }
                   @data = issues_by_assigned_to
                   @report_title = l(:field_assigned_to)
                   render :template => "reports/issue_report_details"
                 when "author"
                   @field = "author_id"
                   @rows = @project.members.collect { |m| m.user }
                   @data = issues_by_author
                   @report_title = l(:field_author)
                   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"
                 else
                   @trackers = @project.trackers
                   @versions = @project.versions.sort
                   @priorities = Enumeration::get_values('IPRI')
                   @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
                   issues_by_category
                   issues_by_assigned_to
                   issues_by_author
                   issues_by_subproject
                   render :template => "reports/issue_report"
                 end
               end
               def delays
                 @trackers = Tracker.find(:all)
                 if request.get?
                   @selected_tracker_ids = @trackers.collect {|t| t.id.to_s }
                 else
                   @selected_tracker_ids = params[:tracker_ids].collect { |id| id.to_i.to_s } if params[:tracker_ids] and params[:tracker_ids].is_a? Array
                 end
                 @selected_tracker_ids ||= []
                 @raw =
                   ActiveRecord::Base.connection.select_all("SELECT datediff( a.created_on, b.created_on ) as delay, count(a.id) as total
                   FROM issue_histories a, issue_histories b, issues i
                   WHERE a.status_id =5
                   AND a.issue_id = b.issue_id
                   AND a.issue_id = i.id
                   AND i.tracker_id in (#{@selected_tracker_ids.join(',')})
                   AND b.id = (
                   SELECT min( c.id )
                   FROM issue_histories c
                   WHERE b.issue_id = c.issue_id )
                   GROUP BY delay") unless @selected_tracker_ids.empty?
                 @raw ||=[]
                 @x_from = 0
                 @x_to = 0
                 @y_from = 0
                 @y_to = 0
                 @sum_total = 0
                 @sum_delay = 0
                 @raw.each do |r|
                   @x_to = [r['delay'].to_i, @x_to].max
                   @y_to = [r['total'].to_i, @y_to].max
                   @sum_total = @sum_total + r['total'].to_i
                   @sum_delay = @sum_delay + r['total'].to_i * r['delay'].to_i
                 end
               end
             private
               # Find project of id params[:id]
               def find_project
                 @project = Project.find(params[:id])
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def issues_by_tracker
                 @issues_by_tracker ||=
                     ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                               s.is_closed as closed,
                                                               t.id as tracker_id,
                                                               count(i.id) as total
                                                             from
                                                               #{Issue.table_name} i, #{IssueStatus.table_name} s, #{Tracker.table_name} t
                                                             where
                                                               i.status_id=s.id
                                                               and i.tracker_id=t.id
                                                               and i.project_id=#{@project.id}
                                                             group by s.id, s.is_closed, t.id")
               end
               def issues_by_version
                 @issues_by_version ||=
                     ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                               s.is_closed as closed,
                                                               v.id as fixed_version_id,
                                                               count(i.id) as total
                                                             from
                                                               #{Issue.table_name} i, #{IssueStatus.table_name} s, #{Version.table_name} v
                                                             where
                                                               i.status_id=s.id
                                                               and i.fixed_version_id=v.id
                                                               and i.project_id=#{@project.id}
                                                             group by s.id, s.is_closed, v.id")
               end
               def issues_by_priority
                 @issues_by_priority ||=
                   ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                               s.is_closed as closed,
                                                               p.id as priority_id,
                                                               count(i.id) as total
                                                             from
                                                               #{Issue.table_name} i, #{IssueStatus.table_name} s, #{Enumeration.table_name} p
                                                             where
                                                               i.status_id=s.id
                                                               and i.priority_id=p.id
                                                               and i.project_id=#{@project.id}
                                                             group by s.id, s.is_closed, p.id")
               end
               def issues_by_category
                 @issues_by_category ||=
                   ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                               s.is_closed as closed,
                                                               c.id as category_id,
                                                               count(i.id) as total
                                                             from
                                                               #{Issue.table_name} i, #{IssueStatus.table_name} s, #{IssueCategory.table_name} c
                                                             where
                                                               i.status_id=s.id
                                                               and i.category_id=c.id
                                                               and i.project_id=#{@project.id}
                                                             group by s.id, s.is_closed, c.id")
               end
               def issues_by_assigned_to
                 @issues_by_assigned_to ||=
                   ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                               s.is_closed as closed,
                                                               a.id as assigned_to_id,
                                                               count(i.id) as total
                                                             from
                                                               #{Issue.table_name} i, #{IssueStatus.table_name} s, #{User.table_name} a
                                                             where
                                                               i.status_id=s.id
                                                               and i.assigned_to_id=a.id
                                                               and i.project_id=#{@project.id}
                                                             group by s.id, s.is_closed, a.id")
               end
               def issues_by_author
                 @issues_by_author ||=
                   ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                               s.is_closed as closed,
                                                               a.id as author_id,
                                                               count(i.id) as total
                                                             from
                                                               #{Issue.table_name} i, #{IssueStatus.table_name} s, #{User.table_name} a
                                                             where
                                                               i.status_id=s.id
                                                               and i.author_id=a.id
                                                               and i.project_id=#{@project.id}
                                                             group by s.id, s.is_closed, a.id")
               end
               def issues_by_subproject
                 @issues_by_subproject ||=
                   ActiveRecord::Base.connection.select_all("select    s.id as status_id,
                                                               s.is_closed as closed,
                                                               i.project_id as project_id,
                                                               count(i.id) as total
                                                             from
                                                               #{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(',')})
+                                                              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.active_children.any?
+                                                            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

             # redMine - project management software
             # Copyright (C) 2006  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class SearchController < ApplicationController
               before_filter :find_optional_project
               helper :messages
               include MessagesHelper
               def index
                 @question = params[:q] || ""
                 @question.strip!
                 @all_words = params[:all_words] || (params[:submit] ? false : true)
                 @titles_only = !params[:titles_only].nil?
                 projects_to_search =
                   case params[:scope]
                   when 'all'
                     nil
                   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
                 offset = nil
                 begin; offset = params[:offset].to_time if params[:offset]; rescue; end
                 # quick jump to an issue
                 if @question.match(/^#?(\d+)$/) && Issue.find_by_id($1, :include => :project, :conditions => Project.visible_by(User.current))
                   redirect_to :controller => "issues", :action => "show", :id => $1
                   return
                 end
                 @object_types = %w(issues news documents changesets wiki_pages messages projects)
                 if projects_to_search.is_a? Project
                   # don't search projects
                   @object_types.delete('projects')
                   # only show what the user is allowed to view
                   @object_types = @object_types.select {|o| User.current.allowed_to?("view_#{o}".to_sym, projects_to_search)}
                 end
                 @scope = @object_types.select {|t| params[t]}
                 @scope = @object_types if @scope.empty?
                 # extract tokens from the question
                 # eg. hello "bye bye" => ["hello", "bye bye"]
                 @tokens = @question.scan(%r{((\s|^)"[\s\w]+"(\s|$)|\S+)}).collect {|m| m.first.gsub(%r{(^\s*"\s*|\s*"\s*$)}, '')}
                 # tokens must be at least 3 character long
                 @tokens = @tokens.uniq.select {|w| w.length > 2 }
                 if !@tokens.empty?
                   # no more than 5 tokens to search for
                   @tokens.slice! 5..-1 if @tokens.size > 5
                   # strings used in sql like statement
                   like_tokens = @tokens.collect {|w| "%#{w.downcase}%"}
                   @results = []
                   @results_by_type = Hash.new {|h,k| h[k] = 0}
                   limit = 10
                   @scope.each do |s|
                     r, c = s.singularize.camelcase.constantize.search(like_tokens, projects_to_search,
                       :all_words => @all_words,
                       :titles_only => @titles_only,
                       :limit => (limit+1),
                       :offset => offset,
                       :before => params[:previous].nil?)
                     @results += r
                     @results_by_type[s] += c
                   end
                   @results = @results.sort {|a,b| b.event_datetime <=> a.event_datetime}
                   if params[:previous].nil?
                     @pagination_previous_date = @results[0].event_datetime if offset && @results[0]
                     if @results.size > limit
                       @pagination_next_date = @results[limit-1].event_datetime
                       @results = @results[0, limit]
                     end
                   else
                     @pagination_next_date = @results[-1].event_datetime if offset && @results[-1]
                     if @results.size > limit
                       @pagination_previous_date = @results[-(limit)].event_datetime
                       @results = @results[-(limit), limit]
                     end
                   end
                 else
                   @question = ""
                 end
                 render :layout => false if request.xhr?
               end
             private
               def find_optional_project
                 return true unless params[:id]
                 @project = Project.find(params[:id])
                 check_project_privacy
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/controllers/users_controller.rb +1 -1

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class UsersController < ApplicationController
               before_filter :require_admin
               helper :sort
               include SortHelper
               helper :custom_fields
               include CustomFieldsHelper
               def index
                 list
                 render :action => 'list' unless request.xhr?
               end
               def list
                 sort_init 'login', 'asc'
                 sort_update %w(login firstname lastname mail admin created_on last_login_on)
                 @status = params[:status] ? params[:status].to_i : 1
                 c = ARCondition.new(@status == 0 ? "status <> 0" : ["status = ?", @status])
                 unless params[:name].blank?
                   name = "%#{params[:name].strip.downcase}%"
                   c << ["LOWER(login) LIKE ? OR LOWER(firstname) LIKE ? OR LOWER(lastname) LIKE ?", name, name, name]
                 end
                 @user_count = User.count(:conditions => c.conditions)
                 @user_pages = Paginator.new self, @user_count,
             								per_page_option,
             								params['page']
                 @users =  User.find :all,:order => sort_clause,
                                     :conditions => c.conditions,
             						:limit  =>  @user_pages.items_per_page,
             						:offset =>  @user_pages.current.offset
                 render :action => "list", :layout => false if request.xhr?
               end
               def add
                 if request.get?
                   @user = User.new(:language => Setting.default_language)
                 else
                   @user = User.new(params[:user])
                   @user.admin = params[:user][:admin] || false
                   @user.login = params[:user][:login]
                   @user.password, @user.password_confirmation = params[:password], params[:password_confirmation] unless @user.auth_source_id
                   if @user.save
                     Mailer.deliver_account_information(@user, params[:password]) if params[:send_information]
                     flash[:notice] = l(:notice_successful_create)
                     redirect_to :action => 'list'
                   end
                 end
                 @auth_sources = AuthSource.find(:all)
               end
               def edit
                 @user = User.find(params[:id])
                 if request.post?
                   @user.admin = params[:user][:admin] if params[:user][:admin]
                   @user.login = params[:user][:login] if params[:user][:login]
                   @user.password, @user.password_confirmation = params[:password], params[:password_confirmation] unless params[:password].nil? or params[:password].empty? or @user.auth_source_id
                   if @user.update_attributes(params[:user])
                     flash[:notice] = l(:notice_successful_update)
                     # Give a string to redirect_to otherwise it would use status param as the response code
                     redirect_to(url_for(:action => 'list', :status => params[:status], :page => params[:page]))
                   end
                 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
               def edit_membership
                 @user = User.find(params[:id])
                 @membership = params[:membership_id] ? Member.find(params[:membership_id]) : Member.new(:user => @user)
                 @membership.attributes = params[:membership]
                 @membership.save if request.post?
                 redirect_to :action => 'edit', :id => @user, :tab => 'memberships'
               end
               def destroy_membership
                 @user = User.find(params[:id])
                 Member.find(params[:membership_id]).destroy if request.post?
                 redirect_to :action => 'edit', :id => @user, :tab => 'memberships'
               end
             end

app/helpers/admin_helper.rb +8 0

             # redMine - project management software
             # Copyright (C) 2006  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module AdminHelper
               def project_status_options_for_select(selected)
                 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

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'coderay'
             require 'coderay/helpers/file_type'
             require 'forwardable'
             require 'cgi'
             module ApplicationHelper
               include Redmine::WikiFormatting::Macros::Definitions
               include GravatarHelper::PublicMethods
               extend Forwardable
               def_delegators :wiki_helper, :wikitoolbar_for, :heads_for_wiki_formatter
               def current_role
                 @current_role ||= User.current.role_for_project(@project)
               end
               # Return true if user is authorized for controller/action, otherwise false
               def authorize_for(controller, action)
                 User.current.allowed_to?({:controller => controller, :action => action}, @project)
               end
               # Display a link if user is authorized
               def link_to_if_authorized(name, options = {}, html_options = nil, *parameters_for_method_reference)
                 link_to(name, options, html_options, *parameters_for_method_reference) if authorize_for(options[:controller] || params[:controller], options[:action])
               end
               # Display a link to remote if user is authorized
               def link_to_remote_if_authorized(name, options = {}, html_options = nil)
                 url = options[:url] || {}
                 link_to_remote(name, options, html_options) if authorize_for(url[:controller] || params[:controller], url[:action])
               end
               # Display a link to user's account page
               def link_to_user(user, options={})
                 (user && !user.anonymous?) ? link_to(user.name(options[:format]), :controller => 'account', :action => 'show', :id => user) : 'Anonymous'
               end
               def link_to_issue(issue, options={})
                 options[:class] ||= ''
                 options[:class] << ' issue'
                 options[:class] << ' closed' if issue.closed?
                 link_to "#{issue.tracker.name} ##{issue.id}", {:controller => "issues", :action => "show", :id => issue}, options
               end
               # Generates a link to an attachment.
               # Options:
               # * :text - Link text (default to attachment filename)
               # * :download - Force download (default: false)
               def link_to_attachment(attachment, options={})
                 text = options.delete(:text) || attachment.filename
                 action = options.delete(:download) ? 'download' : 'show'
                 link_to(h(text), {:controller => 'attachments', :action => action, :id => attachment, :filename => attachment.filename }, options)
               end
               def toggle_link(name, id, options={})
                 onclick = "Element.toggle('#{id}'); "
                 onclick << (options[:focus] ? "Form.Element.focus('#{options[:focus]}'); " : "this.blur(); ")
                 onclick << "return false;"
                 link_to(name, "#", :onclick => onclick)
               end
               def image_to_function(name, function, html_options = {})
                 html_options.symbolize_keys!
                 tag(:input, html_options.merge({
                     :type => "image", :src => image_path(name),
                     :onclick => (html_options[:onclick] ? "#{html_options[:onclick]}; " : "") + "#{function};"
                     }))
               end
               def prompt_to_remote(name, text, param, url, html_options = {})
                 html_options[:onclick] = "promptToRemote('#{text}', '#{param}', '#{url_for(url)}'); return false;"
                 link_to name, {}, html_options
               end
               def format_date(date)
                 return nil unless date
                 # "Setting.date_format.size < 2" is a temporary fix (content of date_format setting changed)
                 @date_format ||= (Setting.date_format.blank? || Setting.date_format.size < 2 ? l(:general_fmt_date) : Setting.date_format)
                 date.strftime(@date_format)
               end
               def format_time(time, include_date = true)
                 return nil unless time
                 time = time.to_time if time.is_a?(String)
                 zone = User.current.time_zone
                 local = zone ? time.in_time_zone(zone) : (time.utc? ? time.localtime : time)
                 @date_format ||= (Setting.date_format.blank? || Setting.date_format.size < 2 ? l(:general_fmt_date) : Setting.date_format)
                 @time_format ||= (Setting.time_format.blank? ? l(:general_fmt_time) : Setting.time_format)
                 include_date ? local.strftime("#{@date_format} #{@time_format}") : local.strftime(@time_format)
               end
               def format_activity_title(text)
                 h(truncate_single_line(text, 100))
               end
               def format_activity_day(date)
                 date == Date.today ? l(:label_today).titleize : format_date(date)
               end
               def format_activity_description(text)
                 h(truncate(text.to_s, 250).gsub(%r{<(pre|code)>.*$}m, '...'))
               end
               def distance_of_date_in_words(from_date, to_date = 0)
                 from_date = from_date.to_date if from_date.respond_to?(:to_date)
                 to_date = to_date.to_date if to_date.respond_to?(:to_date)
                 distance_in_days = (to_date - from_date).abs
                 lwr(:actionview_datehelper_time_in_words_day, distance_in_days)
               end
               def due_date_distance_in_words(date)
                 if date
                   l((date < Date.today ? :label_roadmap_overdue : :label_roadmap_due_in), distance_of_date_in_words(Date.today, date))
                 end
               end
               def render_page_hierarchy(pages, node=nil)
                 content = ''
                 if pages[node]
                   content << "<ul class=\"pages-hierarchy\">\n"
                   pages[node].each do |page|
                     content << "<li>"
                     content << link_to(h(page.pretty_title), {:controller => 'wiki', :action => 'index', :id => page.project, :page => page.title},
                                        :title => (page.respond_to?(:updated_on) ? l(:label_updated_time, distance_of_time_in_words(Time.now, page.updated_on)) : nil))
                     content << "\n" + render_page_hierarchy(pages, page.id) if pages[page.id]
                     content << "</li>\n"
                   end
                   content << "</ul>\n"
                 end
                 content
               end
               # Renders flash messages
               def render_flash_messages
                 s = ''
                 flash.each do |k,v|
                   s << content_tag('div', v, :class => "flash #{k}")
                 end
                 s
               end
+              # Renders the project quick-jump box
+              def render_project_jump_box
+                # Retrieve them now to avoid a COUNT query
+                projects = User.current.projects.all
+                if projects.any?
+                  s = '<select onchange="if (this.value != \'\') { window.location = this.value; }">' +
+                        "<option selected='selected'>#{ l(:label_jump_to_a_project) }</option>" +
+                        '<option disabled="disabled">---</option>'
+                  s << project_tree_options_for_select(projects) do |p|
+                    { :value => url_for(:controller => 'projects', :action => 'show', :id => p) }
+                  end
+                  s << '</select>'
+                  s
+                end
+              end
+              def project_tree_options_for_select(projects, options = {})
+                s = ''
+                project_tree(projects) do |project, level|
+                  name_prefix = (level > 0 ? ('&nbsp;' * 2 * level + '&#187; ') : '')
+                  tag_options = {:value => project.id, :selected => ((project == options[:selected]) ? 'selected' : nil)}
+                  tag_options.merge!(yield(project)) if block_given?
+                  s << content_tag('option', name_prefix + h(project), tag_options)
+                end
+                s
+              end
+              # Yields the given block for each project with its level in the tree
+              def project_tree(projects, &block)
+                ancestors = []
+                projects.sort_by(&:lft).each do |project|
+                  while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
+                    ancestors.pop
+                  end
+                  yield project, ancestors.size
+                  ancestors << project
+                end
+              end
               # Truncates and returns the string as a single line
               def truncate_single_line(string, *args)
                 truncate(string, *args).gsub(%r{[\r\n]+}m, ' ')
               end
               def html_hours(text)
                 text.gsub(%r{(\d+)\.(\d+)}, '<span class="hours hours-int">\1</span><span class="hours hours-dec">.\2</span>')
               end
               def authoring(created, author, options={})
                 time_tag = @project.nil? ? content_tag('acronym', distance_of_time_in_words(Time.now, created), :title => format_time(created)) :
                                            link_to(distance_of_time_in_words(Time.now, created),
                                                    {:controller => 'projects', :action => 'activity', :id => @project, :from => created.to_date},
                                                    :title => format_time(created))
                 author_tag = (author.is_a?(User) && !author.anonymous?) ? link_to(h(author), :controller => 'account', :action => 'show', :id => author) : h(author || 'Anonymous')
                 l(options[:label] || :label_added_time_by, author_tag, time_tag)
               end
               def l_or_humanize(s, options={})
                 k = "#{options[:prefix]}#{s}".to_sym
                 l_has_string?(k) ? l(k) : s.to_s.humanize
               end
               def day_name(day)
                 l(:general_day_names).split(',')[day-1]
               end
               def month_name(month)
                 l(:actionview_datehelper_select_month_names).split(',')[month-1]
               end
               def syntax_highlight(name, content)
                 type = CodeRay::FileType[name]
                 type ? CodeRay.scan(content, type).html : h(content)
               end
               def to_path_param(path)
                 path.to_s.split(%r{[/\\]}).select {|p| !p.blank?}
               end
               def pagination_links_full(paginator, count=nil, options={})
                 page_param = options.delete(:page_param) || :page
                 url_param = params.dup
                 # don't reuse params if filters are present
                 url_param.clear if url_param.has_key?(:set_filter)
                 html = ''
                 html << link_to_remote(('&#171; ' + l(:label_previous)),
                                         {:update => 'content',
                                          :url => url_param.merge(page_param => paginator.current.previous),
                                          :complete => 'window.scrollTo(0,0)'},
                                         {:href => url_for(:params => url_param.merge(page_param => paginator.current.previous))}) + ' ' if paginator.current.previous
                 html << (pagination_links_each(paginator, options) do |n|
                   link_to_remote(n.to_s,
                                   {:url => {:params => url_param.merge(page_param => n)},
                                    :update => 'content',
                                    :complete => 'window.scrollTo(0,0)'},
                                   {:href => url_for(:params => url_param.merge(page_param => n))})
                 end || '')
                 html << ' ' + link_to_remote((l(:label_next) + ' &#187;'),
                                              {:update => 'content',
                                               :url => url_param.merge(page_param => paginator.current.next),
                                               :complete => 'window.scrollTo(0,0)'},
                                              {:href => url_for(:params => url_param.merge(page_param => paginator.current.next))}) if paginator.current.next
                 unless count.nil?
                   html << [" (#{paginator.current.first_item}-#{paginator.current.last_item}/#{count})", per_page_links(paginator.items_per_page)].compact.join(' | ')
                 end
                 html
               end
               def per_page_links(selected=nil)
                 url_param = params.dup
                 url_param.clear if url_param.has_key?(:set_filter)
                 links = Setting.per_page_options_array.collect do |n|
                   n == selected ? n : link_to_remote(n, {:update => "content", :url => params.dup.merge(:per_page => n)},
                                                         {:href => url_for(url_param.merge(:per_page => n))})
                 end
                 links.size > 1 ? l(:label_display_per_page, links.join(', ')) : nil
               end
               def breadcrumb(*args)
                 elements = args.flatten
                 elements.any? ? content_tag('p', args.join(' &#187; ') + ' &#187; ', :class => 'breadcrumb') : nil
               end
               def html_title(*args)
                 if args.empty?
                   title = []
                   title << @project.name if @project
                   title += @html_title if @html_title
                   title << Setting.app_title
                   title.compact.join(' - ')
                 else
                   @html_title ||= []
                   @html_title += args
                 end
               end
               def accesskey(s)
                 Redmine::AccessKeys.key_for s
               end
               # Formats text according to system settings.
               # 2 ways to call this method:
               # * with a String: textilizable(text, options)
               # * with an object and one of its attribute: textilizable(issue, :description, options)
               def textilizable(*args)
                 options = args.last.is_a?(Hash) ? args.pop : {}
                 case args.size
                 when 1
                   obj = options[:object]
                   text = args.shift
                 when 2
                   obj = args.shift
                   text = obj.send(args.shift).to_s
                 else
                   raise ArgumentError, 'invalid arguments to textilizable'
                 end
                 return '' if text.blank?
                 only_path = options.delete(:only_path) == false ? false : true
                 # when using an image link, try to use an attachment, if possible
                 attachments = options[:attachments] || (obj && obj.respond_to?(:attachments) ? obj.attachments : nil)
                 if attachments
                   attachments = attachments.sort_by(&:created_on).reverse
                   text = text.gsub(/!((\<|\=|\>)?(\([^\)]+\))?(\[[^\]]+\])?(\{[^\}]+\})?)(\S+\.(bmp|gif|jpg|jpeg|png))!/i) do |m|
                     style = $1
                     filename = $6
                     rf = Regexp.new(Regexp.escape(filename),  Regexp::IGNORECASE)
                     # search for the picture in attachments
                     if found = attachments.detect { |att| att.filename =~ rf }
                       image_url = url_for :only_path => only_path, :controller => 'attachments', :action => 'download', :id => found
                       desc = found.description.to_s.gsub(/^([^\(\)]*).*$/, "\\1")
                       alt = desc.blank? ? nil : "(#{desc})"
                       "!#{style}#{image_url}#{alt}!"
                     else
                       "!#{style}#{filename}!"
                     end
                   end
                 end
                 text = Redmine::WikiFormatting.to_html(Setting.text_formatting, text) { |macro, args| exec_macro(macro, obj, args) }
                 # different methods for formatting wiki links
                 case options[:wiki_links]
                 when :local
                   # used for local links to html files
                   format_wiki_link = Proc.new {|project, title, anchor| "#{title}.html" }
                 when :anchor
                   # used for single-file wiki export
                   format_wiki_link = Proc.new {|project, title, anchor| "##{title}" }
                 else
                   format_wiki_link = Proc.new {|project, title, anchor| url_for(:only_path => only_path, :controller => 'wiki', :action => 'index', :id => project, :page => title, :anchor => anchor) }
                 end
                 project = options[:project] || @project || (obj && obj.respond_to?(:project) ? obj.project : nil)
                 # Wiki links
                 #
                 # Examples:
                 #   [[mypage]]
                 #   [[mypage|mytext]]
                 # wiki links can refer other project wikis, using project name or identifier:
                 #   [[project:]] -> wiki starting page
                 #   [[project:|mytext]]
                 #   [[project:mypage]]
                 #   [[project:mypage|mytext]]
                 text = text.gsub(/(!)?(\[\[([^\]\n\|]+)(\|([^\]\n\|]+))?\]\])/) do |m|
                   link_project = project
                   esc, all, page, title = $1, $2, $3, $5
                   if esc.nil?
                     if page =~ /^([^\:]+)\:(.*)$/
                       link_project = Project.find_by_name($1) || Project.find_by_identifier($1)
                       page = $2
                       title ||= $1 if page.blank?
                     end
                     if link_project && link_project.wiki
                       # extract anchor
                       anchor = nil
                       if page =~ /^(.+?)\#(.+)$/
                         page, anchor = $1, $2
                       end
                       # check if page exists
                       wiki_page = link_project.wiki.find_page(page)
                       link_to((title || page), format_wiki_link.call(link_project, Wiki.titleize(page), anchor),
                                                :class => ('wiki-page' + (wiki_page ? '' : ' new')))
                     else
                       # project or wiki doesn't exist
                       title || page
                     end
                   else
                     all
                   end
                 end
                 # Redmine links
                 #
                 # Examples:
                 #   Issues:
                 #     #52 -> Link to issue #52
                 #   Changesets:
                 #     r52 -> Link to revision 52
                 #     commit:a85130f -> Link to scmid starting with a85130f
                 #   Documents:
                 #     document#17 -> Link to document with id 17
                 #     document:Greetings -> Link to the document with title "Greetings"
                 #     document:"Some document" -> Link to the document with title "Some document"
                 #   Versions:
                 #     version#3 -> Link to version with id 3
                 #     version:1.0.0 -> Link to version named "1.0.0"
                 #     version:"1.0 beta 2" -> Link to version named "1.0 beta 2"
                 #   Attachments:
                 #     attachment:file.zip -> Link to the attachment of the current object named file.zip
                 #   Source files:
                 #     source:some/file -> Link to the file located at /some/file in the project's repository
                 #     source:some/file@52 -> Link to the file's revision 52
                 #     source:some/file#L120 -> Link to line 120 of the file
                 #     source:some/file@52#L120 -> Link to line 120 of the file's revision 52
                 #     export:some/file -> Force the download of the file
                 #  Forum messages:
                 #     message#1218 -> Link to message with id 1218
                 text = text.gsub(%r{([\s\(,\-\>]|^)(!)?(attachment|document|version|commit|source|export|message)?((#|r)(\d+)|(:)([^"\s<>][^\s<>]*?|"[^"]+?"))(?=(?=[[:punct:]]\W)|\s|<|$)}) do |m|
                   leading, esc, prefix, sep, oid = $1, $2, $3, $5 || $7, $6 || $8
                   link = nil
                   if esc.nil?
                     if prefix.nil? && sep == 'r'
                       if project && (changeset = project.changesets.find_by_revision(oid))
                         link = link_to("r#{oid}", {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :rev => oid},
                                                   :class => 'changeset',
                                                   :title => truncate_single_line(changeset.comments, 100))
                       end
                     elsif sep == '#'
                       oid = oid.to_i
                       case prefix
                       when nil
                         if issue = Issue.find_by_id(oid, :include => [:project, :status], :conditions => Project.visible_by(User.current))
                           link = link_to("##{oid}", {:only_path => only_path, :controller => 'issues', :action => 'show', :id => oid},
                                                     :class => (issue.closed? ? 'issue closed' : 'issue'),
                                                     :title => "#{truncate(issue.subject, 100)} (#{issue.status.name})")
                           link = content_tag('del', link) if issue.closed?
                         end
                       when 'document'
                         if document = Document.find_by_id(oid, :include => [:project], :conditions => Project.visible_by(User.current))
                           link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                             :class => 'document'
                         end
                       when 'version'
                         if version = Version.find_by_id(oid, :include => [:project], :conditions => Project.visible_by(User.current))
                           link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                           :class => 'version'
                         end
                       when 'message'
                         if message = Message.find_by_id(oid, :include => [:parent, {:board => :project}], :conditions => Project.visible_by(User.current))
                           link = link_to h(truncate(message.subject, 60)), {:only_path => only_path,
                                                                             :controller => 'messages',
                                                                             :action => 'show',
                                                                             :board_id => message.board,
                                                                             :id => message.root,
                                                                             :anchor => (message.parent ? "message-#{message.id}" : nil)},
                                                              :class => 'message'
                         end
                       end
                     elsif sep == ':'
                       # removes the double quotes if any
                       name = oid.gsub(%r{^"(.*)"$}, "\\1")
                       case prefix
                       when 'document'
                         if project && document = project.documents.find_by_title(name)
                           link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                             :class => 'document'
                         end
                       when 'version'
                         if project && version = project.versions.find_by_name(name)
                           link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                           :class => 'version'
                         end
                       when 'commit'
                         if project && (changeset = project.changesets.find(:first, :conditions => ["scmid LIKE ?", "#{name}%"]))
                           link = link_to h("#{name}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :rev => changeset.revision},
                                                        :class => 'changeset',
                                                        :title => truncate_single_line(changeset.comments, 100)
                         end
                       when 'source', 'export'
                         if project && project.repository
                           name =~ %r{^[/\\]*(.*?)(@([0-9a-f]+))?(#(L\d+))?$}
                           path, rev, anchor = $1, $3, $5
                           link = link_to h("#{prefix}:#{name}"), {:controller => 'repositories', :action => 'entry', :id => project,
                                                                   :path => to_path_param(path),
                                                                   :rev => rev,
                                                                   :anchor => anchor,
                                                                   :format => (prefix == 'export' ? 'raw' : nil)},
                                                                  :class => (prefix == 'export' ? 'source download' : 'source')
                         end
                       when 'attachment'
                         if attachments && attachment = attachments.detect {|a| a.filename == name }
                           link = link_to h(attachment.filename), {:only_path => only_path, :controller => 'attachments', :action => 'download', :id => attachment},
                                                                  :class => 'attachment'
                         end
                       end
                     end
                   end
                   leading + (link || "#{prefix}#{sep}#{oid}")
                 end
                 text
               end
               # Same as Rails' simple_format helper without using paragraphs
               def simple_format_without_paragraph(text)
                 text.to_s.
                   gsub(/\r\n?/, "\n").                    # \r\n and \r -> \n
                   gsub(/\n\n+/, "<br /><br />").          # 2+ newline  -> 2 br
                   gsub(/([^\n]\n)(?=[^\n])/, '\1<br />')  # 1 newline   -> br
               end
               def error_messages_for(object_name, options = {})
                 options = options.symbolize_keys
                 object = instance_variable_get("@#{object_name}")
                 if object && !object.errors.empty?
                   # build full_messages here with controller current language
                   full_messages = []
                   object.errors.each do |attr, msg|
                     next if msg.nil?
                     msg = msg.first if msg.is_a? Array
                     if attr == "base"
                       full_messages << l(msg)
                     else
                       full_messages << "&#171; " + (l_has_string?("field_" + attr) ? l("field_" + attr) : object.class.human_attribute_name(attr)) + " &#187; " + l(msg) unless attr == "custom_values"
                     end
                   end
                   # retrieve custom values error messages
                   if object.errors[:custom_values]
                     object.custom_values.each do |v|
                       v.errors.each do |attr, msg|
                         next if msg.nil?
                         msg = msg.first if msg.is_a? Array
                         full_messages << "&#171; " + v.custom_field.name + " &#187; " + l(msg)
                       end
                     end
                   end
                   content_tag("div",
                     content_tag(
                       options[:header_tag] || "span", lwr(:gui_validation_error, full_messages.length) + ":"
                     ) +
                     content_tag("ul", full_messages.collect { |msg| content_tag("li", msg) }),
                     "id" => options[:id] || "errorExplanation", "class" => options[:class] || "errorExplanation"
                   )
                 else
                   ""
                 end
               end
               def lang_options_for_select(blank=true)
                 (blank ? [["(auto)", ""]] : []) +
                   GLoc.valid_languages.collect{|lang| [ ll(lang.to_s, :general_lang_name), lang.to_s]}.sort{|x,y| x.last <=> y.last }
               end
               def label_tag_for(name, option_tags = nil, options = {})
                 label_text = l(("field_"+field.to_s.gsub(/\_id$/, "")).to_sym) + (options.delete(:required) ? @template.content_tag("span", " *", :class => "required"): "")
                 content_tag("label", label_text)
               end
               def labelled_tabular_form_for(name, object, options, &proc)
                 options[:html] ||= {}
                 options[:html][:class] = 'tabular' unless options[:html].has_key?(:class)
                 form_for(name, object, options.merge({ :builder => TabularFormBuilder, :lang => current_language}), &proc)
               end
               def back_url_hidden_field_tag
                 back_url = params[:back_url] || request.env['HTTP_REFERER']
                 back_url = CGI.unescape(back_url.to_s)
                 hidden_field_tag('back_url', CGI.escape(back_url)) unless back_url.blank?
               end
               def check_all_links(form_name)
                 link_to_function(l(:button_check_all), "checkAll('#{form_name}', true)") +
                 " | " +
                 link_to_function(l(:button_uncheck_all), "checkAll('#{form_name}', false)")
               end
               def progress_bar(pcts, options={})
                 pcts = [pcts, pcts] unless pcts.is_a?(Array)
                 pcts[1] = pcts[1] - pcts[0]
                 pcts << (100 - pcts[1] - pcts[0])
                 width = options[:width] || '100px;'
                 legend = options[:legend] || ''
                 content_tag('table',
                   content_tag('tr',
                     (pcts[0] > 0 ? content_tag('td', '', :style => "width: #{pcts[0].floor}%;", :class => 'closed') : '') +
                     (pcts[1] > 0 ? content_tag('td', '', :style => "width: #{pcts[1].floor}%;", :class => 'done') : '') +
                     (pcts[2] > 0 ? content_tag('td', '', :style => "width: #{pcts[2].floor}%;", :class => 'todo') : '')
                   ), :class => 'progress', :style => "width: #{width};") +
                   content_tag('p', legend, :class => 'pourcent')
               end
               def context_menu_link(name, url, options={})
                 options[:class] ||= ''
                 if options.delete(:selected)
                   options[:class] << ' icon-checked disabled'
                   options[:disabled] = true
                 end
                 if options.delete(:disabled)
                   options.delete(:method)
                   options.delete(:confirm)
                   options.delete(:onclick)
                   options[:class] << ' disabled'
                   url = '#'
                 end
                 link_to name, url, options
               end
               def calendar_for(field_id)
                 include_calendar_headers_tags
                 image_tag("calendar.png", {:id => "#{field_id}_trigger",:class => "calendar-trigger"}) +
                 javascript_tag("Calendar.setup({inputField : '#{field_id}', ifFormat : '%Y-%m-%d', button : '#{field_id}_trigger' });")
               end
               def include_calendar_headers_tags
                 unless @calendar_headers_tags_included
                   @calendar_headers_tags_included = true
                   content_for :header_tags do
                     javascript_include_tag('calendar/calendar') +
                     javascript_include_tag("calendar/lang/calendar-#{current_language}.js") +
                     javascript_include_tag('calendar/calendar-setup') +
                     stylesheet_link_tag('calendar')
                   end
                 end
               end
               def content_for(name, content = nil, &block)
                 @has_content ||= {}
                 @has_content[name] = true
                 super(name, content, &block)
               end
               def has_content?(name)
                 (@has_content && @has_content[name]) || false
               end
               # Returns the avatar image tag for the given +user+ if avatars are enabled
               # +user+ can be a User or a string that will be scanned for an email address (eg. 'joe <joe@foo.bar>')
               def avatar(user, options = { })
                 if Setting.gravatar_enabled?
                   email = nil
                   if user.respond_to?(:mail)
                     email = user.mail
                   elsif user.to_s =~ %r{<(.+?)>}
                     email = $1
                   end
                   return gravatar(email.to_s.downcase, options) unless email.blank? rescue nil
                 end
               end
               private
               def wiki_helper
                 helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
                 extend helper
                 return self
               end
             end

app/helpers/projects_helper.rb +35 0

             # redMine - project management software
             # Copyright (C) 2006  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module ProjectsHelper
               def link_to_version(version, options = {})
                 return '' unless version && version.is_a?(Version)
                 link_to h(version.name), { :controller => 'versions', :action => 'show', :id => version }, options
               end
               def project_settings_tabs
                 tabs = [{:name => 'info', :action => :edit_project, :partial => 'projects/edit', :label => :label_information_plural},
                         {:name => 'modules', :action => :select_project_modules, :partial => 'projects/settings/modules', :label => :label_module_plural},
                         {:name => 'members', :action => :manage_members, :partial => 'projects/settings/members', :label => :label_member_plural},
                         {:name => 'versions', :action => :manage_versions, :partial => 'projects/settings/versions', :label => :label_version_plural},
                         {:name => 'categories', :action => :manage_categories, :partial => 'projects/settings/issue_categories', :label => :label_issue_category_plural},
                         {:name => 'wiki', :action => :manage_wiki, :partial => 'projects/settings/wiki', :label => :label_wiki},
                         {:name => 'repository', :action => :manage_repository, :partial => 'projects/settings/repository', :label => :label_repository},
                         {:name => 'boards', :action => :manage_boards, :partial => 'projects/settings/boards', :label => :label_board_plural}
                         ]
                 tabs.select {|tab| User.current.allowed_to?(tab[:action], @project)}
               end
+              def parent_project_select_tag(project)
+                options = '<option></option>' + project_tree_options_for_select(project.possible_parents, :selected => project.parent)
+                content_tag('select', options, :name => 'project[parent_id]')
+              end
+              # Renders a tree of projects as a nested set of unordered lists
+              # The given collection may be a subset of the whole project tree
+              # (eg. some intermediate nodes are private and can not be seen)
+              def render_project_hierarchy(projects)
+                s = ''
+                if projects.any?
+                  ancestors = []
+                  projects.each do |project|
+                    if (ancestors.empty? || project.is_descendant_of?(ancestors.last))
+                      s << "<ul class='projects #{ ancestors.empty? ? 'root' : nil}'>\n"
+                    else
+                      ancestors.pop
+                      s << "</li>"
+                      while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
+                        ancestors.pop
+                        s << "</ul></li>\n"
+                      end
+                    end
+                    classes = (ancestors.empty? ? 'root' : 'child')
+                    s << "<li class='#{classes}'><div class='#{classes}'>" +
+                           link_to(h(project), {:controller => 'projects', :action => 'show', :id => project}, :class => "project #{User.current.member_of?(project) ? 'my-project' : nil}")
+                    s << "<div class='wiki description'>#{textilizable(project.short_description, :project => project)}</div>" unless project.description.blank?
+                    s << "</div>\n"
+                    ancestors << project
+                  end
+                  s << ("</li></ul>\n" * ancestors.size)
+                end
+                s
+              end
             end

app/helpers/search_helper.rb +1 -1

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module SearchHelper
               def highlight_tokens(text, tokens)
                 return text unless text && tokens && !tokens.empty?
                 re_tokens = tokens.collect {|t| Regexp.escape(t)}
                 regexp = Regexp.new "(#{re_tokens.join('|')})", Regexp::IGNORECASE
                 result = ''
                 text.split(regexp).each_with_index do |words, i|
                   if result.length > 1200
                     # maximum length of the preview reached
                     result << '...'
                     break
                   end
                   if i.even?
                     result << h(words.length > 100 ? "#{words[0..44]} ... #{words[-45..-1]}" : words)
                   else
                     t = (tokens.index(words.downcase) || 0) % 4
                     result << content_tag('span', h(words), :class => "highlight token-#{t}")
                   end
                 end
                 result
               end
               def type_label(t)
                 l("label_#{t.singularize}_plural")
               end
               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
               def render_results_by_type(results_by_type)
                 links = []
                 # Sorts types by results count
                 results_by_type.keys.sort {|a, b| results_by_type[b] <=> results_by_type[a]}.each do |t|
                   c = results_by_type[t]
                   next if c == 0
                   text = "#{type_label(t)} (#{c})"
                   links << link_to(text, :q => params[:q], :titles_only => params[:title_only], :all_words => params[:all_words], :scope => params[:scope], t => 1)
                 end
                 ('<ul>' + links.map {|link| content_tag('li', link)}.join(' ') + '</ul>') unless links.empty?
               end
             end

app/helpers/users_helper.rb +3 -8

             # redMine - project management software
             # Copyright (C) 2006  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             module UsersHelper
               def users_status_options_for_select(selected)
                 user_count_by_status = User.count(:group => 'status').to_hash
                 options_for_select([[l(:label_all), ''],
                                     ["#{l(:status_active)} (#{user_count_by_status[1].to_i})", 1],
                                     ["#{l(:status_registered)} (#{user_count_by_status[2].to_i})", 2],
                                     ["#{l(:status_locked)} (#{user_count_by_status[3].to_i})", 3]], selected)
               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)
+                options << project_tree_options_for_select(projects) do |p|
-                projects_by_root.keys.sort.each do |root|
+                  {:disabled => (user.projects.include?(p))}
-                  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
                 end
                 options
               end
               def change_status_link(user)
                 url = {:action => 'edit', :id => user, :page => params[:page], :status => params[:status]}
                 if user.locked?
                   link_to l(:button_unlock), url.merge(:user => {:status => User::STATUS_ACTIVE}), :method => :post, :class => 'icon icon-unlock'
                 elsif user.registered?
                   link_to l(:button_activate), url.merge(:user => {:status => User::STATUS_ACTIVE}), :method => :post, :class => 'icon icon-unlock'
                 elsif user != User.current
                   link_to l(:button_lock), url.merge(:user => {:status => User::STATUS_LOCKED}), :method => :post, :class => 'icon icon-lock'
                 end
               end
               def user_settings_tabs
                 tabs = [{:name => 'general', :partial => 'users/general', :label => :label_general},
                         {:name => 'memberships', :partial => 'users/memberships', :label => :label_project_plural}
                         ]
               end
             end

app/models/project.rb +53 -11

             # redMine - project management software
             # Copyright (C) 2006  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class Project < ActiveRecord::Base
               # Project statuses
               STATUS_ACTIVE     = 1
               STATUS_ARCHIVED   = 9
               has_many :members, :include => :user, :conditions => "#{User.table_name}.status=#{User::STATUS_ACTIVE}"
               has_many :users, :through => :members
               has_many :enabled_modules, :dependent => :delete_all
               has_and_belongs_to_many :trackers, :order => "#{Tracker.table_name}.position"
               has_many :issues, :dependent => :destroy, :order => "#{Issue.table_name}.created_on DESC", :include => [:status, :tracker]
               has_many :issue_changes, :through => :issues, :source => :journals
               has_many :versions, :dependent => :destroy, :order => "#{Version.table_name}.effective_date DESC, #{Version.table_name}.name DESC"
               has_many :time_entries, :dependent => :delete_all
               has_many :queries, :dependent => :delete_all
               has_many :documents, :dependent => :destroy
               has_many :news, :dependent => :delete_all, :include => :author
               has_many :issue_categories, :dependent => :delete_all, :order => "#{IssueCategory.table_name}.name"
               has_many :boards, :dependent => :destroy, :order => "position ASC"
               has_one :repository, :dependent => :destroy
               has_many :changesets, :through => :repository
               has_one :wiki, :dependent => :destroy
               # Custom field for the project issues
               has_and_belongs_to_many :issue_custom_fields,
                                       :class_name => 'IssueCustomField',
                                       :order => "#{CustomField.table_name}.position",
                                       :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
               acts_as_customizable
               acts_as_searchable :columns => ['name', 'description'], :project_key => 'id', :permission => nil
               acts_as_event :title => Proc.new {|o| "#{l(:label_project)}: #{o.name}"},
                             :url => Proc.new {|o| {:controller => 'projects', :action => 'show', :id => o.id}},
                             :author => nil
               attr_protected :status, :enabled_module_names
               validates_presence_of :name, :identifier
               validates_uniqueness_of :name, :identifier
               validates_associated :repository, :wiki
               validates_length_of :name, :maximum => 30
               validates_length_of :homepage, :maximum => 255
               validates_length_of :identifier, :in => 2..20
               validates_format_of :identifier, :with => /^[a-z0-9\-]*$/
               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?
               end
               def identifier_frozen?
                 errors[:identifier].nil? && !(new_record? || identifier.blank?)
               end
               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]
                 # Quick and dirty fix for Rails 2 compatibility
                 Issue.send(:with_scope, :find => { :conditions => conditions }) do
                   Version.send(:with_scope, :find => { :conditions => conditions }) do
                     yield
                   end
                 end
               end
               # returns latest created projects
               # non public projects will be returned only if user is a member of those
               def self.latest(user=nil, count=5)
                 find(:all, :limit => count, :conditions => visible_by(user), :order => "created_on DESC")
               end
               def self.visible_by(user=nil)
                 user ||= User.current
                 if user && user.admin?
                   return "#{Project.table_name}.status=#{Project::STATUS_ACTIVE}"
                 elsif user && user.memberships.any?
                   return "#{Project.table_name}.status=#{Project::STATUS_ACTIVE} AND (#{Project.table_name}.is_public = #{connection.quoted_true} or #{Project.table_name}.id IN (#{user.memberships.collect{|m| m.project_id}.join(',')}))"
                 else
                   return "#{Project.table_name}.status=#{Project::STATUS_ACTIVE} AND #{Project.table_name}.is_public = #{connection.quoted_true}"
                 end
               end
               def self.allowed_to_condition(user, permission, options={})
                 statements = []
                 base_statement = "#{Project.table_name}.status=#{Project::STATUS_ACTIVE}"
                 if perm = Redmine::AccessControl.permission(permission)
                   unless perm.project_module.nil?
                     # If the permission belongs to a project module, make sure the module is enabled
                     base_statement << " AND EXISTS (SELECT em.id FROM #{EnabledModule.table_name} em WHERE em.name='#{perm.project_module}' AND em.project_id=#{Project.table_name}.id)"
                   end
                 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?
                   # no restriction
                 else
                   statements << "1=0"
                   if user.logged?
                     statements << "#{Project.table_name}.is_public = #{connection.quoted_true}" if Role.non_member.allowed_to?(permission)
                     allowed_project_ids = user.memberships.select {|m| m.role.allowed_to?(permission)}.collect {|m| m.project_id}
                     statements << "#{Project.table_name}.id IN (#{allowed_project_ids.join(',')})" if allowed_project_ids.any?
                   elsif Role.anonymous.allowed_to?(permission)
                     # anonymous user allowed on public project
                     statements << "#{Project.table_name}.is_public = #{connection.quoted_true}"
                   else
                     # anonymous user is not authorized
                   end
                 end
                 statements.empty? ? base_statement : "((#{base_statement}) AND (#{statements.join(' OR ')}))"
               end
               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
               def self.find(*args)
                 if args.first && args.first.is_a?(String) && !args.first.match(/^\d*$/)
                   project = find_by_identifier(*args)
                   raise ActiveRecord::RecordNotFound, "Couldn't find Project with identifier=#{args.first}" if project.nil?
                   project
                 else
                   super
                 end
               end
               def to_param
                 # id is used for projects with a numeric identifier (compatibility)
                 @to_param ||= (identifier.to_s =~ %r{^\d*$} ? id : identifier)
               end
               def active?
                 self.status == STATUS_ACTIVE
               end
+              # Archives the project and its descendants recursively
               def archive
                 # Archive subprojects if any
                 children.each do |subproject|
                   subproject.archive
                 end
                 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
+              # Returns an array of projects the project can be moved to
-                children.select {|child| child.active?}
+              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
               def rolled_up_trackers
                 @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
               # Deletes all project's members
               def delete_all_members
                 Member.delete_all(['project_id = ?', id])
               end
               # Users issues can be assigned to
               def assignable_users
                 members.select {|m| m.role.assignable?}.collect {|m| m.user}.sort
               end
               # Returns the mail adresses of users that should be always notified on project events
               def recipients
                 members.select {|m| m.mail_notification? || m.user.mail_notification?}.collect {|m| m.user.mail}
               end
               # Returns an array of all custom fields enabled for project issues
               # (explictly associated custom fields and custom fields enabled for all projects)
               def all_issue_custom_fields
                 @all_issue_custom_fields ||= (IssueCustomField.for_all + issue_custom_fields).uniq.sort
               end
               def project
                 self
               end
               def <=>(project)
                 name.downcase <=> project.name.downcase
               end
               def to_s
                 name
               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)
                 if action.is_a? Hash
                   allowed_actions.include? "#{action[:controller]}/#{action[:action]}"
                 else
                   allowed_permissions.include? action
                 end
               end
               def module_enabled?(module_name)
                 module_name = module_name.to_s
                 enabled_modules.detect {|m| m.name == module_name}
               end
               def enabled_module_names=(module_names)
                 enabled_modules.clear
                 module_names = [] unless module_names && module_names.is_a?(Array)
                 module_names.each do |name|
                   enabled_modules << EnabledModule.new(:name => name.to_s)
                 end
               end
               # Returns an auto-generated project identifier based on the last identifier used
               def self.next_identifier
                 p = Project.find(:first, :order => 'created_on DESC')
                 p.nil? ? nil : p.identifier.to_s.succ
               end
             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
             private
               def allowed_permissions
                 @allowed_permissions ||= begin
                   module_names = enabled_modules.collect {|m| m.name}
                   Redmine::AccessControl.modules_permissions(module_names).collect {|p| p.name}
                 end
               end
               def allowed_actions
                 @actions_allowed ||= allowed_permissions.inject([]) { |actions, permission| actions += Redmine::AccessControl.allowed_actions(permission) }.flatten
               end
             end

app/models/query.rb +5 -5

             # Redmine - project management software
             # Copyright (C) 2006-2008  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class QueryColumn
               attr_accessor :name, :sortable, :default_order
               include GLoc
               def initialize(name, options={})
                 self.name = name
                 self.sortable = options[:sortable]
                 self.default_order = options[:default_order]
               end
               def caption
                 set_language_if_valid(User.current.language)
                 l("field_#{name}")
               end
             end
             class QueryCustomFieldColumn < QueryColumn
               def initialize(custom_field)
                 self.name = "cf_#{custom_field.id}".to_sym
                 self.sortable = custom_field.order_statement || false
                 @cf = custom_field
               end
               def caption
                 @cf.name
               end
               def custom_field
                 @cf
               end
             end
             class Query < ActiveRecord::Base
               belongs_to :project
               belongs_to :user
               serialize :filters
               serialize :column_names
               attr_protected :project_id, :user_id
               validates_presence_of :name, :on => :save
               validates_length_of :name, :maximum => 255
               @@operators = { "="   => :label_equals,
                               "!"   => :label_not_equals,
                               "o"   => :label_open_issues,
                               "c"   => :label_closed_issues,
                               "!*"  => :label_none,
                               "*"   => :label_all,
                               ">="   => '>=',
                               "<="   => '<=',
                               "<t+" => :label_in_less_than,
                               ">t+" => :label_in_more_than,
                               "t+"  => :label_in,
                               "t"   => :label_today,
                               "w"   => :label_this_week,
                               ">t-" => :label_less_than_ago,
                               "<t-" => :label_more_than_ago,
                               "t-"  => :label_ago,
                               "~"   => :label_contains,
                               "!~"  => :label_not_contains }
               cattr_reader :operators
               @@operators_by_filter_type = { :list => [ "=", "!" ],
                                              :list_status => [ "o", "=", "!", "c", "*" ],
                                              :list_optional => [ "=", "!", "!*", "*" ],
                                              :list_subprojects => [ "*", "!*", "=" ],
                                              :date => [ "<t+", ">t+", "t+", "t", "w", ">t-", "<t-", "t-" ],
                                              :date_past => [ ">t-", "<t-", "t-", "t", "w" ],
                                              :string => [ "=", "~", "!", "!~" ],
                                              :text => [  "~", "!~" ],
                                              :integer => [ "=", ">=", "<=", "!*", "*" ] }
               cattr_reader :operators_by_filter_type
               @@available_columns = [
                 QueryColumn.new(:tracker, :sortable => "#{Tracker.table_name}.position"),
                 QueryColumn.new(:status, :sortable => "#{IssueStatus.table_name}.position"),
                 QueryColumn.new(:priority, :sortable => "#{Enumeration.table_name}.position", :default_order => 'desc'),
                 QueryColumn.new(:subject, :sortable => "#{Issue.table_name}.subject"),
                 QueryColumn.new(:author),
                 QueryColumn.new(:assigned_to, :sortable => "#{User.table_name}.lastname"),
                 QueryColumn.new(:updated_on, :sortable => "#{Issue.table_name}.updated_on", :default_order => 'desc'),
                 QueryColumn.new(:category, :sortable => "#{IssueCategory.table_name}.name"),
                 QueryColumn.new(:fixed_version, :sortable => "#{Version.table_name}.effective_date", :default_order => 'desc'),
                 QueryColumn.new(:start_date, :sortable => "#{Issue.table_name}.start_date"),
                 QueryColumn.new(:due_date, :sortable => "#{Issue.table_name}.due_date"),
                 QueryColumn.new(:estimated_hours, :sortable => "#{Issue.table_name}.estimated_hours"),
                 QueryColumn.new(:done_ratio, :sortable => "#{Issue.table_name}.done_ratio"),
                 QueryColumn.new(:created_on, :sortable => "#{Issue.table_name}.created_on", :default_order => 'desc'),
               ]
               cattr_reader :available_columns
               def initialize(attributes = nil)
                 super attributes
                 self.filters ||= { 'status_id' => {:operator => "o", :values => [""]} }
                 set_language_if_valid(User.current.language)
               end
               def after_initialize
                 # Store the fact that project is nil (used in #editable_by?)
                 @is_for_all = project.nil?
               end
               def validate
                 filters.each_key do |field|
                   errors.add label_for(field), :activerecord_error_blank unless
                       # filter requires one or more values
                       (values_for(field) and !values_for(field).first.blank?) or
                       # filter doesn't require any value
                       ["o", "c", "!*", "*", "t", "w"].include? operator_for(field)
                 end if filters
               end
               def editable_by?(user)
                 return false unless user
                 # Admin can edit them all and regular users can edit their private queries
                 return true if user.admin? || (!is_public && self.user_id == user.id)
                 # Members can not edit public queries that are for all project (only admin is allowed to)
                 is_public && !@is_for_all && user.allowed_to?(:manage_public_queries, project)
               end
               def available_filters
                 return @available_filters if @available_filters
                 trackers = project.nil? ? Tracker.find(:all, :order => 'position') : project.rolled_up_trackers
                 @available_filters = { "status_id" => { :type => :list_status, :order => 1, :values => IssueStatus.find(:all, :order => 'position').collect{|s| [s.name, s.id.to_s] } },
                                        "tracker_id" => { :type => :list, :order => 2, :values => trackers.collect{|s| [s.name, s.id.to_s] } },
                                        "priority_id" => { :type => :list, :order => 3, :values => Enumeration.find(:all, :conditions => ['opt=?','IPRI'], :order => 'position').collect{|s| [s.name, s.id.to_s] } },
                                        "subject" => { :type => :text, :order => 8 },
                                        "created_on" => { :type => :date_past, :order => 9 },
                                        "updated_on" => { :type => :date_past, :order => 10 },
                                        "start_date" => { :type => :date, :order => 11 },
                                        "due_date" => { :type => :date, :order => 12 },
                                        "estimated_hours" => { :type => :integer, :order => 13 },
                                        "done_ratio" =>  { :type => :integer, :order => 14 }}
                 user_values = []
                 user_values << ["<< #{l(:label_me)} >>", "me"] if User.current.logged?
                 if project
                   user_values += project.users.sort.collect{|s| [s.name, s.id.to_s] }
                 else
                   # members of the user's projects
                   user_values += User.current.projects.collect(&:users).flatten.uniq.sort.collect{|s| [s.name, s.id.to_s] }
                 end
                 @available_filters["assigned_to_id"] = { :type => :list_optional, :order => 4, :values => user_values } unless user_values.empty?
                 @available_filters["author_id"] = { :type => :list, :order => 5, :values => user_values } unless user_values.empty?
                 if project
                   # project specific filters
                   unless @project.issue_categories.empty?
                     @available_filters["category_id"] = { :type => :list_optional, :order => 6, :values => @project.issue_categories.collect{|s| [s.name, s.id.to_s] } }
                   end
                   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?
+                  unless @project.descendants.active.empty?
-                    @available_filters["subproject_id"] = { :type => :list_subprojects, :order => 13, :values => @project.active_children.collect{|s| [s.name, s.id.to_s] } }
+                    @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
                   # global filters for cross project issue list
                   add_custom_fields_filters(IssueCustomField.find(:all, :conditions => {:is_filter => true, :is_for_all => true}))
                 end
                 @available_filters
               end
               def add_filter(field, operator, values)
                 # values must be an array
                 return unless values and values.is_a? Array # and !values.first.empty?
                 # check if field is defined as an available filter
                 if available_filters.has_key? field
                   filter_options = available_filters[field]
                   # check if operator is allowed for that filter
                   #if @@operators_by_filter_type[filter_options[:type]].include? operator
                   #  allowed_values = values & ([""] + (filter_options[:values] || []).collect {|val| val[1]})
                   #  filters[field] = {:operator => operator, :values => allowed_values } if (allowed_values.first and !allowed_values.first.empty?) or ["o", "c", "!*", "*", "t"].include? operator
                   #end
                   filters[field] = {:operator => operator, :values => values }
                 end
               end
               def add_short_filter(field, expression)
                 return unless expression
                 parms = expression.scan(/^(o|c|\!|\*)?(.*)$/).first
                 add_filter field, (parms[0] || "="), [parms[1] || ""]
               end
               def has_filter?(field)
                 filters and filters[field]
               end
               def operator_for(field)
                 has_filter?(field) ? filters[field][:operator] : nil
               end
               def values_for(field)
                 has_filter?(field) ? filters[field][:values] : nil
               end
               def label_for(field)
                 label = available_filters[field][:name] if available_filters.has_key?(field)
                 label ||= field.gsub(/\_id$/, "")
               end
               def available_columns
                 return @available_columns if @available_columns
                 @available_columns = Query.available_columns
                 @available_columns += (project ?
                                         project.all_issue_custom_fields :
                                         IssueCustomField.find(:all, :conditions => {:is_for_all => true})
                                        ).collect {|cf| QueryCustomFieldColumn.new(cf) }
               end
               def columns
                 if has_default_columns?
                   available_columns.select {|c| Setting.issue_list_default_columns.include?(c.name.to_s) }
                 else
                   # preserve the column_names order
                   column_names.collect {|name| available_columns.find {|col| col.name == name}}.compact
                 end
               end
               def column_names=(names)
                 names = names.select {|n| n.is_a?(Symbol) || !n.blank? } if names
                 names = names.collect {|n| n.is_a?(Symbol) ? n : n.to_sym } if names
                 write_attribute(:column_names, names)
               end
               def has_column?(column)
                 column_names && column_names.include?(column.name)
               end
               def has_default_columns?
                 column_names.nil? || column_names.empty?
               end
               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")
                     when '='
                       # include the selected subprojects
                       ids += values_for("subproject_id").each(&:to_i)
                     when '!*'
                       # 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
                   project_clauses << "#{Project.table_name}.id = %d" % project.id
                 end
                 project_clauses <<  Project.allowed_to_condition(User.current, :view_issues)
                 project_clauses.join(' AND ')
               end
               def statement
                 # filters clauses
                 filters_clauses = []
                 filters.each_key do |field|
                   next if field == "subproject_id"
                   v = values_for(field).clone
                   next unless v and !v.empty?
                   sql = ''
                   is_custom_filter = false
                   if field =~ /^cf_(\d+)$/
                     # custom field
                     db_table = CustomValue.table_name
                     db_field = 'value'
                     is_custom_filter = true
                     sql << "#{Issue.table_name}.id IN (SELECT #{Issue.table_name}.id FROM #{Issue.table_name} LEFT OUTER JOIN #{db_table} ON #{db_table}.customized_type='Issue' AND #{db_table}.customized_id=#{Issue.table_name}.id AND #{db_table}.custom_field_id=#{$1} WHERE "
                   else
                     # regular field
                     db_table = Issue.table_name
                     db_field = field
                     sql << '('
                   end
                   # "me" value subsitution
                   if %w(assigned_to_id author_id).include?(field)
                     v.push(User.current.logged? ? User.current.id.to_s : "0") if v.delete("me")
                   end
                   sql = sql + sql_for_field(field, v, db_table, db_field, is_custom_filter)
                   sql << ')'
                   filters_clauses << sql
                 end if filters and valid?
                 (filters_clauses << project_statement).join(' AND ')
               end
               private
               # Helper method to generate the WHERE sql for a +field+ with a +value+
               def sql_for_field(field, value, db_table, db_field, is_custom_filter)
                 sql = ''
                 case operator_for field
                 when "="
                   sql = "#{db_table}.#{db_field} IN (" + value.collect{|val| "'#{connection.quote_string(val)}'"}.join(",") + ")"
                 when "!"
                   sql = "(#{db_table}.#{db_field} IS NULL OR #{db_table}.#{db_field} NOT IN (" + value.collect{|val| "'#{connection.quote_string(val)}'"}.join(",") + "))"
                 when "!*"
                   sql = "#{db_table}.#{db_field} IS NULL"
                   sql << " OR #{db_table}.#{db_field} = ''" if is_custom_filter
                 when "*"
                   sql = "#{db_table}.#{db_field} IS NOT NULL"
                   sql << " AND #{db_table}.#{db_field} <> ''" if is_custom_filter
                 when ">="
                   sql = "#{db_table}.#{db_field} >= #{value.first.to_i}"
                 when "<="
                   sql = "#{db_table}.#{db_field} <= #{value.first.to_i}"
                 when "o"
                   sql = "#{IssueStatus.table_name}.is_closed=#{connection.quoted_false}" if field == "status_id"
                 when "c"
                   sql = "#{IssueStatus.table_name}.is_closed=#{connection.quoted_true}" if field == "status_id"
                 when ">t-"
                   sql = date_range_clause(db_table, db_field, - value.first.to_i, 0)
                 when "<t-"
                   sql = date_range_clause(db_table, db_field, nil, - value.first.to_i)
                 when "t-"
                   sql = date_range_clause(db_table, db_field, - value.first.to_i, - value.first.to_i)
                 when ">t+"
                   sql = date_range_clause(db_table, db_field, value.first.to_i, nil)
                 when "<t+"
                   sql = date_range_clause(db_table, db_field, 0, value.first.to_i)
                 when "t+"
                   sql = date_range_clause(db_table, db_field, value.first.to_i, value.first.to_i)
                 when "t"
                   sql = date_range_clause(db_table, db_field, 0, 0)
                 when "w"
                   from = l(:general_first_day_of_week) == '7' ?
                   # week starts on sunday
                   ((Date.today.cwday == 7) ? Time.now.at_beginning_of_day : Time.now.at_beginning_of_week - 1.day) :
                     # week starts on monday (Rails default)
                     Time.now.at_beginning_of_week
                   sql = "#{db_table}.#{db_field} BETWEEN '%s' AND '%s'" % [connection.quoted_date(from), connection.quoted_date(from + 7.days)]
                 when "~"
                   sql = "#{db_table}.#{db_field} LIKE '%#{connection.quote_string(value.first)}%'"
                 when "!~"
                   sql = "#{db_table}.#{db_field} NOT LIKE '%#{connection.quote_string(value.first)}%'"
                 end
                 return sql
               end
               def add_custom_fields_filters(custom_fields)
                 @available_filters ||= {}
                 custom_fields.select(&:is_filter?).each do |field|
                   case field.field_format
                   when "text"
                     options = { :type => :text, :order => 20 }
                   when "list"
                     options = { :type => :list_optional, :values => field.possible_values, :order => 20}
                   when "date"
                     options = { :type => :date, :order => 20 }
                   when "bool"
                     options = { :type => :list, :values => [[l(:general_text_yes), "1"], [l(:general_text_no), "0"]], :order => 20 }
                   else
                     options = { :type => :string, :order => 20 }
                   end
                   @available_filters["cf_#{field.id}"] = options.merge({ :name => field.name })
                 end
               end
               # Returns a SQL clause for a date or datetime field.
               def date_range_clause(table, field, from, to)
                 s = []
                 if from
                   s << ("#{table}.#{field} > '%s'" % [connection.quoted_date((Date.yesterday + from).to_time.end_of_day)])
                 end
                 if to
                   s << ("#{table}.#{field} <= '%s'" % [connection.quoted_date((Date.today + to).to_time.end_of_day)])
                 end
                 s.join(' AND ')
               end
             end

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

             <div class="contextual">
             <%= link_to l(:label_project_new), {:controller => 'projects', :action => 'add'}, :class => 'icon icon-add' %>
             </div>
             <h2><%=l(:label_project_plural)%></h2>
             <% form_tag({}, :method => :get) do %>
             <fieldset><legend><%= l(:label_filter_plural) %></legend>
             <label><%= l(:field_status) %> :</label>
             <%= select_tag 'status', project_status_options_for_select(@status), :class => "small", :onchange => "this.form.submit(); return false;"  %>
             <label><%= l(:label_project) %>:</label>
             <%= text_field_tag 'name', params[:name], :size => 30 %>
             <%= submit_tag l(:button_apply), :class => "small", :name => nil %>
             </fieldset>
             <% end %>
             &nbsp;
             <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>
+            	<th><%=l(:field_is_public)%></th>
-            	<%= sort_header_tag('is_public', :caption => l(:field_is_public), :default_order => 'desc') %>
+            	<th><%=l(:field_created_on)%></th>
-            	<%= sort_header_tag('created_on', :caption => l(:field_created_on), :default_order => 'desc') %>
                 <th></th>
                 <th></th>
               </tr></thead>
               <tbody>
             <% for project in @projects %>
-              <tr class="<%= cycle("odd", "even") %>">
+              <tr class="<%= cycle("odd", "even") %> <%= css_project_classes(project) %>">
-            	<td><%= project.active? ? link_to(h(project.name), :controller => 'projects', :action => 'settings', :id => project) : h(project.name) %>
+            	<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><%= textilizable project.short_description, :project => project %></td>
-            	<td align="center"><%= project.children.size %>
+            	<td align="center"><%= image_tag 'true.png' if project.is_public? %></td>
-            	<td align="center"><%= image_tag 'true.png' if project.is_public? %>
+            	<td align="center"><%= format_date(project.created_on) %></td>
-            	<td align="center"><%= format_date(project.created_on) %>
               <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? %>
                 <%= link_to(l(:button_unarchive), { :controller => 'projects', :action => 'unarchive', :id => project }, :method => :post, :class => 'icon icon-unlock') if !project.active? && (project.parent.nil? || project.parent.active?) %>
                 </small>
               </td>
               <td align="center" style="width:10%">
                 <small><%= link_to(l(:button_delete), { :controller => 'projects', :action => 'destroy', :id => project }, :class => 'icon icon-del') %></small>
               </td>
               </tr>
             <% end %>
               </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

             <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
             <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
             <head>
             <title><%=h html_title %></title>
             <meta http-equiv="content-type" content="text/html; charset=utf-8" />
             <meta name="description" content="<%= Redmine::Info.app_name %>" />
             <meta name="keywords" content="issue,bug,tracker" />
             <%= stylesheet_link_tag 'application', :media => 'all' %>
             <%= javascript_include_tag :defaults %>
             <%= heads_for_wiki_formatter %>
             <!--[if IE]>
                 <style type="text/css">
                   * html body{ width: expression( document.documentElement.clientWidth < 900 ? '900px' : '100%' ); }
                   body {behavior: url(<%= stylesheet_path "csshover.htc" %>);}
                 </style>
             <![endif]-->
             <%= call_hook :view_layouts_base_html_head %>
             <!-- page specific tags -->
             <%= yield :header_tags -%>
             </head>
             <body>
             <div id="wrapper">
             <div id="top-menu">
                 <div id="account">
                     <%= render_menu :account_menu -%>
                 </div>
                 <%= content_tag('div', "#{l(:label_logged_as)} #{link_to_user(User.current, :format => :username)}", :id => 'loggedas') if User.current.logged? %>
                 <%= render_menu :top_menu -%>
             </div>
             <div id="header">
                 <div id="quick-search">
                     <% form_tag({:controller => 'search', :action => 'index', :id => @project}, :method => :get ) do %>
                     <%= 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>
                 <div id="main-menu">
                     <%= render_main_menu(@project) %>
                 </div>
             </div>
             <%= tag('div', {:id => 'main', :class => (has_content?(:sidebar) ? '' : 'nosidebar')}, true) %>
                 <div id="sidebar">
                     <%= yield :sidebar %>
                 </div>
                 <div id="content">
             				<%= render_flash_messages %>
                     <%= yield %>
                 </div>
             </div>
             <div id="ajax-indicator" style="display:none;"><span><%= l(:label_loading) %></span></div>
             <div id="footer">
                 Powered by <%= link_to Redmine::Info.app_name, Redmine::Info.url %> &copy; 2006-2008 Jean-Philippe Lang
             </div>
             </div>
             <%= call_hook :view_layouts_base_body_bottom %>
             </body>
             </html>

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

             <%= error_messages_for 'project' %>
             <div class="box">
             <!--[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? %>
+            <% if User.current.admin? && !@project.possible_parents.empty? %>
-                <p><%= f.select :parent_id, (@root_projects.collect {|p| [p.name, p.id]}), { :include_blank => true } %></p>
+                <p><label><%= l(:field_parent) %></label><%= parent_project_select_tag(@project) %></p>
             <% end %>
             <p><%= f.text_area :description, :rows => 5, :class => 'wiki-edit' %></p>
             <p><%= f.text_field :identifier, :required => true, :disabled => @project.identifier_frozen? %>
             <% unless @project.identifier_frozen? %>
             <br /><em><%= l(:text_length_between, 2, 20) %> <%= l(:text_project_identifier_info) %></em>
             <% end %></p>
             <p><%= f.text_field :homepage, :size => 60 %></p>
             <p><%= f.check_box :is_public %></p>
             <%= wikitoolbar_for 'project_description' %>
             <% @project.custom_field_values.each do |value| %>
             	<p><%= custom_field_tag_with_label :project, value %></p>
             <% end %>
             <%= call_hook(:view_projects_form, :project => @project, :form => f) %>
             </div>
             <% unless @trackers.empty? %>
             <fieldset class="box"><legend><%=l(:label_tracker_plural)%></legend>
             <% @trackers.each do |tracker| %>
                 <label class="floating">
                 <%= check_box_tag 'project[tracker_ids][]', tracker.id, @project.trackers.include?(tracker) %>
                 <%= tracker %>
                 </label>
             <% end %>
             <%= hidden_field_tag 'project[tracker_ids][]', '' %>
             </fieldset>
             <% end %>
             <% unless @issue_custom_fields.empty? %>
             <fieldset class="box"><legend><%=l(:label_custom_field_plural)%></legend>
             <% @issue_custom_fields.each do |custom_field| %>
                 <label class="floating">
             	<%= check_box_tag 'project[issue_custom_field_ids][]', custom_field.id, (@project.all_issue_custom_fields.include? custom_field), (custom_field.is_for_all? ? {:disabled => "disabled"} : {}) %>
             	<%= custom_field.name %>
             	</label>
             <% end %>
             <%= hidden_field_tag 'project[issue_custom_field_ids][]', '' %>
             </fieldset>
             <% end %>
             <!--[eoform:project]-->

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

             <h2><%= @author.nil? ? l(:label_activity) : l(:label_user_activity, link_to_user(@author)) %></h2>
             <p class="subtitle"><%= "#{l(:label_date_from)} #{format_date(@date_to - @days)} #{l(:label_date_to).downcase} #{format_date(@date_to-1)}" %></p>
             <div id="activity">
             <% @events_by_day.keys.sort.reverse.each do |day| %>
             <h3><%= format_activity_day(day) %></h3>
             <dl>
             <% @events_by_day[day].sort {|x,y| y.event_datetime <=> x.event_datetime }.each do |e| -%>
               <dt class="<%= e.event_type %>  <%= User.current.logged? && e.respond_to?(:event_author) && User.current == e.event_author ? 'me' : nil %>">
             	<%= avatar(e.event_author, :size => "24") if e.respond_to?(:event_author) %>
               <span class="time"><%= format_time(e.event_datetime, false) %></span>
               <%= content_tag('span', h(e.project), :class => 'project') if @project.nil? || @project != e.project %>
               <%= link_to format_activity_title(e.event_title), e.event_url %></dt>
               <dd><span class="description"><%= format_activity_description(e.event_description) %></span>
               <span class="author"><%= e.event_author if e.respond_to?(:event_author) %></span></dd>
             <% end -%>
             </dl>
             <% end -%>
             </div>
             <%= content_tag('p', l(:label_no_data), :class => 'nodata') if @events_by_day.empty? %>
             <div style="float:left;">
             <%= link_to_remote(('&#171; ' + l(:label_previous)),
                                {:update => "content", :url => params.merge(:from => @date_to - @days - 1), :complete => 'window.scrollTo(0,0)'},
                                {:href => url_for(params.merge(:from => @date_to - @days - 1)),
                                 :title => "#{l(:label_date_from)} #{format_date(@date_to - 2*@days)} #{l(:label_date_to).downcase} #{format_date(@date_to - @days - 1)}"}) %>
             </div>
             <div style="float:right;">
             <%= link_to_remote((l(:label_next) + ' &#187;'),
                                {:update => "content", :url => params.merge(:from => @date_to + @days - 1), :complete => 'window.scrollTo(0,0)'},
                                {:href => url_for(params.merge(:from => @date_to + @days - 1)),
                                 :title => "#{l(:label_date_from)} #{format_date(@date_to)} #{l(:label_date_to).downcase} #{format_date(@date_to + @days - 1)}"}) unless @date_to >= Date.today %>
             </div>
             &nbsp;
             <p class="other-formats">
                 <%= l(:label_export_to) %>
                 <%= link_to 'Atom', params.merge(:format => :atom, :from => nil, :key => User.current.rss_key), :class => 'feed' %>
             </p>
             <% content_for :header_tags do %>
             <%= auto_discovery_link_tag(:atom, params.merge(:format => 'atom', :from => nil, :key => User.current.rss_key)) %>
             <% end %>
             <% content_for :sidebar do %>
             <% form_tag({}, :method => :get) do %>
             <h3><%= l(:label_activity) %></h3>
             <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 %>
             <%= hidden_field_tag('user_id', params[:user_id]) unless params[:user_id].blank? %>
             <p><%= submit_tag l(:button_apply), :class => 'button-small', :name => nil %></p>
             <% end %>
             <% end %>
             <% html_title(l(:label_activity), @author) -%>

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

             <h2><%=l(:label_confirmation)%></h2>
             <div class="warning">
             <p><strong><%=h @project_to_destroy %></strong><br />
             <%=l(:text_project_destroy_confirmation)%>
-            <% if @project_to_destroy.children.any? %>
+            <% if @project_to_destroy.descendants.any? %>
-            <br /><%= l(:text_subprojects_destroy_warning, content_tag('strong', h(@project_to_destroy.children.sort.collect{|p| p.to_s}.join(', ')))) %>
+            <br /><%= l(:text_subprojects_destroy_warning, content_tag('strong', h(@project_to_destroy.descendants.collect{|p| p.to_s}.join(', ')))) %>
             <% end %>
             </p>
             <p>
                 <% form_tag({:controller => 'projects', :action => 'destroy', :id => @project_to_destroy}) do %>
                 <label><%= check_box_tag 'confirm', 1 %> <%= l(:general_text_Yes) %></label>
                 <%= submit_tag l(:button_delete) %>
                 <% end %>
             </p>
             </div>

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

             <div class="contextual">
                 <%= link_to(l(:label_project_new), {:controller => 'projects', :action => 'add'}, :class => 'icon icon-add') + ' |' if User.current.admin? %>
                 <%= link_to l(:label_issue_view_all), { :controller => 'issues' } %> |
                 <%= link_to l(:label_overall_activity), { :controller => 'projects', :action => 'activity' }%>
             </div>
             <h2><%=l(:label_project_plural)%></h2>
-            <% @project_tree.keys.sort.each do |project| %>
+            <%= render_project_hierarchy(@projects)%>
-            <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 %>
             <% 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 %>
             <p class="other-formats">
             <%= l(:label_export_to) %>
             <span><%= link_to 'Atom', {:format => 'atom', :key => User.current.rss_key}, :class => 'feed' %></span>
             </p>
             <% html_title(l(:label_project_plural)) -%>

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

             <h2><%=l(:label_overview)%></h2>
             <div class="splitcontentleft">
             	<%= textilizable @project.description %>
             	<ul>
             	<% unless @project.homepage.blank? %><li><%=l(:field_homepage)%>: <%= link_to(h(@project.homepage), @project.homepage) %></li><% end %>
-                <% if @subprojects.any? %>
+              <% 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)%>:
-                <% end %>
+            	    <%= @subprojects.collect{|p| link_to(h(p), :action => 'show', :id => p)}.join(", ") %></li>
-            	<% if @project.parent %>
+              <% end %>
-            	<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? %>
             	   <li><%= custom_value.custom_field.name%>: <%=h show_value(custom_value) %></li>
             	<% end %>
             	<% end %>
             	</ul>
               <% if User.current.allowed_to?(:view_issues, @project) %>
               <div class="box">
                 <h3 class="icon22 icon22-tracker"><%=l(:label_issue_tracking)%></h3>
                 <ul>
                 <% for tracker in @trackers %>
                   <li><%= link_to tracker.name, :controller => 'issues', :action => 'index', :project_id => @project,
                                                             :set_filter => 1,
                                                             "tracker_id" => tracker.id %>:
                   <%= @open_issues_by_tracker[tracker] || 0 %> <%= lwr(:label_open_issues, @open_issues_by_tracker[tracker] || 0) %>
                   <%= l(:label_on) %> <%= @total_issues_by_tracker[tracker] || 0 %></li>
                 <% end %>
                 </ul>
                 <p><%= link_to l(:label_issue_view_all), :controller => 'issues', :action => 'index', :project_id => @project, :set_filter => 1 %></p>
               </div>
               <% end %>
             </div>
             <div class="splitcontentright">
                 <% if @members_by_role.any? %>
             	<div class="box">
             		<h3 class="icon22 icon22-users"><%=l(:label_member_plural)%></h3>
             		<p><% @members_by_role.keys.sort.each do |role| %>
             		<%= role.name %>:
             		<%= @members_by_role[role].collect(&:user).sort.collect{|u| link_to_user u}.join(", ") %>
             		<br />
             		<% end %></p>
             	</div>
             	<% end %>
               <% if @news.any? && authorize_for('news', 'index') %>
               <div class="box">
                 <h3><%=l(:label_news_latest)%></h3>
                 <%= render :partial => 'news/news', :collection => @news %>
                 <p><%= link_to l(:label_news_view_all), :controller => 'news', :action => 'index', :project_id => @project %></p>
               </div>
               <% end %>
             </div>
             <% content_for :sidebar do %>
                 <% planning_links = []
                   planning_links << link_to_if_authorized(l(:label_calendar), :controller => 'issues', :action => 'calendar', :project_id => @project)
                   planning_links << link_to_if_authorized(l(:label_gantt), :controller => 'issues', :action => 'gantt', :project_id => @project)
                   planning_links.compact!
                   unless planning_links.empty? %>
                 <h3><%= l(:label_planning) %></h3>
                 <p><%= planning_links.join(' | ') %></p>
                 <% end %>
                 <% if @total_hours && User.current.allowed_to?(:view_time_entries, @project) %>
                 <h3><%= l(:label_spent_time) %></h3>
                 <p><span class="icon icon-time"><%= lwr(:label_f_hour, @total_hours) %></span></p>
                 <p><%= link_to(l(:label_details), {:controller => 'timelog', :action => 'details', :project_id => @project}) %> |
                 <%= link_to(l(:label_report), {:controller => 'timelog', :action => 'report', :project_id => @project}) %></p>
                 <% end %>
             <% end %>
             <% content_for :header_tags do %>
             <%= auto_discovery_link_tag(:atom, {:action => 'activity', :id => @project, :format => 'atom', :key => User.current.rss_key}) %>
             <% end %>
             <% html_title(l(:label_overview)) -%>

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

             <% if @memberships.any? %>
             <table class="list memberships">
             	<thead>
             	  <th><%= l(:label_project) %></th>
             	  <th><%= l(:label_role) %></th>
             	  <th style="width:15%"></th>
             	</thead>
             	<tbody>
             	<% @memberships.each do |membership| %>
             	<% next if membership.new_record? %>
             	<tr class="<%= cycle 'odd', 'even' %>">
             	<td><%=h membership.project %></td>
                 <td align="center">
                 <% form_tag({ :action => 'edit_membership', :id => @user, :membership_id => membership }) do %>
                     <%= select_tag 'membership[role_id]', options_from_collection_for_select(@roles, "id", "name", membership.role_id) %>
                     <%= submit_tag l(:button_change), :class => "small" %>
                 <% end %>
                 </td>
                 <td align="center">
                   <%= link_to l(:button_delete), {:action => 'destroy_membership', :id => @user, :membership_id => membership }, :method => :post, :class => 'icon icon-del' %>
                 </td>
             	</tr>
             	</tbody>
             <% end; reset_cycle %>
             </table>
             <% else %>
             <p class="nodata"><%= l(:label_no_data) %></p>
             <% end %>
             <% if @projects.any? %>
             <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) %>
             <% end %>
             </p>
             <% end %>

public/stylesheets/application.css +12 0

             body { font-family: Verdana, sans-serif; font-size: 12px; color:#484848; margin: 0; padding: 0; min-width: 900px; }
             h1, h2, h3, h4 { font-family: "Trebuchet MS", Verdana, sans-serif;}
             h1 {margin:0; padding:0; font-size: 24px;}
             h2, .wiki h1 {font-size: 20px;padding: 2px 10px 1px 0px;margin: 0 0 10px 0; border-bottom: 1px solid #bbbbbb; color: #444;}
             h3, .wiki h2 {font-size: 16px;padding: 2px 10px 1px 0px;margin: 0 0 10px 0; border-bottom: 1px solid #bbbbbb; color: #444;}
             h4, .wiki h3 {font-size: 13px;padding: 2px 10px 1px 0px;margin-bottom: 5px; border-bottom: 1px dotted #bbbbbb; color: #444;}
             /***** Layout *****/
             #wrapper {background: white;}
             #top-menu {background: #2C4056; color: #fff; height:1.8em; font-size: 0.8em; padding: 2px 2px 0px 6px;}
             #top-menu ul {margin: 0;  padding: 0;}
             #top-menu li {
               float:left;
               list-style-type:none;
               margin: 0px 0px 0px 0px;
               padding: 0px 0px 0px 0px;
               white-space:nowrap;
             }
             #top-menu a {color: #fff; margin-right: 8px; font-weight: bold;}
             #top-menu #loggedas { float: right; margin-right: 0.5em; color: #fff; }
             #account {float:right;}
             #header {height:5.3em;margin:0;background-color:#507AAA;color:#f8f8f8; padding: 4px 8px 0px 6px; position:relative;}
             #header a {color:#f8f8f8;}
             #quick-search {float:right;}
             #main-menu {position: absolute;  bottom: 0px;  left:6px; margin-right: -500px;}
             #main-menu ul {margin: 0;  padding: 0;}
             #main-menu li {
               float:left;
               list-style-type:none;
               margin: 0px 2px 0px 0px;
               padding: 0px 0px 0px 0px;
               white-space:nowrap;
             }
             #main-menu li a {
               display: block;
               color: #fff;
               text-decoration: none;
               font-weight: bold;
               margin: 0;
               padding: 4px 10px 4px 10px;
             }
             #main-menu li a:hover {background:#759FCF; color:#fff;}
             #main-menu li a.selected, #main-menu li a.selected:hover {background:#fff; color:#555;}
             #main {background-color:#EEEEEE;}
             #sidebar{ float: right; width: 17%; position: relative; z-index: 9; min-height: 600px; padding: 0; margin: 0;}
             * html #sidebar{ width: 17%; }
             #sidebar h3{ font-size: 14px; margin-top:14px; color: #666;  }
             #sidebar hr{ width: 100%; margin: 0 auto; height: 1px; background: #ccc; border: 0; }
             * html #sidebar hr{ width: 95%; position: relative; left: -6px; color: #ccc; }
             #content { width: 80%; background-color: #fff; margin: 0px; border-right: 1px solid #ddd; padding: 6px 10px 10px 10px; z-index: 10; }
             * html #content{ width: 80%; padding-left: 0; margin-top: 0px; padding: 6px 10px 10px 10px;}
             html>body #content { min-height: 600px; }
             * html body #content { height: 600px; } /* IE */
             #main.nosidebar #sidebar{ display: none; }
             #main.nosidebar #content{ width: auto; border-right: 0; }
             #footer {clear: both; border-top: 1px solid #bbb; font-size: 0.9em; color: #aaa; padding: 5px; text-align:center; background:#fff;}
             #login-form table {margin-top:5em; padding:1em; margin-left: auto; margin-right: auto; border: 2px solid #FDBF3B; background-color:#FFEBC1; }
             #login-form table td {padding: 6px;}
             #login-form label {font-weight: bold;}
             .clear:after{ content: "."; display: block; height: 0; clear: both; visibility: hidden; }
             /***** Links *****/
             a, a:link, a:visited{ color: #2A5685; text-decoration: none; }
             a:hover, a:active{ color: #c61a1a; text-decoration: underline;}
             a img{ border: 0; }
             a.issue.closed { text-decoration: line-through; }
             /***** Tables *****/
             table.list { border: 1px solid #e4e4e4;  border-collapse: collapse; width: 100%; margin-bottom: 4px; }
             table.list th {  background-color:#EEEEEE; padding: 4px; white-space:nowrap; }
             table.list td { vertical-align: top; }
             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; }
             tr.issue td.done_ratio table.progress { margin-left:auto; margin-right: auto;}
             tr.entry { border: 1px solid #f8f8f8; }
             tr.entry td { white-space: nowrap; }
             tr.entry td.filename { width: 30%; }
             tr.entry td.size { text-align: right; font-size: 90%; }
             tr.entry td.revision, tr.entry td.author { text-align: center; }
             tr.entry td.age { text-align: right; }
             tr.entry span.expander {background-image: url(../images/bullet_toggle_plus.png); padding-left: 8px; margin-left: 0; cursor: pointer;}
             tr.entry.open span.expander {background-image: url(../images/bullet_toggle_minus.png);}
             tr.entry.file td.filename a { margin-left: 16px; }
             tr.changeset td.author { text-align: center; width: 15%; }
             tr.changeset td.committed_on { text-align: center; width: 15%; }
             tr.message { height: 2.6em; }
             tr.message td.last_message { font-size: 80%; }
             tr.message.locked td.subject a { background-image: url(../images/locked.png); }
             tr.message.sticky td.subject a { background-image: url(../images/sticky.png); font-weight: bold; }
             tr.user td { width:13%; }
             tr.user td.email { width:18%; }
             tr.user td { white-space: nowrap; }
             tr.user.locked, tr.user.registered { color: #aaa; }
             tr.user.locked a, tr.user.registered a { color: #aaa; }
             tr.time-entry { text-align: center; white-space: nowrap; }
             tr.time-entry td.subject, tr.time-entry td.comments { text-align: left; white-space: normal; }
             td.hours { text-align: right; font-weight: bold; padding-right: 0.5em; }
             td.hours .hours-dec { font-size: 0.9em; }
             table.plugins td { vertical-align: middle; }
             table.plugins td.configure { text-align: right; padding-right: 1em; }
             table.plugins span.name { font-weight: bold; display: block; margin-bottom: 6px; }
             table.plugins span.description { display: block; font-size: 0.9em; }
             table.plugins span.url { display: block; font-size: 0.9em; }
             table.list tbody tr:hover { background-color:#ffffdd; }
             table td {padding:2px;}
             table p {margin:0;}
             .odd {background-color:#f6f7f8;}
             .even {background-color: #fff;}
             .highlight { background-color: #FCFD8D;}
             .highlight.token-1 { background-color: #faa;}
             .highlight.token-2 { background-color: #afa;}
             .highlight.token-3 { background-color: #aaf;}
             .box{
             padding:6px;
             margin-bottom: 10px;
             background-color:#f6f6f6;
             color:#505050;
             line-height:1.5em;
             border: 1px solid #e4e4e4;
             }
             div.square {
              border: 1px solid #999;
              float: left;
              margin: .3em .4em 0 .4em;
              overflow: hidden;
              width: .6em; height: .6em;
             }
             .contextual {float:right; white-space: nowrap; line-height:1.4em;margin-top:5px; padding-left: 10px; font-size:0.9em;}
             .contextual input {font-size:0.9em;}
             .splitcontentleft{float:left; width:49%;}
             .splitcontentright{float:right; width:49%;}
             form {display: inline;}
             input, select {vertical-align: middle; margin-top: 1px; margin-bottom: 1px;}
             fieldset {border: 1px solid #e4e4e4; margin:0;}
             legend {color: #484848;}
             hr { width: 100%; height: 1px; background: #ccc; border: 0;}
             blockquote { font-style: italic; border-left: 3px solid #e0e0e0; padding-left: 0.6em; margin-left: 2.4em;}
             blockquote blockquote { margin-left: 0;}
             textarea.wiki-edit { width: 99%; }
             li p {margin-top: 0;}
             div.issue {background:#ffffdd; padding:6px; margin-bottom:6px;border: 1px solid #d7d7d7;}
             p.breadcrumb { font-size: 0.9em; margin: 4px 0 4px 0;}
             p.subtitle { font-size: 0.9em; margin: -6px 0 12px 0; font-style: italic; }
             p.footnote { font-size: 0.9em; margin-top: 0px; margin-bottom: 0px; }
             fieldset#filters, fieldset#date-range { padding: 0.7em; margin-bottom: 8px; }
             fieldset#filters p { margin: 1.2em 0 0.8em 2px; }
             fieldset#filters table { border-collapse: collapse; }
             fieldset#filters table td { padding: 0; vertical-align: middle; }
             fieldset#filters tr.filter { height: 2em; }
             fieldset#filters td.add-filter { text-align: right; vertical-align: top; }
             .buttons { font-size: 0.9em; }
             div#issue-changesets {float:right; width:45%; margin-left: 1em; margin-bottom: 1em; background: #fff; padding-left: 1em; font-size: 90%;}
             div#issue-changesets .changeset { padding: 4px;}
             div#issue-changesets .changeset { border-bottom: 1px solid #ddd; }
             div#issue-changesets p { margin-top: 0; margin-bottom: 1em;}
             div#activity dl, #search-results { margin-left: 2em; }
             div#activity dd, #search-results dd { margin-bottom: 1em; padding-left: 18px; font-size: 0.9em; }
             div#activity dt, #search-results dt { margin-bottom: 0px; padding-left: 20px; line-height: 18px; background-position: 0 50%; background-repeat: no-repeat; }
             div#activity dt.me .time { border-bottom: 1px solid #999; }
             div#activity dt .time { color: #777; font-size: 80%; }
             div#activity dd .description, #search-results dd .description { font-style: italic; }
             div#activity span.project:after, #search-results span.project:after { content: " -"; }
             div#activity dd span.description, #search-results dd span.description { display:block; }
             #search-results dd { margin-bottom: 1em; padding-left: 20px; margin-left:0px; }
             div#search-results-counts {float:right;}
             div#search-results-counts ul { margin-top: 0.5em; }
             div#search-results-counts  li { list-style-type:none; float: left; margin-left: 1em; }
             dt.issue { background-image: url(../images/ticket.png); }
             dt.issue-edit { background-image: url(../images/ticket_edit.png); }
             dt.issue-closed { background-image: url(../images/ticket_checked.png); }
             dt.issue-note { background-image: url(../images/ticket_note.png); }
             dt.changeset { background-image: url(../images/changeset.png); }
             dt.news { background-image: url(../images/news.png); }
             dt.message { background-image: url(../images/message.png); }
             dt.reply { background-image: url(../images/comments.png); }
             dt.wiki-page { background-image: url(../images/wiki_edit.png); }
             dt.attachment { background-image: url(../images/attachment.png); }
             dt.document { background-image: url(../images/document.png); }
             dt.project { background-image: url(../images/projects.png); }
             #search-results dt.issue.closed { background-image: url(../images/ticket_checked.png); }
             div#roadmap fieldset.related-issues { margin-bottom: 1em; }
             div#roadmap fieldset.related-issues ul { margin-top: 0.3em; margin-bottom: 0.3em; }
             div#roadmap .wiki h1:first-child { display: none; }
             div#roadmap .wiki h1 { font-size: 120%; }
             div#roadmap .wiki h2 { font-size: 110%; }
             div#version-summary { float:right; width:380px; margin-left: 16px; margin-bottom: 16px; background-color: #fff; }
             div#version-summary fieldset { margin-bottom: 1em; }
             div#version-summary .total-hours { text-align: right; }
             table#time-report td.hours, table#time-report th.period, table#time-report th.total { text-align: right; padding-right: 0.5em; }
             table#time-report tbody tr { font-style: italic; color: #777; }
             table#time-report tbody tr.last-level { font-style: normal; color: #555; }
             table#time-report tbody tr.total { font-style: normal; font-weight: bold; color: #555; background-color:#EEEEEE; }
             table#time-report .hours-dec { font-size: 0.9em; }
             form#issue-form .attributes { margin-bottom: 8px; }
             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;}
             .total-hours { font-size: 110%; font-weight: bold; }
             .total-hours span.hours-int { font-size: 120%; }
             .autoscroll {overflow-x: auto; padding:1px; margin-bottom: 1.2em;}
             #user_firstname, #user_lastname, #user_mail, #my_account_form select { width: 90%; }
             .pagination {font-size: 90%}
             p.pagination {margin-top:8px;}
             /***** Tabular forms ******/
             .tabular p{
             margin: 0;
             padding: 5px 0 8px 0;
             padding-left: 180px; /*width of left column containing the label elements*/
             height: 1%;
             clear:left;
             }
             html>body .tabular p {overflow:hidden;}
             .tabular label{
             font-weight: bold;
             float: left;
             text-align: right;
             margin-left: -180px; /*width of left column*/
             width: 175px; /*width of labels. Should be smaller than left column to create some right
             margin*/
             }
             .tabular label.floating{
             font-weight: normal;
             margin-left: 0px;
             text-align: left;
             width: 270px;
             }
             input#time_entry_comments { width: 90%;}
             #preview fieldset {margin-top: 1em; background: url(../images/draft.png)}
             .tabular.settings p{ padding-left: 300px; }
             .tabular.settings label{ margin-left: -300px; width: 295px; }
             .required {color: #bb0000;}
             .summary {font-style: italic;}
             #attachments_fields input[type=text] {margin-left: 8px; }
             div.attachments { margin-top: 12px; }
             div.attachments p { margin:4px 0 2px 0; }
             div.attachments img { vertical-align: middle; }
             div.attachments span.author { font-size: 0.9em; color: #888; }
             p.other-formats { text-align: right; font-size:0.9em; color: #666; }
             .other-formats span + span:before { content: "| "; }
             a.feed { background: url(../images/feed.png) no-repeat 1px 50%; padding: 2px 0px 3px 16px; }
             /***** Flash & error messages ****/
             #errorExplanation, div.flash, .nodata, .warning {
                 padding: 4px 4px 4px 30px;
                 margin-bottom: 12px;
             	font-size: 1.1em;
             	border: 2px solid;
             }
             div.flash {margin-top: 8px;}
             div.flash.error, #errorExplanation {
                 background: url(../images/false.png) 8px 5px no-repeat;
             	background-color: #ffe3e3;
             	border-color: #dd0000;
             	color: #550000;
             }
             div.flash.notice {
                 background: url(../images/true.png) 8px 5px no-repeat;
             	background-color: #dfffdf;
             	border-color: #9fcf9f;
             	color: #005f00;
             }
             div.flash.warning {
               background: url(../images/warning.png) 8px 5px no-repeat;
             	background-color: #FFEBC1;
             	border-color: #FDBF3B;
             	color: #A6750C;
               text-align: left;
             }
             .nodata, .warning {
                 text-align: center;
             	background-color: #FFEBC1;
             	border-color: #FDBF3B;
             	color: #A6750C;
             }
             #errorExplanation ul { font-size: 0.9em;}
             /***** Ajax indicator ******/
             #ajax-indicator {
             position: absolute; /* fixed not supported by IE */
             background-color:#eee;
             border: 1px solid #bbb;
             top:35%;
             left:40%;
             width:20%;
             font-weight:bold;
             text-align:center;
             padding:0.6em;
             z-index:100;
             filter:alpha(opacity=50);
             opacity: 0.5;
             }
             html>body #ajax-indicator { position: fixed; }
             #ajax-indicator span {
             background-position: 0% 40%;
             background-repeat: no-repeat;
             background-image: url(../images/loading.gif);
             padding-left: 26px;
             vertical-align: bottom;
             }
             /***** Calendar *****/
             table.cal {border-collapse: collapse; width: 100%; margin: 0px 0 6px 0;border: 1px solid #d7d7d7;}
             table.cal thead th {width: 14%;}
             table.cal tbody tr {height: 100px;}
             table.cal th { background-color:#EEEEEE; padding: 4px; }
             table.cal td {border: 1px solid #d7d7d7; vertical-align: top; font-size: 0.9em;}
             table.cal td p.day-num {font-size: 1.1em; text-align:right;}
             table.cal td.odd p.day-num {color: #bbb;}
             table.cal td.today {background:#ffffdd;}
             table.cal td.today p.day-num {font-weight: bold;}
             /***** Tooltips ******/
             .tooltip{position:relative;z-index:24;}
             .tooltip:hover{z-index:25;color:#000;}
             .tooltip span.tip{display: none; text-align:left;}
             div.tooltip:hover span.tip{
             display:block;
             position:absolute;
             top:12px; left:24px; width:270px;
             border:1px solid #555;
             background-color:#fff;
             padding: 4px;
             font-size: 0.8em;
             color:#505050;
             }
             /***** Progress bar *****/
             table.progress {
                 border: 1px solid #D7D7D7;
                 border-collapse: collapse;
                 border-spacing: 0pt;
                 empty-cells: show;
                 text-align: center;
                 float:left;
                 margin: 1px 6px 1px 0px;
             }
             table.progress td { height: 0.9em; }
             table.progress td.closed { background: #BAE0BA none repeat scroll 0%; }
             table.progress td.done { background: #DEF0DE none repeat scroll 0%; }
             table.progress td.open { background: #FFF none repeat scroll 0%; }
             p.pourcent {font-size: 80%;}
             p.progress-info {clear: left; font-style: italic; font-size: 80%;}
             /***** Tabs *****/
             #content .tabs {height: 2.6em; border-bottom: 1px solid #bbbbbb; margin-bottom:1.2em; position:relative;}
             #content .tabs ul {margin:0; position:absolute; bottom:-2px; padding-left:1em;}
             #content .tabs>ul { bottom:-1px; } /* others */
             #content .tabs ul li {
             float:left;
             list-style-type:none;
             white-space:nowrap;
             margin-right:8px;
             background:#fff;
             }
             #content .tabs ul li a{
             display:block;
             font-size: 0.9em;
             text-decoration:none;
             line-height:1.3em;
             padding:4px 6px 4px 6px;
             border: 1px solid #ccc;
             border-bottom: 1px solid #bbbbbb;
             background-color: #eeeeee;
             color:#777;
             font-weight:bold;
             }
             #content .tabs ul li a:hover {
             background-color: #ffffdd;
             text-decoration:none;
             }
             #content .tabs ul li a.selected {
             background-color: #fff;
             border: 1px solid #bbbbbb;
             border-bottom: 1px solid #fff;
             }
             #content .tabs ul li a.selected:hover {
             background-color: #fff;
             }
             /***** Diff *****/
             .diff_out { background: #fcc; }
             .diff_in { background: #cfc; }
             /***** Wiki *****/
             div.wiki table {
                 border: 1px solid #505050;
                 border-collapse: collapse;
                 margin-bottom: 1em;
             }
             div.wiki table, div.wiki td, div.wiki th {
                 border: 1px solid #bbb;
                 padding: 4px;
             }
             div.wiki .external {
                 background-position: 0% 60%;
                 background-repeat: no-repeat;
                 padding-left: 12px;
                 background-image: url(../images/external.png);
             }
             div.wiki a.new {
                 color: #b73535;
             }
             div.wiki pre {
                 margin: 1em 1em 1em 1.6em;
                 padding: 2px;
                 background-color: #fafafa;
                 border: 1px solid #dadada;
                 width:95%;
                 overflow-x: auto;
             }
             div.wiki ul.toc {
                 background-color: #ffffdd;
                 border: 1px solid #e4e4e4;
                 padding: 4px;
                 line-height: 1.2em;
                 margin-bottom: 12px;
                 margin-right: 12px;
                 margin-left: 0;
                 display: table
             }
             * html div.wiki ul.toc { width: 50%; } /* IE6 doesn't autosize div */
             div.wiki ul.toc.right { float: right; margin-left: 12px; margin-right: 0; width: auto; }
             div.wiki ul.toc.left  { float: left; margin-right: 12px; margin-left: 0; width: auto; }
             div.wiki ul.toc li { list-style-type:none;}
             div.wiki ul.toc li.heading2 { margin-left: 6px; }
             div.wiki ul.toc li.heading3 { margin-left: 12px; font-size: 0.8em; }
             div.wiki ul.toc a {
                 font-size: 0.9em;
                 font-weight: normal;
                 text-decoration: none;
                 color: #606060;
             }
             div.wiki ul.toc a:hover { color: #c61a1a; text-decoration: underline;}
             a.wiki-anchor { display: none; margin-left: 6px; text-decoration: none; }
             a.wiki-anchor:hover { color: #aaa !important; text-decoration: none; }
             h1:hover a.wiki-anchor, h2:hover a.wiki-anchor, h3:hover a.wiki-anchor { display: inline; color: #ddd; }
             /***** My page layout *****/
             .block-receiver {
             border:1px dashed #c0c0c0;
             margin-bottom: 20px;
             padding: 15px 0 15px 0;
             }
             .mypage-box {
             margin:0 0 20px 0;
             color:#505050;
             line-height:1.5em;
             }
             .handle {
             cursor: move;
             }
             a.close-icon {
             display:block;
             margin-top:3px;
             overflow:hidden;
             width:12px;
             height:12px;
             background-repeat: no-repeat;
             cursor:pointer;
             background-image:url('../images/close.png');
             }
             a.close-icon:hover {
             background-image:url('../images/close_hl.png');
             }
             /***** Gantt chart *****/
             .gantt_hdr {
               position:absolute;
               top:0;
               height:16px;
               border-top: 1px solid #c0c0c0;
               border-bottom: 1px solid #c0c0c0;
               border-right: 1px solid #c0c0c0;
               text-align: center;
               overflow: hidden;
             }
             .task {
               position: absolute;
               height:8px;
               font-size:0.8em;
               color:#888;
               padding:0;
               margin:0;
               line-height:0.8em;
             }
             .task_late { background:#f66 url(../images/task_late.png); border: 1px solid #f66; }
             .task_done { background:#66f url(../images/task_done.png); border: 1px solid #66f; }
             .task_todo { background:#aaa url(../images/task_todo.png); border: 1px solid #aaa; }
             .milestone { background-image:url(../images/milestone.png); background-repeat: no-repeat; border: 0; }
             /***** Icons *****/
             .icon {
             background-position: 0% 40%;
             background-repeat: no-repeat;
             padding-left: 20px;
             padding-top: 2px;
             padding-bottom: 3px;
             }
             .icon22 {
             background-position: 0% 40%;
             background-repeat: no-repeat;
             padding-left: 26px;
             line-height: 22px;
             vertical-align: middle;
             }
             .icon-add { background-image: url(../images/add.png); }
             .icon-edit { background-image: url(../images/edit.png); }
             .icon-copy { background-image: url(../images/copy.png); }
             .icon-del { background-image: url(../images/delete.png); }
             .icon-move { background-image: url(../images/move.png); }
             .icon-save { background-image: url(../images/save.png); }
             .icon-cancel { background-image: url(../images/cancel.png); }
             .icon-file { background-image: url(../images/file.png); }
             .icon-folder { background-image: url(../images/folder.png); }
             .open .icon-folder { background-image: url(../images/folder_open.png); }
             .icon-package { background-image: url(../images/package.png); }
             .icon-home { background-image: url(../images/home.png); }
             .icon-user { background-image: url(../images/user.png); }
             .icon-mypage { background-image: url(../images/user_page.png); }
             .icon-admin { background-image: url(../images/admin.png); }
             .icon-projects { background-image: url(../images/projects.png); }
             .icon-help { background-image: url(../images/help.png); }
             .icon-attachment  { background-image: url(../images/attachment.png); }
             .icon-index  { background-image: url(../images/index.png); }
             .icon-history  { background-image: url(../images/history.png); }
             .icon-time  { background-image: url(../images/time.png); }
             .icon-stats  { background-image: url(../images/stats.png); }
             .icon-warning  { background-image: url(../images/warning.png); }
             .icon-fav  { background-image: url(../images/fav.png); }
             .icon-fav-off  { background-image: url(../images/fav_off.png); }
             .icon-reload  { background-image: url(../images/reload.png); }
             .icon-lock  { background-image: url(../images/locked.png); }
             .icon-unlock  { background-image: url(../images/unlock.png); }
             .icon-checked  { background-image: url(../images/true.png); }
             .icon-details  { background-image: url(../images/zoom_in.png); }
             .icon-report  { background-image: url(../images/report.png); }
             .icon-comment  { background-image: url(../images/comment.png); }
             .icon22-projects { background-image: url(../images/22x22/projects.png); }
             .icon22-users { background-image: url(../images/22x22/users.png); }
             .icon22-tracker { background-image: url(../images/22x22/tracker.png); }
             .icon22-role { background-image: url(../images/22x22/role.png); }
             .icon22-workflow { background-image: url(../images/22x22/workflow.png); }
             .icon22-options { background-image: url(../images/22x22/options.png); }
             .icon22-notifications { background-image: url(../images/22x22/notifications.png); }
             .icon22-authent { background-image: url(../images/22x22/authent.png); }
             .icon22-info { background-image: url(../images/22x22/info.png); }
             .icon22-comment { background-image: url(../images/22x22/comment.png); }
             .icon22-package { background-image: url(../images/22x22/package.png); }
             .icon22-settings { background-image: url(../images/22x22/settings.png); }
             .icon22-plugin { background-image: url(../images/22x22/plugin.png); }
             img.gravatar {
             	padding: 2px;
               border: solid 1px #d5d5d5;
               background: #fff;
             }
             div.issue img.gravatar {
             	float: right;
             	margin: 0 0 0 1em;
             	padding: 5px;
             }
             div.issue table img.gravatar {
             	height: 14px;
             	width: 14px;
             	padding: 2px;
             	float: left;
             	margin: 0 0.5em 0 0;
             }
             #history img.gravatar {
             	padding: 3px;
             	margin: 0 1.5em 1em 0;
             	float: left;
             }
             td.username img.gravatar {
             	float: left;
             	margin: 0 1em 0 0;
             }
             #activity dt img.gravatar {
             	float: left;
             	margin: 0 1em 1em 0;
             }
             #activity dt,
             .journal {
             	clear: left;
             }
             h2 img { vertical-align:middle; }
             /***** Media print specific styles *****/
             @media print {
               #top-menu, #header, #main-menu, #sidebar, #footer, .contextual, .other-formats { display:none; }
               #main { background: #fff; }
               #content { width: 99%; margin: 0; padding: 0; border: 0; background: #fff; overflow: visible !important;}
             }

test/fixtures/projects.yml +24 -1

             ---
             projects_001:
               created_on: 2006-07-19 19:13:59 +02:00
               name: eCookbook
               updated_on: 2006-07-19 22:53:01 +02:00
               projects_count: 3
               id: 1
               description: Recipes management application
               homepage: http://ecookbook.somenet.foo/
               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
               updated_on: 2006-07-19 19:14:19 +02:00
               projects_count: 0
               id: 2
               description: E-commerce web site
               homepage: ""
               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
               updated_on: 2006-07-19 19:18:12 +02:00
               projects_count: 0
               id: 3
               description: eCookBook Subproject 1
               homepage: ""
               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
               updated_on: 2006-07-19 19:17:07 +02:00
               projects_count: 0
               id: 4
               description: eCookbook Subproject 2
               homepage: ""
               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
               updated_on: 2006-07-19 19:17:07 +02:00
               projects_count: 0
               id: 5
               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

             # Redmine - project management software
             # Copyright (C) 2006-2008  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.dirname(__FILE__) + '/../test_helper'
             require 'projects_controller'
             # Re-raise errors caught by the controller.
             class ProjectsController; def rescue_action(e) raise e end; end
             class ProjectsControllerTest < Test::Unit::TestCase
               fixtures :projects, :versions, :users, :roles, :members, :issues, :journals, :journal_details,
                        :trackers, :projects_trackers, :issue_statuses, :enabled_modules, :enumerations, :boards, :messages,
                        :attachments
               def setup
                 @controller = ProjectsController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 @request.session[:user_id] = nil
                 Setting.default_language = 'en'
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
-                assert_not_nil assigns(:project_tree)
+                assert_not_nil assigns(:projects)
-                # Root project as hash key
-                assert assigns(:project_tree).keys.include?(Project.find(1))
+                assert_tag :ul, :child => {:tag => 'li',
-                # Subproject in corresponding value
+                                           :descendant => {:tag => 'a', :content => 'eCookbook'},
-                assert assigns(:project_tree)[Project.find(1)].include?(Project.find(3))
+                                           :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
                 get :index, :format => 'atom'
                 assert_response :success
                 assert_template 'common/feed.atom.rxml'
                 assert_select 'feed>title', :text => 'Redmine: Latest projects'
                 assert_select 'feed>entry', :count => Project.count(:conditions => Project.visible_by(User.current))
               end
               def test_show_by_id
                 get :show, :id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:project)
               end
               def test_show_by_identifier
                 get :show, :id => 'ecookbook'
                 assert_response :success
                 assert_template 'show'
                 assert_not_nil assigns(:project)
                 assert_equal Project.find_by_identifier('ecookbook'), assigns(:project)
               end
               def test_private_subprojects_hidden
                 get :show, :id => 'ecookbook'
                 assert_response :success
                 assert_template 'show'
                 assert_no_tag :tag => 'a', :content => /Private child/
               end
               def test_private_subprojects_visible
                 @request.session[:user_id] = 2 # manager who is a member of the private subproject
                 get :show, :id => 'ecookbook'
                 assert_response :success
                 assert_template 'show'
                 assert_tag :tag => 'a', :content => /Private child/
               end
               def test_settings
                 @request.session[:user_id] = 2 # manager
                 get :settings, :id => 1
                 assert_response :success
                 assert_template 'settings'
               end
               def test_edit
                 @request.session[:user_id] = 2 # manager
                 post :edit, :id => 1, :project => {:name => 'Test changed name',
                                                    :issue_custom_field_ids => ['']}
                 assert_redirected_to 'projects/settings/ecookbook'
                 project = Project.find(1)
                 assert_equal 'Test changed name', project.name
               end
               def test_get_destroy
                 @request.session[:user_id] = 1 # admin
                 get :destroy, :id => 1
                 assert_response :success
                 assert_template 'destroy'
                 assert_not_nil Project.find_by_id(1)
               end
               def test_post_destroy
                 @request.session[:user_id] = 1 # admin
                 post :destroy, :id => 1, :confirm => 1
                 assert_redirected_to 'admin/projects'
                 assert_nil Project.find_by_id(1)
               end
               def test_add_file
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 Setting.notified_events = ['file_added']
                 ActionMailer::Base.deliveries.clear
                 assert_difference 'Attachment.count' do
                   post :add_file, :id => 1, :version_id => '',
                        :attachments => {'1' => {'file' => test_uploaded_file('testfile.txt', 'text/plain')}}
                 end
                 assert_redirected_to 'projects/list_files/ecookbook'
                 a = Attachment.find(:first, :order => 'created_on DESC')
                 assert_equal 'testfile.txt', a.filename
                 assert_equal Project.find(1), a.container
                 mail = ActionMailer::Base.deliveries.last
                 assert_kind_of TMail::Mail, mail
                 assert_equal "[eCookbook] New file", mail.subject
                 assert mail.body.include?('testfile.txt')
               end
               def test_add_version_file
                 set_tmp_attachments_directory
                 @request.session[:user_id] = 2
                 Setting.notified_events = ['file_added']
                 assert_difference 'Attachment.count' do
                   post :add_file, :id => 1, :version_id => '2',
                        :attachments => {'1' => {'file' => test_uploaded_file('testfile.txt', 'text/plain')}}
                 end
                 assert_redirected_to 'projects/list_files/ecookbook'
                 a = Attachment.find(:first, :order => 'created_on DESC')
                 assert_equal 'testfile.txt', a.filename
                 assert_equal Version.find(2), a.container
               end
               def test_list_files
                 get :list_files, :id => 1
                 assert_response :success
                 assert_template 'list_files'
                 assert_not_nil assigns(:containers)
                 # file attached to the project
                 assert_tag :a, :content => 'project_file.zip',
                                :attributes => { :href => '/attachments/download/8/project_file.zip' }
                 # file attached to a project's version
                 assert_tag :a, :content => 'version_file.zip',
                                :attributes => { :href => '/attachments/download/9/version_file.zip' }
               end
               def test_changelog
                 get :changelog, :id => 1
                 assert_response :success
                 assert_template 'changelog'
                 assert_not_nil assigns(:versions)
               end
               def test_roadmap
                 get :roadmap, :id => 1
                 assert_response :success
                 assert_template 'roadmap'
                 assert_not_nil assigns(:versions)
                 # Version with no date set appears
                 assert assigns(:versions).include?(Version.find(3))
                 # Completed version doesn't appear
                 assert !assigns(:versions).include?(Version.find(1))
               end
               def test_roadmap_with_completed_versions
                 get :roadmap, :id => 1, :completed => 1
                 assert_response :success
                 assert_template 'roadmap'
                 assert_not_nil assigns(:versions)
                 # Version with no date set appears
                 assert assigns(:versions).include?(Version.find(3))
                 # Completed version appears
                 assert assigns(:versions).include?(Version.find(1))
               end
               def test_project_activity
                 get :activity, :id => 1, :with_subprojects => 0
                 assert_response :success
                 assert_template 'activity'
                 assert_not_nil assigns(:events_by_day)
                 assert_tag :tag => "h3",
                            :content => /#{2.days.ago.to_date.day}/,
                            :sibling => { :tag => "dl",
                              :child => { :tag => "dt",
                                :attributes => { :class => /issue-edit/ },
                                :child => { :tag => "a",
                                  :content => /(#{IssueStatus.find(2).name})/,
                                }
                              }
                            }
               end
               def test_previous_project_activity
                 get :activity, :id => 1, :from => 3.days.ago.to_date
                 assert_response :success
                 assert_template 'activity'
                 assert_not_nil assigns(:events_by_day)
                 assert_tag :tag => "h3",
                            :content => /#{3.day.ago.to_date.day}/,
                            :sibling => { :tag => "dl",
                              :child => { :tag => "dt",
                                :attributes => { :class => /issue/ },
                                :child => { :tag => "a",
                                  :content => /#{Issue.find(1).subject}/,
                                }
                              }
                            }
               end
               def test_global_activity
                 get :activity
                 assert_response :success
                 assert_template 'activity'
                 assert_not_nil assigns(:events_by_day)
                 assert_tag :tag => "h3",
                            :content => /#{5.day.ago.to_date.day}/,
                            :sibling => { :tag => "dl",
                              :child => { :tag => "dt",
                                :attributes => { :class => /issue/ },
                                :child => { :tag => "a",
                                  :content => /#{Issue.find(5).subject}/,
                                }
                              }
                            }
               end
               def test_user_activity
                 get :activity, :user_id => 2
                 assert_response :success
                 assert_template 'activity'
                 assert_not_nil assigns(:events_by_day)
                 assert_tag :tag => "h3",
                            :content => /#{3.day.ago.to_date.day}/,
                            :sibling => { :tag => "dl",
                              :child => { :tag => "dt",
                                :attributes => { :class => /issue/ },
                                :child => { :tag => "a",
                                  :content => /#{Issue.find(1).subject}/,
                                }
                              }
                            }
               end
               def test_activity_atom_feed
                 get :activity, :format => 'atom'
                 assert_response :success
                 assert_template 'common/feed.atom.rxml'
               end
               def test_archive
                 @request.session[:user_id] = 1 # admin
                 post :archive, :id => 1
                 assert_redirected_to 'admin/projects'
                 assert !Project.find(1).active?
               end
               def test_unarchive
                 @request.session[:user_id] = 1 # admin
                 Project.find(1).archive
                 post :unarchive, :id => 1
                 assert_redirected_to 'admin/projects'
                 assert Project.find(1).active?
               end
               def test_jump_should_redirect_to_active_tab
                 get :show, :id => 1, :jump => 'issues'
                 assert_redirected_to 'projects/ecookbook/issues'
               end
               def test_jump_should_not_redirect_to_inactive_tab
                 get :show, :id => 3, :jump => 'documents'
                 assert_response :success
                 assert_template 'show'
               end
               def test_jump_should_not_redirect_to_unknown_tab
                 get :show, :id => 3, :jump => 'foobar'
                 assert_response :success
                 assert_template 'show'
               end
               def test_project_menu
                 assert_no_difference 'Redmine::MenuManager.items(:project_menu).size' do
                   Redmine::MenuManager.map :project_menu do |menu|
                     menu.push :foo, { :controller => 'projects', :action => 'show' }, :cation => 'Foo'
                     menu.push :bar, { :controller => 'projects', :action => 'show' }, :before => :activity
                     menu.push :hello, { :controller => 'projects', :action => 'show' }, :caption => Proc.new {|p| p.name.upcase }, :after => :bar
                   end
                   get :show, :id => 1
                   assert_tag :div, :attributes => { :id => 'main-menu' },
                                    :descendant => { :tag => 'li', :child => { :tag => 'a', :content => 'Foo',
                                                                                            :attributes => { :class => 'foo' } } }
                   assert_tag :div, :attributes => { :id => 'main-menu' },
                                    :descendant => { :tag => 'li', :child => { :tag => 'a', :content => 'Bar',
                                                                                            :attributes => { :class => 'bar' } },
                                                                   :before => { :tag => 'li', :child => { :tag => 'a', :content => 'ECOOKBOOK' } } }
                   assert_tag :div, :attributes => { :id => 'main-menu' },
                                    :descendant => { :tag => 'li', :child => { :tag => 'a', :content => 'ECOOKBOOK',
                                                                                            :attributes => { :class => 'hello' } },
                                                                   :before => { :tag => 'li', :child => { :tag => 'a', :content => 'Activity' } } }
                   # Remove the menu items
                   Redmine::MenuManager.map :project_menu do |menu|
                     menu.delete :foo
                     menu.delete :bar
                     menu.delete :hello
                   end
                 end
               end
               # A hook that is manually registered later
               class ProjectBasedTemplate < Redmine::Hook::ViewListener
                 def view_layouts_base_html_head(context)
                   # Adds a project stylesheet
                   stylesheet_link_tag(context[:project].identifier) if context[:project]
                 end
               end
               # Don't use this hook now
               Redmine::Hook.clear_listeners
               def test_hook_response
                 Redmine::Hook.add_listener(ProjectBasedTemplate)
                 get :show, :id => 1
                 assert_tag :tag => 'link', :attributes => {:href => '/stylesheets/ecookbook.css'},
                                            :parent => {:tag => 'head'}
                 Redmine::Hook.clear_listeners
               end
             end

test/unit/project_test.rb +83 -16

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.dirname(__FILE__) + '/../test_helper'
             class ProjectTest < Test::Unit::TestCase
               fixtures :projects, :issues, :issue_statuses, :journals, :journal_details, :users, :members, :roles, :projects_trackers, :trackers, :boards
               def setup
                 @ecookbook = Project.find(1)
                 @ecookbook_sub1 = Project.find(3)
               end
               def test_truth
                 assert_kind_of Project, @ecookbook
                 assert_equal "eCookbook", @ecookbook.name
               end
               def test_update
                 assert_equal "eCookbook", @ecookbook.name
                 @ecookbook.name = "eCook"
                 assert @ecookbook.save, @ecookbook.errors.full_messages.join("; ")
                 @ecookbook.reload
                 assert_equal "eCook", @ecookbook.name
               end
               def test_validate
                 @ecookbook.name = ""
                 assert !@ecookbook.save
                 assert_equal 1, @ecookbook.errors.count
                 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
                 @ecookbook.reload
                 assert !@ecookbook.active?
                 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
                 user = @ecookbook.members.first.user
                 @ecookbook.archive
                 # A subproject of an archived project can not be unarchived
                 assert !@ecookbook_sub1.unarchive
                 # Unarchive project
                 assert @ecookbook.unarchive
                 @ecookbook.reload
                 assert @ecookbook.active?
                 assert user.projects.include?(@ecookbook)
                 # Subproject can now be unarchived
                 @ecookbook_sub1.reload
                 assert @ecookbook_sub1.unarchive
               end
               def test_destroy
                 # 2 active members
                 assert_equal 2, @ecookbook.members.size
                 # and 1 is locked
                 assert_equal 3, Member.find(:all, :conditions => ['project_id = ?', @ecookbook.id]).size
                 # some boards
                 assert @ecookbook.boards.any?
                 @ecookbook.destroy
                 # make sure that the project non longer exists
                 assert_raise(ActiveRecord::RecordNotFound) { Project.find(@ecookbook.id) }
                 # make sure related data was removed
                 assert Member.find(:all, :conditions => ['project_id = ?', @ecookbook.id]).empty?
                 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
+                sub.set_parent! @ecookbook
-                assert sub.save
                 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.set_parent!(@ecookbook_sub1)
-                assert !sub.save
+              end
+              def test_move_a_root_project_to_a_project
+                sub = @ecookbook
+                assert sub.set_parent!(Project.find(2))
               end
-              def test_subproject_invalid_2
+              def test_should_not_move_a_project_to_its_children
                 sub = @ecookbook
-                sub.parent = Project.find(2)
+                assert !(sub.set_parent!(Project.find(3)))
-                assert !sub.save
+              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
                 parent = Project.find(1)
                 parent.trackers = Tracker.find([1,2])
                 child = parent.children.find(3)
                 assert_equal [1, 2], parent.tracker_ids
                 assert_equal [2, 3], child.tracker_ids
                 assert_kind_of Tracker, parent.rolled_up_trackers.first
                 assert_equal Tracker.find(1), parent.rolled_up_trackers.first
                 assert_equal [1, 2, 3], parent.rolled_up_trackers.collect(&:id)
                 assert_equal [2, 3], child.rolled_up_trackers.collect(&:id)
               end
               def test_next_identifier
                 ProjectCustomField.delete_all
                 Project.create!(:name => 'last', :identifier => 'p2008040')
                 assert_equal 'p2008041', Project.next_identifier
               end
               def test_next_identifier_first_project
                 Project.delete_all
                 assert_nil Project.next_identifier
               end
             end

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