awesome_nested_set 2.1.6 → 3.0.0.rc.6

data/lib/awesome_nested_set/columns.rb

@@ -0,0 +1,84 @@
+# 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 primary_column_name
+          acts_as_nested_set_options[:primary_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
+          ActiveRecord::Base.connection.quote_column_name(left_column_name)
+        end
+
+        def quoted_right_column_name
+          ActiveRecord::Base.connection.quote_column_name(right_column_name)
+        end
+
+        def quoted_depth_column_name
+          ActiveRecord::Base.connection.quote_column_name(depth_column_name)
+        end
+
+        def quoted_primary_column_name
+          ActiveRecord::Base.connection.quote_column_name(primary_column_name)
+        end
+
+        def quoted_parent_column_name
+          ActiveRecord::Base.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
+          ActiveRecord::Base.connection.quote_column_name(order_column)
+        end
+
+        def quoted_primary_key_column_full_name
+          "#{quoted_table_name}.#{quoted_primary_column_name}"
+        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

data/lib/awesome_nested_set/helper.rb

@@ -25,64 +25,19 @@ module CollectiveIdea #:nodoc:
           if class_or_item.is_a? Array
             items = class_or_item.reject { |e| !e.root? }
           else
-            class_or_item = class_or_item.roots if class_or_item.respond_to?(:scoped)
+            class_or_item = class_or_item.roots if class_or_item.respond_to?(:scope)
             items = Array(class_or_item)
           end
           result = []
           items.each do |root|
             result += root.class.associate_parents(root.self_and_descendants).map do |i|
               if mover.nil? || mover.new_record? || mover.move_possible?(i)
-                [yield(i), i.id]
+                [yield(i), i.primary_id]
               end
             end.compact
           end
           result
         end
-        
-        # Returns options for select as nested_set_options, sorted by an specific column
-        # It requires passing a string with the name of the column to sort the set with
-        # 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
-        #  * +:column+ - Column to sort the set (this will sort each children for all root elements)
-        #  * +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, :sort_by_this_column,  @category) {|i|
-        #       "#{'–' * i.level} #{i.name}"
-        #     }) %>
-        #
-        def sorted_nested_set_options(class_or_item, order, mover = nil)
-          if class_or_item.is_a? Array
-            items = class_or_item.reject { |e| !e.root? }
-          else
-            class_or_item = class_or_item.roots if class_or_item.is_a?(Class)
-            items = Array(class_or_item)
-          end
-          result = []
-          children = []
-          items.each do |root|
-            root.class.associate_parents(root.self_and_descendants).map do |i|
-              if mover.nil? || mover.new_record? || mover.move_possible?(i)
-                if !i.leaf?
-                  children.sort_by! &order
-                  children.each { |c| result << [yield(c), c.id] }
-                  children = []
-                  result << [yield(i), i.id]
-                else
-                  children << i
-                 end
-              end   
-            end.compact
-          end
-          children.sort_by! &order
-          children.each { |c| result << [yield(c), c.id] }
-          result
-        end
       end
     end
   end

data/lib/awesome_nested_set/iterator.rb

@@ -0,0 +1,29 @@
+module CollectiveIdea #:nodoc:
+  module Acts #:nodoc:
+    module NestedSet #:nodoc:
+      class Iterator
+        attr_reader :objects
+
+        def initialize(objects)
+          @objects = objects
+        end
+
+        def each_with_level
+          path = [nil]
+          objects.each do |o|
+            if o.parent_id != path.last
+              # we are on a new level, did we descend or ascend?
+              if path.include?(o.parent_id)
+                # remove wrong tailing paths elements
+                path.pop while path.last != o.parent_id
+              else
+                path << o.parent_id
+              end
+            end
+            yield(o, path.length - 1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/awesome_nested_set/model/movable.rb

@@ -0,0 +1,146 @@
+require 'awesome_nested_set/move'
+
+module CollectiveIdea #:nodoc:
+  module Acts #:nodoc:
+    module NestedSet #:nodoc:
+      module Model
+        module Movable
+
+          def move_possible?(target)
+            self != target && # Can't target self
+              same_scope?(target) && # can't be in different scopes
+              # detect impossible move
+              within_bounds?(target.left, target.left) &&
+              within_bounds?(target.right, target.right)
+          end
+
+          # Shorthand method for finding the left sibling and moving to the left of it.
+          def move_left
+            move_to_left_of left_sibling
+          end
+
+          # Shorthand method for finding the right sibling and moving to the right of it.
+          def move_right
+            move_to_right_of right_sibling
+          end
+
+          # Move the node to the left of another node
+          def move_to_left_of(node)
+            move_to node, :left
+          end
+
+          # Move the node to the right of another node
+          def move_to_right_of(node)
+            move_to node, :right
+          end
+
+          # Move the node to the child of another node
+          def move_to_child_of(node)
+            move_to node, :child
+          end
+
+          # Move the node to the child of another node with specify index
+          def move_to_child_with_index(node, index)
+            if node.children.empty?
+              move_to_child_of(node)
+            elsif node.children.count == index
+              move_to_right_of(node.children.last)
+            else
+              my_position = node.children.index(self)
+              if my_position && my_position < index
+                # e.g. if self is at position 0 and we want to move self to position 1 then self
+                # needs to move to the *right* of the node at position 1. That's because the node
+                # that is currently at position 1 will be at position 0 after the move completes.
+                move_to_right_of(node.children[index])
+              elsif my_position && my_position == index
+                # do nothing. already there.
+              else
+                move_to_left_of(node.children[index])
+              end
+            end
+          end
+
+          # Move the node to root nodes
+          def move_to_root
+            move_to self, :root
+          end
+
+          # Order children in a nested set by an attribute
+          # Can order by any attribute class that uses the Comparable mixin, for example a string or integer
+          # Usage example when sorting categories alphabetically: @new_category.move_to_ordered_child_of(@root, "name")
+          def move_to_ordered_child_of(parent, order_attribute, ascending = true)
+            self.move_to_root and return unless parent
+
+            left_neighbor = find_left_neighbor(parent, order_attribute, ascending)
+            self.move_to_child_of(parent)
+
+            return unless parent.children.many?
+
+            if left_neighbor
+              self.move_to_right_of(left_neighbor)
+            else # Self is the left most node.
+              self.move_to_left_of(parent.children[0])
+            end
+          end
+
+          # Find the node immediately to the left of this node.
+          def find_left_neighbor(parent, order_attribute, ascending)
+            left = nil
+            parent.children.each do |n|
+              if ascending
+                left = n if n.send(order_attribute) < self.send(order_attribute)
+              else
+                left = n if n.send(order_attribute) > self.send(order_attribute)
+              end
+            end
+            left
+          end
+
+          def move_to(target, position)
+            prevent_unpersisted_move
+
+            run_callbacks :move do
+              in_tenacious_transaction do
+                target = reload_target(target, position)
+                self.reload_nested_set
+
+                Move.new(target, position, self).move
+              end
+              after_move_to(target, position)
+            end
+          end
+
+          protected
+
+          def after_move_to(target, position)
+            target.reload_nested_set if target
+            self.set_depth_for_self_and_descendants!
+            self.reload_nested_set
+          end
+
+          def move_to_new_parent
+            if @move_to_new_parent_id.nil?
+              move_to_root
+            elsif @move_to_new_parent_id
+              move_to_child_of(@move_to_new_parent_id)
+            end
+          end
+
+          def out_of_bounds?(left_bound, right_bound)
+            left <= left_bound && right >= right_bound
+          end
+
+          def prevent_unpersisted_move
+            if self.new_record?
+              raise ActiveRecord::ActiveRecordError, "You cannot move a new node"
+            end
+          end
+
+          def within_bounds?(left_bound, right_bound)
+            !out_of_bounds?(left_bound, right_bound)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/awesome_nested_set/model/prunable.rb

@@ -0,0 +1,70 @@
+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(primary_id).lock(true)
+
+              return false unless 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
+            elsif acts_as_nested_set_options[:dependent] == :restrict_with_exception
+              raise ActiveRecord::DeleteRestrictionError.new(:children) unless leaf?
+            elsif acts_as_nested_set_options[:dependent] == :restrict_with_error
+              unless leaf?
+                record = self.class.human_attribute_name(:children).downcase
+                errors.add(:base, :"restrict_dependent_destroy.many", record: record)
+                return false
+              end
+              return true
+            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

data/lib/awesome_nested_set/model/rebuildable.rb

@@ -0,0 +1,42 @@
+require 'awesome_nested_set/tree'
+
+module CollectiveIdea
+  module Acts
+    module NestedSet
+      module Model
+        module Rebuildable
+
+
+          # Rebuilds the left & rights if unset or invalid.
+          # Also very useful for converting from acts_as_tree.
+          def rebuild!(validate_nodes = true)
+            # default_scope with order may break database queries so we do all operation without scope
+            unscoped do
+              Tree.new(self, validate_nodes).rebuild!
+            end
+          end
+
+          def scope_for_rebuild
+            scope = proc {}
+
+            if acts_as_nested_set_options[:scope]
+              scope = proc {|node|
+                scope_column_names.inject("") {|str, column_name|
+                  column_value = node.send(column_name)
+                  cond = column_value.nil? ? "IS NULL" : "= #{connection.quote(column_value)}"
+                  str << "AND #{connection.quote_column_name(column_name)} #{cond} "
+                }
+              }
+            end
+            scope
+          end
+
+          def order_for_rebuild
+            "#{quoted_left_column_full_name}, #{quoted_right_column_full_name}, #{primary_key}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/awesome_nested_set/model/relatable.rb

@@ -0,0 +1,121 @@
+module CollectiveIdea
+  module Acts
+    module NestedSet
+      module Model
+        module Relatable
+
+          # Returns an collection of all parents
+          def ancestors
+            without_self self_and_ancestors
+          end
+
+          # Returns the collection of all parents and self
+          def self_and_ancestors
+            nested_set_scope.
+              where(arel_table[left_column_name].lteq(left)).
+              where(arel_table[right_column_name].gteq(right))
+          end
+
+          # Returns the collection of all children of the parent, except self
+          def siblings
+            without_self self_and_siblings
+          end
+
+          # Returns the collection of all children of the parent, including self
+          def self_and_siblings
+            nested_set_scope.children_of parent_id
+          end
+
+          # Returns a set of all of its nested children which do not have children
+          def leaves
+            descendants.where(
+              "#{quoted_right_column_full_name} - #{quoted_left_column_full_name} = 1"
+            )
+          end
+
+          # Returns the level of this object in the tree
+          # root level is 0
+          def level
+            parent_id.nil? ? 0 : compute_level
+          end
+
+          # Returns a collection including all of its children and nested children
+          def descendants
+            without_self self_and_descendants
+          end
+
+          # Returns a collection including itself and all of its nested children
+          def self_and_descendants
+            # using _left_ for both sides here lets us benefit from an index on that column if one exists
+            nested_set_scope.right_of(left).left_of(right)
+          end
+
+          def is_descendant_of?(other)
+            within_node?(other, self) && same_scope?(other)
+          end
+
+          def is_or_is_descendant_of?(other)
+            (other == self || within_node?(other, self)) && same_scope?(other)
+          end
+
+          def is_ancestor_of?(other)
+            within_node?(self, other) && same_scope?(other)
+          end
+
+          def is_or_is_ancestor_of?(other)
+            (self == other || within_node?(self, other)) && same_scope?(other)
+          end
+
+          # Check if other model is in the same scope
+          def same_scope?(other)
+            Array(acts_as_nested_set_options[:scope]).all? do |attr|
+              self.send(attr) == other.send(attr)
+            end
+          end
+
+          # Find the first sibling to the left
+          def left_sibling
+            siblings.left_of(left).last
+          end
+
+          # Find the first sibling to the right
+          def right_sibling
+            siblings.right_of(left).first
+          end
+
+          def root
+            return self_and_ancestors.children_of(nil).first if persisted?
+
+            if parent_id && current_parent = nested_set_scope.where(primary_column_name => parent_id).first!
+              current_parent.root
+            else
+              self
+            end
+          end
+
+          protected
+
+          def compute_level
+            node, nesting = determine_depth
+
+            node == self ? ancestors.count : node.level + nesting
+          end
+
+          def determine_depth(node = self, nesting = 0)
+            while (association = node.association(:parent)).loaded? && association.target
+              nesting += 1
+              node = node.parent
+            end if node.respond_to?(:association)
+
+            [node, nesting]
+          end
+
+          def within_node?(node, within)
+            node.left < within.left && within.left < node.right
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/awesome_nested_set/model/transactable.rb

@@ -0,0 +1,27 @@
+module CollectiveIdea #:nodoc:
+  module Acts #:nodoc:
+    module NestedSet #:nodoc:
+      module Model
+        module Transactable
+
+          protected
+          def in_tenacious_transaction(&block)
+            retry_count = 0
+            begin
+              transaction(&block)
+            rescue ActiveRecord::StatementInvalid => error
+              raise unless self.class.connection.open_transactions.zero?
+              raise unless error.message =~ /[Dd]eadlock|Lock wait timeout exceeded/
+              raise unless retry_count < 10
+              retry_count += 1
+              logger.info "Deadlock detected on retry #{retry_count}, restarting transaction"
+              sleep(rand(retry_count)*0.1) # Aloha protocol
+              retry
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/awesome_nested_set/model/validatable.rb

@@ -0,0 +1,70 @@
+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}) as _count").
+                group("#{scope_string}#{column}", quoted_primary_key_column_full_name).
+                having("COUNT(#{column}) > 1").
+                order(quoted_primary_key_column_full_name).
+                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