awesome_nested_set 2.1.6 → 3.0.0.rc.1

data/lib/awesome_nested_set/columns.rb

@@ -0,0 +1,72 @@
+# 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
+          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_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}.#{ActiveRecord::Base.connection.quote_column_name('id')}"
+        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

@@ -38,51 +38,6 @@ module CollectiveIdea #:nodoc:
           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.rb

@@ -0,0 +1,212 @@
+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)
+
+            where(options[:conditions]).order(options.delete(:order))
+          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

data/lib/awesome_nested_set/model/movable.rb

@@ -0,0 +1,137 @@
+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 left 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
+              move_to_left_of(node.children[index])
+            end
+          end
+
+          # Move the node to root nodes
+          def move_to_root
+            move_to_right_of(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)
+                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!
+            self.descendants.each(&:save)
+            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