acts_as_ordered_tree 1.3.1 → 2.0.0.beta3

data/lib/acts_as_ordered_tree/tree/association.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+module ActsAsOrderedTree
+  class Tree
+    class Association
+      attr_reader :tree
+
+      delegate :klass, :to => :tree
+
+      def initialize(tree)
+        @tree = tree
+      end
+
+      protected
+      def class_name
+        "::#{tree.base_class.name}"
+      end
+    end # class Association
+  end # class Tree
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/tree/callbacks.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+require 'active_support/core_ext/hash/slice'
+
+module ActsAsOrderedTree
+  class Tree
+    # Tree callbacks storage
+    #
+    # @example
+    #   MyModel.ordered_tree.callbacks.before_add(parent, child)
+    #
+    # @api private
+    class Callbacks
+      VALID_KEYS = :before_add,
+                   :after_add,
+                   :before_remove,
+                   :after_remove
+
+      def initialize(klass, options)
+        @klass = klass
+        @callbacks = {}
+
+        options.slice(*VALID_KEYS).each do |k, v|
+          @callbacks[k] = v if v
+        end
+      end
+
+      # generate accessors and predicates
+      VALID_KEYS.each do |method|
+        define_method(method) do |parent, record| # def before_add(parent, record)
+          run_callbacks(method, parent, record)
+        end
+      end
+
+      private
+      def run_callbacks(method, parent, record)
+        callback = callback_for(method)
+
+        case callback
+          when Symbol
+            parent.send(callback, record)
+          when Proc
+            callback.call(parent, record)
+          when nil, false
+            # do nothing
+          else
+            # parent.before_add(record)
+            callback.send(method, parent, record)
+        end
+      end
+
+      def callback_for(method)
+        @callbacks[method]
+      end
+    end # class Callbacks
+  end # class Tree
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/tree/children_association.rb

@@ -0,0 +1,120 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/compatibility'
+require 'acts_as_ordered_tree/tree/association'
+require 'acts_as_ordered_tree/relation/iterable'
+
+module ActsAsOrderedTree
+  class Tree
+    # @api private
+    class ChildrenAssociation < Association
+      # CounterCache extensions will allow to use cached value
+      #
+      # @api private
+      module CounterCache
+        def size
+          ordered_tree_node.parent_id_changed? ? super : ordered_tree_node.counter_cache
+        end
+
+        def empty?
+          size == 0
+        end
+
+        private
+        def ordered_tree_node
+          @association.owner.ordered_tree_node
+        end
+      end
+
+      # Builds association object
+      def build
+        Compatibility.version '< 4.0.0' do
+          opts = options.merge(:conditions => conditions, :order => order)
+
+          klass.has_many(:children, opts)
+        end
+
+        Compatibility.version '>= 4.0.0' do
+          klass.has_many(:children, scope, options)
+        end
+      end
+
+      private
+      def options
+        Hash[
+          :class_name => class_name,
+          :foreign_key => tree.columns.parent,
+          :inverse_of => inverse_of,
+          :dependent => :destroy,
+          :extend => [extension, Relation::Iterable].compact
+        ]
+      end
+
+      def inverse_of
+        :parent unless tree.options[:polymorphic]
+      end
+
+      # rails 4.x scope for has_many association
+      def scope
+        assoc_scope = method(:association_scope)
+        join_scope = method(:join_association_scope)
+
+        ->(join_or_parent) {
+          if join_or_parent.is_a?(ActiveRecord::Associations::JoinDependency::JoinAssociation)
+            join_scope[join_or_parent]
+          elsif join_or_parent.is_a?(ActiveRecord::Base)
+            assoc_scope[join_or_parent]
+          else
+            where(nil)
+          end.extending(Relation::Iterable)
+        }
+      end
+
+      # Rails 3.x :conditions options for has_many association
+      def conditions
+        return nil unless tree.columns.scope?
+
+        assoc_scope = method(:association_scope)
+        join_scope = method(:join_association_scope)
+
+        Proc.new do |join_association|
+          conditions = if join_association.is_a?(ActiveRecord::Associations::JoinDependency::JoinAssociation)
+            join_scope[join_association]
+          elsif self.is_a?(ActiveRecord::Base)
+            assoc_scope[self]
+          else
+            where(nil)
+          end.where_values.reduce(:and)
+
+          conditions.try(:to_sql)
+        end
+      end
+
+      def order
+        tree.columns.position
+      end
+
+      def extension
+        if tree.columns.counter_cache?
+          CounterCache
+        end
+      end
+
+      def join_association_scope(join_association)
+        parent = join_association.respond_to?(:parent) ?
+            join_association.parent.table :
+            join_association.base_klass.arel_table
+
+        child = join_association.table
+
+        conditions = tree.columns.scope.map { |column| parent[column].eq child[column] }.reduce(:and)
+
+        klass.unscoped.where(conditions)
+      end
+
+      def association_scope(owner)
+        owner.ordered_tree_node.scope.order(tree.columns.position)
+      end
+    end # class ChildrenAssociation
+  end # class Tree
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/tree/columns.rb

@@ -0,0 +1,102 @@
+# coding: utf-8
+
+module ActsAsOrderedTree
+  class Tree
+    # Ordered tree columns store
+    #
+    # @example
+    #   MyModel.tree.columns.parent # => "parent_id"
+    #   MyModel.tree.columns.counter_cache # => nil
+    #   MyModel.tree.columns.counter_cache? # => false
+    class Columns
+      # This error is raised when unknown column given in :scope option
+      UnknownColumn = Class.new(StandardError)
+
+      # @api private
+      def self.column_accessor(*names)
+        names.each do |name|
+          define_method "#{name}=" do |value|
+            @columns[name] = value.to_s if column_exists?(value)
+          end
+          private "#{name}=".to_sym
+
+          define_method "#{name}?" do
+            @columns[name].present?
+          end
+
+          define_method name do
+            @columns[name]
+          end
+        end
+      end
+
+      # @!method parent
+      # @!method parent?
+      # @!method parent=(value)
+      # @!method position
+      # @!method position?
+      # @!method position=(value)
+      # @!method depth
+      # @!method depth?
+      # @!method depth=(value)
+      # @!method counter_cache
+      # @!method counter_cache?
+      # @!method counter_cache=(value)
+      # @!method scope
+      # @!method scope?
+      column_accessor :parent,
+                      :position,
+                      :depth,
+                      :counter_cache,
+                      :scope
+
+      def initialize(klass, options = {})
+        @klass = klass
+        @columns = { :id => id }
+
+        self.parent = options[:parent_column]
+        self.position = options[:position_column]
+        self.depth = options[:depth_column]
+        self.counter_cache = counter_cache_name(options[:counter_cache])
+        self.scope = options[:scope]
+      end
+
+      def [](name)
+        @columns[name]
+      end
+
+      def id
+        @klass.primary_key
+      end
+
+      # Returns array of columns names associated with ordered tree structure
+      def to_a
+        @columns.values.flatten.compact
+      end
+
+      private
+      undef_method :scope=
+      def scope=(value)
+        columns = Array.wrap(value)
+
+        unknown = columns.reject { |name| column_exists?(name) }
+
+        raise UnknownColumn, "Unknown column#{'s' if unknown.size > 1} passed to :scope option: #{unknown.join(', ')}" if unknown.any?
+
+        @columns[:scope] = columns.map(&:to_s)
+      end
+
+      def counter_cache_name(value)
+        if value == true
+          "#{@klass.name.demodulize.underscore.pluralize}_count"
+        else
+          value
+        end
+      end
+
+      def column_exists?(name)
+        name.present? && @klass.columns_hash.include?(name.to_s)
+      end
+    end # class Columns
+  end # class Tree
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/tree/deprecated_columns_accessors.rb

@@ -0,0 +1,24 @@
+module ActsAsOrderedTree
+  class Tree
+    # @deprecated Use `ordered_tree.columns` object
+    module DeprecatedColumnsAccessors
+      class << self
+        # @api private
+        def deprecated_method(method, delegate)
+          define_method(method) do
+            ActiveSupport::Deprecation.warn("#{name}.#{method} is deprecated in favor of #{name}.ordered_tree.columns.#{delegate}", caller(1))
+
+            ordered_tree.columns.send(delegate)
+          end
+        end
+        private :deprecated_method
+      end
+
+      deprecated_method :parent_column, :parent
+      deprecated_method :position_column, :position
+      deprecated_method :depth_column, :depth
+      deprecated_method :children_counter_cache_column, :counter_cache
+      deprecated_method :scope_column_name, :scope
+    end
+  end
+end

data/lib/acts_as_ordered_tree/tree/parent_association.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/tree/association'
+
+module ActsAsOrderedTree
+  class Tree
+    class ParentAssociation < Association
+      # create parent association
+      #
+      # we cannot use native :counter_cache callbacks because they suck! :(
+      # they act like this:
+      #   node.parent = new_parent # and here counters are updated, outside of transaction!
+      def build
+        klass.belongs_to(:parent, options)
+      end
+
+      private
+      def options
+        Hash[
+          :class_name => class_name,
+          :foreign_key => tree.columns.parent,
+          :inverse_of => inverse_of
+        ]
+      end
+
+      def inverse_of
+        :children unless tree.options[:polymorphic]
+      end
+    end # class ParentAssociation
+  end # class Tree
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/tree/perseverance.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+
+require 'acts_as_ordered_tree/persevering_transaction'
+
+module ActsAsOrderedTree
+  class Tree
+    # This module contains overridden :with_transaction_returning_status method
+    # which wraps itself into PerseveringTransaction.
+    #
+    # This module is mixed in into Class after Class.acts_as_ordered_tree invocation.
+    #
+    # @api private
+    module Perseverance
+      def with_transaction_returning_status
+        PerseveringTransaction.new(self.class.connection).start { super }
+      end
+    end
+  end
+end

data/lib/acts_as_ordered_tree/tree/scopes.rb

@@ -0,0 +1,56 @@
+# coding: utf-8
+
+module ActsAsOrderedTree
+  class Tree
+    module Scopes
+      # Returns nodes ordered by their position.
+      #
+      # @return [ActiveRecord::Relation]
+      def preorder
+        order arel_table[ordered_tree.columns.position].asc
+      end
+
+      # Returns all nodes that don't have parent.
+      #
+      # @return [ActiveRecord::Relation]
+      def roots
+        preorder.where arel_table[ordered_tree.columns.parent].eq nil
+      end
+
+      # Returns all nodes that do not have any children. May be quite inefficient.
+      #
+      # @return [ActiveRecord::Relation]
+      def root
+        roots.first
+      end
+
+      # Returns all nodes that do not have any children. May be quite inefficient.
+      #
+      # @return [ActiveRecord::Relation]
+      def leaves
+        if ordered_tree.columns.counter_cache?
+          leaves_with_counter_cache
+        else
+          leaves_without_counter_cache
+        end
+      end
+
+      private
+      def leaves_without_counter_cache
+        aliaz = Arel::Nodes::TableAlias.new(arel_table, 't')
+
+        subquery = unscoped.select('1').
+            from(aliaz).
+            where(aliaz[ordered_tree.columns.parent].eq(arel_table[primary_key])).
+            limit(1).
+            reorder(nil)
+
+        where "NOT EXISTS (#{subquery.to_sql})"
+      end
+
+      def leaves_with_counter_cache
+        where arel_table[ordered_tree.columns.counter_cache].eq 0
+      end
+    end # module Scopes
+  end # class Tree
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/validators.rb

@@ -8,7 +8,7 @@ module ActsAsOrderedTree
 
     class ScopeValidator < ActiveModel::Validator
       def validate(record)
-        record.errors.add(:parent, :scope) unless record.same_scope?(record.parent)
+        record.errors.add(:parent, :scope) unless record.ordered_tree_node.same_scope?(record.parent)
       end
     end
   end