acts_as_recursive_tree 2.0.0

data/lib/acts_as_recursive_tree/builders/ancestors.rb

@@ -0,0 +1,17 @@
+module ActsAsRecursiveTree
+  module Builders
+    class Ancestors < RelationBuilder
+
+      def build_join_condition
+        travers_loc_table[config.parent_key].eq(base_table[config.primary_key])
+      end
+
+      def get_query_options(_)
+        opts = super
+        opts.ensure_ordering!
+        opts
+      end
+
+    end
+  end
+end

data/lib/acts_as_recursive_tree/builders/descendants.rb

@@ -0,0 +1,9 @@
+module ActsAsRecursiveTree
+  module Builders
+    class Descendants < RelationBuilder
+      def build_join_condition
+        base_table[config.parent_key].eq(travers_loc_table[config.primary_key])
+      end
+    end
+  end
+end

data/lib/acts_as_recursive_tree/builders/leaves.rb

@@ -0,0 +1,26 @@
+module ActsAsRecursiveTree
+  module Builders
+    class Leaves < Descendants
+
+      def create_select_manger
+        select_manager = super
+
+        select_manager.where(
+            travers_loc_table[config.primary_key].not_in(
+                travers_loc_table.where(
+                    travers_loc_table[config.parent_key].not_eq(nil)
+                ).project(travers_loc_table[config.parent_key])
+            )
+        )
+        select_manager
+
+      end
+
+      def get_query_options(_)
+        # do not allow any custom options
+        ActsAsRecursiveTree::Options::QueryOptions.new
+      end
+
+    end
+  end
+end

data/lib/acts_as_recursive_tree/builders/relation_builder.rb

@@ -0,0 +1,121 @@
+module ActsAsRecursiveTree
+  module Builders
+    class RelationBuilder
+
+      def self.build(klass, ids, exclude_ids: false, &block)
+        new(klass, ids, exclude_ids: exclude_ids, &block).build
+      end
+
+      attr_reader :klass, :ids, :recursive_temp_table, :travers_loc_table
+      attr_reader :query_opts, :without_ids
+      mattr_reader(:random) { Random.new }
+
+      def initialize(klass, ids, exclude_ids: false, &block)
+        @klass       = klass
+        @ids         = ActsAsRecursiveTree::Options::Values.create(ids, config)
+        @without_ids = exclude_ids
+
+        @query_opts = get_query_options(block)
+
+        rand_int              = random.rand(1_000_000)
+        @recursive_temp_table = Arel::Table.new("recursive_#{klass.table_name}_#{rand_int}_temp")
+        @travers_loc_table    = Arel::Table.new("traverse_#{rand_int}_loc")
+      end
+
+      def get_query_options(proc)
+        opts = ActsAsRecursiveTree::Options::QueryOptions.new
+
+        proc.call(opts) if proc
+
+        opts
+      end
+
+      def base_table
+        klass.arel_table
+      end
+
+      def config
+        klass._recursive_tree_config
+      end
+
+      def build
+        final_select_mgr = base_table.join(
+          create_select_manger.as(recursive_temp_table.name)
+        ).on(
+          base_table[config.primary_key].eq(recursive_temp_table[config.primary_key])
+        )
+
+        relation = klass.joins(final_select_mgr.join_sources)
+
+        relation = apply_except_id(relation)
+        relation = apply_depth(relation)
+        relation = apply_order(relation)
+
+        relation
+      end
+
+      def apply_except_id(relation)
+        return relation unless without_ids
+        relation.where(ids.apply_negated_to(base_table[config.primary_key]))
+      end
+
+      def apply_depth(relation)
+        return relation unless query_opts.depth_present?
+
+        relation.where(query_opts.depth.apply_to(recursive_temp_table[config.depth_column]))
+      end
+
+      def apply_order(relation)
+        return relation unless query_opts.ensure_ordering
+        relation.order(recursive_temp_table[config.depth_column].asc)
+      end
+
+      def create_select_manger
+        travers_loc_table.project(Arel.star).with(:recursive, build_cte_table)
+      end
+
+      def build_cte_table
+        Arel::Nodes::As.new(
+          travers_loc_table,
+          build_base_select.union(build_union_select)
+        )
+      end
+
+      def build_base_select
+        id_node = base_table[config.primary_key]
+
+        base_table.where(
+          ids.apply_to(id_node)
+        ).project(
+          id_node,
+          base_table[config.parent_key],
+          Arel.sql('0').as(config.depth_column.to_s)
+        )
+      end
+
+      def build_union_select
+        select_manager = base_table.join(travers_loc_table).on(
+          build_join_condition
+        )
+
+        # need to use ActiveRecord here for merging relation
+        relation = klass.select(
+          base_table[config.primary_key],
+          base_table[config.parent_key],
+          Arel.sql(
+            (travers_loc_table[config.depth_column] + 1).to_sql
+          ).as(config.depth_column.to_s)
+        ).unscope(where: :type).joins(select_manager.join_sources)
+
+        relation = relation.merge(query_opts.condition) unless query_opts.condition.nil?
+        relation = relation.where(config.parent_type_column => klass.to_s) if config.parent_type_column
+        relation.arel
+      end
+
+      def build_join_condition
+        raise 'not implemented'
+      end
+
+    end
+  end
+end

data/lib/acts_as_recursive_tree/builders.rb

@@ -0,0 +1,13 @@
+module ActsAsRecursiveTree
+  module Builders
+    extend ActiveSupport::Autoload
+
+    autoload :Values
+    autoload :DepthCondition
+    autoload :QueryOptions
+    autoload :RelationBuilder
+    autoload :Descendants
+    autoload :Ancestors
+    autoload :Leaves
+  end
+end

data/lib/acts_as_recursive_tree/model.rb

@@ -0,0 +1,125 @@
+module ActsAsRecursiveTree
+  module Model
+    extend ActiveSupport::Concern
+
+    ##
+    # Returns list of ancestors, starting from parent until root.
+    #
+    # subchild1.ancestors # => [child1, root]
+    #
+    def ancestors(&block)
+      base_class.ancestors_of(self, &block)
+    end
+
+    # Returns ancestors and current node itself.
+    #
+    # subchild1.self_and_ancestors # => [subchild1, child1, root]
+    #
+    def self_and_ancestors(&block)
+      base_class.self_and_ancestors_of(self, &block)
+    end
+
+    ##
+    # Returns list of descendants, starting from current node, not including current node.
+    #
+    # root.descendants # => [child1, child2, subchild1, subchild2, subchild3, subchild4]
+    #
+    def descendants(&block)
+      base_class.descendants_of(self, &block)
+    end
+
+    ##
+    # Returns list of descendants, starting from current node, including current node.
+    #
+    # root.self_and_descendants # => [root, child1, child2, subchild1, subchild2, subchild3, subchild4]
+    #
+    def self_and_descendants(&block)
+      base_class.self_and_descendants_of(self, &block)
+    end
+
+    ##
+    # Returns the root node of the tree.
+    def root
+      self_and_ancestors.where(self._recursive_tree_config.parent_key => nil).first
+    end
+
+    ##
+    # Returns all siblings of the current node.
+    #
+    # subchild1.siblings # => [subchild2]
+    def siblings
+      self_and_siblings.where.not(id: self.id)
+    end
+
+    ##
+    # Returns children (without subchildren) and current node itself.
+    #
+    # root.self_and_children # => [root, child1]
+    def self_and_children
+      table = self.class.arel_table
+      id    = self.attributes[self._recursive_tree_config.primary_key.to_s]
+
+      base_class.where(
+        table[self._recursive_tree_config.primary_key].eq(id).or(
+          table[self._recursive_tree_config.parent_key].eq(id)
+        )
+      )
+    end
+
+    ##
+    # Returns all Leaves
+    #
+    def leaves
+      base_class.leaves_of(self)
+    end
+
+
+    # Returns true if node has no parent, false otherwise
+    #
+    # subchild1.root? # => false
+    # root.root? # => true
+    def root?
+      self.attributes[self._recursive_tree_config.parent_key.to_s].blank?
+    end
+
+    # Returns true if node has no children, false otherwise
+    #
+    # subchild1.leaf? # => true
+    # child1.leaf? # => false
+    def leaf?
+      !children.any?
+    end
+
+    def base_class
+      self.class.base_class
+    end
+
+    private :base_class
+
+    module ClassMethods
+      def self_and_ancestors_of(ids, &block)
+        Builders::Ancestors.build(self, ids, &block)
+      end
+
+      def ancestors_of(ids, &block)
+        Builders::Ancestors.build(self, ids, exclude_ids: true, &block)
+      end
+
+      def roots_of(ids)
+        self_and_ancestors_of(ids).roots
+      end
+
+      def self_and_descendants_of(ids, &block)
+        Builders::Descendants.build(self, ids, &block)
+      end
+
+      def descendants_of(ids, &block)
+        Builders::Descendants.build(self, ids, exclude_ids: true, &block)
+      end
+
+      def leaves_of(ids, &block)
+        Builders::Leaves.build(self, ids, &block)
+      end
+    end
+  end
+end

data/lib/acts_as_recursive_tree/options/depth_condition.rb

@@ -0,0 +1,48 @@
+module ActsAsRecursiveTree
+  module Options
+    class DepthCondition
+
+      def ==(other)
+        @value     = Values.create(other)
+        @operation = true
+      end
+
+      def !=(other)
+        @value     = Values.create(other)
+        @operation = false
+      end
+
+      def <(other)
+        @value     = other
+        @operation = :lt
+      end
+
+      def <=(other)
+        @value     = other
+        @operation = :lteq
+      end
+
+      def >(other)
+        @value     = other
+        @operation = :gt
+      end
+
+      def >=(other)
+        @value     = other
+        @operation = :gteq
+      end
+
+      def apply_to(attribute)
+        if @value.is_a?(Values::Base)
+          if @operation
+            @value.apply_to(attribute)
+          else
+            @value.apply_negated_to(attribute)
+          end
+        else
+          attribute.send(@operation, @value)
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_recursive_tree/options/query_options.rb

@@ -0,0 +1,21 @@
+module ActsAsRecursiveTree
+  module Options
+    class QueryOptions
+
+      attr_accessor :condition
+      attr_reader :ensure_ordering
+
+      def depth
+        @depth ||= DepthCondition.new
+      end
+
+      def ensure_ordering!
+        @ensure_ordering = true
+      end
+
+      def depth_present?
+        @depth.present?
+      end
+    end
+  end
+end

data/lib/acts_as_recursive_tree/options/values.rb

@@ -0,0 +1,77 @@
+module ActsAsRecursiveTree
+  module Options
+    module Values
+      class Base
+        attr_reader :value, :config
+
+        def initialize(value, config)
+          @value  = value
+          @config = config
+        end
+
+        def prepared_value
+          value
+        end
+
+        def apply_to(attribute)
+
+        end
+
+        def apply_negated_to(attribute)
+
+        end
+      end
+
+      class SingleValue < Base
+        def apply_to(attribute)
+          attribute.eq(prepared_value)
+        end
+
+        def apply_negated_to(attribute)
+          attribute.not_eq(prepared_value)
+        end
+      end
+
+      class ActiveRecord < SingleValue
+        def prepared_value
+          value.id
+        end
+      end
+
+      class MultiValue < Base
+        def apply_to(attribute)
+          attribute.in(prepared_value)
+        end
+
+        def apply_negated_to(attribute)
+          attribute.not_in(prepared_value)
+        end
+      end
+
+      class Relation < MultiValue
+        def prepared_value
+          select_manager = value.arel
+          select_manager.projections.clear
+          select_manager.project(select_manager.froms.last[config.primary_key])
+        end
+      end
+
+      def self.create(value, config = nil)
+        klass = case value
+        when ::Numeric, ::String
+          SingleValue
+        when ::ActiveRecord::Relation
+          Relation
+        when Enumerable
+          MultiValue
+        when ::ActiveRecord::Base
+          ActiveRecord
+        else
+          raise "#{value.class} is not supported"
+        end
+
+        klass.new(value, config)
+      end
+    end
+  end
+end

data/lib/acts_as_recursive_tree/options.rb

@@ -0,0 +1,9 @@
+module ActsAsRecursiveTree
+  module Options
+    extend ActiveSupport::Autoload
+
+    autoload :Values
+    autoload :DepthCondition
+    autoload :QueryOptions
+  end
+end

data/lib/acts_as_recursive_tree/railtie.rb

@@ -0,0 +1,9 @@
+module ActsAsRecursiveTree
+  class Railtie < Rails::Railtie
+    initializer 'acts_as_recursive_tree.active_record_initializer' do
+      ActiveRecord::Base.class_exec do
+        extend ActsAsRecursiveTree::ActsMacro
+      end
+    end
+  end
+end

data/lib/acts_as_recursive_tree/scopes.rb

@@ -0,0 +1,16 @@
+module ActsAsRecursiveTree
+  module Scopes
+    extend ActiveSupport::Concern
+
+    included do
+      scope :roots, -> {
+        rel = where(_recursive_tree_config.parent_key => nil)
+        rel = rel.or(
+          where.not(_recursive_tree_config.parent_type_column => self.to_s)
+        ) if _recursive_tree_config.parent_type_column
+
+        rel
+      }
+    end
+  end
+end

data/lib/acts_as_recursive_tree/version.rb

@@ -0,0 +1,3 @@
+module ActsAsRecursiveTree
+  VERSION = '2.0.0'.freeze
+end

data/lib/acts_as_recursive_tree.rb

@@ -0,0 +1,14 @@
+require 'active_support/all'
+require_relative 'acts_as_recursive_tree/railtie' if defined?(Rails)
+
+module ActsAsRecursiveTree
+  extend ActiveSupport::Autoload
+
+  autoload :ActsMacro
+  autoload :Model
+  autoload :Associations
+  autoload :Scopes
+  autoload :Version
+  autoload :Options
+  autoload :Builders
+end

data/spec/builders_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+shared_context 'setup with enforced ordering' do
+  let(:ordering) { false }
+  include_context 'base_setup' do
+    let(:proc) { -> (config) { config.ensure_ordering! } }
+  end
+end
+
+shared_context 'base_setup' do
+  let(:model_id) { 1 }
+  let(:model_class) { Node }
+  let(:exclude_ids) { false }
+  let(:proc) { nil }
+  let(:builder) do
+    described_class.new(model_class, model_id, exclude_ids: exclude_ids, &proc)
+  end
+  subject(:query) { builder.build.to_sql }
+end
+
+shared_examples 'basic recursive examples' do
+  it { is_expected.to start_with "SELECT \"#{model_class.table_name}\".* FROM \"#{model_class.table_name}\"" }
+  it { is_expected.to match /WHERE "#{model_class.table_name}"."#{model_class.primary_key}" = #{model_id}/ }
+  it { is_expected.to match /WITH RECURSIVE "#{builder.travers_loc_table.name}" AS/ }
+  it { is_expected.to match /SELECT "#{model_class.table_name}"."#{model_class.primary_key}", "#{model_class.table_name}"."#{model_class._recursive_tree_config.parent_key}", 0 AS recursive_depth FROM "#{model_class.table_name}"/ }
+  it { is_expected.to match /SELECT "#{model_class.table_name}"."#{model_class.primary_key}", "#{model_class.table_name}"."#{model_class._recursive_tree_config.parent_key}", \("#{builder.travers_loc_table.name}"."recursive_depth" \+ 1\) AS recursive_depth FROM "#{model_class.table_name}"/ }
+  it { is_expected.to match /#{Regexp.escape(builder.travers_loc_table.project(Arel.star).to_sql)}/ }
+  it { is_expected.to match /"#{model_class.table_name}"."#{model_class.primary_key}" = "#{builder.recursive_temp_table.name}"."#{model_class.primary_key}"/ }
+end
+
+shared_examples 'build recursive query' do
+  context 'simple id' do
+    context 'with simple class' do
+      include_context 'base_setup' do
+        let(:model_class) { Node }
+        it_behaves_like 'basic recursive examples'
+      end
+    end
+
+    context 'with class with different parent key' do
+      include_context 'base_setup' do
+        let(:model_class) { NodeWithOtherParentKey }
+        it_behaves_like 'basic recursive examples'
+      end
+    end
+
+    context 'with Subclass' do
+      include_context 'base_setup' do
+        let(:model_class) { Floor }
+        it_behaves_like 'basic recursive examples'
+      end
+    end
+
+    context 'with polymorphic parent relation' do
+      include_context 'base_setup' do
+        let(:model_class) { NodeWithPolymorphicParent }
+        it_behaves_like 'basic recursive examples'
+      end
+    end
+  end
+end
+
+shared_examples 'ancestor query' do
+  include_context 'base_setup'
+
+  it { is_expected.to match /"#{builder.travers_loc_table.name}"."#{model_class._recursive_tree_config.parent_key}" = "#{model_class.table_name}"."#{model_class.primary_key}"/ }
+end
+
+shared_examples 'descendant query' do
+  include_context 'base_setup'
+
+  it { is_expected.to match /"#{model_class.table_name}"."#{model_class._recursive_tree_config.parent_key}" = "#{builder.travers_loc_table.name}"."#{model_class.primary_key}"/ }
+end
+
+shared_context 'context with ordering' do
+  include_context 'base_setup' do
+    it_behaves_like 'with ordering'
+  end
+end
+
+shared_context 'context without ordering' do
+  include_context 'base_setup' do
+    it_behaves_like 'without ordering'
+  end
+end
+
+shared_examples 'with ordering' do
+  it { is_expected.to match /ORDER BY #{Regexp.escape(builder.recursive_temp_table[model_class._recursive_tree_config.depth_column].asc.to_sql)}/ }
+end
+
+shared_examples 'without ordering' do
+  it { is_expected.to_not match /ORDER BY/ }
+end
+
+describe ActsAsRecursiveTree::Builders::Descendants do
+  context 'basic' do
+    it_behaves_like 'build recursive query'
+    it_behaves_like 'descendant query'
+    include_context 'context without ordering'
+  end
+
+  context 'with options' do
+    include_context 'setup with enforced ordering' do
+      let(:ordering) { true }
+      it_behaves_like 'with ordering'
+    end
+  end
+end
+
+describe ActsAsRecursiveTree::Builders::Ancestors do
+  context 'basic' do
+    it_behaves_like 'build recursive query'
+    it_behaves_like 'ancestor query'
+    include_context 'context with ordering'
+  end
+  context 'with options' do
+    include_context 'setup with enforced ordering' do
+      it_behaves_like 'with ordering'
+    end
+  end
+end
+
+describe ActsAsRecursiveTree::Builders::Leaves do
+  context 'basic' do
+    it_behaves_like 'build recursive query'
+    it_behaves_like 'descendant query'
+    include_context 'context without ordering'
+  end
+
+  context 'with options' do
+    include_context 'setup with enforced ordering' do
+      let(:ordering) { true }
+      it_behaves_like 'without ordering'
+    end
+  end
+end

data/spec/db/database.rb

@@ -0,0 +1,22 @@
+database_folder           = "#{File.dirname(__FILE__)}/../db"
+database_adapter          = 'sqlite'
+
+# Logger setup
+ActiveRecord::Base.logger = nil
+
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Base.configurations = YAML::load(File.read("#{database_folder}/database.yml"))
+
+config = ActiveRecord::Base.configurations[database_adapter]
+
+# remove database if present
+FileUtils.rm config['database'], force: true
+
+ActiveRecord::Base.establish_connection(database_adapter.to_sym)
+ActiveRecord::Base.establish_connection(config)
+
+# require schemata and models
+require_relative 'schema'
+require_relative 'models'
+

data/spec/db/database.yml

@@ -0,0 +1,12 @@
+common: &common
+  database:
+  host: localhost
+  pool: 50
+  timeout: 5000
+  reaping_frequency: 1000
+  min_messages: ERROR
+
+sqlite:
+  <<: *common
+  adapter: sqlite3
+  database: test.sqlite3