acts_as_recursive_tree 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 78b84c59d5275ca8152223f64df66c813a6b9b03
-  data.tar.gz: 7aa3a0fb72cc5ed2c5bd8f93d312b972273e06dd
+  metadata.gz: ffd168c454a68c9fdc6ae7fb32b705bdaba8964f
+  data.tar.gz: 2367e9b864ee904abc49198936f5afb59bb2d46b
 SHA512:
-  metadata.gz: f84ae5d103dc3df1ea1184db885771a082cd9d4a7b83af99c10fef9ef68d51f134d7e5150ed930fbc3abf7fcf98ee5ee567ccb528537dafb3e46b6df4ed002c0
-  data.tar.gz: fcb95ae5256b96813a63658897462e99b596512ab8cae861e4236de41ce746bc22261cf2649a61ee4535ef92a876e337f600558a3aecf87c392373a028f66b2e
+  metadata.gz: 4c4e359bbc497ff24f6ba6e8ccfbd846ce17178c0842850d3e3a0bee43e7d15cd8cd6a0a40072aa74d48e538d4a4dc892be743a677c34c39b7280348588ed74e
+  data.tar.gz: 12c7f7bac25c0547573d66bc8efa7b6e6ea4e3815f3490c929b8551886512c2cef6619f48a954d02a89518a79ac4da412d66fb69973b8321245d9bd7049952ba

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+### Version 2.0.1
+- fix for parent_type_column applied not properly
+
 ### Version 2.0.0
 - drop support for rails < 5.0
 - support for polymorphic parent relations

data/README.md

@@ -164,7 +164,44 @@ node_instance.descendants{ |opts| opts.ensure_ordering! }
 
 NOTE: if there are many descendants this may cause a severe increase in execution time! 
 
+## Single Table Inheritance (STI)
+
+STI works out of the box. Consider following classes: 
+
+```ruby
+class Node  < ActiveRecord::Base
+  recursive_tree
+end
+
+class SubNode  < Node
   
+end
+```
+
+When calling ClassMethods the results depend on the class on which you call the method:
+
+```ruby
+Node.descendants_of(123) # => returns Node and SubNode instances
+SubNode.descendants_of(123) # => returns SubNode instances only
+```
+
+Instance Methods make no difference of the class from which they are called:
+
+```ruby
+sub_node_instance.descendants # => returns Node and SubNode instances
+```
+
+
+## Known Issues
+
+When using PostgreSQL as underlying database system chances are good that you encounter following error message:
+
+`
+ActiveRecord::StatementInvalid: PG::ProtocolViolation: ERROR:  bind message supplies 1 parameters, but prepared statement "" requires 2
+`
+
+This is a known ActiveRecord issue which should be fixed in Rails 5.2. Alternative 
+
 
 ## Contributing
 

data/lib/acts_as_recursive_tree/builders/ancestors.rb

@@ -3,7 +3,7 @@ module ActsAsRecursiveTree
     class Ancestors < RelationBuilder
 
       def build_join_condition
-        travers_loc_table[config.parent_key].eq(base_table[config.primary_key])
+        travers_loc_table[parent_key].eq(base_table[primary_key])
       end
 
       def get_query_options(_)

data/lib/acts_as_recursive_tree/builders/descendants.rb

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

data/lib/acts_as_recursive_tree/builders/leaves.rb

@@ -6,10 +6,10 @@ module ActsAsRecursiveTree
         select_manager = super
 
         select_manager.where(
-            travers_loc_table[config.primary_key].not_in(
+            travers_loc_table[primary_key].not_in(
                 travers_loc_table.where(
-                    travers_loc_table[config.parent_key].not_eq(nil)
-                ).project(travers_loc_table[config.parent_key])
+                    travers_loc_table[parent_key].not_eq(nil)
+                ).project(travers_loc_table[parent_key])
             )
         )
         select_manager

data/lib/acts_as_recursive_tree/builders/relation_builder.rb

@@ -6,13 +6,16 @@ module ActsAsRecursiveTree
         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
+      attr_reader :klass, :ids, :recursive_temp_table, :travers_loc_table, :without_ids
       mattr_reader(:random) { Random.new }
 
+      delegate :primary_key, :depth_column, :parent_key, :parent_type_column, to: :@config
+      delegate :depth_present?, :depth, :condition, :ensure_ordering, to: :@query_opts
+
       def initialize(klass, ids, exclude_ids: false, &block)
         @klass       = klass
-        @ids         = ActsAsRecursiveTree::Options::Values.create(ids, config)
+        @config      = klass._recursive_tree_config
+        @ids         = ActsAsRecursiveTree::Options::Values.create(ids, @config)
         @without_ids = exclude_ids
 
         @query_opts = get_query_options(block)
@@ -34,15 +37,11 @@ module ActsAsRecursiveTree
         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])
+          base_table[primary_key].eq(recursive_temp_table[primary_key])
         )
 
         relation = klass.joins(final_select_mgr.join_sources)
@@ -56,18 +55,18 @@ module ActsAsRecursiveTree
 
       def apply_except_id(relation)
         return relation unless without_ids
-        relation.where(ids.apply_negated_to(base_table[config.primary_key]))
+        relation.where(ids.apply_negated_to(base_table[primary_key]))
       end
 
       def apply_depth(relation)
-        return relation unless query_opts.depth_present?
+        return relation unless depth_present?
 
-        relation.where(query_opts.depth.apply_to(recursive_temp_table[config.depth_column]))
+        relation.where(depth.apply_to(recursive_temp_table[depth_column]))
       end
 
       def apply_order(relation)
-        return relation unless query_opts.ensure_ordering
-        relation.order(recursive_temp_table[config.depth_column].asc)
+        return relation unless ensure_ordering
+        relation.order(recursive_temp_table[depth_column].asc)
       end
 
       def create_select_manger
@@ -82,34 +81,47 @@ module ActsAsRecursiveTree
       end
 
       def build_base_select
-        id_node = base_table[config.primary_key]
+        id_node = base_table[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)
+          base_table[parent_key],
+          Arel.sql('0').as(depth_column.to_s)
         )
       end
 
       def build_union_select
-        select_manager = base_table.join(travers_loc_table).on(
-          build_join_condition
-        )
+        join_condition = apply_parent_type_column(build_join_condition)
+
+        select_manager = base_table.join(travers_loc_table).on(join_condition)
 
         # need to use ActiveRecord here for merging relation
-        relation = klass.select(
-          base_table[config.primary_key],
-          base_table[config.parent_key],
+        relation = build_base_join_select(select_manager)
+
+        relation = apply_query_opts_condition(relation)
+        relation.arel
+      end
+
+      def apply_parent_type_column(arel_condition)
+        return arel_condition unless parent_type_column.present?
+        arel_condition.and(base_table[parent_type_column].eq(klass.base_class))
+      end
+
+      def build_base_join_select(select_manager)
+        klass.select(
+          base_table[primary_key],
+          base_table[parent_key],
           Arel.sql(
-            (travers_loc_table[config.depth_column] + 1).to_sql
-          ).as(config.depth_column.to_s)
+            (travers_loc_table[depth_column] + 1).to_sql
+          ).as(depth_column.to_s)
         ).unscope(where: :type).joins(select_manager.join_sources)
+      end
 
-        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
+      def apply_query_opts_condition(relation)
+        return relation unless condition.present?
+        relation.merge(condition)
       end
 
       def build_join_condition

data/lib/acts_as_recursive_tree/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_recursive_tree
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Wolfgang Wedelich-John
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-22 00:00:00.000000000 Z
+date: 2018-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord