acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/lib/acts_as_ordered_tree/compatibility.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/compatibility/features'
+
+module ActsAsOrderedTree
+  # Since we support multiple Rails versions, we need to turn on some features
+  # for old Rails versions.
+  #
+  # @api private
+  module Compatibility
+    features do
+      scope :active_record do
+        versions '< 4.0.0' do
+          feature :association_scope
+          feature :null_relation
+        end
+
+        feature :default_scoped, '< 4.1.0'
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/compatibility/active_record/association_scope.rb

@@ -0,0 +1,9 @@
+module ActiveRecord
+  module Associations
+    class Association
+      def scope
+        scoped
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/compatibility/active_record/default_scoped.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module Scoping
+    module Default
+      module ClassMethods
+        # default_scoped is a new method from Rails 4.1.
+        # Used in RecursiveRelation
+        def default_scoped
+          scope = relation.merge(send(:build_default_scope))
+          scope.default_scoped = true
+          scope
+        end
+      end
+    end
+  end
+end
+
+ActsAsOrderedTree::Compatibility.version '< 3.2.0' do
+  ActiveRecord::Base.extend(ActiveRecord::Scoping::Default::ClassMethods)
+end

data/lib/acts_as_ordered_tree/compatibility/active_record/null_relation.rb

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+
+module ActiveRecord
+  module NullRelation # :nodoc:
+    def exec_queries
+      @records = []
+    end
+
+    def to_a
+      []
+    end
+
+    def pluck(*column_names)
+      []
+    end
+
+    def delete_all(_conditions = nil)
+      0
+    end
+
+    def update_all(_updates, _conditions = nil, _options = {})
+      0
+    end
+
+    def delete(_id_or_array)
+      0
+    end
+
+    def size
+      0
+    end
+
+    def empty?
+      true
+    end
+
+    def any?
+      false
+    end
+
+    def many?
+      false
+    end
+
+    def to_sql
+      @to_sql ||= ""
+    end
+
+    def count(*)
+      0
+    end
+
+    def sum(*)
+      0
+    end
+
+    def calculate(_operation, _column_name, _options = {})
+      nil
+    end
+
+    def exists?(_id = false)
+      false
+    end
+  end
+
+  class Relation
+    def none
+      extending(NullRelation)
+    end
+  end
+end

data/lib/acts_as_ordered_tree/compatibility/features.rb

@@ -0,0 +1,153 @@
+# coding: utf-8
+
+require 'tsort'
+
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/array/wrap'
+
+module ActsAsOrderedTree
+  module Compatibility
+    UnknownFeature = Class.new(StandardError)
+
+    class Feature
+      class Version
+        def initialize(operator, version = nil)
+          operator, version = operator.split unless version
+          operator, version = '=', operator unless version
+          operator = '==' if operator == '='
+
+          @operator, @version = operator, version.to_s
+        end
+
+        def matches?
+          ActiveRecord::VERSION::STRING.send(@operator, @version)
+        end
+
+        def to_s
+          [@operator, @version].join(' ')
+        end
+      end
+
+      attr_reader :name, :versions, :prerequisites
+
+      def initialize(name, versions, prerequisites)
+        @name = name.to_s
+        @versions = Array.wrap(versions).map { |v| Version.new(v) }
+        @prerequisites = Array.wrap(prerequisites)
+      end
+
+      # Requires dependency
+      def require
+        Kernel.require(path) if @versions.all?(&:matches?)
+      end
+
+      private
+      def path
+        "acts_as_ordered_tree/compatibility/#{name}"
+      end
+    end
+
+    class DependencyTree
+      include TSort
+
+      def initialize
+        @features = Hash.new
+      end
+
+      def require
+        @features.each_value(&:require)
+      end
+
+      def <<(feature)
+        feature.prerequisites.each do |pre|
+          unless @features.key?(pre.to_s)
+            @features[pre.to_s] = Feature.new(pre, feature.versions.map(&:to_s), [])
+          end
+        end
+
+        @features[feature.name] = feature
+      end
+
+      def [](name)
+        @features[name.to_s]
+      end
+
+      def each_dependency(name, &block)
+        raise UnknownFeature, "Unknown compatibility feature #{name}" unless @features.key?(name.to_s)
+
+        each_strongly_connected_component_from(name.to_s, &block)
+      end
+
+      private
+      def tsort_each_node(&block)
+        @features.each_key(&block)
+      end
+
+      def tsort_each_child(node, &block)
+        @features[node].prerequisites.each(&block) if @features[node]
+      end
+    end
+
+    class DependencyTreeBuilder
+      attr_reader :tree
+
+      def initialize
+        @tree = DependencyTree.new
+        @default_versions = nil
+        @prerequisites = []
+        @scope = ''
+      end
+
+      def versions(*versions, &block)
+        @default_versions = versions
+
+        instance_eval(&block)
+      ensure
+        @default_versions = nil
+      end
+      alias_method :version, :versions
+
+      def scope(name, &block)
+        if name.is_a?(Hash)
+          @scope = name.keys.first.to_s
+          @prerequisites = Array.wrap(name.values.first)
+        else
+          @scope = name.to_s
+        end
+
+        instance_eval(&block)
+      ensure
+        @scope = ''
+        @prerequisites = []
+      end
+
+      def feature(name, options = {})
+        @tree << if name.is_a?(Hash)
+          version = name.delete(:versions) || @default_versions
+          name, prereq = *name.first
+
+          prereq = @prerequisites + Array.wrap(prereq).map { |x| [@scope, x].join('/') }
+
+          Feature.new([@scope, name].join('/'), version, prereq)
+        else
+          version = options.is_a?(Hash) ? options.delete(:versions) : options
+          Feature.new([@scope, name].join('/'), version || @default_versions, @prerequisites)
+        end
+      end
+    end
+
+    module DSL
+      def features(&block)
+        builder = DependencyTreeBuilder.new
+        builder.instance_eval(&block)
+        builder.tree.require
+      end
+
+      def version(*versions)
+        versions = versions.map { |v| Feature::Version.new(*v) }
+        yield if versions.all?(&:matches?)
+      end
+    end
+    extend DSL
+  end
+end

data/lib/acts_as_ordered_tree/deprecate.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+module ActsAsOrderedTree
+  # @api private
+  module Deprecate
+    NEXT_VERSION = '2.1'
+
+    def deprecated_method(method, replacement = nil, &block)
+      define_method(method) do |*args, &method_block|
+        message = "#{self.class.name}##{__method__} is "\
+                  "deprecated and will be removed in acts_as_ordered_tree-#{NEXT_VERSION}"
+        message << ", use ##{replacement} instead" if replacement
+
+        ActiveSupport::Deprecation.warn message, caller(2)
+
+        if block
+          instance_exec(*args, &block)
+        elsif replacement
+          __send__(replacement, *args, &method_block)
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/hooks.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+require 'active_support/concern'
+
+require 'acts_as_ordered_tree/hooks/update'
+
+module ActsAsOrderedTree
+  # Included into AR::Base this module allows to intercept
+  # internal AR calls, such as +create_record+ and execute
+  # patched code.
+  #
+  # Hooks intention is to execute well optimized INSERTs and
+  # UPDATEs at certain cases.
+  #
+  # @example
+  #   class Category < ActiveRecord::Base
+  #     include ActsAsOrderedTree::Hooks
+  #   end
+  #
+  #   category.hook_update do |update|
+  #     update.scope = category.parent.children
+  #     update.values = {:counter => Category.arel_table[:counter] + 1}
+  #
+  #     # all callbacks, including :before_save and :after_save will
+  #     # be invoked, but patched UPDATE will be called instead of
+  #     # original AR `ActiveRecord::Persistence#update_record`
+  #     category.save
+  #   end
+  #
+  # @api private
+  module Hooks
+    extend ActiveSupport::Concern
+
+    included do
+      include Update
+    end
+  end
+end

data/lib/acts_as_ordered_tree/hooks/update.rb

@@ -0,0 +1,86 @@
+# coding: utf-8
+
+require 'active_support/concern'
+
+module ActsAsOrderedTree
+  module Hooks
+    # This AR-hook is used in Move transactions to update parent_id, position
+    # and other changed attributes using single SQL-query.
+    #
+    # @example
+    #   class Category < ActiveRecord::Base
+    #     include ActsAsOrderedTree::Hooks
+    #   end
+    #
+    #   category = Category.first
+    #   category.hook_update do |update|
+    #     update.scope = Category.where(:parent_id => category.parent_id)
+    #     update.values = { :name => Arel.sql('CASE WHEN parent_id IS NULL THEN name ELSE name || name END') }
+    #
+    #     # `update.update!` will be called instead of usual `AR::Persistence#update`
+    #     record.save
+    #   end
+    #
+    # @api private
+    module Update
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :__update_hook
+
+        # Since rails 4.0 :update_record is used for actual updates
+        # Since rails 4.0.x and 4.1.x (i really don't know which is x) :_update_record is used
+        method_name = [:update_record, :_update_record].detect { |m| private_method_defined?(m) } || :update
+
+        alias_method :update_without_hook, method_name
+        alias_method method_name, :update_with_hook
+      end
+
+      def hook_update
+        self.__update_hook = UpdateManager.new(self)
+        yield __update_hook
+      ensure
+        self.__update_hook = nil
+      end
+
+      private
+      def update_with_hook(*args)
+        if __update_hook
+          __update_hook.update!
+        else
+          update_without_hook(*args)
+        end
+      end
+
+      class UpdateManager
+        attr_reader :record
+        attr_accessor :scope, :values
+
+        def initialize(record)
+          @record = record
+          @values = {}
+        end
+
+        def update!
+          scope.update_all(to_sql)
+          record.reload
+        end
+
+        private
+        def to_sql
+          values.keys.map do |attr|
+            name = attr.is_a?(Arel::Attributes::Attribute) ? attr.name : attr.to_s
+
+            quoted = record.class.connection.quote_column_name(name)
+            "#{quoted} = (#{value_of(attr)})"
+          end.join(', ')
+        end
+
+        def value_of(attr)
+          value = values[attr]
+          value.respond_to?(:to_sql) ? value.to_sql : record.class.connection.quote(value)
+        end
+      end # class CustomUpdate
+    end # module Update
+  end # module Hooks
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/instance_methods.rb

@@ -1,472 +1,111 @@
 # coding: utf-8
-require 'acts_as_ordered_tree/tenacious_transaction'
-require 'acts_as_ordered_tree/relation/preloaded'
-require 'acts_as_ordered_tree/arrangeable'
+
+require 'acts_as_ordered_tree/node'
+require 'acts_as_ordered_tree/transaction/factory'
+require 'acts_as_ordered_tree/deprecate'
 
 module ActsAsOrderedTree
   module InstanceMethods
-    include ActsAsOrderedTree::TenaciousTransaction
-
-    # Returns true if this is a root node.
-    def root?
-      self[parent_column].nil?
-    end
-
-    # Returns true if this is the end of a branch.
-    def leaf?
-      persisted? && if children_counter_cache_column
-        self[children_counter_cache_column] == 0
-      else
-        !children.reorder(nil).exists?
-      end
-    end
-
-    def branch?
-      !leaf?
-    end
-
-    # Returns true is this is a child node
-    def child?
-      !root?
-    end
-
-    # Returns root (not really fast operation)
-    def root
-      root? ? self : parent.root
-    end
-
-    # Returns the array of all parents and self starting from root
-    def self_and_ancestors
-      # 1. recursively load ancestors
-      nodes = []
-      node = self
-
-      while node
-        nodes << node
-        node = node.parent
-      end
-
-      # 2. first ancestor is a root
-      nodes.reverse!
-
-      # 3. create fake scope
-      ActsAsOrderedTree::Relation::Preloaded.new(self.class).
-          where(:id => nodes.map(&:id).compact).
-          extending(Arrangeable).
-          records(nodes)
-    end
-
-    # Returns the array of all parents starting from root
-    def ancestors
-      records = self_and_ancestors - [self]
-
-      scope = self_and_ancestors.where(arel[:id].not_eq(id))
-      scope.records(records)
-    end
-
-    # Returns the array of all children of the parent, including self
-    def self_and_siblings
-      ordered_tree_scope.where(parent_column => self[parent_column])
-    end
-
-    # Returns the array of all children of the parent, except self
-    def siblings
-      self_and_siblings.where(arel[:id].not_eq(id))
-    end
-
-    def level
-      if depth_column
-        # cached result becomes invalid when parent is changed
-        if new_record? ||
-            changed_attributes.include?(parent_column.to_s) ||
-            self[depth_column].blank?
-          self[depth_column] = compute_level
-        else
-          self[depth_column]
-        end
-      else
-        compute_level
-      end
-    end
-
-    # Returns a set of all of its children and nested children.
-    # A little bit tricky. use RDBMS with recursive queries support (PostgreSQL)
-    def descendants
-      records = fetch_self_and_descendants - [self]
-
-      ActsAsOrderedTree::Relation::Preloaded.new(self.class).
-          where(:id => records.map(&:id).compact).
-          extending(Arrangeable).
-          records(records)
+    extend Deprecate
+
+    delegate :root?,
+             :leaf?,
+             :has_children?,
+             :has_parent?,
+             :first?,
+             :last?,
+             :is_descendant_of?,
+             :is_or_is_descendant_of?,
+             :is_ancestor_of?,
+             :is_or_is_ancestor_of?,
+             :to => :ordered_tree_node
+
+    delegate :move_to_root,
+             :move_higher,
+             :move_left,
+             :move_lower,
+             :move_right,
+             :move_to_above_of,
+             :move_to_left_of,
+             :move_to_bottom_of,
+             :move_to_right_of,
+             :move_to_child_of,
+             :move_to_child_with_index,
+             :move_to_child_with_position,
+             :to => :ordered_tree_node
+
+    delegate :ancestors,
+             :self_and_ancestors,
+             :descendants,
+             :self_and_descendants,
+             :root,
+             :siblings,
+             :self_and_siblings,
+             :left_siblings,
+             :higher_items,
+             :left_sibling,
+             :higher_item,
+             :left_sibling=,
+             :left_sibling_id=,
+             :higher_item=,
+             :higher_item_id=,
+             :right_siblings,
+             :lower_items,
+             :right_sibling,
+             :lower_item,
+             :right_sibling=,
+             :right_sibling_id=,
+             :lower_item=,
+             :lower_item_id=,
+             :to => :ordered_tree_node
+
+    delegate :level, :to => :ordered_tree_node
+
+    # Returns ordered tree node - an object which maintains tree integrity.
+    # WARNING: THIS METHOD IS NOT THREAD SAFE!
+    # Though I'm not sure if it can cause any problems.
+    #
+    # @return [ActsAsOrderedTree::Node]
+    def ordered_tree_node
+      @ordered_tree_node ||= ActsAsOrderedTree::Node.new(self)
     end
 
-    # Returns a set of itself and all of its nested children
-    def self_and_descendants
-      records = fetch_self_and_descendants
-
-      ActsAsOrderedTree::Relation::Preloaded.new(self.class).
-          where(:id => records.map(&:id)).
-          extending(Arrangeable).
-          records(records)
-    end
-
-    def is_descendant_of?(other)
-      ancestors.include? other
-    end
-
-    def is_or_is_descendant_of?(other)
-      self == other || is_descendant_of?(other)
-    end
-
-    def is_ancestor_of?(other)
-      other.is_descendant_of? self
-    end
-
-    def is_or_is_ancestor_of?(other)
-      other.is_or_is_descendant_of? self
-    end
-
-    # Return +true+ if this object is the first in the list.
-    def first?
-      self[position_column] <= 1
-    end
-
-    # Return +true+ if this object is the last in the list.
-    def last?
-      !right_sibling
-    end
-
-    # Returns a left (upper) sibling of the node
-    def left_sibling
-      siblings.
-          where( arel[position_column].lt(self[position_column]) ).
-          reorder( arel[position_column].desc ).
-          first
-    end
-    alias higher_item left_sibling
-
-    # Returns a right (lower) sibling of the node
-    def right_sibling
-      siblings.
-          where( arel[position_column].gt(self[position_column]) ).
-          reorder( arel[position_column].asc ).
-          first
-    end
-    alias lower_item right_sibling
-
     # Insert the item at the given position (defaults to the top position of 1).
-    # +acts_as_list+ compatability
-    def insert_at(position = 1)
-      move_to_child_with_index(parent, position - 1)
-    end
-
-    # Shorthand method for finding the left sibling and moving to the left of it.
-    def move_left
-      tenacious_transaction do
-        move_to_left_of left_sibling.try(:lock!)
-      end
-    end
-    alias move_higher move_left
-
-    # Shorthand method for finding the right sibling and moving to the right of it.
-    def move_right
-      tenacious_transaction do
-        move_to_right_of right_sibling.try(:lock!)
-      end
-    end
-    alias move_lower move_right
-
-    # Move the node to the left of another node
-    def move_to_left_of(node)
-      move_to node, :left
-    end
-    alias move_to_above_of move_to_left_of
-
-    # Move the node to the left of another node
-    def move_to_right_of(node)
-      move_to node, :right
+    # +acts_as_list+ compatibility
+    #
+    # @deprecated
+    deprecated_method :insert_at, :move_to_child_with_position do |position = 1|
+      move_to_child_with_position(parent, position)
     end
-    alias move_to_bottom_of move_to_right_of
 
-    # Move the node to the child of another node
-    def move_to_child_of(node)
-      move_to node, :child
+    # Returns +true+ if it is possible to move node to left/right/child of +target+.
+    #
+    # @param [ActiveRecord::Base] target
+    # @deprecated
+    deprecated_method :move_possible? do |target|
+      ordered_tree_node.same_scope?(target) &&
+          !ordered_tree_node.is_or_is_ancestor_of?(target)
     end
 
-    # Move the node to the child of another node with specify index
-    def move_to_child_with_index(node, index)
-      raise ActiveRecord::ActiveRecordError, "index can't be nil" unless index
+    # Returns true if node contains any children.
+    #
+    # @deprecated
+    deprecated_method :branch?, :has_children?
 
-      tenacious_transaction do
-        new_siblings = (node.try(:children) || ordered_tree_scope.roots).
-            reload.
-            lock(true).
-            reject { |root_node| root_node == self }
-
-        if new_siblings.empty?
-          node ? move_to_child_of(node) : move_to_root
-        elsif new_siblings.count <= index
-          move_to_right_of(new_siblings.last)
-        elsif
-          index >= 0 ? move_to_left_of(new_siblings[index]) : move_to_right_of(new_siblings[index])
-        end
-      end
-    end
-
-    # Move the node to root nodes
-    def move_to_root
-      move_to nil, :root
-    end
-
-    # Returns +true+ it is possible to move node to left/right/child of +target+
-    def move_possible?(target)
-      same_scope?(target) && !is_or_is_ancestor_of?(target)
-    end
-
-    # Check if other model is in the same scope
-    def same_scope?(other)
-      scope_column_names.empty? || scope_column_names.all? do |attr|
-        self[attr] == other[attr]
-      end
-    end
+    # Returns true is node is not a root node.
+    #
+    # @deprecated
+    deprecated_method :child?, :has_parent?
 
     private
-
-    def compute_level #:nodoc:
-      ancestors.count
-    end
-
-    def compute_ordered_tree_columns(target, pos) #:nodoc:
-      position_was = send("#{position_column}_was")
-
-      case pos
-        when :root  then
-          parent_id = nil
-          position = if root? && self[position_column]
-            # already root node
-            self[position_column]
-          else
-            ordered_tree_scope.roots.maximum(position_column).try(:succ) || 1
-          end
-          depth = 0
-        when :left  then
-          parent_id = target[parent_column]
-          position = target[position_column]
-          position -= 1 if position_was && target[parent_column] == send("#{parent_column}_was") && target[position_column] > position_was # right
-          depth = target.level
-        when :right then
-          parent_id = target[parent_column]
-          position = target[position_column]
-          position += 1 if target[parent_column] != send("#{parent_column}_was") || position_was.blank? || target[position_column] < position_was # left
-          depth = target.level
-        when :child then
-          parent_id = target.id
-          position = if self[parent_column] == parent_id && self[position_column]
-            # already child of target node
-            self[position_column]
-          else
-            # lock should be obtained on target
-            target.children.maximum(position_column).try(:succ) || 1
-          end
-          depth = target.level + 1
-        else raise ActiveRecord::ActiveRecordError, "Position should be :child, :left, :right or :root ('#{pos}' received)."
-      end
-      return parent_id, position, depth
-    end
-
-    # This method do real node movements
-    def move_to(target, pos) #:nodoc:
-      tenacious_transaction do
-        if pos != :root && target
-          # load object if node is not an object
-          target = self.class.lock(true).find(target)
-        elsif pos == :root
-          # Obtain lock on all root nodes
-          ordered_tree_scope.
-              roots.
-              lock(true).
-              reload
-        end
-
-        unless pos == :root || target && move_possible?(target)
-          raise ActiveRecord::ActiveRecordError, "Impossible move"
-        end
-
-        position_was = send("#{position_column}_was")
-        parent_id_was = send("#{parent_column}_was")
-        parent_id, position, depth = compute_ordered_tree_columns(target, pos)
-
-        # nothing changed - quit
-        return if parent_id == parent_id_was && position == position_was
-
-        self.class.lock(true).find(self)
-        self[position_column], self[parent_column] = position, parent_id
-
-        move_kind = case
-          when id_was && parent_id != parent_id_was then :move
-          when id_was && position  != position_was  then :reorder
-          else nil
-        end
-
-        update = proc do
-          if move_kind == :move
-            move!(id, parent_id_was, parent_id, position_was, position, depth)
-          else
-            reorder!(parent_id, position_was, position)
-          end
-
-          reload
-        end
-
-        if move_kind
-          run_callbacks move_kind, &update
-        else
-          update.call
-        end
-
-      end
-    end
-
-    def decrement_lower_positions(parent_id, position) #:nodoc:
-      conditions = arel[parent_column].eq(parent_id).and(arel[position_column].gt(position))
-
-      ordered_tree_scope.where(conditions).update_all("#{position_column} = #{position_column} - 1")
-    end
-
-    # Internal
-    def move!(id, parent_id_was, parent_id, position_was, position, depth) #:nodoc:
-      pk = self.class.primary_key
-
-      assignments = [
-          "#{parent_column} = CASE " +
-              "WHEN #{pk} = :id " +
-              "THEN :parent_id " +
-              "ELSE #{parent_column} " +
-          "END",
-          "#{position_column} = CASE " +
-              # set new position
-              "WHEN #{pk} = :id " +
-              "THEN :position " +
-              # decrement lower positions within old parent
-              "WHEN #{parent_column} #{parent_id_was.nil? ? " IS NULL" : " = :parent_id_was"} AND #{position_column} > :position_was " +
-              "THEN #{position_column} - 1 " +
-              # increment lower positions within new parent
-              "WHEN #{parent_column} #{parent_id.nil? ? "IS NULL" : " = :parent_id"} AND #{position_column} >= :position " +
-              "THEN #{position_column} + 1 " +
-              "ELSE #{position_column} " +
-          "END",
-          ("#{depth_column} = CASE " +
-              "WHEN #{pk} = :id " +
-              "THEN :depth " +
-              "ELSE #{depth_column} " +
-          "END" if depth_column)
-      ]
-
-      conditions = arel[pk].eq(id).or(
-        arel[parent_column].eq(parent_id_was)
-      ).or(
-        arel[parent_column].eq(parent_id)
-      )
-
-      binds = {:id => id,
-               :parent_id_was => parent_id_was,
-               :parent_id => parent_id,
-               :position_was => position_was,
-               :position => position,
-               :depth => depth}
-
-      ordered_tree_scope.where(conditions).update_all([assignments.compact.join(', '), binds])
-    end
-
-    # Internal
-    def reorder!(parent_id, position_was, position)
-      assignments = [
-        if position_was
-          <<-SQL
-          #{position_column} = CASE
-              WHEN #{position_column} = :position_was
-              THEN :position
-              WHEN #{position_column} <= :position AND #{position_column} > :position_was AND :position > :position_was
-              THEN #{position_column} - 1
-              WHEN #{position_column} >= :position AND #{position_column} < :position_was AND :position < :position_was
-              THEN #{position_column} + 1
-              ELSE #{position_column}
-          END
-          SQL
-        else
-          <<-SQL
-          #{position_column} = CASE
-              WHEN #{position_column} > :position
-              THEN #{position_column} + 1
-              WHEN #{position_column} IS NULL
-              THEN :position
-              ELSE #{position_column}
-          END
-          SQL
-        end
-      ]
-
-      conditions = arel[parent_column].eq(parent_id)
-      binds = {:id => id, :position_was => position_was, :position => position}
-
-      ordered_tree_scope.where(conditions).update_all([assignments.compact.join(', '), binds])
-    end
-
-    # recursively load descendants
-    def fetch_self_and_descendants #:nodoc:
-      @self_and_descendants ||= [self] + children.map { |child| [child, child.descendants] }.flatten
-    end
-
-    def set_depth! #:nodoc:
-      self[depth_column] = compute_level
-    end
-
-    def set_scope! #:nodoc:
-      scope_column_names.each do |column|
-        self[column] = parent[column]
-      end
-    end
-
-    def flush_descendants #:nodoc:
-      @self_and_descendants = nil
-    end
-
-    def update_descendants_depth #:nodoc:
-      depth_was = send("#{depth_column}_was")
-
-      yield
-
-      diff = self[depth_column] - depth_was
-      if diff != 0
-        sign = diff > 0 ? "+" : "-"
-        # update categories set depth = depth - 1 where id in (...)
-        descendants.update_all(["#{depth_column} = #{depth_column} #{sign} ?", diff.abs]) if descendants.count > 0
-      end
-    end
-
-    # Used in built-in around_move routine
-    def update_counter_cache #:nodoc:
-      parent_id_was = send "#{parent_column}_was"
-
-      yield
-
-      parent_id_new = self[parent_column]
-      unless parent_id_new == parent_id_was
-        self.class.increment_counter(children_counter_cache_column, parent_id_new) if parent_id_new
-        self.class.decrement_counter(children_counter_cache_column, parent_id_was) if parent_id_was
-      end
-    end
-
-    def arel #:nodoc:
-      self.class.arel_table
+    # Around callback that starts ActsAsOrderedTree::Transaction
+    def save_ordered_tree_node(&block)
+      Transaction::Factory.create(ordered_tree_node).start(&block)
     end
 
-    def ordered_tree_scope #:nodoc:
-      if scope_column_names.empty?
-        self.class.base_class
-      else
-        self.class.base_class.where Hash[scope_column_names.map { |column| [column, self[column]] }]
-      end
+    # Around callback that starts ActsAsOrderedTree::Transaction
+    def destroy_ordered_tree_node(&block)
+      Transaction::Factory.create(ordered_tree_node, true).start(&block)
     end
   end # module InstanceMethods
 end # module ActsAsOrderedTree