acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d1d945d226f1b6846fa1b58f24a6adab1d41425
-  data.tar.gz: a894af6acac2e1d1bbc044cc008effc846b5b42a
+  metadata.gz: 43c7e01b6a7953300b7be948777fc396f0c3d00a
+  data.tar.gz: 73aa9566feb83f5edbafaa39b9a01d3438cd9934
 SHA512:
-  metadata.gz: 458af4339a7cdb37ab604344970a7c83264827b62923b90f90e5e607355babd918df26b96897ff91ca2f1b6064f8d0cb6f2d95d1af14c3da6d67cb9cd3ecd060
-  data.tar.gz: 62cd0756ebb2c63518cd73ef53b6163eac7bf1716ebb3d3614217bd2bebe2eefa14109dd87a53ae755032f63ce0c75a24a4f43fd1069b8d5dbca0c7edd970f78
+  metadata.gz: 35b94b1c3a68e9f11ac53fc6ebe07cf88635d0955dfa3ac6af11172766c57f9be7597c0ee1a139567ff1c7c7ee6316cb9e1b6409139dab120cbfa6ac267561f1
+  data.tar.gz: 08ff712d44b295769c4761d9bed62cb722c6ab3c5e7b6b0cf63cf7c2e77bfb389cfd452da9dfe1ae52caabd19fcf364d2d2e0b244900f3e2564a46741e2b62e8

data/lib/acts_as_ordered_tree.rb

@@ -1,15 +1,11 @@
-require 'active_record'
 require 'acts_as_ordered_tree/version'
-require 'acts_as_ordered_tree/class_methods'
-require 'acts_as_ordered_tree/instance_methods'
-require 'acts_as_ordered_tree/validators'
+require 'active_support/lazy_load_hooks'
 
 module ActsAsOrderedTree
-  PROTECTED_ATTRIBUTES_SUPPORTED = ActiveRecord::VERSION::STRING < '4.0.0' ||
-    defined?(ProtectedAttributes)
+  autoload :Tree, 'acts_as_ordered_tree/tree'
 
-  # can we use has_many :children, :order => :position
-  PLAIN_ORDER_OPTION_SUPPORTED = ActiveRecord::VERSION::STRING < '4.0.0'
+  # @!attribute [r] ordered_tree
+  #   @return [ActsAsOrderedTree::Tree] ordered tree object
 
   # == Usage
   #   class Category < ActiveRecord::Base
@@ -19,101 +15,27 @@ module ActsAsOrderedTree
   #                          :counter_cache => :children_count
   #   end
   def acts_as_ordered_tree(options = {})
-    options = {
-      :parent_column   => :parent_id,
-      :position_column => :position,
-      :depth_column    => :depth
-    }.merge(options)
-
-    class_attribute :acts_as_ordered_tree_options, :instance_writer => false
-    self.acts_as_ordered_tree_options = options
-
-    acts_as_ordered_tree_options[:depth_column] = nil unless
-        columns_hash.include?(acts_as_ordered_tree_options[:depth_column].to_s)
-
-    extend  Columns
-    include Columns
-
-    has_many_children_options = {
-      :class_name    => "::#{base_class.name}",
-      :foreign_key   => options[:parent_column],
-      :inverse_of    => (:parent unless options[:polymorphic]),
-      :dependent     => :destroy
-    }
-
-    [:before_add, :after_add, :before_remove, :after_remove].each do |callback|
-      has_many_children_options[callback] = options[callback] if options.key?(callback)
-    end
-
-    if PLAIN_ORDER_OPTION_SUPPORTED
-      has_many_children_options[:order] = options[:position_column]
-
-      if scope_column_names.any?
-        has_many_children_options[:conditions] = proc do
-          [scope_column_names.map { |c| "#{c} = ?" }.join(' AND '),
-           scope_column_names.map { |c| self[c] }]
-        end
-      end
-
-      has_many :children, has_many_children_options
-    else
-      scope = ->(parent) {
-        relation = order(options[:position_column])
-
-        if scope_column_names.any?
-          relation = relation.where(
-            Hash[scope_column_names.map { |c| [c, parent[c]]}]
-          )
-        end
-
-        relation
-      }
-
-      has_many :children, scope, has_many_children_options
-    end
-
-    # create parent association
-    belongs_to :parent,
-               :class_name => "::#{base_class.name}",
-               :foreign_key => options[:parent_column],
-               :counter_cache => options[:counter_cache],
-               :inverse_of => (:children unless options[:polymorphic])
-
-    include ClassMethods
-    include InstanceMethods
-    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 if PROTECTED_ATTRIBUTES_SUPPORTED
-    end
-
-    def parent_column
-      acts_as_ordered_tree_options[:parent_column]
-    end
-
-    def position_column
-      acts_as_ordered_tree_options[:position_column]
-    end
+    Tree.setup!(self, options)
+  end
 
-    def depth_column
-      acts_as_ordered_tree_options[:depth_column] || nil
-    end
+  # @api private
+  def self.extended(base)
+    base.class_attribute :ordered_tree, :instance_writer => false
+  end
 
-    def children_counter_cache_column
-      acts_as_ordered_tree_options[:counter_cache] || nil
-    end
+  # Rebuild ordered tree structure for subclasses. It needs to be rebuilt
+  # mainly because of :children and :parent associations, which are created
+  # with option :class_name. It matters for class hierarchies without STI,
+  # they can't work properly with associations inherited from superclass.
+  #
+  # @api private
+  def inherited(subclass)
+    super
 
-    def scope_column_names
-      Array(acts_as_ordered_tree_options[:scope]).compact
-    end
+    subclass.acts_as_ordered_tree(ordered_tree.options) if ordered_tree?
   end
 end # module ActsAsOrderedTree
 
-ActiveRecord::Base.extend(ActsAsOrderedTree)
+ActiveSupport.on_load(:active_record) do
+  extend ActsAsOrderedTree
+end

data/lib/acts_as_ordered_tree/adapters.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+
+require 'active_support/hash_with_indifferent_access'
+require 'acts_as_ordered_tree/adapters/recursive'
+require 'acts_as_ordered_tree/adapters/postgresql'
+
+module ActsAsOrderedTree
+  module Adapters
+    # adapters map
+    ADAPTERS = HashWithIndifferentAccess['PostgreSQL' => PostgreSQL]
+    ADAPTERS.default = Recursive
+
+    def self.lookup(name)
+      ADAPTERS[name]
+    end
+  end
+end

data/lib/acts_as_ordered_tree/adapters/abstract.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+module ActsAsOrderedTree
+  module Adapters
+    class Abstract
+      attr_reader :tree
+
+      # @param [ActsAsOrderedTree::Tree] tree
+      def initialize(tree)
+        @tree = tree
+      end
+
+      protected
+      def preloaded(records)
+        tree.klass.where(nil).extending(Relation::Preloaded).records(records)
+      end
+
+      def none
+        tree.klass.where(nil).none
+      end
+    end # class Abstract
+  end # module Adapters
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/adapters/postgresql.rb

@@ -0,0 +1,150 @@
+# coding: utf-8
+
+require 'active_record/hierarchical_query'
+
+require 'acts_as_ordered_tree/adapters/abstract'
+require 'acts_as_ordered_tree/relation/preloaded'
+
+module ActsAsOrderedTree
+  module Adapters
+    # PostgreSQL adapter implements traverse operations with CTEs
+    class PostgreSQL < Abstract
+      attr_reader :tree
+
+      delegate :columns, :to => :tree
+      delegate :quote_column_name, :to => 'tree.klass.connection'
+
+      def self_and_descendants(node, &block)
+        traverse_down(node) do
+          descendants_scope(node.ordered_tree_node, &block)
+        end
+      end
+
+      def descendants(node, &block)
+        traverse_down(node) do
+          without(node) { self_and_descendants(node, &block) }
+        end
+      end
+
+      def self_and_ancestors(node, &block)
+        traverse_up(node, [node]) do
+          ancestors_scope(node.ordered_tree_node, &block)
+        end
+      end
+
+      def ancestors(node, &block)
+        traverse_up(node) do
+          without(node) { self_and_ancestors(node, &block) }
+        end
+      end
+
+      private
+      def without(node)
+        scope = yield
+        scope.where(scope.table[columns.id].not_eq(node.id))
+      end
+
+      def traverse_down(node)
+        if node && node.persisted?
+          yield
+        else
+          none
+        end
+      end
+
+      # Yields to block if record is persisted and its parent was not changed.
+      # Returns empty scope (or scope with +including+ records) if record is root.
+      # Otherwise recursively fetches ancestors and returns preloaded relation.
+      def traverse_up(node, including = [])
+        return none unless node
+
+        if can_traverse_up?(node)
+          if node.ordered_tree_node.has_parent?
+            yield
+          else
+            including.empty? ? none : preloaded(including)
+          end
+        else
+          preloaded(persisted_ancestors(node) + including)
+        end
+      end
+
+      # Generates scope that traverses tree down to deep, starting from given +scope+
+      def descendants_scope(node)
+        node.scope.join_recursive do |query|
+          query.connect_by(join_columns(columns.id => columns.parent))
+               .start_with(node.to_relation)
+
+          yield query if block_given?
+
+          query.order_siblings(position)
+        end
+      end
+
+      # Generates scope that traverses tree up to root, starting from given +scope+
+      def ancestors_scope(node, &block)
+        if columns.depth?
+          build_ancestors_query(node, &block).reorder(depth)
+        else
+          build_ancestors_query(node) do |query|
+            query.start_with { |start| start.select Arel.sql('0').as('__depth') }
+                 .select(query.prior['__depth'] - 1, :start_with => false)
+
+            yield query if block_given?
+          end.reorder('__depth')
+        end
+      end
+
+      def build_ancestors_query(node)
+        node.scope.join_recursive do |query|
+          query.connect_by(join_columns(columns.parent => columns.id))
+               .start_with(node.to_relation)
+
+          yield query if block_given?
+        end
+      end
+
+      def attribute(name)
+        @tree.klass.arel_table[name]
+      end
+
+      def depth
+        attribute(columns.depth)
+      end
+
+      def position
+        attribute(columns.position)
+      end
+
+      def can_traverse_up?(node)
+        node.persisted? && !node.ordered_tree_node.parent_id_changed?
+      end
+
+      # Recursively fetches node's parents until one of them will be persisted.
+      # Returns persisted ancestor and array of non-persistent ancestors
+      def persisted_ancestors(node)
+        queue = []
+
+        parent = node
+
+        while (parent = parent.parent)
+          break if parent && parent.persisted?
+
+          queue.unshift(parent)
+        end
+
+        ancestors(parent) + [parent].compact + queue
+      end
+
+      def scope_columns_hash
+        Hash[tree.columns.scope.map { |x| [x, x] }]
+      end
+
+      def join_columns(hash)
+        scope_columns_hash.merge(hash).each_with_object({}) do |(k, v), h|
+          h[k.to_sym] = v.to_sym
+        end
+      end
+    end # class PostgreSQL
+  end # module Adapters
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/adapters/recursive.rb

@@ -0,0 +1,157 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/adapters/abstract'
+
+module ActsAsOrderedTree
+  module Adapters
+    # Recursive adapter implements tree traversal in pure Ruby.
+    class Recursive < Abstract
+      def self_and_ancestors(node, &block)
+        return none unless node
+
+        ancestors_scope(node, :include_first => true, &block)
+      end
+
+      def ancestors(node, &block)
+        ancestors_scope(node, :include_first => false, &block)
+      end
+
+      def descendants(node, &block)
+        descendants_scope(node, :include_first => false, &block)
+      end
+
+      def self_and_descendants(node, &block)
+        descendants_scope(node, :include_first => true, &block)
+      end
+
+      private
+      def ancestors_scope(node, options, &block)
+        traversal = Traversal.new(node, options, &block)
+        traversal.follow :parent
+        traversal.to_scope.reverse_order!
+      end
+
+      def descendants_scope(node, options, &block)
+        return none unless node.persisted?
+
+        traversal = Traversal.new(node, options, &block)
+        traversal.follow :children
+        traversal.to_scope
+      end
+
+      class Traversal
+        delegate :klass, :to => :@start_record
+        attr_accessor :include_first
+
+        def initialize(start_record, options = {})
+          @start_record = start_record
+          @start_with = nil
+          @order_values = []
+          @where_values = []
+          @include_first = options[:include_first]
+          follow(options[:follow]) if options.key?(:follow)
+
+          yield self if block_given?
+        end
+
+        def follow(association_name)
+          @association = association_name
+
+          self
+        end
+
+        def start_with(scope = nil, &block)
+          @start_with = scope || block
+
+          self
+        end
+
+        def order_siblings(*values)
+          @order_values << values
+
+          self
+        end
+        alias_method :order, :order_siblings
+
+        def where(*values)
+          @where_values << values
+
+          self
+        end
+
+        def table
+          klass.arel_table
+        end
+
+        def klass
+          @start_record.class
+        end
+
+        def to_scope
+          null_scope.records(to_enum.to_a)
+        end
+
+        private
+        def each(&block)
+          return unless validate_start_conditions
+
+          yield @start_record if include_first
+
+          expand(@start_record, &block)
+        end
+
+        def validate_start_conditions
+          start_scope ? start_scope.exists? : true
+        end
+
+        def start_scope
+          return nil unless @start_with
+
+          if @start_with.is_a?(Proc)
+            @start_with.call klass.where(klass.primary_key => @start_record.id)
+          else
+            @start_with
+          end
+        end
+
+        def expand(record, &block)
+          expand_association(record).each do |child|
+            yield child
+
+            expand(child, &block)
+          end
+        end
+
+        def expand_association(record)
+          if constraints?
+            build_scope(record)
+          else
+            follow_association(record)
+          end
+        end
+
+        def build_scope(record)
+          scope = record.association(@association).scope
+
+          @where_values.each { |v| scope = scope.where(*v) }
+          scope = scope.except(:order).order(*@order_values.flatten) if @order_values.any?
+
+          scope
+        end
+
+        def follow_association(record)
+          Array.wrap(record.send(@association))
+        end
+
+        def null_scope
+          klass.where(nil).extending(Relation::Preloaded)
+        end
+
+        def constraints?
+          @where_values.any? || @order_values.any?
+        end
+      end
+      private_constant :Traversal
+    end # class Recursive
+  end # module Adapters
+end # module ActsAsOrderedTree