Redmine

    @projects = Project.find :all, :order => 'lft',

                                   :conditions => c.conditions

        @projects = Project.visible.find(:all, :order => 'lft') 

        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)}")

        @project.set_parent!(params[:project]['parent_id']) if User.current.admin? && params[:project].has_key?('parent_id')

    @subprojects = @project.children.visible

    @ancestors = @project.ancestors.visible

        @project.set_parent!(params[:project]['parent_id']) if User.current.admin? && params[:project].has_key?('parent_id')

      @rows = @project.descendants.active

      @subprojects = @project.descendants.active

                                                  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?

        @project ? (@project.self_and_descendants.active) : nil

    @projects = Project.active.find(:all, :order => 'lft')

  def css_project_classes(project)

    s = 'project'

    s << ' root' if project.root?

    s << ' child' if project.child?

    s << (project.leaf? ? ' leaf' : ' parent')

    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 ? (' ' * 2 * level + '» ') : '')

      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

  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

    options << [l(:label_and_its_subprojects, @project.name), 'subprojects'] unless @project.nil? || @project.descendants.active.empty?

  def options_for_membership_project_select(user, projects)

    options << project_tree_options_for_select(projects) do |p|

      {:disabled => (user.projects.include?(p))}

  acts_as_nested_set :order => 'name', :dependent => :destroy

  named_scope :active, { :conditions => "#{Project.table_name}.status = #{STATUS_ACTIVE}"}

  named_scope :visible, lambda { { :conditions => Project.visible_by(User.current) } }

      ids = [id] + descendants.collect(&:id)

      project_statement << " OR (#{Project.table_name}.lft > #{options[:project].lft} AND #{Project.table_name}.rgt < #{options[:project].rgt})" if options[:with_subprojects]

    cond = "(#{cond} OR (#{Project.table_name}.lft > #{lft} AND #{Project.table_name}.rgt < #{rgt}))" if with_subprojects

  # Archives the project and its descendants recursively

  # Unarchives the project

  # All its ancestors must be active

    return false if ancestors.detect {|a| !a.active?}

  # Returns an array of projects the project can be moved to

  def possible_parents

    @possible_parents ||= (Project.active.find(:all) - self_and_descendants)

  # 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

                         :conditions => ["#{Project.table_name}.lft >= ? AND #{Project.table_name}.rgt <= ?", lft, rgt],

    description.gsub(/^(.{#{length}}[^\n\r]*).*$/m, '\1...').strip if description

      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] } }

    if project && !@project.descendants.active.empty?

          ids += project.descendants.collect(&:id)

        ids += project.descendants.collect(&:id)

	<th><%=l(:label_project)%></th>

	<th><%=l(:field_is_public)%></th>

	<th><%=l(:field_created_on)%></th>

  <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>

        <%= render_project_jump_box %>

<% if User.current.admin? && [email protected]_parents.empty? %>

    <p><label><%= l(:field_parent) %></label><%= parent_project_select_tag(@project) %></p>

<% if @project && @project.descendants.active.any? %>

<% 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(', ')))) %>

<%= render_project_hierarchy(@projects)%>

<span class="my-project"><%= l(:label_my_projects) %></span>

  <% 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>

<%= select_tag 'membership[project_id]', options_for_membership_project_select(@user, @projects) %>

class AddProjectsLftAndRgt < ActiveRecord::Migration

  def self.up

    add_column :projects, :lft, :integer

    add_column :projects, :rgt, :integer

  end

  def self.down

    remove_column :projects, :lft

    remove_column :projects, :rgt

  end

end

class BuildProjectsTree < ActiveRecord::Migration

  def self.up

    Project.rebuild!

  end

  def self.down

  end

end

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; }

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%; }

  lft: 1

  rgt: 10

  lft: 11

  rgt: 12

  lft: 6

  rgt: 7

  lft: 8

  rgt: 9

  identifier: private-child

  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

    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/

    assert @ecookbook.descendants.active.empty?

  def test_move_an_orphan_project_to_a_root_project

    sub.set_parent! @ecookbook

  def test_move_an_orphan_project_to_a_subproject

    assert sub.set_parent!(@ecookbook_sub1)

  def test_move_a_root_project_to_a_project

    assert sub.set_parent!(Project.find(2))

  def test_should_not_move_a_project_to_its_children

    sub = @ecookbook

    assert !(sub.set_parent!(Project.find(3)))

  end

  def test_set_parent_should_add_roots_in_alphabetical_order

    ProjectCustomField.delete_all

    Project.delete_all

    Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(nil)

    Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(nil)

    Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(nil)

    Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(nil)

    assert_equal 4, Project.count

    assert_equal Project.all.sort_by(&:name), Project.all.sort_by(&:lft)

  end

  def test_set_parent_should_add_children_in_alphabetical_order

    ProjectCustomField.delete_all

    parent = Project.create!(:name => 'Parent', :identifier => 'parent')

    Project.create!(:name => 'Project C', :identifier => 'project-c').set_parent!(parent)

    Project.create!(:name => 'Project B', :identifier => 'project-b').set_parent!(parent)

    Project.create!(:name => 'Project D', :identifier => 'project-d').set_parent!(parent)

    Project.create!(:name => 'Project A', :identifier => 'project-a').set_parent!(parent)

    parent.reload

    assert_equal 4, parent.children.size

    assert_equal parent.children.sort_by(&:name), parent.children

  end

  def test_rebuild_should_sort_children_alphabetically

    ProjectCustomField.delete_all

    parent = Project.create!(:name => 'Parent', :identifier => 'parent')

    Project.create!(:name => 'Project C', :identifier => 'project-c').move_to_child_of(parent)

    Project.create!(:name => 'Project B', :identifier => 'project-b').move_to_child_of(parent)

    Project.create!(:name => 'Project D', :identifier => 'project-d').move_to_child_of(parent)

    Project.create!(:name => 'Project A', :identifier => 'project-a').move_to_child_of(parent)

    Project.update_all("lft = NULL, rgt = NULL")

    Project.rebuild!

    parent.reload

    assert_equal 4, parent.children.size

    assert_equal parent.children.sort_by(&:name), parent.children

  end

  def test_parent

    p = Project.find(6).parent

    assert p.is_a?(Project)

    assert_equal 5, p.id

  end

  def test_ancestors

    a = Project.find(6).ancestors

    assert a.first.is_a?(Project)

    assert_equal [1, 5], a.collect(&:id)

  end

  def test_root

    r = Project.find(6).root

    assert r.is_a?(Project)

    assert_equal 1, r.id

  end

  def test_children

    c = Project.find(1).children

    assert c.first.is_a?(Project)

    assert_equal [5, 3, 4], c.collect(&:id)

  end

  def test_descendants

    d = Project.find(1).descendants

    assert d.first.is_a?(Project)

    assert_equal [5, 6, 3, 4], d.collect(&:id)

  end

Copyright (c) 2007 [name of plugin creator]

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the

"Software"), to deal in the Software without restriction, including

without limitation the rights to use, copy, modify, merge, publish,

distribute, sublicense, and/or sell copies of the Software, and to

permit persons to whom the Software is furnished to do so, subject to

the following conditions:

The above copyright notice and this permission notice shall be

included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

= AwesomeNestedSet

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.

== What makes this so awesome?

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.

== Installation

If you are on Rails 2.1 or later:

  script/plugin install git://github.com/collectiveidea/awesome_nested_set.git

== Usage

To make use of awesome_nested_set, your model needs to have 3 fields: lft, rgt, and parent_id:

  class CreateCategories < ActiveRecord::Migration

    def self.up

      create_table :categories do |t|

        t.string :name

        t.integer :parent_id

        t.integer :lft

        t.integer :rgt

      end

    end

    def self.down

      drop_table :categories

    end

  end

Enable the nested set functionality by declaring acts_as_nested_set on your model

  class Category < ActiveRecord::Base

    acts_as_nested_set

  end

Run `rake rdoc` to generate the API docs and see CollectiveIdea::Acts::NestedSet::SingletonMethods for more info.

== View Helper

The view helper is called #nested_set_options. 

Example usage:

  <%= f.select :parent_id, nested_set_options(Category, @category) {|i| "#{'-' * i.level} #{i.name}" } %>

  <%= select_tag 'parent_id', options_for_select(nested_set_options(Category) {|i| "#{'-' * i.level} #{i.name}" } ) %>

See CollectiveIdea::Acts::NestedSet::Helper for more information about the helpers.

== References

You can learn more about nested sets at:

  http://www.dbmsmag.com/9603d06.html

  http://threebit.net/tutorials/nestedset/tutorial1.html

  http://api.rubyonrails.com/classes/ActiveRecord/Acts/NestedSet/ClassMethods.html

  http://opensource.symetrie.com/trac/better_nested_set/

Copyright (c) 2008 Collective Idea, released under the MIT license

require 'rake'

require 'rake/testtask'

require 'rake/rdoctask'

require 'rake/gempackagetask'

require 'rcov/rcovtask'

require "load_multi_rails_rake_tasks" 

spec = eval(File.read("#{File.dirname(__FILE__)}/awesome_nested_set.gemspec"))

PKG_NAME = spec.name

PKG_VERSION = spec.version

Rake::GemPackageTask.new(spec) do |pkg|

  pkg.need_zip = true

  pkg.need_tar = true

end

desc 'Default: run unit tests.'

task :default => :test

desc 'Test the awesome_nested_set plugin.'

Rake::TestTask.new(:test) do |t|

  t.libs << 'lib'

  t.pattern = 'test/**/*_test.rb'

  t.verbose = true

end

desc 'Generate documentation for the awesome_nested_set plugin.'

Rake::RDocTask.new(:rdoc) do |rdoc|

  rdoc.rdoc_dir = 'rdoc'

  rdoc.title    = 'AwesomeNestedSet'

  rdoc.options << '--line-numbers' << '--inline-source'

  rdoc.rdoc_files.include('README.rdoc')

  rdoc.rdoc_files.include('lib/**/*.rb')

end

namespace :test do

  desc "just rcov minus html output"

  Rcov::RcovTask.new(:coverage) do |t|

    # t.libs << 'test'

    t.test_files = FileList['test/**/*_test.rb']

    t.output_dir = 'coverage'

    t.verbose = true

    t.rcov_opts = %w(--exclude test,/usr/lib/ruby,/Library/Ruby,lib/awesome_nested_set/named_scope.rb --sort coverage)

  end

end

Gem::Specification.new do |s|

  s.name = "awesome_nested_set"

  s.version = "1.1.1"

  s.summary = "An awesome replacement for acts_as_nested_set and better_nested_set."

  s.description = s.summary

  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)

  s.add_dependency "activerecord", ['>= 1.1']

  s.has_rdoc = true

  s.extra_rdoc_files = [ "README.rdoc"]

  s.rdoc_options = ["--main", "README.rdoc", "--inline-source", "--line-numbers"]

  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)

  s.require_path = 'lib'

  s.author = "Collective Idea"

  s.email = "[email protected]"

  s.homepage = "http://collectiveidea.com"

end

require File.dirname(__FILE__) + "/rails/init"  

# Rails <2.x doesn't define #except

class Hash #:nodoc:

  # Returns a new hash without the given keys.

  def except(*keys)

    clone.except!(*keys)

  end unless method_defined?(:except)

  # Replaces the hash without the given keys.

  def except!(*keys)

    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)

    keys.each { |key| delete(key) }

    self

  end unless method_defined?(:except!)

end

# NamedScope is new to Rails 2.1

unless defined? ActiveRecord::NamedScope

  require 'awesome_nested_set/named_scope'

  ActiveRecord::Base.class_eval do

    include CollectiveIdea::NamedScope

  end

end

# Rails 1.2.x doesn't define #quoted_table_name

class ActiveRecord::Base  #:nodoc:

  def self.quoted_table_name

    self.connection.quote_column_name(self.table_name)

  end unless methods.include?('quoted_table_name')

end

module CollectiveIdea #:nodoc:

  module Acts #:nodoc:

    module NestedSet #:nodoc:

      # This module provides some helpers for the model classes using acts_as_nested_set.

      # It is included by default in all views.

      #

      module Helper

        # Returns options for select.

        # You can exclude some items from the tree.

        # You can pass a block receiving an item and returning the string displayed in the select.

        #

        # == Params

        #  * +class_or_item+ - Class name or top level times

        #  * +mover+ - The item that is being move, used to exlude impossible moves

        #  * +&block+ - a block that will be used to display: { |item| ... item.name }

        #

        # == Usage

        #

        #   <%= f.select :parent_id, nested_set_options(Category, @category) {|i|

        #       "#{'–' * i.level} #{i.name}"

        #     }) %>

        #

        def nested_set_options(class_or_item, mover = nil)

          class_or_item = class_or_item.roots if class_or_item.is_a?(Class)

          items = Array(class_or_item)

          result = []

          items.each do |root|

            result += root.self_and_descendants.map do |i|

              if mover.nil? || mover.new_record? || mover.move_possible?(i)

                [yield(i), i.id]

              end

            end.compact

          end

          result

        end  

      end

    end  

  end

end

# Taken from Rails 2.1

module CollectiveIdea #:nodoc:

  module NamedScope #:nodoc:

    # All subclasses of ActiveRecord::Base have two named_scopes:

    # * <tt>all</tt>, which is similar to a <tt>find(:all)</tt> query, and

    # * <tt>scoped</tt>, which allows for the creation of anonymous scopes, on the fly:

    #

    #   Shirt.scoped(:conditions => {:color => 'red'}).scoped(:include => :washing_instructions)

    #

    # These anonymous scopes tend to be useful when procedurally generating complex queries, where passing

    # intermediate values (scopes) around as first-class objects is convenient.

    def self.included(base)

      base.class_eval do

        extend ClassMethods

        named_scope :scoped, lambda { |scope| scope }

      end

    end

    module ClassMethods #:nodoc:

      def scopes

        read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})

      end

      # Adds a class method for retrieving and querying objects. A scope represents a narrowing of a database query,

      # such as <tt>:conditions => {:color => :red}, :select => 'shirts.*', :include => :washing_instructions</tt>.

      #

      #   class Shirt < ActiveRecord::Base

      #     named_scope :red, :conditions => {:color => 'red'}

      #     named_scope :dry_clean_only, :joins => :washing_instructions, :conditions => ['washing_instructions.dry_clean_only = ?', true]

      #   end

      # 

      # 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>, 

      # in effect, represents the query <tt>Shirt.find(:all, :conditions => {:color => 'red'})</tt>.

      #

      # Unlike Shirt.find(...), however, the object returned by <tt>Shirt.red</tt> is not an Array; it resembles the association object

      # constructed by a <tt>has_many</tt> declaration. For instance, you can invoke <tt>Shirt.red.find(:first)</tt>, <tt>Shirt.red.count</tt>,

      # <tt>Shirt.red.find(:all, :conditions => {:size => 'small'})</tt>. Also, just

      # as with the association objects, name scopes acts like an Array, implementing Enumerable; <tt>Shirt.red.each(&block)</tt>,

      # <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if Shirt.red really were an Array.

      #

      # 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.

      # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt> returns the number of garments

      # for which these criteria obtain. Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.

      #

      # All scopes are available as class methods on the ActiveRecord descendent upon which the scopes were defined. But they are also available to

      # <tt>has_many</tt> associations. If,

      #

      #   class Person < ActiveRecord::Base

      #     has_many :shirts

      #   end

      #

      # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean

      # only shirts.

      #

      # Named scopes can also be procedural.

      #

      #   class Shirt < ActiveRecord::Base

      #     named_scope :colored, lambda { |color|

      #       { :conditions => { :color => color } }

      #     }

      #   end

      #

      # In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.

      #

      # Named scopes can also have extensions, just as with <tt>has_many</tt> declarations:

      #

      #   class Shirt < ActiveRecord::Base

      #     named_scope :red, :conditions => {:color => 'red'} do

      #       def dom_id

      #         'red_shirts'

      #       end

      #     end

      #   end

      #

      #

      # For testing complex named scopes, you can examine the scoping options using the

      # <tt>proxy_options</tt> method on the proxy itself.

      #

      #   class Shirt < ActiveRecord::Base

      #     named_scope :colored, lambda { |color|

      #       { :conditions => { :color => color } }

      #     }

      #   end

      #

      #   expected_options = { :conditions => { :colored => 'red' } }

      #   assert_equal expected_options, Shirt.colored('red').proxy_options

      def named_scope(name, options = {}, &block)

        scopes[name] = lambda do |parent_scope, *args|

          Scope.new(parent_scope, case options

            when Hash

              options

            when Proc

              options.call(*args)

          end, &block)

        end

        (class << self; self end).instance_eval do

          define_method name do |*args|

            scopes[name].call(self, *args)

          end

        end

      end

    end

    class Scope #:nodoc:

      attr_reader :proxy_scope, :proxy_options

      [].methods.each { |m| delegate m, :to => :proxy_found unless m =~ /(^__|^nil\?|^send|class|extend|find|count|sum|average|maximum|minimum|paginate)/ }

      delegate :scopes, :with_scope, :to => :proxy_scope

      def initialize(proxy_scope, options, &block)

        [options[:extend]].flatten.each { |extension| extend extension } if options[:extend]

        extend Module.new(&block) if block_given?

        @proxy_scope, @proxy_options = proxy_scope, options.except(:extend)

      end

      def reload

        load_found; self

      end

      protected

      def proxy_found

        @found || load_found

      end

      private

      def method_missing(method, *args, &block)

        if scopes.include?(method)

          scopes[method].call(self, *args)

        else

          with_scope :find => proxy_options do

            proxy_scope.send(method, *args, &block)

          end

        end

      end

      def load_found

        @found = find(:all)

      end

    end

  end

end

module CollectiveIdea #:nodoc:

  module Acts #:nodoc:

    module NestedSet #:nodoc:

      def self.included(base)

        base.extend(SingletonMethods)

      end

      # This acts provides Nested Set functionality. Nested Set is a smart way to implement

      # an _ordered_ tree, with the added feature that you can select the children and all of their

      # descendants with a single query. The drawback is that insertion or move need some complex

      # sql queries. But everything is done here by this module!

      #

      # Nested sets are appropriate each time you want either an orderd tree (menus,

      # commercial categories) or an efficient way of querying big trees (threaded posts).

      #

      # == API

      #

      # Methods names are aligned with acts_as_tree as much as possible, to make replacment from one

      # by another easier, except for the creation:

      #

      # in acts_as_tree:

      #   item.children.create(:name => "child1")

      #

      # in acts_as_nested_set:

      #   # adds a new item at the "end" of the tree, i.e. with child.left = max(tree.right)+1

      #   child = MyClass.new(:name => "child1")

      #   child.save

      #   # now move the item to its right place

      #   child.move_to_child_of my_item

      #

      # You can pass an id or an object to:

      # * <tt>#move_to_child_of</tt>

      # * <tt>#move_to_right_of</tt>

      # * <tt>#move_to_left_of</tt>

      #

      module SingletonMethods

        # Configuration options are:

        #

        # * +:parent_column+ - specifies the column name to use for keeping the position integer (default: parent_id)

        # * +:left_column+ - column name for left boundry data, default "lft"

        # * +:right_column+ - column name for right boundry data, default "rgt"

        # * +:scope+ - restricts what is to be considered a list. Given a symbol, it'll attach "_id"

        #   (if it hasn't been already) and use that as the foreign key restriction. You

        #   can also pass an array to scope by multiple attributes.

        #   Example: <tt>acts_as_nested_set :scope => [:notable_id, :notable_type]</tt>

        # * +:dependent+ - behavior for cascading destroy. If set to :destroy, all the

        #   child objects are destroyed alongside this object by calling their destroy

        #   method. If set to :delete_all (default), all the child objects are deleted

        #   without calling their destroy method.

        #

        # See CollectiveIdea::Acts::NestedSet::ClassMethods for a list of class methods and

        # CollectiveIdea::Acts::NestedSet::InstanceMethods for a list of instance methods added 

        # to acts_as_nested_set models

        def acts_as_nested_set(options = {})

          options = {

            :parent_column => 'parent_id',

            :left_column => 'lft',