acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/lib/acts_as_ordered_tree/relation/arrangeable.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/iterators/arranger'
+require 'acts_as_ordered_tree/iterators/orphans_pruner'
+
+module ActsAsOrderedTree
+  module Relation
+    # This AR::Relation extension allows to arrange collection into
+    # Hash of nested Hashes
+    module Arrangeable
+      # Arrange associated collection into a nested hash of the form
+      # {node => children}, where children = {} if the node has no children.
+      #
+      # It is possible to discard orphaned nodes (nodes which don't have
+      # corresponding parent node in this collection) by passing `:orphans => :discard`
+      # as option.
+      #
+      # @param [Hash] options
+      # @option options [:discard, nil] :orphans
+      # @return [Hash<ActiveRecord::Base => Hash>]
+      def arrange(options = {})
+        collection = self
+
+        if options && options[:orphans] == :discard
+          collection = Iterators::OrphansPruner.new(self)
+        end
+
+        @arranger ||= Iterators::Arranger.new(collection)
+        @arranger.arrange
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/relation/iterable.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/iterators/level_calculator'
+require 'acts_as_ordered_tree/iterators/orphans_pruner'
+
+module ActsAsOrderedTree
+  module Relation
+    module Iterable
+      # Iterates over tree elements and determines the current level in the tree.
+      # Only accepts default ordering, no orphans allowed (they considered as root elements).
+      # This method is efficient on trees that don't cache level.
+      #
+      # @example
+      #   node.descendants.each_with_level do |descendant, level|
+      #   end
+      #
+      # @return [Enumerator] if block is not given
+      def each_with_level(&block)
+        Iterators::LevelCalculator.new(self).each(&block)
+      end
+
+      # Iterates over tree elements but discards any orphaned nodes (e.g. nodes
+      # which have a parent, but parent isn't in current collection).
+      #
+      # @example Collection with orphaned nodes
+      #   # Assume we have following tree:
+      #   # root 1
+      #   #   child 1
+      #   # root 2
+      #   #   child 2
+      #
+      #   MyModel.where('id != ?', root_1.id).extending(Iterable).each_without_orphans.to_a
+      #   # => [root_2, child_2]
+      #
+      # @return [Enumerator] if block is not given
+      def each_without_orphans(&block)
+        Iterators::OrphansPruner.new(self).each(&block)
+      end
+    end # module Iterable
+  end # module Relation
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/relation/preloaded.rb

@@ -1,16 +1,51 @@
-require "acts_as_ordered_tree/relation/base"
+# coding: utf-8
 
 module ActsAsOrderedTree
   module Relation
-    # Common relation, but with already loaded records
-    class Preloaded < Base
-      # Set loaded records to +records+
+    # AR::Relation extension which adds ability to explicitly set records
+    #
+    # @example
+    #   records = MyModel.where(:parent_id => nil).to_a
+    #   relation = MyModel.where(:parent_id => nil).
+    #      extending(ActsAsOrderedTree::Relation::Preloaded).
+    #      records(records)
+    #   relation.to_a.should be records
+    module Preloaded
       def records(records)
-        relation = clone
-        relation.instance_variable_set :@records, records
-        relation.instance_variable_set :@loaded,  true
-        relation
+        @loaded = false
+        @records = records
+
+        build_where!
+
+        @loaded = true
+
+        self
+      end
+
+      # Reverse the existing order of records on the relation.
+      def reverse_order
+        (respond_to?(:spawn) ? spawn : clone).records(@records.reverse)
+      end
+
+      def reverse_order!
+        @records = @records.reverse
+
+        self
+      end
+
+      # Extending relation is not really intrusive operation, so we can save preloaded records
+      def extending(*)
+        super.tap { |relation| relation.records(@records) if loaded? }
+      end
+
+      private
+      def record_ids
+        @records.map { |r| r.id if r }.compact
+      end
+
+      def build_where!
+        self.where_values = build_where(:id => record_ids)
       end
-    end
-  end
-end
+    end # module Preloaded
+  end # module Relation
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/transaction/base.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/persevering_transaction'
+require 'acts_as_ordered_tree/transaction/callbacks'
+
+module ActsAsOrderedTree
+  module Transaction
+    # Persevering transaction, which restarts on deadlock
+    #
+    # Here we have a tree of possible transaction types:
+    #
+    #   Base (abstract)
+    #     Save (abstract)
+    #       Create
+    #       Update (abstract)
+    #         Move
+    #         Reorder
+    #     Destroy
+    #
+    # @api private
+    class Base
+      extend Callbacks
+
+      attr_reader :node
+
+      delegate :record, :tree, :to => :node
+      delegate :connection, :to => :klass
+
+      # @param [ActsAsOrderedTree::Node] node
+      def initialize(node)
+        @node = node
+      end
+
+      # Start persevering transaction, which will restart on deadlock
+      def start(&block)
+        transaction.start do
+          run_callbacks(:transaction, &block)
+        end
+      end
+
+      protected
+      def klass
+        record.class
+      end
+
+      # Returns underlying transaction object
+      def transaction
+        @transaction ||= PerseveringTransaction.new(connection)
+      end
+
+      # Trigger tree callback (before_add, after_add, before_remove, after_remove)
+      def trigger_callback(kind, owner)
+        tree.callbacks.send(kind, owner, record) if owner.present?
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/transaction/callbacks.rb

@@ -0,0 +1,67 @@
+require 'active_support/callbacks'
+
+module ActsAsOrderedTree
+  module Transaction
+    module Callbacks
+      def self.extended(base)
+        base.send(:include, ActiveSupport::Callbacks)
+        base.define_callbacks :transaction
+      end
+
+      def before(filter, *options, &block)
+        set_callback :transaction, :before, filter, *options, &block
+      end
+
+      def after(filter, *options, &block)
+        set_callback :transaction, :after, filter, *options, &block
+      end
+
+      def around(filter, *options, &block)
+        set_callback :transaction, :around, filter, *options, &block
+      end
+
+      # This method should be called in concrete transaction classes to prevent
+      # race conditions in multi-threaded environments.
+      #
+      # @api private
+      def finalize
+        finalize_callbacks :transaction
+      end
+
+      private
+      Compatibility.version '< 3.2.0' do
+        def finalize_callbacks(kind)
+          __define_runner(kind)
+        end
+      end
+
+      Compatibility.version '>= 3.2.0', '< 4.0.0' do
+        def finalize_callbacks(kind)
+          __reset_runner(kind)
+
+          object = allocate
+
+          name = __callback_runner_name(nil, kind)
+          unless object.respond_to?(name, true)
+            str = object.send("_#{kind}_callbacks").compile(nil, object)
+            class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+              def #{name}() #{str} end
+              protected :#{name}
+            RUBY_EVAL
+          end
+        end
+      end
+
+      Compatibility.version '>= 4.0.0', '< 4.1.0' do
+        def finalize_callbacks(kind)
+          __define_callbacks(kind, allocate)
+        end
+      end
+
+      # Rails 4.1 is thread safe
+      Compatibility.version '>= 4.1.0' do
+        def finalize_callbacks(kind) end
+      end
+    end # module Callbacks
+  end # module Transaction
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/transaction/create.rb

@@ -0,0 +1,68 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/transaction/save'
+require 'acts_as_ordered_tree/transaction/dsl'
+
+module ActsAsOrderedTree
+  module Transaction
+    # Create transaction (for new records only)
+    # @api private
+    class Create < Save
+      include DSL
+
+      before :push_to_bottom_after_commit, :if => 'push_to_bottom? && to.root?'
+      before :set_counter_cache, :if => 'tree.columns.counter_cache?'
+      before :increment_lower_positions, :unless => :push_to_bottom?
+      before 'trigger_callback(:before_add, to.parent)'
+
+      after  'to.increment_counter'
+      after  'node.reload'
+      after  'trigger_callback(:after_add, to.parent)'
+
+      finalize
+
+      private
+      def set_counter_cache
+        record[tree.columns.counter_cache] = 0
+      end
+
+      def increment_lower_positions
+        to.lower.update_all set position => position + 1
+      end
+
+      # If record was created as root there is a chance that position will collide,
+      # but this callback will force record to placed at the bottom of tree.
+      #
+      # Yep, concurrency is a tough thing.
+      #
+      # @see https://github.com/take-five/acts_as_ordered_tree/issues/24
+      def push_to_bottom_after_commit
+        transaction.after_commit do
+          connection.logger.debug { "Forcing new record (id=#{record.id}, position=#{node.position}) to be placed to bottom" }
+
+          connection.transaction do
+            # lock new siblings
+            to.siblings.lock.reload
+
+            if positions_collided?
+              update_created set position => siblings.select(coalesce(max(position), 0) + 1)
+            end
+          end
+        end
+      end
+
+      # Checks if there is +position_column+ collision within new parent
+      def positions_collided?
+        to.siblings.where(id.not_eq(record.id).and(position.eq(to.position))).exists?
+      end
+
+      def update_created(*args)
+        to.siblings.where(id.eq(record.id)).update_all(*args)
+      end
+
+      def siblings
+        to.siblings.where(id.not_eq(record.id))
+      end
+    end # class Create
+  end # module Transaction
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/transaction/destroy.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/transaction/base'
+require 'acts_as_ordered_tree/transaction/dsl'
+
+module ActsAsOrderedTree
+  module Transaction
+    class Destroy < Base
+      include DSL
+
+      attr_reader :from
+
+      before 'trigger_callback(:before_remove, from.parent)'
+
+      after :decrement_lower_positions
+      after 'from.decrement_counter'
+      after 'trigger_callback(:after_remove, from.parent)'
+
+      finalize
+
+      # @param [ActsAsOrderedTree::Node] node
+      # @param [ActsAsOrderedTree::Position] from from which position given +node+ is destroyed
+      def initialize(node, from)
+        super(node)
+        @from = from
+      end
+
+      private
+      def decrement_lower_positions
+        from.lower.update_all set position => position - 1
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/transaction/dsl.rb

@@ -0,0 +1,214 @@
+# coding: utf-8
+
+require 'active_support/core_ext/string/inflections'
+
+module Arel
+  module Nodes
+    # Case node
+    #
+    # @example
+    #   switch.when(table[:x].gt(1), table[:y]).else(table[:z])
+    #   # CASE WHEN "table"."x" > 1 THEN "table"."y" ELSE "table"."z" END
+    #   switch.when(table[:x].gt(1)).then(table[:y]).else(table[:z])
+    class Case < Arel::Nodes::Node
+      include Arel::OrderPredications
+      include Arel::Predications
+
+      attr_reader :conditions, :default
+
+      def initialize
+        @conditions = []
+        @default = nil
+      end
+
+      def when(condition, expression = nil)
+        @conditions << When.new(condition, expression)
+        self
+      end
+
+      def then(expression)
+        @conditions.last.right = expression
+        self
+      end
+
+      def else(expression)
+        @default = Else.new(expression)
+        self
+      end
+    end
+
+    class When < Arel::Nodes::Binary
+    end
+
+    class Else < Arel::Nodes::Unary
+    end
+  end
+
+  module Visitors
+    class ToSql < Arel::Visitors::ToSql.superclass
+      private
+      def visit_Arel_Nodes_Case o, *a
+        conditions = o.conditions.map { |x| visit x, *a }.join(' ')
+        default = o.default && visit(o.default, *a)
+
+        "CASE #{[conditions, default].compact.join(' ')} END"
+      end
+
+      def visit_Arel_Nodes_When o, *a
+        "WHEN #{visit o.left, *a} THEN #{visit o.right, *a}"
+      end
+
+      def visit_Arel_Nodes_Else o, *a
+        "ELSE #{visit o.expr, *a}"
+      end
+
+      if Arel::VERSION >= '6.0.0'
+        def visit_Arel_Nodes_Case o, collector
+          collector << 'CASE '
+          o.conditions.each do |x|
+            visit x, collector
+            collector << ' '
+          end
+          if o.default
+            visit o.default, collector
+            collector << ' '
+          end
+          collector << 'END'
+        end
+
+        def visit_Arel_Nodes_When o, collector
+          collector << 'WHEN '
+          visit o.left, collector
+          collector << ' THEN '
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_Else o, collector
+          collector << 'ELSE'
+          visit o.expr, collector
+        end
+
+        def visit_NilClass o, collector
+          collector << 'NULL'
+        end
+      end
+    end
+
+    class DepthFirst < Arel::Visitors::Visitor
+      def visit_Arel_Nodes_Case o, *a
+        visit o.conditions, *a
+        visit o.default, *a
+      end
+      alias :visit_Arel_Nodes_When :binary
+      alias :visit_Arel_Nodes_Else :unary
+    end
+  end
+end
+
+module ActsAsOrderedTree
+  module Transaction
+    # Simple DSL to generate complex UPDATE queries.
+    # Requires +record+ method.
+    #
+    # @api private
+    module DSL
+      module Shortcuts
+        INFIX_OPERATIONS = Hash[
+            :==   => Arel::Nodes::Equality,
+            :'!=' => Arel::Nodes::NotEqual,
+            :>    => Arel::Nodes::GreaterThan,
+            :>=   => Arel::Nodes::GreaterThanOrEqual,
+            :<    => Arel::Nodes::LessThan,
+            :<=   => Arel::Nodes::LessThanOrEqual,
+            :=~   => Arel::Nodes::Matches,
+            :'!~' => Arel::Nodes::DoesNotMatch,
+            :|    => Arel::Nodes::Or
+        ]
+
+        # generate subclasses and methods
+        INFIX_OPERATIONS.each do |operator, klass|
+          subclass = Class.new(klass) { include Shortcuts }
+          const_set(klass.name.demodulize, subclass)
+          INFIX_OPERATIONS[operator] = subclass
+
+          define_method(operator) do |arg|
+            subclass.new(self, arg)
+          end
+        end
+
+        And = Class.new(Arel::Nodes::And) { include Shortcuts }
+
+        def &(arg)
+          And.new [self, arg]
+        end
+      end
+
+      Attribute = Class.new(Arel::Attributes::Attribute) { include Shortcuts }
+      SqlLiteral = Class.new(Arel::Nodes::SqlLiteral) { include Shortcuts }
+
+      NamedFunction = Class.new(Arel::Nodes::NamedFunction) {
+        include Shortcuts
+        include Arel::Math
+      }
+
+      # Create Arel::Nodes::Case node
+      def switch
+        Arel::Nodes::Case.new
+      end
+
+      # Create assignments expression for UPDATE statement
+      #
+      # @example
+      #   Model.where(:parent_id => nil).update_all(set :name => switch.when(x < 10).then('OK').else('TOO LARGE'))
+      #
+      # @param [Hash] assignments
+      def set(assignments)
+        assignments.map do |attr, value|
+          next unless attr.present?
+
+          name = attr.is_a?(Arel::Attributes::Attribute) ? attr.name : attr.to_s
+
+          quoted = record.class.connection.quote_column_name(name)
+          "#{quoted} = (#{value.to_sql})"
+        end.join(', ')
+      end
+
+      def attribute(name)
+        name && Attribute.new(table, name.to_sym)
+      end
+
+      def expression(expr)
+        SqlLiteral.new(expr.to_s)
+      end
+
+      def id
+        attribute(record.ordered_tree.columns.id)
+      end
+
+      def parent_id
+        attribute(record.ordered_tree.columns.parent)
+      end
+
+      def position
+        attribute(record.ordered_tree.columns.position)
+      end
+
+      def depth
+        attribute(record.ordered_tree.columns.depth)
+      end
+
+      def table
+        record.class.arel_table
+      end
+
+      def method_missing(id, *args)
+        if args.length > 0
+          # function
+          NamedFunction.new(id.to_s.upcase, args)
+        else
+          super
+        end
+      end
+    end # module DSL
+  end # module Transaction
+end # module ActsAsOrderedTree