acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/lib/acts_as_ordered_tree/iterators/arranger.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+
+module ActsAsOrderedTree
+  module Iterators
+    # @api private
+    class Arranger
+      include Enumerable
+
+      delegate :each, :to => :arrange
+
+      def initialize(collection)
+        @collection = collection
+        @cache = Hash.new
+      end
+
+      def arrange
+        @collection.each_with_object(Hash.new) do |node, result|
+          @cache[node.id] ||= node
+
+          insertion_point = result
+
+          ancestors(node).each { |a| insertion_point = (insertion_point[a] ||= {}) }
+
+          insertion_point[node] = {}
+        end
+      end
+
+      private
+      def ancestors(node)
+        parent = @cache[node.ordered_tree_node.parent_id]
+        parent ? ancestors(parent) + [parent] : []
+      end
+    end # class Arranger
+  end # module Iterators
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/iterators/level_calculator.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+module ActsAsOrderedTree
+  module Iterators
+    # @api private
+    class LevelCalculator
+      include Enumerable
+
+      def initialize(collection)
+        @collection = collection
+        @level = nil # minimal nodes level (first item level)
+      end
+
+      def each(&block)
+        return to_enum unless block_given?
+
+        if @collection.klass.ordered_tree.columns.depth?
+          each_with_cached_level(&block)
+        else
+          each_without_cached_level(&block)
+        end
+      end
+
+      private
+      def each_with_cached_level
+        @collection.each { |node| yield node, node.level }
+      end
+
+      def each_without_cached_level
+        path = []
+
+        @collection.each do |node|
+          parent_id = node.ordered_tree_node.parent_id
+
+          @level ||= node.level
+          path << parent_id if path.empty?
+
+          if parent_id != path.last
+            # parent changed
+            if path.include?(parent_id) # ascend
+              path.pop while path.last != parent_id
+            else # descend
+              path << parent_id
+            end
+          end
+
+          yield node, @level + path.length - 1
+        end
+      end
+    end # class LevelCalculator
+  end
+end

data/lib/acts_as_ordered_tree/iterators/orphans_pruner.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+
+module ActsAsOrderedTree
+  module Iterators
+    # @api private
+    class OrphansPruner
+      include Enumerable
+
+      def initialize(collection)
+        @collection = collection
+        @cache = Hash.new
+        @level = nil # minimal node level
+      end
+
+      def each
+        return to_enum unless block_given?
+
+        prepare if @cache.empty?
+
+        @collection.each do |node|
+          if orphan?(node)
+            discard(node.id)
+          else
+            yield node
+          end
+        end
+      end
+
+      private
+      def orphan?(node)
+        !has_parent?(node) && node.level > @level
+      end
+
+      def has_parent?(node)
+        @cache.key?(node.ordered_tree_node.parent_id)
+      end
+
+      def prepare
+        @collection.each do |node|
+          @cache[node.id] = []
+
+          if has_parent?(node)
+            @cache[node.ordered_tree_node.parent_id] << node.id
+          else
+            @level = [@level, node.level].compact.min
+          end
+        end
+      end
+
+      def discard(id)
+        if @cache.key?(id)
+          @cache[id].each { |k| discard(k) }
+          @cache.delete(id)
+        end
+      end
+    end # class OrphansPruner
+  end # module Iterators
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/node.rb

@@ -0,0 +1,78 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/node/attributes'
+require 'acts_as_ordered_tree/node/movements'
+require 'acts_as_ordered_tree/node/predicates'
+require 'acts_as_ordered_tree/node/reloading'
+require 'acts_as_ordered_tree/node/siblings'
+require 'acts_as_ordered_tree/node/traversals'
+
+module ActsAsOrderedTree
+  # ActsAsOrderedTree::Node takes care of tree integrity when record is saved
+  # via usual ActiveRecord mechanism
+  class Node
+    include Attributes
+    include Movements
+    include Predicates
+    include Reloading
+    include Siblings
+    include Traversals
+
+    # @attr_reader [ActiveRecord::Base] original AR record, created, updated or destroyed
+    attr_reader :record
+
+    delegate :id, :parent, :children, :==, :to => :record
+
+    def initialize(record)
+      @record = record
+    end
+
+    # Returns scope to which record should be applied
+    def scope
+      if tree.columns.scope?
+        tree.base_class.where Hash[tree.columns.scope.map { |column| [column, record[column]] }]
+      else
+        tree.base_class.where(nil)
+      end
+    end
+
+    # Convert node to AR::Relation
+    #
+    # @return [ActiveRecord::Relation]
+    def to_relation
+      scope.where(tree.columns.id => id)
+    end
+
+    # @return [ActsAsOrderedTree::Tree]
+    def tree
+      record.class.ordered_tree
+    end
+
+    # Returns node level value (0 for root)
+    #
+    # @return [Fixnum]
+    def level
+      case
+        when root? then 0
+        when depth_column_could_be_used? then depth
+        when parent_association_loaded? then parent.level + 1
+        # @todo move it adapters
+        else ancestors.size
+      end
+    end
+
+    private
+    # @return [Arel::Table]
+    def table
+      record.class.arel_table
+    end
+
+    def depth_column_could_be_used?
+      tree.columns.depth? && record.persisted? && !parent_id_changed? && depth?
+    end
+
+    def parent_association_loaded?
+      record.association(:parent).loaded?
+    end
+  end # class Node
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/node/attributes.rb

@@ -0,0 +1,48 @@
+# coding: utf-8
+
+require 'active_support/concern'
+
+module ActsAsOrderedTree
+  class Node
+    # This module when included creates accessor to record's attributes that related to tree structure
+    #
+    # @example
+    #   class Node
+    #     include Attributes
+    #   end
+    #
+    #   node = Node.new(record)
+    #   node.parent_id # => record.parent_id
+    #   node.position # => record.position
+    #   node.position_was # => record.position_was
+    #   # etc.
+    module Attributes
+      extend ActiveSupport::Concern
+
+      METHODS = ['', '?',  ?=, '_was', '_changed?', %w(reset_ !)].freeze
+
+      included do
+        dynamic_attribute_accessor :position
+        dynamic_attribute_accessor :parent_id, :parent
+        dynamic_attribute_accessor :depth
+        dynamic_attribute_accessor :counter_cache
+      end
+
+      module ClassMethods
+        # Generates methods based on configurable record attributes
+        #
+        # @api private
+        def dynamic_attribute_accessor(name, column_name_accessor = name)
+          METHODS.each do |prefix, suffix|
+            prefix, suffix = suffix, prefix unless suffix
+            method_name = "#{prefix}#{name}#{suffix}"
+
+            define_method method_name do |*args|
+              record.send "#{prefix}#{tree.columns[column_name_accessor]}#{suffix}", *args
+            end
+          end
+        end
+      end # module ClassMethods
+    end # module Attributes
+  end # class Node
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/node/movement.rb

@@ -0,0 +1,62 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/persevering_transaction'
+
+module ActsAsOrderedTree
+  class Node
+    # @api private
+    class Movement
+      attr_reader :node, :options
+
+      delegate :record, :position, :position=, :to => :node
+
+      def initialize(node, target = nil, options = {}, &block)
+        @node, @options, @block = node, options, block
+        @_target = target
+      end
+
+      def parent=(id_or_record)
+        if id_or_record.is_a?(ActiveRecord::Base)
+          record.parent = id_or_record
+        else
+          node.parent_id = id_or_record
+        end
+      end
+
+      def start
+        transaction do
+          record.reload
+
+          @block[self] if @block
+
+          record.save
+        end
+      end
+
+      def target
+        return @target if defined?(@target)
+
+        # load target
+        @target = case @_target
+                    when ActiveRecord::Base, nil
+                      @_target.lock!
+                    when nil
+                      nil
+                    else
+                      scope = node.scope.lock
+
+                      if options.fetch(:strict, false)
+                        scope.find(@_target)
+                      else
+                        scope.where(:id => @_target).first
+                      end
+                  end.try(:ordered_tree_node)
+      end
+
+      private
+      def transaction(&block)
+        PerseveringTransaction.new(record.class.connection).start(&block)
+      end
+    end # class Movement
+  end # class Node
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/node/movements.rb

@@ -0,0 +1,111 @@
+# coding: utf-8
+
+require 'active_support/core_ext/module/aliasing'
+
+require 'acts_as_ordered_tree/node/movement'
+
+module ActsAsOrderedTree
+  class Node
+    # This module provides node with movement functionality
+    #
+    # Methods:
+    # * move_to_root
+    # * move_left (move_higher)
+    # * move_right (move_lower)
+    # * move_to_left_of (move_to_above_of)
+    # * move_to_right_of (move_to_bottom_of)
+    # * move_to_child_of
+    # * move_to_child_with_index
+    # * move_to_child_with_position
+    module Movements
+      # Transform node into root node
+      def move_to_root
+        movement do |to|
+          to.position = record.root? ? position : nil
+          to.parent = nil
+        end
+      end
+
+      # Swap node with higher sibling
+      def move_higher
+        movement { self.position -= 1 }
+      end
+      alias_method :move_left, :move_higher
+
+      # Swap node with lower sibling
+      def move_lower
+        movement { self.position += 1 }
+      end
+      alias_method :move_right, :move_lower
+
+      # Move node to above(left) of another node
+      #
+      # @param [ActiveRecord::Base, #to_i] node may be another record of ID
+      def move_to_above_of(node)
+        movement(node, :strict => true) do |to|
+          self.right_sibling = to.target.record
+        end
+      end
+      alias_method :move_to_left_of, :move_to_above_of
+
+      # Move node to bottom (right) of another node
+      #
+      # @param [ActiveRecord::Base, #to_i] node may be another record of ID
+      def move_to_bottom_of(node)
+        movement(node, :strict => true) do |to|
+          self.left_sibling = to.target.record
+        end
+      end
+      alias_method :move_to_right_of, :move_to_bottom_of
+
+      # Move node to child of another node
+      #
+      # @param [ActiveRecord::Base, #to_i] node may be another record of ID
+      def move_to_child_of(node)
+        if node
+          movement(node) do |to|
+            to.parent = node
+            to.position = nil if parent_id_changed?
+          end
+        else
+          move_to_root
+        end
+      end
+
+      # Move node to child of another node with specified index (which may be negative)
+      #
+      # @param [ActiveRecord::Base, Fixnum] node
+      # @param [#to_i] index
+      def move_to_child_with_index(node, index)
+        index = index.to_i
+
+        if index >= 0
+          move_to_child_with_position node, index + 1
+        elsif node
+          movement(node, :strict => true) do |to|
+            to.parent = node
+            to.position = to.target.children.size + index + 1
+          end
+        else
+          move_to_child_with_position nil, scope.roots.size + index + 1
+        end
+      end
+
+      # Move node to child of another node with specified position
+      #
+      # @param [ActiveRecord::Base, Fixnum] node
+      # @param [Integer, nil] position
+      def move_to_child_with_position(node, position)
+        movement(node) do |to|
+          to.parent = node
+          to.position = position
+        end
+      end
+
+      private
+      def movement(target = nil, options = {}, &block)
+        Movement.new(self, target, options, &block).start
+      end
+    end # module Movements
+  end # class Node
+end # module ActsAsOrderedTree