acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/lib/acts_as_ordered_tree/transaction/factory.rb

@@ -0,0 +1,67 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/position'
+require 'acts_as_ordered_tree/transaction/create'
+require 'acts_as_ordered_tree/transaction/destroy'
+require 'acts_as_ordered_tree/transaction/move'
+require 'acts_as_ordered_tree/transaction/passthrough'
+require 'acts_as_ordered_tree/transaction/reorder'
+
+module ActsAsOrderedTree
+  module Transaction
+    # @api private
+    module Factory
+      # Creates previous and current position objects for node
+      # @api private
+      class PositionFactory
+        def initialize(node)
+          @node = node
+        end
+
+        def previous
+          Position.new @node, @node.parent_id_was, @node.position_was
+        end
+
+        def current
+          Position.new @node, @node.parent_id, @node.position
+        end
+
+        def transition
+          Position::Transition.new(previous, current)
+        end
+      end
+      private_constant :PositionFactory
+
+      # Creates proper transaction according to +node+
+      #
+      # @param [ActsAsOrderedTree::Node] node
+      # @param [true, false] destroy set to true if node should be destroyed
+      # @return [ActsAsOrderedTree::Transaction::Base]
+      def create(node, destroy = false)
+        pos = PositionFactory.new(node)
+
+        case
+          when destroy
+            Destroy.new(node, pos.previous)
+          when node.record.new_record?
+            Create.new(node, pos.current)
+          else
+            create_from_transition(node, pos.transition)
+        end
+      end
+      module_function :create
+
+      def create_from_transition(node, transition)
+        case
+          when transition.movement?
+            Move.new(node, transition)
+          when transition.reorder?
+            Reorder.new(node, transition)
+          else
+            Passthrough.new
+        end
+      end
+      module_function :create_from_transition
+    end
+  end
+end

data/lib/acts_as_ordered_tree/transaction/move.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/transaction/update'
+
+module ActsAsOrderedTree
+  module Transaction
+    class Move < Update
+      before 'trigger_callback(:before_remove, from.parent)'
+      before 'trigger_callback(:before_add, to.parent)'
+
+      after :update_descendants_depth, :if => [
+          'transition.movement?',
+          'tree.columns.depth?',
+          'transition.level_changed?',
+          'record.children.size > 0'
+      ]
+
+      after 'trigger_callback(:after_add, to.parent)'
+      after 'trigger_callback(:after_remove, from.parent)'
+      after 'transition.update_counters'
+
+      finalize
+
+      private
+      def update_values
+        updates = Hash[
+            position => position_value,
+            parent_id => parent_id_value
+        ]
+
+        updates[depth] = depth_value if tree.columns.depth? && transition.level_changed?
+
+        updates
+      end
+
+      # Records to be updated
+      def update_scope
+        filter = (id == record.id) | (parent_id == from.parent_id) | (parent_id == to.parent_id)
+        node.scope.where(filter.to_sql)
+      end
+
+      def parent_id_value
+        switch.when(id == record.id, to.parent_id).else(parent_id)
+      end
+
+      def position_value
+        switch.
+            when(id == record.id).
+                then(@to.position).
+            # decrement lower positions in old parent
+            when((parent_id == from.parent_id) & (position > from.position)).
+                then(position - 1).
+            # increment positions in new parent
+            when((parent_id == to.parent_id) & (position >= to.position)).
+                then(position + 1).
+            else(position)
+      end
+
+      def depth_value
+        switch.
+            when(id == record.id, to.depth).
+            else(depth)
+      end
+
+      def update_descendants_depth
+        record.descendants.update_all set depth => depth + (to.depth - from.depth)
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/transaction/passthrough.rb

@@ -0,0 +1,12 @@
+# coding: utf-8
+
+module ActsAsOrderedTree
+  module Transaction
+    # Null transaction, does nothing but delegates to caller
+    class Passthrough
+      def start(&block)
+        block.call if block_given?
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/transaction/reorder.rb

@@ -0,0 +1,42 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/transaction/update'
+
+module ActsAsOrderedTree
+  module Transaction
+    class Reorder < Update
+      finalize
+
+      protected
+      # if we reorder node then we cannot put it to position higher than highest
+      def push_to_bottom
+        to.position = highest_position.zero? ? 1 : highest_position
+      end
+
+      private
+      def update_scope
+        to.siblings.where(positions_range)
+      end
+
+      def update_values
+        { position => position_value }
+      end
+
+      def positions_range
+        position.in([from.position, to.position].min..[from.position, to.position].max)
+      end
+
+      def position_value
+        expr = switch.
+            when(position == from.position).then(to.position).
+            else(position)
+
+        if to.position > from.position
+          expr.when(positions_range).then(position - 1)
+        else
+          expr.when(positions_range).then(position + 1)
+        end
+      end
+    end # class Reorder
+  end # module Transaction
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/transaction/save.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/transaction/base'
+
+module ActsAsOrderedTree
+  module Transaction
+    class Save < Base
+      attr_reader :to
+
+      before 'to.lock!'
+      before :set_scope!, :if => 'to.parent?'
+      before :push_to_bottom, :if => :push_to_bottom?
+      before 'to.position = 1', :if => 'to.position <= 0'
+
+      around :copy_attributes
+
+      # @param [ActsAsOrderedTree::Node] node
+      # @param [ActsAsOrderedTree::Position] to to which position given +node+ is saved
+      def initialize(node, to)
+        super(node)
+        @to = to
+      end
+
+      protected
+      # Copies parent_id, position and depth from destination to record
+      def copy_attributes
+        record.parent = to.parent
+        node.position = to.position
+        node.depth = to.depth if tree.columns.depth?
+
+        yield
+      end
+
+      # Returns highest position within node's siblings
+      def highest_position
+        @highest_position ||= to.siblings.maximum(tree.columns.position) || 0
+      end
+
+      # Should be fired when given position is empty
+      def push_to_bottom
+        to.position = highest_position + 1
+      end
+
+      # Returns true if record should be pushed to bottom of list
+      def push_to_bottom?
+        to.position.blank? ||
+            position_out_of_bounds?
+      end
+
+      private
+      def set_scope!
+        tree.columns.scope.each do |column|
+          record[column] = to.parent[column]
+        end
+
+        nil
+      end
+
+      def position_out_of_bounds?
+        to.position > highest_position
+      end
+    end # class Save
+  end # module Transaction
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/transaction/update.rb

@@ -0,0 +1,78 @@
+# coding: utf-8
+
+require 'active_support/core_ext/object/with_options'
+
+require 'acts_as_ordered_tree/position'
+require 'acts_as_ordered_tree/transaction/save'
+require 'acts_as_ordered_tree/transaction/dsl'
+
+module ActsAsOrderedTree
+  module Transaction
+    # Update transaction includes Move and Reorder
+    #
+    # @abstract
+    # @api private
+    class Update < Save
+      include DSL
+
+      attr_reader :from, :transition
+
+      around :update_tree
+
+      # @param [ActsAsOrderedTree::Node] node
+      # @param [ActsAsOrderedTree::Position::Transition] transition
+      def initialize(node, transition)
+        @transition = transition
+        @from = transition.from
+
+        super(node, transition.to)
+      end
+
+      protected
+      def update_tree
+        callbacks = transition.reorder? ? :reorder : :move
+
+        record.run_callbacks(callbacks) do
+          record.hook_update do |update|
+            update.scope = update_scope
+            update.values = update_values.merge(changed_attributes)
+
+            yield
+          end
+        end
+      end
+
+      def update_scope
+        # implement in successors
+      end
+
+      def update_values
+        # implement in successors
+      end
+
+      private
+      # Returns hash of UPDATE..SET expressions for each
+      # changed record attribute (except tree attributes)
+      #
+      # @return [Hash<String => Arel::Nodes::Node>]
+      def changed_attributes
+        changed_attributes_names.each_with_object({}) do |attr, hash|
+          hash[attr] = attribute_value(attr)
+        end
+      end
+
+      def attribute_value(attr)
+        attr_value = record.read_attribute(attr)
+        quoted = record.class.connection.quote(attr_value)
+
+        switch.
+            when(id == record.id).then(Arel.sql(quoted)).
+            else(attribute(attr))
+      end
+
+      def changed_attributes_names
+        record.changed - (tree.columns.to_a - tree.columns.scope)
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/tree.rb

@@ -0,0 +1,148 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/compatibility'
+
+require 'acts_as_ordered_tree/tree/callbacks'
+require 'acts_as_ordered_tree/tree/columns'
+require 'acts_as_ordered_tree/tree/children_association'
+require 'acts_as_ordered_tree/tree/deprecated_columns_accessors'
+require 'acts_as_ordered_tree/tree/parent_association'
+require 'acts_as_ordered_tree/tree/perseverance'
+require 'acts_as_ordered_tree/tree/scopes'
+
+require 'acts_as_ordered_tree/hooks'
+
+require 'acts_as_ordered_tree/adapters'
+require 'acts_as_ordered_tree/validators'
+
+require 'acts_as_ordered_tree/instance_methods'
+
+module ActsAsOrderedTree
+  # ActsAsOrderedTree::Tree
+  class Tree
+    # Default ordered tree options
+    DEFAULT_OPTIONS = {
+      :parent_column => :parent_id,
+      :position_column => :position,
+      :depth_column => :depth
+    }.freeze
+
+    PROTECTED_ATTRIBUTES = :left_sibling, :left_sibling_id,
+                           :higher_item, :higher_item_id,
+                           :right_sibling, :right_sibling_id,
+                           :lower_item, :lower_item_id
+
+    attr_reader :klass
+
+    # @!attribute [r] columns
+    #   Columns information aggregator
+    #
+    #   @return [ActsAsOrderedTree::Tree::Columns] column object
+    attr_reader :columns
+
+    # @!attribute [r] callbacks
+    #   :before_add, :after_add, :before_remove and :after_remove callbacks storage
+    #
+    #   @return [ActsAsOrderedTree::Tree::Callbacks] callbacks object
+    attr_reader :callbacks
+
+    # @!attribute [r] adapter
+    #   Ordered tree adapter which contains implementation of some traverse methods
+    #
+    #   @return [ActsAsOrderedTree::Adapters::Abstract] adapter object
+    attr_reader :adapter
+
+    # @!attribute [r] options
+    #   Ordered tree options
+    #
+    #   @return [Hash]
+    attr_reader :options
+
+    # Create and setup tree object
+    #
+    # @param [Class] klass
+    # @param [Hash] options
+    def self.setup!(klass, options)
+      klass.ordered_tree = new(klass, options).setup
+    end
+
+    # @param [Class] klass
+    # @param [Hash] options
+    def initialize(klass, options)
+      @klass = klass
+      @options = DEFAULT_OPTIONS.merge(options).freeze
+      @columns = Columns.new(klass, @options)
+      @callbacks = Callbacks.new(klass, @options)
+      @children = ChildrenAssociation.new(self)
+      @parent = ParentAssociation.new(self)
+      @adapter = Adapters.lookup(klass.connection.adapter_name).new(self)
+    end
+
+    # Builds associations, callbacks, validations etc.
+    def setup
+      setup_associations
+      setup_once
+
+      self
+    end
+
+    # Returns Class object which will be used for associations,
+    # scopes and tree traversals.
+    #
+    # @return [Class]
+    def base_class
+      if klass.finder_needs_type_condition?
+        klass.base_class
+      else
+        klass
+      end
+    end
+
+    private
+    def already_setup?
+      klass.ordered_tree?
+    end
+
+    def setup_once
+      return if already_setup?
+
+      setup_validations
+      setup_callbacks
+      protect_attributes *PROTECTED_ATTRIBUTES
+
+      klass.class_eval do
+        extend Scopes
+        extend DeprecatedColumnsAccessors
+
+        include InstanceMethods
+        include Perseverance
+        include Hooks
+      end
+    end
+
+    def setup_associations
+      @parent.build
+      @children.build
+    end
+
+    def setup_validations
+      if columns.scope?
+        klass.validates_with Validators::ScopeValidator, :on => :update, :if => :parent
+      end
+
+      klass.validates_with Validators::CyclicReferenceValidator, :on => :update, :if => :parent
+    end
+
+    def setup_callbacks
+      klass.define_model_callbacks(:move, :reorder)
+      klass.around_save(:save_ordered_tree_node)
+      klass.around_destroy(:destroy_ordered_tree_node)
+    end
+
+    def protect_attributes(*attributes)
+      Compatibility.version '< 4.0.0' do
+        klass.attr_protected *attributes
+      end
+    end
+  end
+end