jro_apps/redmine Commit - r12870:9ea1ae48dbed

awesome_nested_set: import git 2-1-stable branch revision (#6579)...

Toshi MARUYAMA -

r12870:9ea1ae48dbed

parent child

Context file:

r12870:9ea1ae48dbed

Collapse all files

lib/plugins/awesome_nested_set/lib/awesome_nested_set/columns.rb +4 0

             # Mixed into both classes and instances to provide easy access to the column names
             module CollectiveIdea #:nodoc:
               module Acts #:nodoc:
                 module NestedSet #:nodoc:
                   module Columns
                     def left_column_name
                       acts_as_nested_set_options[:left_column]
                     end
                     def right_column_name
                       acts_as_nested_set_options[:right_column]
                     end
                     def depth_column_name
                       acts_as_nested_set_options[:depth_column]
                     end
                     def parent_column_name
                       acts_as_nested_set_options[:parent_column]
                     end
                     def order_column
                       acts_as_nested_set_options[:order_column] || left_column_name
                     end
                     def scope_column_names
                       Array(acts_as_nested_set_options[:scope])
                     end
                     def quoted_left_column_name
                       connection.quote_column_name(left_column_name)
                     end
                     def quoted_right_column_name
                       connection.quote_column_name(right_column_name)
                     end
                     def quoted_depth_column_name
                       connection.quote_column_name(depth_column_name)
                     end
                     def quoted_parent_column_name
                       connection.quote_column_name(parent_column_name)
                     end
                     def quoted_scope_column_names
                       scope_column_names.collect {|column_name| connection.quote_column_name(column_name) }
                     end
                     def quoted_order_column_name
                       connection.quote_column_name(order_column)
                     end
+                    def quoted_order_column_full_name
+                      "#{quoted_table_name}.#{quoted_order_column_name}"
+                    end
                     def quoted_left_column_full_name
                       "#{quoted_table_name}.#{quoted_left_column_name}"
                     end
                     def quoted_right_column_full_name
                       "#{quoted_table_name}.#{quoted_right_column_name}"
                     end
                     def quoted_parent_column_full_name
                       "#{quoted_table_name}.#{quoted_parent_column_name}"
                     end
                   end
                 end
               end
             end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/model.rb +1 -1

             require 'awesome_nested_set/model/prunable'
             require 'awesome_nested_set/model/movable'
             require 'awesome_nested_set/model/transactable'
             require 'awesome_nested_set/model/relatable'
             require 'awesome_nested_set/model/rebuildable'
             require 'awesome_nested_set/model/validatable'
             require 'awesome_nested_set/iterator'
             module CollectiveIdea #:nodoc:
               module Acts #:nodoc:
                 module NestedSet #:nodoc:
                   module Model
                     extend ActiveSupport::Concern
                     included do
                       delegate :quoted_table_name, :arel_table, :to => self
                       extend Validatable
                       extend Rebuildable
                       include Movable
                       include Prunable
                       include Relatable
                       include Transactable
                     end
                     module ClassMethods
                       def associate_parents(objects)
                         return objects unless objects.all? {|o| o.respond_to?(:association)}
                         id_indexed = objects.index_by(&:id)
                         objects.each do |object|
                           association = object.association(:parent)
                           parent = id_indexed[object.parent_id]
                           if !association.loaded? && parent
                             association.target = parent
                             association.set_inverse_instance(parent)
                           end
                         end
                       end
                       def children_of(parent_id)
                         where arel_table[parent_column_name].eq(parent_id)
                       end
                       # Iterates over tree elements and determines the current level in the tree.
                       # Only accepts default ordering, odering by an other column than lft
                       # does not work. This method is much more efficent than calling level
                       # because it doesn't require any additional database queries.
                       #
                       # Example:
                       #    Category.each_with_level(Category.root.self_and_descendants) do |o, level|
                       #
                       def each_with_level(objects, &block)
                         Iterator.new(objects).each_with_level(&block)
                       end
                       def leaves
                         nested_set_scope.where "#{quoted_right_column_full_name} - #{quoted_left_column_full_name} = 1"
                       end
                       def left_of(node)
                         where arel_table[left_column_name].lt(node)
                       end
                       def left_of_right_side(node)
                         where arel_table[right_column_name].lteq(node)
                       end
                       def right_of(node)
                         where arel_table[left_column_name].gteq(node)
                       end
                       def nested_set_scope(options = {})
-                        options = {:order => quoted_order_column_name}.merge(options)
+                        options = {:order => quoted_order_column_full_name}.merge(options)
                         order(options.delete(:order)).scoped options
                       end
                       def primary_key_scope(id)
                         where arel_table[primary_key].eq(id)
                       end
                       def root
                         roots.first
                       end
                       def roots
                         nested_set_scope.children_of nil
                       end
                     end # end class methods
                     # 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.
                     #
                     #   category.self_and_descendants.count
                     #   category.ancestors.find(:all, :conditions => "name like '%foo%'")
                     # Value of the parent column
                     def parent_id(target = self)
                       target[parent_column_name]
                     end
                     # Value of the left column
                     def left(target = self)
                       target[left_column_name]
                     end
                     # Value of the right column
                     def right(target = self)
                       target[right_column_name]
                     end
                     # Returns true if this is a root node.
                     def root?
                       parent_id.nil?
                     end
                     # Returns true is this is a child node
                     def child?
                       !root?
                     end
                     # Returns true if this is the end of a branch.
                     def leaf?
                       persisted? && right.to_i - left.to_i == 1
                     end
                     # All nested set queries should use this nested_set_scope, which
                     # performs finds on the base ActiveRecord class, using the :scope
                     # declared in the acts_as_nested_set declaration.
                     def nested_set_scope(options = {})
                       if (scopes = Array(acts_as_nested_set_options[:scope])).any?
                         options[:conditions] = scopes.inject({}) do |conditions,attr|
                           conditions.merge attr => self[attr]
                         end
                       end
                       self.class.nested_set_scope options
                     end
                     def to_text
                       self_and_descendants.map do |node|
                         "#{'*'*(node.level+1)} #{node.id} #{node.to_s} (#{node.parent_id}, #{node.left}, #{node.right})"
                       end.join("\n")
                     end
                     protected
                     def without_self(scope)
                       return scope if new_record?
                       scope.where(["#{self.class.quoted_table_name}.#{self.class.primary_key} != ?", self])
                     end
                     def store_new_parent
                       @move_to_new_parent_id = send("#{parent_column_name}_changed?") ? parent_id : false
                       true # force callback to return true
                     end
                     def has_depth_column?
                       nested_set_scope.column_names.map(&:to_s).include?(depth_column_name.to_s)
                     end
                     def right_most_node
                       @right_most_node ||= self.class.base_class.unscoped.nested_set_scope(
                         :order => "#{quoted_right_column_full_name} desc"
                       ).first
                     end
                     def right_most_bound
                       @right_most_bound ||= begin
                         return 0 if right_most_node.nil?
                         right_most_node.lock!
                         right_most_node[right_column_name] || 0
                       end
                     end
                     def set_depth!
                       return unless has_depth_column?
                       in_tenacious_transaction do
                         reload
                         nested_set_scope.primary_key_scope(id).
                           update_all(["#{quoted_depth_column_name} = ?", level])
                       end
                       self[depth_column_name] = self.level
                     end
                     def set_default_left_and_right
                       # adds the new node to the right of all existing nodes
                       self[left_column_name] = right_most_bound + 1
                       self[right_column_name] = right_most_bound + 2
                     end
                     # reload left, right, and parent
                     def reload_nested_set
                       reload(
                         :select => "#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, #{quoted_parent_column_full_name}",
                         :lock => true
                       )
                     end
                     def reload_target(target)
                       if target.is_a? self.class.base_class
                         target.reload
                       else
                         nested_set_scope.find(target)
                       end
                     end
                   end
                 end
               end
             end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/model/prunable.rb +3 0

             module CollectiveIdea #:nodoc:
               module Acts #:nodoc:
                 module NestedSet #:nodoc:
                   module Model
                     module Prunable
                       # Prunes a branch off of the tree, shifting all of the elements on the right
                       # back to the left so the counts still work.
                       def destroy_descendants
                         return if right.nil? || left.nil? || skip_before_destroy
                         in_tenacious_transaction do
                           reload_nested_set
                           # select the rows in the model that extend past the deletion point and apply a lock
                           nested_set_scope.right_of(left).select(id).lock(true)
                           destroy_or_delete_descendants
                           # update lefts and rights for remaining nodes
                           update_siblings_for_remaining_nodes
+                          # Reload is needed because children may have updated their parent (self) during deletion.
+                          reload
                           # Don't allow multiple calls to destroy to corrupt the set
                           self.skip_before_destroy = true
                         end
                       end
                       def destroy_or_delete_descendants
                         if acts_as_nested_set_options[:dependent] == :destroy
                           descendants.each do |model|
                             model.skip_before_destroy = true
                             model.destroy
                           end
                         else
                           descendants.delete_all
                         end
                       end
                       def update_siblings_for_remaining_nodes
                         update_siblings(:left)
                         update_siblings(:right)
                       end
                       def update_siblings(direction)
                         full_column_name = send("quoted_#{direction}_column_full_name")
                         column_name = send("quoted_#{direction}_column_name")
                         nested_set_scope.where(["#{full_column_name} > ?", right]).
                           update_all(["#{column_name} = (#{column_name} - ?)", diff])
                       end
                       def diff
                         right - left + 1
                       end
                     end
                   end
                 end
               end
             end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/model/validatable.rb +1 -1

             require 'awesome_nested_set/set_validator'
             module CollectiveIdea
               module Acts
                 module NestedSet
                   module Model
                     module Validatable
                       def valid?
                         left_and_rights_valid? && no_duplicates_for_columns? && all_roots_valid?
                       end
                       def left_and_rights_valid?
                         SetValidator.new(self).valid?
                       end
                       def no_duplicates_for_columns?
                         [quoted_left_column_full_name, quoted_right_column_full_name].all? do |column|
                           # No duplicates
-                          select("#{scope_string}#{column}, COUNT(#{column})").
+                          select("#{scope_string}#{column}, COUNT(#{column}) as _count").
                             group("#{scope_string}#{column}").
                             having("COUNT(#{column}) > 1").
                             first.nil?
                         end
                       end
                       # Wrapper for each_root_valid? that can deal with scope.
                       def all_roots_valid?
                         if acts_as_nested_set_options[:scope]
                           all_roots_valid_by_scope?(roots)
                         else
                           each_root_valid?(roots)
                         end
                       end
                       def all_roots_valid_by_scope?(roots_to_validate)
                         roots_grouped_by_scope(roots_to_validate).all? do |scope, grouped_roots|
                           each_root_valid?(grouped_roots)
                         end
                       end
                       def each_root_valid?(roots_to_validate)
                         left = right = 0
                         roots_to_validate.all? do |root|
                           (root.left > left && root.right > right).tap do
                             left = root.left
                             right = root.right
                           end
                         end
                       end
                       private
                       def roots_grouped_by_scope(roots_to_group)
                         roots_to_group.group_by {|record|
                           scope_column_names.collect {|col| record.send(col) }
                         }
                       end
                       def scope_string
                         Array(acts_as_nested_set_options[:scope]).map do |c|
                           connection.quote_column_name(c)
                         end.push(nil).join(", ")
                       end
                     end
                   end
                 end
               end
             end

lib/plugins/awesome_nested_set/lib/awesome_nested_set/move.rb +19 -6

             module CollectiveIdea #:nodoc:
               module Acts #:nodoc:
                 module NestedSet #:nodoc:
                   class Move
                     attr_reader :target, :position, :instance
                     def initialize(target, position, instance)
                       @target = target
                       @position = position
                       @instance = instance
                     end
                     def move
                       prevent_impossible_move
                       bound, other_bound = get_boundaries
                       # there would be no change
                       return if bound == right || bound == left
                       # we have defined the boundaries of two non-overlapping intervals,
                       # so sorting puts both the intervals and their boundaries in order
                       a, b, c, d = [left, right, bound, other_bound].sort
                       lock_nodes_between! a, d
-                      nested_set_scope.where(where_statement(a, d)).
+                      nested_set_scope.where(where_statement(a, d)).update_all(
-                                       update_all(conditions(a, b, c, d))
+                        conditions(a, b, c, d)
+                      )
                     end
                     private
                     delegate :left, :right, :left_column_name, :right_column_name,
                              :quoted_left_column_name, :quoted_right_column_name,
                              :quoted_parent_column_name, :parent_column_name, :nested_set_scope,
                              :to => :instance
                     delegate :arel_table, :class, :to => :instance, :prefix => true
                     delegate :base_class, :to => :instance_class, :prefix => :instance
                     def where_statement(left_bound, right_bound)
                       instance_arel_table[left_column_name].in(left_bound..right_bound).
                         or(instance_arel_table[right_column_name].in(left_bound..right_bound))
                     end
                     def conditions(a, b, c, d)
+                      _conditions = case_condition_for_direction(:quoted_left_column_name) +
+                                    case_condition_for_direction(:quoted_right_column_name) +
+                                    case_condition_for_parent
+                      # We want the record to be 'touched' if it timestamps.
+                      if @instance.respond_to?(:updated_at)
+                        _conditions << ", updated_at = :timestamp"
+                      end
                       [
-                       case_condition_for_direction(:quoted_left_column_name) +
+                        _conditions,
-                       case_condition_for_direction(:quoted_right_column_name) +
-                       case_condition_for_parent,
+                          :a => a, :b => b, :c => c, :d => d,
-                       {:a => a, :b => b, :c => c, :d => d, :id => instance.id, :new_parent => new_parent}
+                          :id => instance.id,
+                          :new_parent => new_parent,
+                          :timestamp => Time.now.utc
+                        }
                       ]
                     end
                     def case_condition_for_direction(column_name)
                       column = send(column_name)
                       "#{column} = CASE " +
                         "WHEN #{column} BETWEEN :a AND :b " +
                         "THEN #{column} + :d - :b " +
                         "WHEN #{column} BETWEEN :c AND :d " +
                         "THEN #{column} + :a - :c " +
                         "ELSE #{column} END, "
                     end
                     def case_condition_for_parent
                       "#{quoted_parent_column_name} = CASE " +
                         "WHEN #{instance_base_class.primary_key} = :id THEN :new_parent " +
                         "ELSE #{quoted_parent_column_name} END"
                     end
                     def lock_nodes_between!(left_bound, right_bound)
                       # select the rows in the model between a and d, and apply a lock
                       instance_base_class.right_of(left_bound).left_of_right_side(right_bound).
                                           select(:id).lock(true)
                     end
                     def root
                       position == :root
                     end
                     def new_parent
                       case position
                       when :child
                         target.id
                       else
                         target[parent_column_name]
                       end
                     end
                     def get_boundaries
                       if (bound = target_bound) > right
                         bound -= 1
                         other_bound = right + 1
                       else
                         other_bound = left - 1
                       end
                       [bound, other_bound]
                     end
                     def prevent_impossible_move
                       if !root && !instance.move_possible?(target)
                         raise ActiveRecord::ActiveRecordError, "Impossible move, target node cannot be inside moved tree."
                       end
                     end
                     def target_bound
                       case position
                       when :child;  right(target)
                       when :left;   left(target)
                       when :right;  right(target) + 1
                       else raise ActiveRecord::ActiveRecordError, "Position should be :child, :left, :right or :root ('#{position}' received)."
                       end
                     end
                   end
                 end
               end
             end

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