Redmine

# Loads the core plugins located in lib/plugins

Dir.glob(File.join(Rails.root, "lib/plugins/*")).sort.each do |directory|

  if File.directory?(directory)

    lib = File.join(directory, "lib")

    if File.directory?(lib)

      $:.unshift lib

      ActiveSupport::Dependencies.autoload_paths += [lib]

    end

    initializer = File.join(directory, "init.rb")

    if File.file?(initializer)

      config = config = RedmineApp::Application.config

      eval(File.read(initializer), binding, initializer)

    end

  end

end

require File.dirname(__FILE__) + '/lib/acts_as_activity_provider'

ActiveRecord::Base.send(:include, Redmine::Acts::ActivityProvider)

# Redmine - project management software

# Copyright (C) 2006-2012  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 Redmine

  module Acts

    module ActivityProvider

      def self.included(base)

        base.extend ClassMethods

      end

      module ClassMethods

        def acts_as_activity_provider(options = {})

          unless self.included_modules.include?(Redmine::Acts::ActivityProvider::InstanceMethods)

            cattr_accessor :activity_provider_options

            send :include, Redmine::Acts::ActivityProvider::InstanceMethods

          end

          options.assert_valid_keys(:type, :permission, :timestamp, :author_key, :find_options)

          self.activity_provider_options ||= {}

          # One model can provide different event types

          # We store these options in activity_provider_options hash

          event_type = options.delete(:type) || self.name.underscore.pluralize

          options[:timestamp] ||= "#{table_name}.created_on"

          options[:find_options] ||= {}

          options[:author_key] = "#{table_name}.#{options[:author_key]}" if options[:author_key].is_a?(Symbol)

          self.activity_provider_options[event_type] = options

        end

      end

      module InstanceMethods

        def self.included(base)

          base.extend ClassMethods

        end

        module ClassMethods

          # Returns events of type event_type visible by user that occured between from and to

          def find_events(event_type, user, from, to, options)

            provider_options = activity_provider_options[event_type]

            raise "#{self.name} can not provide #{event_type} events." if provider_options.nil?

            scope = self

            if from && to

              scope = scope.scoped(:conditions => ["#{provider_options[:timestamp]} BETWEEN ? AND ?", from, to])

            end

            if options[:author]

              return [] if provider_options[:author_key].nil?

              scope = scope.scoped(:conditions => ["#{provider_options[:author_key]} = ?", options[:author].id])

            end

            if options[:limit]

              # id and creation time should be in same order in most cases

              scope = scope.scoped(:order => "#{table_name}.id DESC", :limit => options[:limit])

            end

            if provider_options.has_key?(:permission)

              scope = scope.scoped(:conditions => Project.allowed_to_condition(user, provider_options[:permission] || :view_project, options))

            elsif respond_to?(:visible)

              scope = scope.visible(user, options)

            else

              ActiveSupport::Deprecation.warn "acts_as_activity_provider with implicit :permission option is deprecated. Add a visible scope to the #{self.name} model or use explicit :permission option."

              scope = scope.scoped(:conditions => Project.allowed_to_condition(user, "view_#{self.name.underscore.pluralize}".to_sym, options))

            end

            scope.all(provider_options[:find_options].dup)

          end

        end

      end

    end

  end

end

require File.dirname(__FILE__) + '/lib/acts_as_attachable'

ActiveRecord::Base.send(:include, Redmine::Acts::Attachable)

# Redmine - project management software

# Copyright (C) 2006-2012  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 Redmine

  module Acts

    module Attachable

      def self.included(base)

        base.extend ClassMethods

      end

      module ClassMethods

        def acts_as_attachable(options = {})

          cattr_accessor :attachable_options

          self.attachable_options = {}

          attachable_options[:view_permission] = options.delete(:view_permission) || "view_#{self.name.pluralize.underscore}".to_sym

          attachable_options[:delete_permission] = options.delete(:delete_permission) || "edit_#{self.name.pluralize.underscore}".to_sym

          has_many :attachments, options.merge(:as => :container,

                                               :order => "#{Attachment.table_name}.created_on",

                                               :dependent => :destroy)

          send :include, Redmine::Acts::Attachable::InstanceMethods

          before_save :attach_saved_attachments

        end

      end

      module InstanceMethods

        def self.included(base)

          base.extend ClassMethods

        end

        def attachments_visible?(user=User.current)

          (respond_to?(:visible?) ? visible?(user) : true) &&

            user.allowed_to?(self.class.attachable_options[:view_permission], self.project)

        end

        def attachments_deletable?(user=User.current)

          (respond_to?(:visible?) ? visible?(user) : true) &&

            user.allowed_to?(self.class.attachable_options[:delete_permission], self.project)

        end

        def saved_attachments

          @saved_attachments ||= []

        end

        def unsaved_attachments

          @unsaved_attachments ||= []

        end

        def save_attachments(attachments, author=User.current)

          if attachments.is_a?(Hash)

            attachments = attachments.values

          end

          if attachments.is_a?(Array)

            attachments.each do |attachment|

              a = nil

              if file = attachment['file']

                next unless file.size > 0

                a = Attachment.create(:file => file, :author => author)

              elsif token = attachment['token']

                a = Attachment.find_by_token(token)

                next unless a

                a.filename = attachment['filename'] unless attachment['filename'].blank?

                a.content_type = attachment['content_type']

              end

              next unless a

              a.description = attachment['description'].to_s.strip

              if a.new_record?

                unsaved_attachments << a

              else

                saved_attachments << a

              end

            end

          end

          {:files => saved_attachments, :unsaved => unsaved_attachments}

        end

        def attach_saved_attachments

          saved_attachments.each do |attachment|

            self.attachments << attachment

          end

        end

        module ClassMethods

        end

      end

    end

  end

end

require File.dirname(__FILE__) + '/lib/acts_as_customizable'

ActiveRecord::Base.send(:include, Redmine::Acts::Customizable)

# Redmine - project management software

# Copyright (C) 2006-2012  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 Redmine

  module Acts

    module Customizable

      def self.included(base)

        base.extend ClassMethods

      end

      module ClassMethods

        def acts_as_customizable(options = {})

          return if self.included_modules.include?(Redmine::Acts::Customizable::InstanceMethods)

          cattr_accessor :customizable_options

          self.customizable_options = options

          has_many :custom_values, :as => :customized,

                                   :include => :custom_field,

                                   :order => "#{CustomField.table_name}.position",

                                   :dependent => :delete_all,

                                   :validate => false

          send :include, Redmine::Acts::Customizable::InstanceMethods

          validate :validate_custom_field_values

          after_save :save_custom_field_values

        end

      end

      module InstanceMethods

        def self.included(base)

          base.extend ClassMethods

        end

        def available_custom_fields

          CustomField.find(:all, :conditions => "type = '#{self.class.name}CustomField'",

                                 :order => 'position')

        end

        # Sets the values of the object's custom fields

        # values is an array like [{'id' => 1, 'value' => 'foo'}, {'id' => 2, 'value' => 'bar'}]

        def custom_fields=(values)

          values_to_hash = values.inject({}) do |hash, v|

            v = v.stringify_keys

            if v['id'] && v.has_key?('value')

              hash[v['id']] = v['value']

            end

            hash

          end

          self.custom_field_values = values_to_hash

        end

        # Sets the values of the object's custom fields

        # values is a hash like {'1' => 'foo', 2 => 'bar'}

        def custom_field_values=(values)

          values = values.stringify_keys

          custom_field_values.each do |custom_field_value|

            key = custom_field_value.custom_field_id.to_s

            if values.has_key?(key)

              value = values[key]

              if value.is_a?(Array)

                value = value.reject(&:blank?).uniq

                if value.empty?

                  value << ''

                end

              end

              custom_field_value.value = value

            end

          end

          @custom_field_values_changed = true

        end

        def custom_field_values

          @custom_field_values ||= available_custom_fields.collect do |field|

            x = CustomFieldValue.new

            x.custom_field = field

            x.customized = self

            if field.multiple?

              values = custom_values.select { |v| v.custom_field == field }

              if values.empty?

                values << custom_values.build(:customized => self, :custom_field => field, :value => nil)

              end

              x.value = values.map(&:value)

            else

              cv = custom_values.detect { |v| v.custom_field == field }

              cv ||= custom_values.build(:customized => self, :custom_field => field, :value => nil)

              x.value = cv.value

            end

            x

          end

        end

        def visible_custom_field_values

          custom_field_values.select(&:visible?)

        end

        def custom_field_values_changed?

          @custom_field_values_changed == true

        end

        def custom_value_for(c)

          field_id = (c.is_a?(CustomField) ? c.id : c.to_i)

          custom_values.detect {|v| v.custom_field_id == field_id }

        end

        def custom_field_value(c)

          field_id = (c.is_a?(CustomField) ? c.id : c.to_i)

          custom_field_values.detect {|v| v.custom_field_id == field_id }.try(:value)

        end

        def validate_custom_field_values

          if new_record? || custom_field_values_changed?

            custom_field_values.each(&:validate_value)

          end

        end

        def save_custom_field_values

          target_custom_values = []

          custom_field_values.each do |custom_field_value|

            if custom_field_value.value.is_a?(Array)

              custom_field_value.value.each do |v|

                target = custom_values.detect {|cv| cv.custom_field == custom_field_value.custom_field && cv.value == v}

                target ||= custom_values.build(:customized => self, :custom_field => custom_field_value.custom_field, :value => v)

                target_custom_values << target

              end

            else

              target = custom_values.detect {|cv| cv.custom_field == custom_field_value.custom_field}

              target ||= custom_values.build(:customized => self, :custom_field => custom_field_value.custom_field)

              target.value = custom_field_value.value

              target_custom_values << target

            end

          end

          self.custom_values = target_custom_values

          custom_values.each(&:save)

          @custom_field_values_changed = false

          true

        end

        def reset_custom_values!

          @custom_field_values = nil

          @custom_field_values_changed = true

        end

        module ClassMethods

        end

      end

    end

  end

end

require File.dirname(__FILE__) + '/lib/acts_as_event'

ActiveRecord::Base.send(:include, Redmine::Acts::Event)

# Redmine - project management software

# Copyright (C) 2006-2012  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 Redmine

  module Acts

    module Event

      def self.included(base)

        base.extend ClassMethods

      end

      module ClassMethods

        def acts_as_event(options = {})

          return if self.included_modules.include?(Redmine::Acts::Event::InstanceMethods)

          default_options = { :datetime => :created_on,

                              :title => :title,

                              :description => :description,

                              :author => :author,

                              :url => {:controller => 'welcome'},

                              :type => self.name.underscore.dasherize }

          cattr_accessor :event_options

          self.event_options = default_options.merge(options)

          send :include, Redmine::Acts::Event::InstanceMethods

        end

      end

      module InstanceMethods

        def self.included(base)

          base.extend ClassMethods

        end

        %w(datetime title description author type).each do |attr|

          src = <<-END_SRC

            def event_#{attr}

              option = event_options[:#{attr}]

              if option.is_a?(Proc)

                option.call(self)

              elsif option.is_a?(Symbol)

                send(option)

              else

                option

              end

            end

          END_SRC

          class_eval src, __FILE__, __LINE__

        end

        def event_date

          event_datetime.to_date

        end

        def event_url(options = {})

          option = event_options[:url]

          if option.is_a?(Proc)

            option.call(self).merge(options)

          elsif option.is_a?(Hash)

            option.merge(options)

          elsif option.is_a?(Symbol)

            send(option).merge(options)

          else

            option

          end

        end

        # Returns the mail adresses of users that should be notified

        def recipients

          notified = project.notified_users

          notified.reject! {|user| !visible?(user)}

          notified.collect(&:mail)

        end

        module ClassMethods

        end

      end

    end

  end

end

ActsAsList

==========

This acts_as extension provides the capabilities for sorting and reordering a number of objects in a list. The class that has this specified needs to have a +position+ column defined as an integer on the mapped database table.

Example

=======

  class TodoList < ActiveRecord::Base

    has_many :todo_items, :order => "position"

  end

  class TodoItem < ActiveRecord::Base

    belongs_to :todo_list

    acts_as_list :scope => :todo_list

  end

  todo_list.first.move_to_bottom

  todo_list.last.move_higher

Copyright (c) 2007 David Heinemeier Hansson, released under the MIT license

$:.unshift "#{File.dirname(__FILE__)}/lib"

require 'active_record/acts/list'

ActiveRecord::Base.class_eval { include ActiveRecord::Acts::List }

module ActiveRecord

  module Acts #:nodoc:

    module List #:nodoc:

      def self.included(base)

        base.extend(ClassMethods)

      end

      # This +acts_as+ extension provides the capabilities for sorting and reordering a number of objects in a list.

      # The class that has this specified needs to have a +position+ column defined as an integer on

      # the mapped database table.

      #

      # Todo list example:

      #

      #   class TodoList < ActiveRecord::Base

      #     has_many :todo_items, :order => "position"

      #   end

      #

      #   class TodoItem < ActiveRecord::Base

      #     belongs_to :todo_list

      #     acts_as_list :scope => :todo_list

      #   end

      #

      #   todo_list.first.move_to_bottom

      #   todo_list.last.move_higher

      module ClassMethods

        # Configuration options are:

        #

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

        # * +scope+ - restricts what is to be considered a list. Given a symbol, it'll attach <tt>_id</tt> 

        #   (if it hasn't already been added) and use that as the foreign key restriction. It's also possible 

        #   to give it an entire string that is interpolated if you need a tighter scope than just a foreign key.

        #   Example: <tt>acts_as_list :scope => 'todo_list_id = #{todo_list_id} AND completed = 0'</tt>

        def acts_as_list(options = {})

          configuration = { :column => "position", :scope => "1 = 1" }

          configuration.update(options) if options.is_a?(Hash)

          configuration[:scope] = "#{configuration[:scope]}_id".intern if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/

          if configuration[:scope].is_a?(Symbol)

            scope_condition_method = %(

              def scope_condition

                if #{configuration[:scope].to_s}.nil?

                  "#{configuration[:scope].to_s} IS NULL"

                else

                  "#{configuration[:scope].to_s} = \#{#{configuration[:scope].to_s}}"

                end

              end

            )

          else

            scope_condition_method = "def scope_condition() \"#{configuration[:scope]}\" end"

          end

          class_eval <<-EOV

            include ActiveRecord::Acts::List::InstanceMethods

            def acts_as_list_class

              ::#{self.name}

            end

            def position_column

              '#{configuration[:column]}'

            end

            #{scope_condition_method}

            before_destroy :remove_from_list

            before_create  :add_to_list_bottom

          EOV

        end

      end

      # All the methods available to a record that has had <tt>acts_as_list</tt> specified. Each method works

      # by assuming the object to be the item in the list, so <tt>chapter.move_lower</tt> would move that chapter

      # lower in the list of all chapters. Likewise, <tt>chapter.first?</tt> would return +true+ if that chapter is

      # the first in the list of all chapters.

      module InstanceMethods

        # Insert the item at the given position (defaults to the top position of 1).

        def insert_at(position = 1)

          insert_at_position(position)

        end

        # Swap positions with the next lower item, if one exists.

        def move_lower

          return unless lower_item

          acts_as_list_class.transaction do

            lower_item.decrement_position

            increment_position

          end

        end

        # Swap positions with the next higher item, if one exists.

        def move_higher

          return unless higher_item

          acts_as_list_class.transaction do

            higher_item.increment_position

            decrement_position

          end

        end

        # Move to the bottom of the list. If the item is already in the list, the items below it have their

        # position adjusted accordingly.

        def move_to_bottom

          return unless in_list?

          acts_as_list_class.transaction do

            decrement_positions_on_lower_items

            assume_bottom_position

          end

        end

        # Move to the top of the list. If the item is already in the list, the items above it have their

        # position adjusted accordingly.

        def move_to_top

          return unless in_list?

          acts_as_list_class.transaction do

            increment_positions_on_higher_items

            assume_top_position

          end

        end

        # Move to the given position

        def move_to=(pos)

          case pos.to_s

          when 'highest'

            move_to_top

          when 'higher'

            move_higher

          when 'lower'

            move_lower

          when 'lowest'

            move_to_bottom

          end

        end

        # Removes the item from the list.

        def remove_from_list

          if in_list?

            decrement_positions_on_lower_items

            update_attribute position_column, nil

          end

        end

        # Increase the position of this item without adjusting the rest of the list.

        def increment_position

          return unless in_list?

          update_attribute position_column, self.send(position_column).to_i + 1

        end

        # Decrease the position of this item without adjusting the rest of the list.

        def decrement_position

          return unless in_list?

          update_attribute position_column, self.send(position_column).to_i - 1

        end

        # Return +true+ if this object is the first in the list.

        def first?

          return false unless in_list?

          self.send(position_column) == 1

        end

        # Return +true+ if this object is the last in the list.

        def last?

          return false unless in_list?

          self.send(position_column) == bottom_position_in_list

        end

        # Return the next higher item in the list.

        def higher_item

          return nil unless in_list?

          acts_as_list_class.find(:first, :conditions =>

            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}"

          )

        end

        # Return the next lower item in the list.

        def lower_item

          return nil unless in_list?

          acts_as_list_class.find(:first, :conditions =>

            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}"

          )

        end

        # Test if this record is in a list

        def in_list?

          !send(position_column).nil?

        end

        private

          def add_to_list_top

            increment_positions_on_all_items

          end

          def add_to_list_bottom

            self[position_column] = bottom_position_in_list.to_i + 1

          end

          # Overwrite this method to define the scope of the list changes

          def scope_condition() "1" end

          # Returns the bottom position number in the list.

          #   bottom_position_in_list    # => 2

          def bottom_position_in_list(except = nil)

            item = bottom_item(except)

            item ? item.send(position_column) : 0

          end

          # Returns the bottom item

          def bottom_item(except = nil)

            conditions = scope_condition

            conditions = "#{conditions} AND #{self.class.primary_key} != #{except.id}" if except

            acts_as_list_class.find(:first, :conditions => conditions, :order => "#{position_column} DESC")

          end

          # Forces item to assume the bottom position in the list.

          def assume_bottom_position

            update_attribute(position_column, bottom_position_in_list(self).to_i + 1)

          end

          # Forces item to assume the top position in the list.

          def assume_top_position

            update_attribute(position_column, 1)

          end

          # This has the effect of moving all the higher items up one.

          def decrement_positions_on_higher_items(position)

            acts_as_list_class.update_all(

              "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} <= #{position}"

            )

          end

          # This has the effect of moving all the lower items up one.

          def decrement_positions_on_lower_items

            return unless in_list?

            acts_as_list_class.update_all(

              "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}"

            )

          end

          # This has the effect of moving all the higher items down one.

          def increment_positions_on_higher_items

            return unless in_list?

            acts_as_list_class.update_all(

              "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}"

            )

          end

          # This has the effect of moving all the lower items down one.

          def increment_positions_on_lower_items(position)

            acts_as_list_class.update_all(

              "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} >= #{position}"

           )

          end

          # Increments position (<tt>position_column</tt>) of all items in the list.

          def increment_positions_on_all_items

            acts_as_list_class.update_all(

              "#{position_column} = (#{position_column} + 1)",  "#{scope_condition}"

            )

          end

          def insert_at_position(position)

            remove_from_list

            increment_positions_on_lower_items(position)

            self.update_attribute(position_column, position)

          end

      end 

    end

  end

end

require 'test/unit'

require 'rubygems'

gem 'activerecord', '>= 1.15.4.7794'

require 'active_record'

require "#{File.dirname(__FILE__)}/../init"

ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")

def setup_db

  ActiveRecord::Schema.define(:version => 1) do

    create_table :mixins do |t|

      t.column :pos, :integer

      t.column :parent_id, :integer

      t.column :created_at, :datetime      

      t.column :updated_at, :datetime

    end

  end

end

def teardown_db

  ActiveRecord::Base.connection.tables.each do |table|

    ActiveRecord::Base.connection.drop_table(table)

  end

end

class Mixin < ActiveRecord::Base

end

class ListMixin < Mixin

  acts_as_list :column => "pos", :scope => :parent

  def self.table_name() "mixins" end

end

class ListMixinSub1 < ListMixin

end

class ListMixinSub2 < ListMixin

end

class ListWithStringScopeMixin < ActiveRecord::Base

  acts_as_list :column => "pos", :scope => 'parent_id = #{parent_id}'

  def self.table_name() "mixins" end

end

class ListTest < Test::Unit::TestCase

  def setup

    setup_db

    (1..4).each { |counter| ListMixin.create! :pos => counter, :parent_id => 5 }

  end

  def teardown

    teardown_db

  end

  def test_reordering

    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    ListMixin.find(2).move_lower

    assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    ListMixin.find(2).move_higher

    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    ListMixin.find(1).move_to_bottom

    assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    ListMixin.find(1).move_to_top

    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    ListMixin.find(2).move_to_bottom

    assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    ListMixin.find(4).move_to_top

    assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

  end

  def test_move_to_bottom_with_next_to_last_item

    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    ListMixin.find(3).move_to_bottom

    assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

  end

  def test_next_prev

    assert_equal ListMixin.find(2), ListMixin.find(1).lower_item

    assert_nil ListMixin.find(1).higher_item

    assert_equal ListMixin.find(3), ListMixin.find(4).higher_item

    assert_nil ListMixin.find(4).lower_item

  end

  def test_injection

    item = ListMixin.new(:parent_id => 1)

    assert_equal "parent_id = 1", item.scope_condition

    assert_equal "pos", item.position_column

  end

  def test_insert

    new = ListMixin.create(:parent_id => 20)

    assert_equal 1, new.pos

    assert new.first?

    assert new.last?

    new = ListMixin.create(:parent_id => 20)

    assert_equal 2, new.pos

    assert !new.first?

    assert new.last?

    new = ListMixin.create(:parent_id => 20)

    assert_equal 3, new.pos

    assert !new.first?

    assert new.last?

    new = ListMixin.create(:parent_id => 0)

    assert_equal 1, new.pos

    assert new.first?

    assert new.last?

  end

  def test_insert_at

    new = ListMixin.create(:parent_id => 20)

    assert_equal 1, new.pos

    new = ListMixin.create(:parent_id => 20)

    assert_equal 2, new.pos

    new = ListMixin.create(:parent_id => 20)

    assert_equal 3, new.pos

    new4 = ListMixin.create(:parent_id => 20)

    assert_equal 4, new4.pos

    new4.insert_at(3)

    assert_equal 3, new4.pos

    new.reload

    assert_equal 4, new.pos

    new.insert_at(2)

    assert_equal 2, new.pos

    new4.reload

    assert_equal 4, new4.pos

    new5 = ListMixin.create(:parent_id => 20)

    assert_equal 5, new5.pos

    new5.insert_at(1)

    assert_equal 1, new5.pos

    new4.reload

    assert_equal 5, new4.pos

  end

  def test_delete_middle

    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    ListMixin.find(2).destroy

    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    assert_equal 1, ListMixin.find(1).pos

    assert_equal 2, ListMixin.find(3).pos

    assert_equal 3, ListMixin.find(4).pos

    ListMixin.find(1).destroy

    assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    assert_equal 1, ListMixin.find(3).pos

    assert_equal 2, ListMixin.find(4).pos

  end

  def test_with_string_based_scope

    new = ListWithStringScopeMixin.create(:parent_id => 500)

    assert_equal 1, new.pos

    assert new.first?

    assert new.last?

  end

  def test_nil_scope

    new1, new2, new3 = ListMixin.create, ListMixin.create, ListMixin.create

    new2.move_higher

    assert_equal [new2, new1, new3], ListMixin.find(:all, :conditions => 'parent_id IS NULL', :order => 'pos')

  end

  def test_remove_from_list_should_then_fail_in_list? 

    assert_equal true, ListMixin.find(1).in_list?

    ListMixin.find(1).remove_from_list

    assert_equal false, ListMixin.find(1).in_list?

  end 

  def test_remove_from_list_should_set_position_to_nil 

    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    ListMixin.find(2).remove_from_list 

    assert_equal [2, 1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    assert_equal 1,   ListMixin.find(1).pos

    assert_equal nil, ListMixin.find(2).pos

    assert_equal 2,   ListMixin.find(3).pos

    assert_equal 3,   ListMixin.find(4).pos

  end 

  def test_remove_before_destroy_does_not_shift_lower_items_twice 

    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    ListMixin.find(2).remove_from_list 

    ListMixin.find(2).destroy 

    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5', :order => 'pos').map(&:id)

    assert_equal 1, ListMixin.find(1).pos

    assert_equal 2, ListMixin.find(3).pos

    assert_equal 3, ListMixin.find(4).pos

  end 

end

class ListSubTest < Test::Unit::TestCase

  def setup

    setup_db

    (1..4).each { |i| ((i % 2 == 1) ? ListMixinSub1 : ListMixinSub2).create! :pos => i, :parent_id => 5000 }

  end

  def teardown

    teardown_db

  end

  def test_reordering

    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)

    ListMixin.find(2).move_lower

    assert_equal [1, 3, 2, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)

    ListMixin.find(2).move_higher

    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)

    ListMixin.find(1).move_to_bottom

    assert_equal [2, 3, 4, 1], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)

    ListMixin.find(1).move_to_top

    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)

    ListMixin.find(2).move_to_bottom

    assert_equal [1, 3, 4, 2], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)

    ListMixin.find(4).move_to_top

    assert_equal [4, 1, 3, 2], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)

  end

  def test_move_to_bottom_with_next_to_last_item

    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)

    ListMixin.find(3).move_to_bottom

    assert_equal [1, 2, 4, 3], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)

  end

  def test_next_prev

    assert_equal ListMixin.find(2), ListMixin.find(1).lower_item

    assert_nil ListMixin.find(1).higher_item

    assert_equal ListMixin.find(3), ListMixin.find(4).higher_item

    assert_nil ListMixin.find(4).lower_item

  end

  def test_injection

    item = ListMixin.new("parent_id"=>1)

    assert_equal "parent_id = 1", item.scope_condition

    assert_equal "pos", item.position_column

  end

  def test_insert_at

    new = ListMixin.create("parent_id" => 20)

    assert_equal 1, new.pos

    new = ListMixinSub1.create("parent_id" => 20)

    assert_equal 2, new.pos

    new = ListMixinSub2.create("parent_id" => 20)

    assert_equal 3, new.pos

    new4 = ListMixin.create("parent_id" => 20)

    assert_equal 4, new4.pos

    new4.insert_at(3)

    assert_equal 3, new4.pos

    new.reload

    assert_equal 4, new.pos

    new.insert_at(2)

    assert_equal 2, new.pos

    new4.reload

    assert_equal 4, new4.pos

    new5 = ListMixinSub1.create("parent_id" => 20)

    assert_equal 5, new5.pos

    new5.insert_at(1)

    assert_equal 1, new5.pos

    new4.reload

    assert_equal 5, new4.pos

  end

  def test_delete_middle

    assert_equal [1, 2, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)

    ListMixin.find(2).destroy

    assert_equal [1, 3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)

    assert_equal 1, ListMixin.find(1).pos

    assert_equal 2, ListMixin.find(3).pos

    assert_equal 3, ListMixin.find(4).pos

    ListMixin.find(1).destroy

    assert_equal [3, 4], ListMixin.find(:all, :conditions => 'parent_id = 5000', :order => 'pos').map(&:id)

    assert_equal 1, ListMixin.find(3).pos

    assert_equal 2, ListMixin.find(4).pos

  end

end

require File.dirname(__FILE__) + '/lib/acts_as_searchable'

ActiveRecord::Base.send(:include, Redmine::Acts::Searchable)

# Redmine - project management software

# Copyright (C) 2006-2012  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 Redmine

  module Acts

    module Searchable

      def self.included(base)

        base.extend ClassMethods

      end

      module ClassMethods

        # Options:

        # * :columns - a column or an array of columns to search

        # * :project_key - project foreign key (default to project_id)

        # * :date_column - name of the datetime column (default to created_on)

        # * :sort_order - name of the column used to sort results (default to :date_column or created_on)

        # * :permission - permission required to search the model (default to :view_"objects")

        def acts_as_searchable(options = {})

          return if self.included_modules.include?(Redmine::Acts::Searchable::InstanceMethods)

          cattr_accessor :searchable_options

          self.searchable_options = options

          if searchable_options[:columns].nil?

            raise 'No searchable column defined.'

          elsif !searchable_options[:columns].is_a?(Array)

            searchable_options[:columns] = [] << searchable_options[:columns]

          end

          searchable_options[:project_key] ||= "#{table_name}.project_id"

          searchable_options[:date_column] ||= "#{table_name}.created_on"

          searchable_options[:order_column] ||= searchable_options[:date_column]

          # Should we search custom fields on this model ?

          searchable_options[:search_custom_fields] = !reflect_on_association(:custom_values).nil?

          send :include, Redmine::Acts::Searchable::InstanceMethods

        end

      end

      module InstanceMethods

        def self.included(base)

          base.extend ClassMethods

        end

        module ClassMethods

          # Searches the model for the given tokens

          # projects argument can be either nil (will search all projects), a project or an array of projects

          # Returns the results and the results count

          def search(tokens, projects=nil, options={})

            if projects.is_a?(Array) && projects.empty?

              # no results

              return [[], 0]

            end

            # TODO: make user an argument

            user = User.current

            tokens = [] << tokens unless tokens.is_a?(Array)

            projects = [] << projects unless projects.nil? || projects.is_a?(Array)

            find_options = {:include => searchable_options[:include]}

            find_options[:order] = "#{searchable_options[:order_column]} " + (options[:before] ? 'DESC' : 'ASC')

            limit_options = {}

            limit_options[:limit] = options[:limit] if options[:limit]

            if options[:offset]

              limit_options[:conditions] = "(#{searchable_options[:date_column]} " + (options[:before] ? '<' : '>') + "'#{connection.quoted_date(options[:offset])}')"

            end

            columns = searchable_options[:columns]

            columns = columns[0..0] if options[:titles_only]

            token_clauses = columns.collect {|column| "(LOWER(#{column}) LIKE ?)"}

            if !options[:titles_only] && searchable_options[:search_custom_fields]

              searchable_custom_field_ids = CustomField.find(:all,

                                                             :select => 'id',

                                                             :conditions => { :type => "#{self.name}CustomField",

                                                                              :searchable => true }).collect(&:id)

              if searchable_custom_field_ids.any?

                custom_field_sql = "#{table_name}.id IN (SELECT customized_id FROM #{CustomValue.table_name}" +

                  " WHERE customized_type='#{self.name}' AND customized_id=#{table_name}.id AND LOWER(value) LIKE ?" +

                  " AND #{CustomValue.table_name}.custom_field_id IN (#{searchable_custom_field_ids.join(',')}))"

                token_clauses << custom_field_sql

              end

            end

            sql = (['(' + token_clauses.join(' OR ') + ')'] * tokens.size).join(options[:all_words] ? ' AND ' : ' OR ')

            find_options[:conditions] = [sql, * (tokens.collect {|w| "%#{w.downcase}%"} * token_clauses.size).sort]

            scope = self

            project_conditions = []

            if searchable_options.has_key?(:permission)

              project_conditions << Project.allowed_to_condition(user, searchable_options[:permission] || :view_project)

            elsif respond_to?(:visible)

              scope = scope.visible(user)

            else

              ActiveSupport::Deprecation.warn "acts_as_searchable with implicit :permission option is deprecated. Add a visible scope to the #{self.name} model or use explicit :permission option."

              project_conditions << Project.allowed_to_condition(user, "view_#{self.name.underscore.pluralize}".to_sym)

            end

            # TODO: use visible scope options instead

            project_conditions << "#{searchable_options[:project_key]} IN (#{projects.collect(&:id).join(',')})" unless projects.nil?

            project_conditions = project_conditions.empty? ? nil : project_conditions.join(' AND ')

            results = []

            results_count = 0

            scope = scope.scoped({:conditions => project_conditions}).scoped(find_options)

            results_count = scope.count(:all)

            results = scope.find(:all, limit_options)

            [results, results_count]

          end

        end

      end

    end

  end

end

acts_as_tree

============

Specify this +acts_as+ extension if you want to model a tree structure by providing a parent association and a children

association. This requires that you have a foreign key column, which by default is called +parent_id+.

  class Category < ActiveRecord::Base

    acts_as_tree :order => "name"

  end

  Example:

  root

   \_ child1

        \_ subchild1

        \_ subchild2

  root      = Category.create("name" => "root")

  child1    = root.children.create("name" => "child1")

  subchild1 = child1.children.create("name" => "subchild1")

  root.parent   # => nil

  child1.parent # => root

  root.children # => [child1]

  root.children.first.children.first # => subchild1

Copyright (c) 2007 David Heinemeier Hansson, released under the MIT license  

require 'rake'

require 'rake/testtask'

require 'rake/rdoctask'

desc 'Default: run unit tests.'

task :default => :test

desc 'Test acts_as_tree plugin.'

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

  t.libs << 'lib'

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

  t.verbose = true

end

desc 'Generate documentation for acts_as_tree plugin.'

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

  rdoc.rdoc_dir = 'rdoc'

  rdoc.title    = 'acts_as_tree'

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

  rdoc.rdoc_files.include('README')

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

end

ActiveRecord::Base.send :include, ActiveRecord::Acts::Tree

module ActiveRecord