acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/lib/acts_as_ordered_tree/node/predicates.rb

@@ -0,0 +1,98 @@
+# coding: utf-8
+
+module ActsAsOrderedTree
+  class Node
+    module Predicates
+      # Returns true if this is a root node.
+      def root?
+        !parent_id?
+      end
+
+      # Returns true if this is the end of a branch.
+      def leaf?
+        record.persisted? && if children.loaded? || tree.columns.counter_cache?
+                               # no SQL-queries here
+                               children.empty?
+                             else
+                               !children.exists?
+                             end
+      end
+
+      # Returns true if node contains any children.
+      def has_children?
+        !leaf?
+      end
+
+      # Returns true is node is not a root node.
+      def has_parent?
+        !root?
+      end
+
+      # Returns true if current node is descendant of +other+ node.
+      #
+      # @param [ActiveRecord::Base] other
+      def is_descendant_of?(other)
+        same_scope?(other) &&
+            ancestors.include?(other) &&
+            ancestors.all? { |x| x.ordered_tree_node.same_scope?(record) }
+      end
+
+      # Returns true if current node is equal to +other+ node or is descendant of +other+ node.
+      #
+      # @param [ActiveRecord::Base] other
+      def is_or_is_descendant_of?(other)
+        record == other || is_descendant_of?(other)
+      end
+
+      # Returns true if current node is ancestor of +other+ node.
+      #
+      # @param [ActiveRecord::Base] other
+      def is_ancestor_of?(other)
+        same_scope?(other) && other.is_descendant_of?(record)
+      end
+
+      # Returns true if current node is equal to +other+ node or is ancestor of +other+ node.
+      #
+      # @param [ActiveRecord::Base] other
+      def is_or_is_ancestor_of?(other)
+        same_scope?(other) && other.is_or_is_descendant_of?(record)
+      end
+
+      # Return +true+ if this object is the first in the list.
+      def first?
+        position <= 1
+      end
+
+      # Return +true+ if this object is the last in the list.
+      def last?
+        if tree.columns.counter_cache? && parent
+          parent.children.size == position
+        else
+          !right_sibling
+        end
+      end
+
+      # Check if other node is in the same scope.
+      #
+      # @api private
+      def same_scope?(other)
+        same_kind?(other) && tree.columns.scope.all? do |attr|
+          record[attr] == other[attr]
+        end
+      end
+
+      # Check if other node has the same parent
+      #
+      # @api private
+      def same_parent?(other)
+        same_scope?(other) && parent_id == other.ordered_tree_node.parent_id
+      end
+
+      private
+      # Check if other node belongs to same class hierarchy.
+      def same_kind?(other)
+        other.ordered_tree && other.ordered_tree.base_class == tree.base_class
+      end
+    end # module Predicates
+  end # class Node
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/node/reloading.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/compatibility'
+
+module ActsAsOrderedTree
+  class Node
+    module Reloading
+      Compatibility.version '< 4.0.0' do
+        # Reloads node's attributes related to tree structure
+        def reload(options = {})
+          record.reload(options.merge(:select => tree_columns))
+        end
+      end
+
+      Compatibility.version '>= 4.0.0' do
+        # Reloads node's attributes related to tree structure
+        def reload(options = {})
+          record.association_cache.delete(:parent)
+          record.association_cache.delete(:children)
+
+          fresh_object = reload_scope(options).find(record.id)
+
+          fresh_object.attributes.each_pair do |key, value|
+            record[key] = value
+          end
+
+          record.instance_eval do
+            # @attributes.update(fresh_object.instance_variable_get(:@attributes))
+            @attributes_cache = {}
+          end
+
+          record
+        end
+
+        private
+        def reload_scope(options)
+          options ||= {}
+          lock_value = options.fetch(:lock, false)
+          record.class.unscoped.select(tree_columns).lock(lock_value)
+        end
+      end
+
+      private
+      def tree_columns
+        tree.columns.to_a
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/node/siblings.rb

@@ -0,0 +1,139 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/node/predicates'
+
+module ActsAsOrderedTree
+  class Node
+    module Siblings
+      include Predicates
+
+      # Returns collection of all children of the parent, including self
+      #
+      # @return [ActiveRecord::Relation]
+      def self_and_siblings
+        scope.where( tree.columns.parent => parent_id ).preorder
+      end
+
+      # Returns collection of all children of the parent, except self
+      #
+      # @return [ActiveRecord::Relation]
+      def siblings
+        self_and_siblings.where( table[tree.columns.id].not_eq(id) )
+      end
+
+      # Returns siblings lying to the left of (upper than) current node.
+      #
+      # @return [ActiveRecord::Relation]
+      def left_siblings
+        siblings.where( table[tree.columns.position].lteq(position) )
+      end
+      alias :higher_items :left_siblings
+
+      # Returns a left (upper) sibling of node.
+      #
+      # @return [ActiveRecord::Base, nil]
+      def left_sibling
+        higher_items.last
+      end
+      alias :higher_item :left_sibling
+
+      # Set node new left (upper) sibling.
+      # Just changes node's parent_id and position attributes.
+      #
+      # @param [ActiveRecord::Base] node new left sibling
+      # @raise [ActiveRecord::AssociationTypeMismatch] if +node+ class does not
+      #   match current node class.
+      def left_sibling=(node)
+        return node if record == node
+
+        to = validate_sibling!(node)
+
+        self.position = higher_than?(node) ? to.position : to.position + 1
+        self.parent_id = to.parent_id
+
+        node
+      end
+      alias :higher_item= :left_sibling=
+
+      # Set node new left sibling by its ID.
+      # Changes node's parent_id and position.
+      #
+      # @param [Fixnum] id new left sibling ID
+      # @raise [ActiveRecord::RecordNotFound] if given +id+ was not found
+      def left_sibling_id=(id)
+        assign_sibling_by_id(id, :left)
+      end
+      alias :higher_item_id= :left_sibling_id=
+
+      # Returns siblings lying to the right of (lower than) current node.
+      #
+      # @return [ActiveRecord::Relation]
+      def right_siblings
+        siblings.where( table[tree.columns.position].gteq(position) )
+      end
+      alias :lower_items :right_siblings
+
+      # Returns a right (lower) sibling of the node
+      #
+      # @return [ActiveRecord::Base, nil]
+      def right_sibling
+        right_siblings.first
+      end
+      alias :lower_item :right_sibling
+
+      # Set node new right (lower) sibling.
+      # Just changes node's parent_id and position attributes.
+      #
+      # @param [ActiveRecord::Base] node new right sibling
+      # @raise [ActiveRecord::AssociationTypeMismatch] if +node+ class does not
+      #   match current node class.
+      def right_sibling=(node)
+        to = validate_sibling!(node)
+
+        self.position = higher_than?(node) ? to.position - 1 : to.position
+        self.parent_id = to.parent_id
+
+        node
+      end
+      alias :lower_item= :right_sibling=
+
+      # Set node new right sibling by its ID.
+      # Changes node's parent_id and position.
+      #
+      # @param [Fixnum] id new right sibling ID
+      # @raise [ActiveRecord::RecordNotFound] if given +id+ was not found
+      def right_sibling_id=(id)
+        assign_sibling_by_id(id, :right)
+      end
+      alias :lower_item_id= :right_sibling_id=
+
+      private
+      def higher_than?(other)
+        same_parent?(other) && position < other.ordered_tree_node.position
+      end
+
+      # Raises exception if +other+ is kind of wrong class
+      #
+      # @return [ActsAsOrderedTree::Node]
+      def validate_sibling!(other)
+        unless other.is_a?(tree.base_class)
+          message = "#{tree.base_class.name} expected, got #{other.class.name}"
+          raise ActiveRecord::AssociationTypeMismatch, message
+        end
+
+        other.ordered_tree_node
+      end
+
+      # @api private
+      def assign_sibling_by_id(id, position)
+        node = tree.base_class.find(id)
+
+        case position
+          when :left, :higher then self.left_sibling = node
+          when :right, :lower then self.right_sibling = node
+          else raise RuntimeError, 'Unknown sibling position'
+        end
+      end
+    end # module Siblings
+  end # class Node
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/node/traversals.rb

@@ -0,0 +1,53 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/relation/arrangeable'
+require 'acts_as_ordered_tree/relation/iterable'
+
+module ActsAsOrderedTree
+  class Node
+    module Traversals
+      # Returns relation that contains all node's parents, starting from root.
+      #
+      # @return [ActiveRecord::Relation]
+      def ancestors
+        iterable tree.adapter.ancestors(record)
+      end
+
+      # Returns relation that containt all node's parents
+      # and node itself, starting from root.
+      #
+      # @return [ActiveRecord::Relation]
+      def self_and_ancestors
+        iterable tree.adapter.self_and_ancestors(record)
+      end
+
+      # Returns collection of all node's children including their nested children.
+      #
+      # @return [ActiveRecord::Relation]
+      def descendants
+        iterable tree.adapter.descendants(record)
+      end
+
+      # Returns collection of all node's children including their
+      # nested children, and node itself.
+      #
+      # @return [ActiveRecord::Relation]
+      def self_and_descendants
+        iterable tree.adapter.self_and_descendants(record)
+      end
+
+      # Returns very first ancestor of current node. If current node is root,
+      # then method returns node itself.
+      #
+      # @return [ActiveRecord::Base]
+      def root
+        root? ? record : ancestors.first
+      end
+
+      private
+      def iterable(scope)
+        scope.extending(Relation::Arrangeable, Relation::Iterable)
+      end
+    end # module Traversals
+  end # module Node
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/persevering_transaction.rb

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+module ActsAsOrderedTree
+  class PerseveringTransaction
+    module State
+      # Generate helper methods for given +state+.
+      # AR adapter calls :committed! and :rolledback! methods
+      #
+      # @api private
+      def state_method(state)
+        define_method "#{state}!" do |*|
+          @state = state
+        end
+
+        define_method "#{state}?" do
+          @state == state
+        end
+      end
+    end
+    extend State
+
+    # Which errors should be treated as deadlocks
+    DEADLOCK_MESSAGES = Regexp.new [
+      'Deadlock found when trying to get lock',
+      'Lock wait timeout exceeded',
+      'deadlock detected',
+      'database is locked'
+    ].join(?|).freeze
+    # How many times we should retry transaction
+    RETRY_COUNT = 10
+
+    attr_reader :connection, :attempts
+    delegate :logger, :to => :connection
+
+    state_method :committed
+    state_method :rolledback
+
+    def initialize(connection)
+      @connection = connection
+      @attempts = 0
+      @callbacks = []
+      @state = nil
+    end
+
+    # Starts persevering transaction
+    def start(&block)
+      @attempts += 1
+
+      with_transaction_state(&block)
+    rescue ActiveRecord::StatementInvalid => error
+      raise unless connection.open_transactions.zero?
+      raise unless error.message =~ DEADLOCK_MESSAGES
+      raise if attempts >= RETRY_COUNT
+
+      logger.info "Deadlock detected on attempt #{attempts}, restarting transaction"
+
+      pause and retry
+    end
+
+    # Execute given +block+ when after transaction _real_ commit
+    def after_commit(&block)
+      @callbacks << block if block_given?
+    end
+
+    # This method is called by AR adapter
+    # @api private
+    def has_transactional_callbacks?
+      true
+    end
+
+    # Marks this transaction as committed and executes its commit callbacks
+    # @api private
+    def committed_with_callbacks!
+      committed_without_callbacks!
+      @callbacks.each { |callback| callback.call }
+    end
+    alias_method_chain :committed!, :callbacks
+
+    private
+    def pause
+      sleep(rand(attempts) * 0.1)
+    end
+
+    # Runs real transaction and remembers its state
+    def with_transaction_state
+      connection.transaction do
+        connection.add_transaction_record(self)
+
+        yield
+      end
+    end
+  end # class PerseveringTransaction
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/position.rb

@@ -0,0 +1,143 @@
+# coding: utf-8
+
+module ActsAsOrderedTree
+  # Position structure aggregates knowledge about node's position in the tree
+  #
+  # @api private
+  class Position
+    # This class represents node position change
+    #
+    # @api private
+    class Transition
+      # @return [ActsAsOrderedTree::Position]
+      attr_reader :from
+
+      # @return [ActsAsOrderedTree::Position]
+      attr_reader :to
+
+      # @param [ActsAsOrderedTree::Position] from
+      # @param [ActsAsOrderedTree::Position] to
+      def initialize(from, to)
+        @from, @to = from, to
+      end
+
+      def changed?
+        from != to
+      end
+
+      def reorder?
+        changed? && from.parent_id == to.parent_id
+      end
+
+      def movement?
+        changed? && from.parent_id != to.parent_id
+      end
+
+      def level_changed?
+        from.depth != to.depth
+      end
+
+      def update_counters
+        if movement?
+          from.decrement_counter
+          to.increment_counter
+        end
+      end
+    end
+
+    attr_reader   :node, :position
+    attr_accessor :parent_id
+
+    delegate :record, :to => :node
+
+    # @param [ActsAsOrderedTree::Node] node
+    # @param [Integer] parent_id
+    # @param [Integer] position
+    def initialize(node, parent_id, position)
+      @node, @parent_id, self.position = node, parent_id, position
+    end
+
+    # attr_writer with coercion to [nil or Integer]
+    def position=(value)
+      @position = value.presence && value.to_i
+    end
+
+    def klass
+      record.class
+    end
+
+    def parent
+      return @parent if defined?(@parent)
+
+      @parent = parent_id ? fetch_parent : nil
+    end
+
+    def parent?
+      parent.present?
+    end
+
+    def root?
+      parent.blank?
+    end
+
+    def depth
+      @depth ||= parent ? parent.level + 1 : 0
+    end
+
+    # Locks current position. Technically, it means that pessimistic
+    # lock will be obtained on parent node (or all root nodes if position is root)
+    def lock!
+      if parent
+        parent.lock!
+      else
+        siblings.lock.reload
+      end
+    end
+
+    # predicate
+    def position?
+      position.present?
+    end
+
+    # Returns all nodes within given position
+    def siblings
+      node.scope.where(klass.ordered_tree.columns.parent => parent_id)
+    end
+
+    # Returns all nodes that are lower than current position
+    def lower
+      position? ?
+          siblings.where(klass.arel_table[klass.ordered_tree.columns.position].gteq(position)) :
+          siblings
+    end
+
+    def increment_counter
+      update_counter(:increment_counter)
+    end
+
+    def decrement_counter
+      update_counter(:decrement_counter)
+    end
+
+    # @param [ActsAsOrderedTree::Node::Position] other
+    def ==(other)
+      other.is_a?(self.class) &&
+          other.record == record &&
+          other.parent_id == parent_id &&
+          other.position == position
+    end
+
+    private
+    def fetch_parent
+      parent_id == record[klass.ordered_tree.columns.parent] ?
+          record.parent :
+          node.scope.find(parent_id)
+    end
+
+    def update_counter(method)
+      if (column = klass.ordered_tree.columns.counter_cache) && parent_id
+        klass.send(method, column, parent_id)
+      end
+    end
+  end # class Position
+end