acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/lib/acts_as_ordered_tree/adapters/postgresql_adapter.rb

@@ -1,104 +0,0 @@
-require 'acts_as_ordered_tree/arrangeable'
-require 'acts_as_ordered_tree/relation/preloaded'
-
-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
-
-          with_recursive_join(query, 'self_and_ancestors').
-              order('self_and_ancestors._depth DESC').
-              extending(Arrangeable)
-        else
-          (ancestors + [self]).tap { |ary| ary.extend(Arrangeable) }
-        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
-
-        with_recursive_join(query, 'ancestors').
-            order('ancestors._depth DESC').
-            extending(Arrangeable)
-      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
-
-        with_recursive_join(query, 'descendants').
-            order('descendants._positions ASC').
-            extending(Arrangeable)
-      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
-
-      def with_recursive_join(recursive_query_sql, aliaz)
-        join_sql = 'INNER JOIN (' +
-            "WITH RECURSIVE #{aliaz} AS (" +
-            recursive_query_sql +
-            ") SELECT * FROM #{aliaz} " +
-            ") #{aliaz} ON #{aliaz}.id = #{self.class.quoted_table_name}.id"
-
-        ordered_tree_scope.joins(join_sql)
-      end
-
-      # Rails 3.0 does not support update_all with joins, so we patch it :(
-      if ActiveRecord::VERSION::STRING <= '3.1.0'
-        module Rails30UpdateAllPatch
-          def update_all(updates, conditions = nil, options = {})
-            relation = except(:joins, :where).
-                where(:id => select(klass.arel_table[:id]).except(:order, :limit).arel)
-            relation.update_all(updates, conditions, options)
-          end
-        end
-
-        def with_recursive_join_30(recursive_query_sql, aliaz)
-          relation = with_recursive_join_31(recursive_query_sql, aliaz)
-          relation.extend(Rails30UpdateAllPatch)
-          relation
-        end
-        alias_method :with_recursive_join_31, :with_recursive_join
-        alias_method :with_recursive_join, :with_recursive_join_30
-      end
-    end
-  end
-end

data/lib/acts_as_ordered_tree/arrangeable.rb

@@ -1,80 +0,0 @@
-module ActsAsOrderedTree
-  module Arrangeable
-    # @api private
-    class Arranger
-      attr_reader :collection, :cache
-
-      def initialize(collection, options = {})
-        @collection = collection
-        @discard_orphans = options[:orphans] == :discard
-        @min_level = nil
-
-        if discard_orphans? && !collection.klass.depth_column && ActiveRecord::Base.logger
-          ActiveRecord::Base.logger.warn {
-            '%s model has no `depth` column, '\
-            'it can lead to N+1 queries during #arrange method invocation' % collection.klass
-          }
-        end
-
-        @cache = Hash.new
-        @prepared = false
-      end
-
-      def arrange
-        prepare unless prepared?
-
-        @arranged ||= collection.each_with_object(Hash.new) do |node, result|
-          ancestors = ancestors(node)
-
-          if discard_orphans?
-            root = ancestors.first || node
-
-            next if root.level > @min_level
-          end
-
-          insertion_point = result
-
-          ancestors.each { |a| insertion_point = (insertion_point[a] ||= {}) }
-
-          insertion_point[node] = {}
-        end
-      end
-
-      private
-      def prepare
-        collection.each do |node|
-          cache[node.id] = node if node.id
-          @min_level = [@min_level, node.level].compact.min
-        end
-
-        @prepared = true
-      end
-
-      def discard_orphans?
-        @discard_orphans
-      end
-
-      def prepared?
-        @prepared
-      end
-
-      # get parent node of +node+
-      def parent(node)
-        cache[node[node.parent_column]]
-      end
-
-      def ancestors(node)
-        parent = parent(node)
-        parent ? ancestors(parent) + [parent] : []
-      end
-    end
-    private_constant :Arranger
-
-    # Arrange associated collection into a nested hash of the form
-    # {node => children}, where children = {} if the node has no children.
-    def arrange(options = {})
-      @arranger ||= Arranger.new(self, options)
-      @arranger.arrange
-    end
-  end
-end

data/lib/acts_as_ordered_tree/class_methods.rb

@@ -1,72 +0,0 @@
-require "acts_as_ordered_tree/adapters/postgresql_adapter"
-
-module ActsAsOrderedTree
-  module ClassMethods
-    extend ActiveSupport::Concern
-
-    included do
-      scope :preorder, -> { order(arel_table[position_column].asc) }
-      scope :roots, -> { where(arel_table[parent_column].eq(nil)).preorder }
-
-      # add +leaves+ scope only if counter_cache column present
-      scope :leaves, -> { where(arel_table[children_counter_cache_column].eq(0)) } if
-          children_counter_cache?
-
-      # when default value for counter_cache is absent we should set it manually
-      before_create "self.#{children_counter_cache_column} = 0" if children_counter_cache?
-    end
-
-    module ClassMethods
-      # Returns the first root
-      def root
-        roots.first
-      end
-
-      private
-      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/relation/base.rb

@@ -1,26 +0,0 @@
-module ActsAsOrderedTree
-  module Relation
-    class Base < ActiveRecord::Relation
-      EMPTY_SCOPE_METHOD = ActiveRecord::VERSION::STRING < '4.0.0' ? :scoped : :all
-
-      # 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.send(EMPTY_SCOPE_METHOD)
-          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/tenacious_transaction.rb

@@ -1,30 +0,0 @@
-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 self.class.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/spec/concurrency_support_spec.rb

@@ -1,156 +0,0 @@
-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)
-        size.times.map { |x|
-          Thread.new do
-            ActiveRecord::Base.connection_pool.with_connection { yield x }
-          end
-        }.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