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)
-                 @project_pages = Paginator.new self, @project_count,
-             								per_page_option,
-             								params['page']
-                 @projects = Project.find :all, :order => sort_clause,
-                                     :conditions => c.conditions,
-             						:limit  =>  @project_pages.items_per_page,
-             						:offset =>  @project_pages.current.offset
+                 @projects = Project.find :all, :order => 'lft',
+                                                :conditions => c.conditions
                  render :action => "projects", :layout => false if request.xhr?
                end
                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}
-                     @project_tree.keys.each {|p| @project_tree[p] -= [p]}
+                     @projects = Project.visible.find(:all, :order => 'lft')
                    }
                    format.atom {
-                     render_feed(projects.sort_by(&:created_on).reverse.slice(0, Setting.feeds_limit.to_i),
-                                               :title => "#{Setting.app_title}: #{l(:label_project_latest)}")
+                     projects = Project.visible.find(:all, :order => 'created_on DESC',
+                                                           :limit => Setting.feeds_limit.to_i)
+                     render_feed(projects, :title => "#{Setting.app_title}: #{l(:label_project_latest)}")
                    }
                  end
                end
                # 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(',')})
-                                                             group by s.id, s.is_closed, i.project_id") if @project.active_children.any?
+                                                               and i.project_id IN (#{@project.descendants.active.collect{|p| p.id}.join(',')})
+                                                             group by s.id, s.is_closed, i.project_id") if @project.descendants.active.any?
                  @issues_by_subproject ||= []
                end
              end

app/controllers/search_controller.rb +1 -1

              # 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)
-                 projects_by_root.keys.sort.each do |root|
-                   options << content_tag('option', h(root.name), :value => root.id, :disabled => (!projects.include?(root)))
-                   projects_by_root[root].sort.each do |project|
-                     next if project == root
-                     options << content_tag('option', '&#187; ' + h(project.name), :value => project.id)
-                   end
+                 options << project_tree_options_for_select(projects) do |p|
+                   {:disabled => (user.projects.include?(p))}
                  end
                  options
                end
                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
-                 children.select {|child| child.active?}
+               # Returns an array of projects the project can be moved to
+               def possible_parents
+                 @possible_parents ||= (Project.active.find(:all) - self_and_descendants)
+               end
+               # Sets the parent of the project
+               # Argument can be either a Project, a String, a Fixnum or nil
+               def set_parent!(p)
+                 unless p.nil? || p.is_a?(Project)
+                   if p.to_s.blank?
+                     p = nil
+                   else
+                     p = Project.find_by_id(p)
+                     return false unless p
+                   end
+                 end
+                 if p == parent && !p.nil?
+                   # Nothing to do
+                   true
+                 elsif p.nil? || (p.active? && move_possible?(p))
+                   # Insert the project so that target's children or root projects stay alphabetically sorted
+                   sibs = (p.nil? ? self.class.roots : p.children)
+                   to_be_inserted_before = sibs.detect {|c| c.name.to_s.downcase > name.to_s.downcase }
+                   if to_be_inserted_before
+                     move_to_left_of(to_be_inserted_before)
+                   elsif p.nil?
+                     if sibs.empty?
+                       # move_to_root adds the project in first (ie. left) position
+                       move_to_root
+                     else
+                       move_to_right_of(sibs.last) unless self == sibs.last
+                     end
+                   else
+                     # move_to_child_of adds the project in last (ie.right) position
+                     move_to_child_of(p)
+                   end
+                   true
+                 else
+                   # Can not move to the given target
+                   false
+                 end
                end
                # Returns an array of the trackers used by the project and its sub projects
                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?
-                     @available_filters["subproject_id"] = { :type => :list_subprojects, :order => 13, :values => @project.active_children.collect{|s| [s.name, s.id.to_s] } }
+                   unless @project.descendants.active.empty?
+                     @available_filters["subproject_id"] = { :type => :list_subprojects, :order => 13, :values => @project.descendants.visible.collect{|s| [s.name, s.id.to_s] } }
                    end
                    add_custom_fields_filters(@project.all_issue_custom_fields)
                  else
                    # 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>
-             	<%= sort_header_tag('is_public', :caption => l(:field_is_public), :default_order => 'desc') %>
-             	<%= sort_header_tag('created_on', :caption => l(:field_created_on), :default_order => 'desc') %>
+             	<th><%=l(:field_is_public)%></th>
+             	<th><%=l(:field_created_on)%></th>
                  <th></th>
                  <th></th>
                </tr></thead>
                <tbody>
              <% for project in @projects %>
-               <tr class="<%= cycle("odd", "even") %>">
-             	<td><%= project.active? ? link_to(h(project.name), :controller => 'projects', :action => 'settings', :id => project) : h(project.name) %>
-             	<td><%= textilizable project.short_description, :project => project %>
-             	<td align="center"><%= project.children.size %>
-             	<td align="center"><%= image_tag 'true.png' if project.is_public? %>
-             	<td align="center"><%= format_date(project.created_on) %>
+               <tr class="<%= cycle("odd", "even") %> <%= css_project_classes(project) %>">
+             	<td class="name" style="padding-left: <%= project.level %>em;"><%= project.active? ? link_to(h(project.name), :controller => 'projects', :action => 'settings', :id => project) : h(project.name) %></td>
+             	<td><%= textilizable project.short_description, :project => project %></td>
+             	<td align="center"><%= image_tag 'true.png' if project.is_public? %></td>
+             	<td align="center"><%= format_date(project.created_on) %></td>
                <td align="center" style="width:10%">
                  <small>
                  <%= link_to(l(:button_archive), { :controller => 'projects', :action => 'archive', :id => project }, :confirm => l(:text_are_you_sure), :method => :post, :class => 'icon icon-lock') if project.active? %>
                  <%= 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? %>
-                 <p><%= f.select :parent_id, (@root_projects.collect {|p| [p.name, p.id]}), { :include_blank => true } %></p>
+             <% if User.current.admin? && !@project.possible_parents.empty? %>
+                 <p><label><%= l(:field_parent) %></label><%= parent_project_select_tag(@project) %></p>
              <% end %>
              <p><%= f.text_area :description, :rows => 5, :class => 'wiki-edit' %></p>
              <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? %>
-             <br /><%= l(:text_subprojects_destroy_warning, content_tag('strong', h(@project_to_destroy.children.sort.collect{|p| p.to_s}.join(', ')))) %>
+             <% if @project_to_destroy.descendants.any? %>
+             <br /><%= l(:text_subprojects_destroy_warning, content_tag('strong', h(@project_to_destroy.descendants.collect{|p| p.to_s}.join(', ')))) %>
              <% end %>
              </p>
              <p>
                  <% 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| %>
-             <h3><%= link_to h(project.name), {:action => 'show', :id => project}, :class => (User.current.member_of?(project) ? "icon icon-fav" : "") %></h3>
-             <%= textilizable(project.short_description, :project => project) %>
-             <% if @project_tree[project].any? %>
-                 <p><%= l(:label_subproject_plural) %>:
-                 <%= @project_tree[project].sort.collect {|subproject|
-                    link_to(h(subproject.name), {:action => 'show', :id => subproject}, :class => (User.current.member_of?(subproject) ? "icon icon-fav" : ""))}.join(', ') %></p>
-             <% end %>
-             <% end %>
+             <%= render_project_hierarchy(@projects)%>
              <% if User.current.logged? %>
              <p style="text-align:right;">
-             <span class="icon icon-fav"><%= l(:label_my_projects) %></span>
+             <span class="my-project"><%= l(:label_my_projects) %></span>
              </p>
              <% end %>
              <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? %>
-              	<li><%=l(:label_subproject_plural)%>: <%= @subprojects.collect{|p| link_to(h(p.name), :action => 'show', :id => p)}.join(", ") %></li>
-                 <% end %>
-             	<% if @project.parent %>
-             	<li><%=l(:field_parent)%>: <%= link_to h(@project.parent.name), :controller => 'projects', :action => 'show', :id => @project.parent %></li>
+               <% if @subprojects.any? %>
+              	<li><%=l(:label_subproject_plural)%>:
+             	    <%= @subprojects.collect{|p| link_to(h(p), :action => 'show', :id => p)}.join(", ") %></li>
+               <% end %>
+             	<% 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)
-                 # Root project as hash key
-                 assert assigns(:project_tree).keys.include?(Project.find(1))
-                 # Subproject in corresponding value
-                 assert assigns(:project_tree)[Project.find(1)].include?(Project.find(3))
+                 assert_not_nil assigns(:projects)
+                 assert_tag :ul, :child => {:tag => 'li',
+                                            :descendant => {:tag => 'a', :content => 'eCookbook'},
+                                            :child => { :tag => 'ul',
+                                                        :descendant => { :tag => 'a',
+                                                                         :content => 'Child of private child'
+                                                                        }
+                                                       }
+                                            }
+                 assert_no_tag :a, :content => /Private child of eCookbook/
                end
                def test_index_atom
                  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
-                 assert sub.save
+                 sub.set_parent! @ecookbook
                  assert_equal @ecookbook.id, sub.parent.id
                  @ecookbook.reload
                  assert_equal 4, @ecookbook.children.size
                end
-               def test_subproject_invalid
+               def test_move_an_orphan_project_to_a_subproject
                  sub = Project.find(2)
-                 sub.parent = @ecookbook_sub1
-                 assert !sub.save
+                 assert sub.set_parent!(@ecookbook_sub1)
+               end
+               def test_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.save
+                 assert !(sub.set_parent!(Project.find(3)))
+               end
+               def test_set_parent_should_add_roots_in_alphabetical_order
+                 ProjectCustomField.delete_all
+                 Project.delete_all
+                 Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(nil)
+                 Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(nil)
+                 Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(nil)
+                 Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(nil)
+                 assert_equal 4, Project.count
+                 assert_equal Project.all.sort_by(&:name), Project.all.sort_by(&:lft)
+               end
+               def test_set_parent_should_add_children_in_alphabetical_order
+                 ProjectCustomField.delete_all
+                 parent = Project.create!(:name => 'Parent', :identifier => 'parent')
+                 Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(parent)
+                 Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(parent)
+                 Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(parent)
+                 Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(parent)
+                 parent.reload
+                 assert_equal 4, parent.children.size
+                 assert_equal parent.children.sort_by(&:name), parent.children
+               end
+               def test_rebuild_should_sort_children_alphabetically
+                 ProjectCustomField.delete_all
+                 parent = Project.create!(:name => 'Parent', :identifier => 'parent')
+                 Project.create!(:name => 'Project C', :identifier => 'project-c').move_to_child_of(parent)
+                 Project.create!(:name => 'Project B', :identifier => 'project-b').move_to_child_of(parent)
+                 Project.create!(:name => 'Project D', :identifier => 'project-d').move_to_child_of(parent)
+                 Project.create!(:name => 'Project A', :identifier => 'project-a').move_to_child_of(parent)
+                 Project.update_all("lft = NULL, rgt = NULL")
+                 Project.rebuild!
+                 parent.reload
+                 assert_equal 4, parent.children.size
+                 assert_equal parent.children.sort_by(&:name), parent.children
+               end
+               def test_parent
+                 p = Project.find(6).parent
+                 assert p.is_a?(Project)
+                 assert_equal 5, p.id
+               end
+               def test_ancestors
+                 a = Project.find(6).ancestors
+                 assert a.first.is_a?(Project)
+                 assert_equal [1, 5], a.collect(&:id)
+               end
+               def test_root
+                 r = Project.find(6).root
+                 assert r.is_a?(Project)
+                 assert_equal 1, r.id
+               end
+               def test_children
+                 c = Project.find(1).children
+                 assert c.first.is_a?(Project)
+                 assert_equal [5, 3, 4], c.collect(&:id)
+               end
+               def test_descendants
+                 d = Project.find(1).descendants
+                 assert d.first.is_a?(Project)
+                 assert_equal [5, 6, 3, 4], d.collect(&:id)
                end
                def test_rolled_up_trackers
                  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