acts_as_ordered_tree 1.0.5 → 1.1.1

data/lib/acts_as_ordered_tree/adapters/postgresql_adapter.rb

@@ -0,0 +1,71 @@
+require "acts_as_ordered_tree/relation/recursive"
+
+module ActsAsOrderedTree
+  module Adapters
+    module PostgreSQLAdapter
+      # Recursive ancestors fetcher
+      def self_and_ancestors
+        if persisted? && !send("#{parent_column}_changed?")
+          query = <<-QUERY
+            SELECT id, #{parent_column}, 1 AS _depth
+            FROM #{self.class.quoted_table_name}
+            WHERE #{arel[:id].eq(id).to_sql}
+            UNION ALL
+            SELECT alias1.id, alias1.#{parent_column}, _depth + 1
+            FROM #{self.class.quoted_table_name} alias1
+              INNER JOIN self_and_ancestors ON alias1.id = self_and_ancestors.#{parent_column}
+          QUERY
+
+          recursive_scope.with_recursive("self_and_ancestors", query).
+                          order("self_and_ancestors._depth DESC")
+        else
+          ancestors + [self]
+        end
+      end
+
+      # Recursive ancestors fetcher
+      def ancestors
+        query = <<-QUERY
+          SELECT id, #{parent_column}, 1 AS _depth
+          FROM #{self.class.quoted_table_name}
+          WHERE #{arel[:id].eq(parent.try(:id)).to_sql}
+          UNION ALL
+          SELECT alias1.id, alias1.#{parent_column}, _depth + 1
+          FROM #{self.class.quoted_table_name} alias1
+            INNER JOIN ancestors ON alias1.id = ancestors.#{parent_column}
+        QUERY
+
+        recursive_scope.with_recursive("ancestors", query).
+                        order("ancestors._depth DESC")
+      end
+
+      def root
+        root? ? self : ancestors.first
+      end
+
+      def self_and_descendants
+        query = <<-QUERY
+          SELECT id, #{parent_column}, ARRAY[#{position_column}] AS _positions
+          FROM #{self.class.quoted_table_name}
+          WHERE #{arel[:id].eq(id).to_sql}
+          UNION ALL
+          SELECT alias1.id, alias1.#{parent_column}, _positions || alias1.#{position_column}
+          FROM descendants INNER JOIN
+            #{self.class.quoted_table_name} alias1 ON alias1.parent_id = descendants.id
+        QUERY
+
+        recursive_scope.with_recursive("descendants", query).
+                        order("descendants._positions ASC")
+      end
+
+      def descendants
+        self_and_descendants.where(arel[:id].not_eq(id))
+      end
+
+      private
+      def recursive_scope
+        ActsAsOrderedTree::Relation::Recursive.new(ordered_tree_scope)
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/class_methods.rb

@@ -1,3 +1,5 @@
+require "acts_as_ordered_tree/adapters/postgresql_adapter"
+
 module ActsAsOrderedTree
   module ClassMethods
     extend ActiveSupport::Concern
@@ -24,6 +26,47 @@ module ActsAsOrderedTree
       def children_counter_cache? #:nodoc:
         children_counter_cache_column && columns_hash.key?(children_counter_cache_column.to_s)
       end
+
+      def setup_ordered_tree_adapter #:nodoc:
+        include "ActsAsOrderedTree::Adapters::#{connection.class.name.demodulize}".constantize
+      rescue NameError, LoadError
+        # ignore
+      end
+
+      def setup_ordered_tree_callbacks #:nodoc:
+        define_model_callbacks :move, :reorder
+
+        if depth_column
+          before_create :set_depth!
+          before_save   :set_depth!, :if => "#{parent_column}_changed?".to_sym
+          around_move   :update_descendants_depth
+        end
+
+        if children_counter_cache_column
+          around_move :update_counter_cache
+        end
+
+        unless scope_column_names.empty?
+          before_save :set_scope!, :unless => :root?
+        end
+
+        after_save :move_to_root, :unless => [position_column, parent_column]
+        after_save 'move_to_child_of(parent)', :if => parent_column, :unless => position_column
+        after_save "move_to_child_with_index(parent, #{position_column})",
+                   :if => "#{position_column} && (#{position_column}_changed? || #{parent_column}_changed?)"
+
+        before_destroy :flush_descendants
+        after_destroy "decrement_lower_positions(#{parent_column}_was, #{position_column}_was)", :if => position_column
+      end
+
+      def setup_ordered_tree_validations #:nodoc:
+        unless scope_column_names.empty?
+          validates_with Validators::ScopeValidator, :on => :update, :unless => :root?
+        end
+
+        # setup validations
+        validates_with Validators::CyclicReferenceValidator, :on => :update, :if => :parent
+      end
     end # module ClassMethods
   end # module ClassMethods
 end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/instance_methods.rb

@@ -1,7 +1,10 @@
 # coding: utf-8
+require "acts_as_ordered_tree/tenacious_transaction"
+require "acts_as_ordered_tree/relation/preloaded"
+
 module ActsAsOrderedTree
   module InstanceMethods
-    extend ActiveSupport::Concern
+    include ActsAsOrderedTree::TenaciousTransaction
 
     # Returns true if this is a root node.
     def root?
@@ -46,7 +49,9 @@ module ActsAsOrderedTree
       nodes.reverse!
 
       # 3. create fake scope
-      ActsAsOrderedTree::FakeScope.new(self.class, nodes, :where => {:id => nodes.map(&:id)})
+      ActsAsOrderedTree::Relation::Preloaded.new(self.class).
+          where(:id => nodes.map(&:id)).
+          records(nodes)
     end
 
     # Returns the array of all parents starting from root
@@ -54,7 +59,7 @@ module ActsAsOrderedTree
       records = self_and_ancestors - [self]
 
       scope = self_and_ancestors.where(arel[:id].not_eq(id))
-      ActsAsOrderedTree::FakeScope.new(scope, records)
+      scope.records(records)
     end
 
     # Returns the array of all children of the parent, including self
@@ -87,14 +92,18 @@ module ActsAsOrderedTree
     def descendants
       records = fetch_self_and_descendants - [self]
 
-      ActsAsOrderedTree::FakeScope.new self.class, records, :where => {:id => records.map(&:id)}
+      ActsAsOrderedTree::Relation::Preloaded.new(self.class).
+          where(:id => records.map(&:id)).
+          records(records)
     end
 
     # Returns a set of itself and all of its nested children
     def self_and_descendants
       records = fetch_self_and_descendants
 
-      ActsAsOrderedTree::FakeScope.new self.class, records, :where => {:id => records.map(&:id)}
+      ActsAsOrderedTree::Relation::Preloaded.new(self.class).
+          where(:id => records.map(&:id)).
+          records(records)
     end
 
     def is_descendant_of?(other)
@@ -149,13 +158,17 @@ module ActsAsOrderedTree
 
     # Shorthand method for finding the left sibling and moving to the left of it.
     def move_left
-      move_to_left_of left_sibling
+      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
-      move_to_right_of right_sibling
+      tenacious_transaction do
+        move_to_right_of right_sibling.try(:lock!)
+      end
     end
     alias move_lower move_right
 
@@ -178,15 +191,21 @@ module ActsAsOrderedTree
 
     # Move the node to the child of another node with specify index
     def move_to_child_with_index(node, index)
-      raise ActiveRecord::ActiveRecordError, "index cant be nil" unless index
-      new_siblings = (node.try(:children) || self.class.roots).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])
+      raise ActiveRecord::ActiveRecordError, "index can't be nil" unless index
+
+      tenacious_transaction do
+        new_siblings = (node.try(:children) || self.class.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
 
@@ -247,9 +266,10 @@ module ActsAsOrderedTree
         when :child then
           parent_id = target.id
           position = if self[parent_column] == parent_id && self[position_column]
-            # already children of target node
+            # 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
@@ -260,58 +280,138 @@ module ActsAsOrderedTree
 
     # This method do real node movements
     def move_to(target, pos) #:nodoc:
-      if target.is_a? self.class.base_class
-        target.reload
-      elsif pos != :root && target
-        # load object if node is not an object
-        target = self.class.find(target)
-      end
-
-      unless pos == :root || target && move_possible?(target)
-        raise ActiveRecord::ActiveRecordError, "Impossible move"
-      end
+      tenacious_transaction do
+        if target.is_a? self.class.base_class
+          # lock obtained here
+          target.send(:reload_node)
+        elsif pos != :root && target
+          # load object if node is not an object
+          target = self.class.find(target, :lock => true)
+        elsif pos == :root
+          # Obtain lock on all root nodes
+          ordered_tree_scope.
+              roots.
+              lock(true).
+              reload
+        end
 
-      position_was = send "#{position_column}_was".intern
-      parent_id_was = send "#{parent_column}_was".intern
-      parent_id, position, depth = compute_ordered_tree_columns(target, pos)
+        unless pos == :root || target && move_possible?(target)
+          raise ActiveRecord::ActiveRecordError, "Impossible move"
+        end
 
-      # nothing changed - quit
-      return if parent_id == parent_id_was && position == position_was
+        position_was = send "#{position_column}_was".intern
+        parent_id_was = send "#{parent_column}_was".intern
+        parent_id, position, depth = compute_ordered_tree_columns(target, pos)
 
-      update = proc do
-        decrement_lower_positions parent_id_was, position_was if position_was
-        increment_lower_positions parent_id, position
+        # nothing changed - quit
+        return if parent_id == parent_id_was && position == position_was
 
-        columns = {parent_column => parent_id, position_column => position}
-        columns[depth_column] = depth if depth_column
+        move_kind = case
+          when id_was && parent_id != parent_id_was then :move
+          when id_was && position  != position_was  then :reorder
+          else nil
+        end
 
-        ordered_tree_scope.update_all(columns, :id => id)
-        reload_node
-      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
 
-      move_kind = case
-        when id_was && parent_id != parent_id_was then :move
-        when id_was && position  != position_was  then :reorder
-        else nil
-      end
+          reload_node
+        end
 
-      if move_kind
-        run_callbacks move_kind, &update
-      else
-        update.call
+        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.update_all "#{position_column} = #{position_column} - 1", conditions
-    end
+      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)
+      ].compact.join(', ')
+
+      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, 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)
 
-    def increment_lower_positions(parent_id, position) #:nodoc:
-      conditions = arel[parent_column].eq(parent_id).and(arel[position_column].gteq(position))
+      binds = {:position_was => position_was, :position => position}
 
-      ordered_tree_scope.update_all "#{position_column} = #{position_column} + 1", conditions
+      ordered_tree_scope.where(conditions).update_all([assignments, binds])
     end
 
     # recursively load descendants
@@ -342,10 +442,11 @@ module ActsAsOrderedTree
       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])
+        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 = self[parent_column]
 
@@ -362,7 +463,7 @@ module ActsAsOrderedTree
       self.class.arel_table
     end
 
-    def ordered_tree_scope
+    def ordered_tree_scope #:nodoc:
       if scope_column_names.empty?
         self.class.base_class.scoped
       else

data/lib/acts_as_ordered_tree/relation/base.rb

@@ -0,0 +1,24 @@
+module ActsAsOrderedTree
+  module Relation
+    class Base < ActiveRecord::Relation
+      # Create from existing +relation+ or from +class+ and +table+
+      def initialize(class_or_relation, table = nil)
+        relation = class_or_relation
+
+        if class_or_relation.is_a?(Class)
+          relation = class_or_relation.scoped
+          table ||= class_or_relation.arel_table
+
+          super(class_or_relation, table)
+        else
+          super(class_or_relation.klass, class_or_relation.table)
+        end
+
+        # copy instance variables from real relation
+        relation.instance_variables.each do |ivar|
+          instance_variable_set(ivar, relation.instance_variable_get(ivar))
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/relation/preloaded.rb

@@ -0,0 +1,16 @@
+require "acts_as_ordered_tree/relation/base"
+
+module ActsAsOrderedTree
+  module Relation
+    # Common relation, but with already loaded records
+    class Preloaded < Base
+      # Set loaded records to +records+
+      def records(records)
+        relation = clone
+        relation.instance_variable_set :@records, records
+        relation.instance_variable_set :@loaded,  true
+        relation
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/relation/recursive.rb

@@ -0,0 +1,57 @@
+require "acts_as_ordered_tree/relation/base"
+
+module ActsAsOrderedTree
+  module Relation
+    # Recursive relation fixes Rails3.0 issue https://github.com/rails/rails/issues/522 for
+    # relations with joins to subqueries
+    class Recursive < Base
+      attr_accessor :recursive_table_value, :recursive_query_value
+
+      # relation.with_recursive("table_name", "SELECT * FROM table_name")
+      def with_recursive(recursive_table_name, query)
+        relation = clone
+        relation.recursive_table_value = recursive_table_name
+        relation.recursive_query_value = query
+        relation
+      end
+
+      def build_arel
+        if recursive_table_value && recursive_query_value
+          join_sql = "INNER JOIN (" +
+                       recursive_query_sql +
+                     ") AS #{recursive_table_value} ON #{recursive_table_value}.id = #{table.name}.id"
+
+          except(:recursive_table, :recursive_query).joins(join_sql).build_arel
+        else
+          super
+        end
+      end
+
+      def update_all(updates, conditions = nil, options = {})
+        if recursive_table_value && recursive_query_value
+          scope = where("id IN (SELECT id FROM (#{recursive_query_sql}) AS #{recursive_table_value})").
+              except(:recursive_table, :recursive_query, :limit, :order)
+
+          scope.update_all(updates, conditions, options)
+        else
+          super
+        end
+      end
+
+      def except(*skips)
+        result = super
+        ([:recursive_table, :recursive_query] - skips).each do |method|
+          result.send("#{method}_value=", send(:"#{method}_value"))
+        end
+
+        result
+      end
+
+      private
+      def recursive_query_sql
+        "WITH RECURSIVE #{recursive_table_value} AS (#{recursive_query_value}) " +
+        "SELECT * FROM #{recursive_table_value}"
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/tenacious_transaction.rb

@@ -0,0 +1,30 @@
+module ActsAsOrderedTree
+  module TenaciousTransaction
+    DEADLOCK_MESSAGES = /Deadlock found when trying to get lock|Lock wait timeout exceeded|deadlock detected/.freeze
+    RETRY_COUNT = 10
+
+    # Partially borrowed from awesome_nested_set
+    def tenacious_transaction(&block) #:nodoc:
+      return transaction(&block) if @in_tenacious_transaction
+
+      @in_tenacious_transaction = true
+      retry_count = 0
+      begin
+        transaction(&block)
+      rescue ActiveRecord::StatementInvalid => error
+        raise unless connection.open_transactions.zero?
+        raise unless error.message =~ DEADLOCK_MESSAGES
+        raise unless retry_count < RETRY_COUNT
+        retry_count += 1
+
+        logger.info "Deadlock detected on retry #{retry_count}, restarting transaction"
+
+        sleep(rand(retry_count)*0.1) # Aloha protocol
+
+        retry
+      ensure
+        @in_tenacious_transaction = false
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/version.rb

@@ -1,3 +1,3 @@
 module ActsAsOrderedTree
-  VERSION = "1.0.5"
+  VERSION = "1.1.1"
 end

data/lib/acts_as_ordered_tree.rb

@@ -1,7 +1,6 @@
 require "active_record"
 require "acts_as_ordered_tree/version"
 require "acts_as_ordered_tree/class_methods"
-require "acts_as_ordered_tree/fake_scope"
 require "acts_as_ordered_tree/instance_methods"
 require "acts_as_ordered_tree/validators"
 
@@ -56,43 +55,21 @@ module ActsAsOrderedTree
                :counter_cache => options[:counter_cache],
                :inverse_of => (:children unless options[:polymorphic])
 
-    define_model_callbacks :move, :reorder
-
     include ClassMethods
     include InstanceMethods
-
-    # protect position&depth from mass-assignment
-    attr_protected depth_column, position_column
-
-    if depth_column
-      before_create :set_depth!
-      before_save   :set_depth!, :if => "#{parent_column}_changed?".to_sym
-      around_move   :update_descendants_depth
-    end
-
-    if children_counter_cache_column
-      around_move :update_counter_cache
-    end
-
-    unless scope_column_names.empty?
-      before_save :set_scope!, :unless => :root?
-      validates_with Validators::ScopeValidator, :on => :update, :unless => :root?
-    end
-
-    after_save :move_to_root, :unless => [position_column, parent_column]
-    after_save 'move_to_child_of(parent)', :if => parent_column, :unless => position_column
-    after_save "move_to_child_with_index(parent, #{position_column})",
-               :if => "#{position_column} && (#{position_column}_changed? || #{parent_column}_changed?)"
-
-    before_destroy :flush_descendants
-    after_destroy "decrement_lower_positions(#{parent_column}_was, #{position_column}_was)", :if => position_column
-
-    # setup validations
-    validates_with Validators::CyclicReferenceValidator, :on => :update, :if => :parent
+    setup_ordered_tree_adapter
+    setup_ordered_tree_callbacks
+    setup_ordered_tree_validations
   end # def acts_as_ordered_tree
 
   # Mixed into both classes and instances to provide easy access to the column names
   module Columns
+    extend ActiveSupport::Concern
+
+    included do
+      attr_protected depth_column, position_column
+    end
+
     def parent_column
       acts_as_ordered_tree_options[:parent_column]
     end

data/spec/acts_as_ordered_tree_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path('../spec_helper', __FILE__)
 
-describe ActsAsOrderedTree do
+describe ActsAsOrderedTree, :transactional do
   describe "defaults" do
     subject { Default }
 
@@ -207,7 +207,6 @@ describe ActsAsOrderedTree do
       subject { grandchild.self_and_ancestors }
 
       it { should be_a ActiveRecord::Relation }
-      it { should be_loaded }
       it { should have(3).items }
       its(:first) { should eq root }
       its(:last) { should eq subject }
@@ -217,7 +216,6 @@ describe ActsAsOrderedTree do
       subject { child.self_and_ancestors }
 
       it { should be_a ActiveRecord::Relation }
-      it { should be_loaded }
       it { should have(2).items }
       its(:first) { should eq root }
       its(:last) { should eq subject }
@@ -227,10 +225,29 @@ describe ActsAsOrderedTree do
       subject { root.self_and_ancestors }
 
       it { should be_a ActiveRecord::Relation }
-      it { should be_loaded }
       it { should have(1).item }
       its(:first) { should eq root }
     end
+
+    context "when record is new" do
+      let(:record) { build(:default, :parent => grandchild) }
+      subject { record.self_and_ancestors }
+
+      it { should have(4).items }
+      it { should include root }
+      it { should include child }
+      it { should include grandchild }
+      it { should include record }
+    end
+
+    context "when parent is changed" do
+      before { grandchild.parent = root }
+      subject { grandchild.self_and_ancestors }
+
+      it { should include root }
+      it { should_not include child }
+      it { should include grandchild }
+    end
   end
 
   describe "#ancestors" do
@@ -243,7 +260,6 @@ describe ActsAsOrderedTree do
       subject { grandchild.ancestors }
 
       it { should be_a ActiveRecord::Relation }
-      it { should be_loaded }
       it { should have(2).items }
       its(:first) { should eq root }
       its(:last) { should eq child }
@@ -253,7 +269,6 @@ describe ActsAsOrderedTree do
       subject { child.ancestors }
 
       it { should be_a ActiveRecord::Relation }
-      it { should be_loaded }
       it { should have(1).item }
       its(:first) { should eq root }
     end
@@ -262,7 +277,6 @@ describe ActsAsOrderedTree do
       subject { root.ancestors }
 
       it { should be_a ActiveRecord::Relation }
-      it { should be_loaded }
       it { should be_empty }
     end
   end
@@ -277,7 +291,6 @@ describe ActsAsOrderedTree do
       subject { grandchild.self_and_descendants }
 
       it { should be_a ActiveRecord::Relation }
-      it { should be_loaded }
       it { should have(1).item }
       its(:first) { should eq grandchild }
     end
@@ -286,7 +299,6 @@ describe ActsAsOrderedTree do
       subject { child.self_and_descendants }
 
       it { should be_a ActiveRecord::Relation }
-      it { should be_loaded }
       it { should have(2).items }
       its(:first) { should eq child }
       its(:last) { should eq grandchild }
@@ -296,7 +308,6 @@ describe ActsAsOrderedTree do
       subject { root.self_and_descendants }
 
       it { should be_a ActiveRecord::Relation }
-      it { should be_loaded }
       it { should have(3).items }
       its(:first) { should eq root }
       its(:last) { should eq grandchild }

data/spec/concurrency_support_spec.rb

@@ -0,0 +1,159 @@
+require "spec_helper"
+
+# FIXME: These tests are buggy on Rails 3.0
+# Sqlite is not concurrent database
+if ActiveRecord::VERSION::STRING >= "3.1" && ENV['DB'] != 'sqlite3'
+  describe ActsAsOrderedTree, :non_transactional do
+    module Concurrency
+      # run block in its own thread, create +size+ threads
+      def pool(size)
+        body = proc do |x|
+          ActiveRecord::Base.connection_pool.with_connection do
+            yield x
+          end
+        end
+        threads = size.times.map { |x| Thread.new { body.call(x) } }
+
+        threads.each(&:join)
+      end
+    end
+    include Concurrency
+
+    let!(:root) { create :default }
+
+    it "should not create nodes with same position" do
+      pool(3) do
+        create :default, :parent => root
+      end
+
+      root.children.map(&:position).should eq [1, 2, 3]
+    end
+
+    it "should not move nodes to same position when moving to child of certain node" do
+      nodes = create_list :default, 3
+
+      pool(3) do |x|
+        nodes[x].move_to_child_of(root)
+      end
+
+      root.children.map(&:position).should eq [1, 2, 3]
+    end
+
+    it "should not move nodes to same position when moving to left of root node" do
+      nodes = create_list :default, 3, :parent => root
+
+      pool(3) do |x|
+        nodes[x].move_to_left_of(root)
+      end
+
+      Default.roots.map(&:position).should eq [1, 2, 3, 4]
+    end
+
+    it "should not move nodes to same position when moving to left of child node" do
+      child = create :default, :parent => root
+      nodes = create_list :default, 3, :parent => child
+
+      pool(3) do |x|
+        nodes[x].move_to_left_of(child)
+      end
+
+      root.children.map(&:position).should eq [1, 2, 3, 4]
+      root.children.last.should eq child
+    end
+
+    it "should not move nodes to same position when moving to right of child node" do
+      child = create :default, :parent => root
+      nodes = create_list :default, 3, :parent => child
+
+      pool(3) do |x|
+        nodes[x].move_to_right_of(child)
+      end
+
+      root.children.map(&:position).should eq [1, 2, 3, 4]
+      root.children.first.should eq child
+    end
+
+    it "should not move nodes to same position when moving to root" do
+      nodes = create_list :default, 3, :parent => root
+
+      pool(3) do |x|
+        nodes[x].move_to_root
+      end
+
+      Default.roots.map(&:position).should eq [1, 2, 3, 4]
+    end
+
+    # checking deadlock also
+    it "should not move nodes to same position when moving to specified index" do
+      # root
+      # * child1
+      #   * nodes1_1
+      #   * nodes1_2
+      # * child2
+      #   * nodes2_1
+      #   * nodes2_2
+      child1, child2 = create_list :default, 2, :parent => root
+
+      nodes1, nodes2 = create_list(:default, 2, :parent => child1),
+                       create_list(:default, 2, :parent => child2)
+
+      nodes1_1, nodes1_2 = nodes1
+      nodes2_1, nodes2_2 = nodes2
+
+      # nodes2_2 -> child1[0]
+      thread1 = Thread.new do
+        ActiveRecord::Base.connection_pool.with_connection do
+          nodes2_2.move_to_child_with_index(child1, 0)
+        end
+      end
+      # nodes1_1 -> child2[2]
+      thread2 = Thread.new do
+        ActiveRecord::Base.connection_pool.with_connection do
+          nodes1_1.move_to_child_with_index(child2, 2)
+        end
+      end
+      [thread1, thread2].map(&:join)
+
+      child1.children.reload.should == [nodes2_2, nodes1_2]
+      child2.children.reload.should == [nodes2_1, nodes1_1]
+    end
+
+    it "should not move nodes to same position when moving higher" do
+      child1, child2, child3 = create_list :default, 3, :parent => root
+
+      thread1 = Thread.new do
+        ActiveRecord::Base.connection_pool.with_connection do
+          child2.move_higher
+        end
+      end
+      thread2 = Thread.new do
+        ActiveRecord::Base.connection_pool.with_connection do
+          child3.move_higher
+        end
+      end
+
+      [thread1, thread2].map(&:join)
+
+      root.children.map(&:position).should eq [1, 2, 3]
+    end
+
+    it "should not move nodes to same position when moving lower" do
+      child1, child2, child3 = create_list :default, 3, :parent => root
+
+      thread1 = Thread.new do
+        ActiveRecord::Base.connection_pool.with_connection do
+          child1.move_lower
+        end
+      end
+      thread2 = Thread.new do
+        ActiveRecord::Base.connection_pool.with_connection do
+          child2.move_lower
+        end
+      end
+
+      [thread1, thread2].map(&:join)
+
+      root.children.map(&:position).should eq [1, 2, 3]
+    end
+  end
+end

data/spec/db/config.yml

@@ -0,0 +1,16 @@
+pg:
+  adapter: postgresql
+  username: postgres
+  database: acts_as_ordered_tree_test
+  host: 127.0.0.1
+  encoding: unicode
+  min_messages: ERROR
+mysql:
+  adapter: mysql2
+  database: acts_as_ordered_tree_test
+  username: root
+  password:
+  encoding: utf8
+sqlite3:
+  adapter: sqlite3
+  database: acts_as_ordered_tree.sqlite3.db

data/spec/spec_helper.rb

@@ -13,20 +13,19 @@ rescue LoadError
   #ignore
 end
 
-require "active_model"
 require "active_record"
-require "action_controller"
 require "factory_girl"
 
 require "acts_as_ordered_tree"
 require "logger"
+require "yaml"
 
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Base.configurations = YAML::load(IO.read(test_dir + "/db/config.yml"))
+ActiveRecord::Base.establish_connection(ENV['DB'] || "pg")
 ActiveRecord::Base.logger = Logger.new(ENV['DEBUG'] ? $stderr : '/dev/null')
 ActiveRecord::Migration.verbose = false
 load(File.join(test_dir, "db", "schema.rb"))
 
-require "rspec/rails"
 require "shoulda-matchers"
 require "support/models"
 require "support/factories"
@@ -34,13 +33,24 @@ require "support/matchers"
 
 RSpec.configure do |config|
   config.include FactoryGirl::Syntax::Methods
-  config.use_transactional_fixtures = true
 
-  config.around :each do |example|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  config.around :each, :transactional do |example|
     ActiveRecord::Base.transaction do
       example.run
 
       raise ActiveRecord::Rollback
     end
   end
+
+  config.around :each, :non_transactional do |example|
+    begin
+      example.run
+    ensure
+      Default.delete_all
+      DefaultWithCounterCache.delete_all
+      Scoped.delete_all
+    end
+  end
 end

data/spec/support/matchers.rb

@@ -118,7 +118,7 @@ module RSpec::Matchers
     def matches?(*records)
       @records = Array.wrap(records).flatten
 
-      @records.sort_by { |record| record[record.position_column] } == @records
+      @records.sort_by { |record| record.reload[record.position_column] } == @records
     end
 
     def failure_message_for_should
@@ -129,4 +129,25 @@ module RSpec::Matchers
       "expected #{@records.inspect} not to be ordered by position, but they are"
     end
   end
+end
+
+# Taken from rspec-rails
+module ::ActiveModel::Validations
+  # Extension to enhance `should have` on AR Model instances.  Calls
+  # model.valid? in order to prepare the object's errors object.
+  #
+  # You can also use this to specify the content of the error messages.
+  #
+  # @example
+  #
+  #     model.should have(:no).errors_on(:attribute)
+  #     model.should have(1).error_on(:attribute)
+  #     model.should have(n).errors_on(:attribute)
+  #
+  #     model.errors_on(:attribute).should include("can't be blank")
+  def errors_on(attribute)
+    self.valid?
+    [self.errors[attribute]].flatten.compact
+  end
+  alias :error_on :errors_on
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_ordered_tree
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-22 00:00:00.000000000 Z
+date: 2012-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -29,13 +29,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 0.9.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,15 +43,15 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 0.9.2
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -59,7 +59,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -76,22 +76,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '2.11'
-- !ruby/object:Gem::Dependency
-  name: rspec-rails
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '2.11'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '2.11'
 - !ruby/object:Gem::Dependency
   name: shoulda-matchers
   requirement: !ruby/object:Gem::Requirement
@@ -124,22 +108,6 @@ dependencies:
     - - <
       - !ruby/object:Gem::Version
         version: '3'
-- !ruby/object:Gem::Dependency
-  name: factory_girl_rails
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - <
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - <
-      - !ruby/object:Gem::Version
-        version: '3'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -165,12 +133,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/acts_as_ordered_tree.rb
+- lib/acts_as_ordered_tree/adapters/postgresql_adapter.rb
 - lib/acts_as_ordered_tree/class_methods.rb
-- lib/acts_as_ordered_tree/fake_scope.rb
 - lib/acts_as_ordered_tree/instance_methods.rb
+- lib/acts_as_ordered_tree/relation/base.rb
+- lib/acts_as_ordered_tree/relation/preloaded.rb
+- lib/acts_as_ordered_tree/relation/recursive.rb
+- lib/acts_as_ordered_tree/tenacious_transaction.rb
 - lib/acts_as_ordered_tree/validators.rb
 - lib/acts_as_ordered_tree/version.rb
 - spec/acts_as_ordered_tree_spec.rb
+- spec/concurrency_support_spec.rb
+- spec/db/config.yml
 - spec/db/schema.rb
 - spec/spec_helper.rb
 - spec/support/factories.rb
@@ -190,7 +164,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3932473491474199545
+      hash: 2475944794341416152
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -199,7 +173,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3932473491474199545
+      hash: 2475944794341416152
 requirements: []
 rubyforge_project: acts_as_ordered_tree
 rubygems_version: 1.8.24
@@ -208,6 +182,8 @@ specification_version: 3
 summary: ActiveRecord extension for sorted adjacency lists support
 test_files:
 - spec/acts_as_ordered_tree_spec.rb
+- spec/concurrency_support_spec.rb
+- spec/db/config.yml
 - spec/db/schema.rb
 - spec/spec_helper.rb
 - spec/support/factories.rb

data/lib/acts_as_ordered_tree/fake_scope.rb

@@ -1,28 +0,0 @@
-# coding: utf-8
-module ActsAsOrderedTree
-  class FakeScope < ActiveRecord::Relation
-    # create fake relation, with loaded records
-    #
-    # == Usage
-    #   FakeScope.new(Category.where(:id => 1), [record])
-    #   FakeScope.new(Category, [record]) { where(:id => 1) }
-    #   FakeScope.new(Category, [record], :where => {:id => 1}, :order => "id desc")
-    def initialize(relation, records, conditions = {})
-      relation = relation.scoped if relation.is_a?(Class)
-
-      conditions.each do |method, arg|
-        relation = relation.send(method, arg)
-      end
-
-      super(relation.klass, relation.table)
-
-      # copy instance variables from real relation
-      relation.instance_variables.each do |ivar|
-        instance_variable_set(ivar, relation.instance_variable_get(ivar))
-      end
-
-      @loaded  = true
-      @records = records
-    end
-  end
-end