with_recursive_tree 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 108a3060c431b14be0274538083b1251da56c3c5404ff96628007c849a86b94c
-  data.tar.gz: 6d3619942217a168e4eb8bfc04533b5aa78edd6e0bf428eac9cd628007a47582
+  metadata.gz: 135e72700b84ad5ba2129e6b2e6afe8ab4ada838d83f696085e1e0fb0c33bb86
+  data.tar.gz: bf922dd155ba9cf2cea2833fce5ebf2cec06a68043eb0b5866259363065f22df
 SHA512:
-  metadata.gz: be39718928d3296a0dcbd9e2d149a6d8c7dcb3fece985620b433a4e45f5f83a4bdcc3e87f8b6840b2b6194d6428b476ba260a49c874754454622bc88811d4b06
-  data.tar.gz: 7e66c836eced475a35d398a4bceb47cd1ca441178b823b5be7c82d3a47534dd9e8ff1b9fd3842e72c1c288233c4a2c40b0703c7bdaad2e75e0273d551268ebfb
+  metadata.gz: 49af47e2ede3b23bb0063ca1ee6082580c0e84b71d7974b2d5fbb5d7aacdfbb5510b49a49f2242bb6377956a73ad42435065dc95a7d11ce6f37796ca354b12c6
+  data.tar.gz: 7def7190b8c6540a1e655ddadf63be9611239e45c8ea046766a6be9dacc360a55aaf880c37daa521f72b1cdf8ad43fa95721dc129fb5ab5521094574dbd8de99

data/README.md

@@ -1,6 +1,6 @@
 # with_recursive_tree
 
-Tree structures for ActiveRecord using CTE (Common Table Expressions). Traverse the whole tree with just one query.
+Tree structures for ActiveRecord using CTEs (Common Table Expressions). Traverse an entire tree with just one query.
 
 ## Installation
 
@@ -18,7 +18,7 @@ $ bundle
 
 ## Usage
 
-First, your model needs a reference to the its parent. Typically, this is a `parent_id` column in your table. Once you have that reference, you can add `with_recursive_tree` to your model:
+First, your model needs a reference to its parent. Typically, this is a `parent_id` column in your table. Once you have that reference, you can add `with_recursive_tree` to your model:
 
 ```ruby
 class Category < ApplicationRecord
@@ -28,10 +28,10 @@ end
 
 By doing this, with_recursive_tree will add 2 associations:
 
-* `parent`: the parent of the node
-* `children`: the children of this node
+* `parent`: the node's parent
+* `children`: the node's children
 
-To build these associations, with_recursive_tree will use the `id` and the `parent_id` columns as the primary and foreign keys, respectively. If you want to specify different primary and foreign keys, you can do that by passing the `primary_key` and `foreign_key` options. For example, for a categories table whose primary key is `category_id` and the parent record id is `parent_category_id`, you would set it up as follows:
+To build these associations, with_recursive_tree will use the `id` and the `parent_id` columns as the primary and foreign keys, respectively. If you want to specify different primary and foreign keys, you can specify them by passing the `primary_key` and `foreign_key` options. For example, for a categories table whose primary key is `category_id` and the parent record id is `parent_category_id`, you would set it up as follows:
 
 ```ruby
 class Category < ApplicationRecord
@@ -39,6 +39,27 @@ class Category < ApplicationRecord
 end
 ```
 
+For polymorphic associations where a node can have different types of parents, you can use the `foreign_key_type` option to specify a column that stores the parent model's class name:
+
+```ruby
+class Comment < ApplicationRecord
+  with_recursive_tree foreign_key: :parent_id, foreign_key_type: :parent_type
+end
+```
+
+This allows nodes to belong to different parent model types while maintaining proper tree structure constraints.
+
+When using `foreign_key_type`, a node is considered a root if it meets any of these conditions:
+
+1. Both `foreign_key` and `foreign_key_type` are `nil` (traditional root)
+2. `foreign_key` is `nil` and `foreign_key_type` matches the model's class name
+3. `foreign_key` is not `nil` but `foreign_key_type` is different from the model's class name (belongs to a different model type)
+
+The `foreign_key_type` value is automatically managed through a `before_save` callback:
+
+* When setting a parent (`foreign_key`), the `foreign_key_type` is automatically set to the model's class name if it's blank
+* When clearing a parent (`foreign_key` becomes `nil`), the `foreign_key_type` is set to `nil` unless it's explicitly set to the model's class name
+
 Lastly, you can specify how to sort each node's `children` by passing the `order` option to `with_recursive_tree`. If no `order` option is set, it will default to `id`. This option is useful especially when you need to traverse the tree in a specific order. For example:
 
 ```ruby
@@ -49,24 +70,24 @@ end
 
 ### Class methods
 
-| Method | Description |
-|--------|-------------|
+| Method    | Description                               |
+| --------- | ----------------------------------------- |
 | `::roots` | Returns all roots (nodes without parent). |
 
 ### Instance methods
 
-| Method | Description |
-|--------|-------------|
-| `#ancestors` | Returns all ancestors of the node. |
-| `#descendants` | Returns all descendants of the node (subtree). |
-| `#leaf?` | Returns whether the node is a leaf (has no children). |
-| `#depth` | Returns the depth of the current node. |
-| `#root` | Returns the root node of the current node's tree. |
-| `#root?` | Returns whether the node is a root (has no parent). |
-| `#self_and_ancestors` | Returns the node and all its ancestors. |
-| `#self_and_descendants` | Returns the node and all its descendants (subtree). |
-| `#self_and_siblings` | Returns the current node and all its siblings. |
-| `#siblings` | Returns the current node's siblings. |
+| Method                  | Description                                           |
+| ----------------------- | ----------------------------------------------------- |
+| `#ancestors`            | Returns all ancestors of the node.                    |
+| `#descendants`          | Returns all descendants of the node (subtree).        |
+| `#leaf?`                | Returns whether the node is a leaf (has no children). |
+| `#depth`                | Returns the depth of the current node.                |
+| `#root`                 | Returns the root node of the current node's tree.     |
+| `#root?`                | Returns whether the node is a root (has no parent).   |
+| `#self_and_ancestors`   | Returns the node and all its ancestors.               |
+| `#self_and_descendants` | Returns the node and all its descendants (subtree).   |
+| `#self_and_siblings`    | Returns the current node and all its siblings.        |
+| `#siblings`             | Returns the current node's siblings.                  |
 
 ### Tree traversing
 
@@ -74,7 +95,27 @@ You can traverse the tree using `#descendants` or `#self_and_descendants` in com
 
 For example, given the following tree:
 
-![sample tree](/assets/tree.png)
+```mermaid
+flowchart TD
+  A
+  A --> B
+  A --> L
+  B --> C
+  B --> H
+  C --> D
+  D --> E
+  D --> F
+  D --> G
+  H --> I
+  I --> J
+  J --> K
+  L --> M
+  L --> N
+  N --> O
+  N --> P
+  N --> Q
+  N --> R
+```
 
 and the following class:
 

data/lib/with_recursive_tree/version.rb

@@ -1,3 +1,3 @@
 module WithRecursiveTree
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/with_recursive_tree.rb

@@ -2,15 +2,18 @@ require "with_recursive_tree/version"
 
 module WithRecursiveTree
   module ClassMethods
-    def with_recursive_tree(primary_key: :id, foreign_key: :parent_id, order: nil)
+    def with_recursive_tree(primary_key: :id, foreign_key: :parent_id, foreign_key_type: nil, order: nil)
       include InstanceMethods
 
-      belongs_to :parent, class_name: name, primary_key: primary_key, foreign_key: foreign_key, inverse_of: :children, optional: true
+      scope_condition = foreign_key_type.present? ? -> { where foreign_key_type => self.class.name } : -> { self }
 
-      has_many :children, -> { order order }, class_name: name, primary_key: primary_key, foreign_key: foreign_key, inverse_of: :parent
+      belongs_to :parent, scope_condition, class_name: name, primary_key: primary_key, foreign_key: foreign_key, inverse_of: :children, optional: true
+
+      has_many :children, -> { scope_condition.call.order(order) }, class_name: name, primary_key: primary_key, foreign_key: foreign_key, inverse_of: :parent
 
       define_singleton_method(:with_recursive_tree_primary_key) { primary_key }
       define_singleton_method(:with_recursive_tree_foreign_key) { foreign_key }
+      define_singleton_method(:with_recursive_tree_foreign_key_type) { foreign_key_type }
       define_singleton_method(:with_recursive_tree_order) { order || primary_key }
       define_singleton_method(:with_recursive_tree_order_column) do
         if with_recursive_tree_order.is_a?(Hash)
@@ -20,6 +23,20 @@ module WithRecursiveTree
         end
       end
 
+      if foreign_key_type.present?
+        before_save do
+          if send(:"#{foreign_key}_changed?")
+            if send(foreign_key).present?
+              # When setting a parent, the foreign_key_type is automatically set to the model's class name if it's blank
+              send(:"#{foreign_key_type}=", self.class.name) if send(foreign_key_type).blank?
+            elsif send(foreign_key).nil?
+              # When clearing parent, the foreign_key_type is to nil unless it's explicitly set to the model's class name
+              send(:"#{foreign_key_type}=", nil) unless send(foreign_key_type) == self.class.name
+            end
+          end
+        end
+      end
+
       scope :bfs, -> {
         if defined?(ActiveRecord::ConnectionAdapters::MySQL)
           order(:depth, with_recursive_tree_order)
@@ -36,7 +53,22 @@ module WithRecursiveTree
           self
         end
       end
-      scope :roots, -> { where with_recursive_tree_foreign_key => nil }
+      scope :roots, -> {
+        if with_recursive_tree_foreign_key_type.present?
+          # Root conditions with foreign_key_type:
+          # 1. foreign_key is nil AND foreign_key_type is nil
+          # 2. foreign_key is nil AND foreign_key_type matches the model's class name
+          # 3. foreign_key is not nil AND foreign_key_type is different from model's class name
+          where(with_recursive_tree_foreign_key => nil)
+            .where(with_recursive_tree_foreign_key_type => [nil, name])
+            .or(
+              where.not(with_recursive_tree_foreign_key => nil)
+                .where.not(with_recursive_tree_foreign_key_type => name)
+            )
+        else
+          where with_recursive_tree_foreign_key => nil
+        end
+      }
     end
   end
 
@@ -59,18 +91,46 @@ module WithRecursiveTree
     alias_method :level, :depth
 
     def root
-      self_and_ancestors.find_by self.class.with_recursive_tree_foreign_key => nil
+      return self if root?
+
+      if self.class.with_recursive_tree_foreign_key_type.present?
+        # For foreign_key_type, find the first ancestor that satisfies root conditions
+        self_and_ancestors.where(
+          self.class.with_recursive_tree_foreign_key => nil,
+          self.class.with_recursive_tree_foreign_key_type => [nil, self.class.name]
+        ).or(
+          self_and_ancestors.where.not(self.class.with_recursive_tree_foreign_key => nil)
+            .where.not(self.class.with_recursive_tree_foreign_key_type => self.class.name)
+        ).first
+      else
+        self_and_ancestors.find_by self.class.with_recursive_tree_foreign_key => nil
+      end
     end
 
     def root?
-      parent.blank?
+      foreign_key_value = send(self.class.with_recursive_tree_foreign_key)
+
+      if self.class.with_recursive_tree_foreign_key_type.present?
+        foreign_key_type_value = send(self.class.with_recursive_tree_foreign_key_type)
+
+        # Root conditions with foreign_key_type:
+        # 1. foreign_key is nil AND foreign_key_type is nil
+        # 2. foreign_key is nil AND foreign_key_type matches the model's class name
+        # 3. foreign_key is not nil AND foreign_key_type is different from model's class name
+        (foreign_key_value.nil? && [nil, self.class.name].include?(foreign_key_type_value)) ||
+          (foreign_key_value.present? && foreign_key_type_value != self.class.name)
+      else
+        foreign_key_value.nil?
+      end
     end
 
     def self_and_ancestors
+      scope_condition = self.class.with_recursive_tree_foreign_key_type.present? ? {"tree.#{self.class.with_recursive_tree_foreign_key_type}" => self.class.name} : nil
+
       self.class.with_recursive(
         tree: [
           self.class.where(self.class.with_recursive_tree_primary_key => send(self.class.with_recursive_tree_primary_key)),
-          self.class.joins("JOIN tree ON #{self.class.table_name}.#{self.class.with_recursive_tree_primary_key} = tree.#{self.class.with_recursive_tree_foreign_key}")
+          self.class.joins("JOIN tree ON #{self.class.table_name}.#{self.class.with_recursive_tree_primary_key} = tree.#{self.class.with_recursive_tree_foreign_key}").where(scope_condition)
         ]
       ).select("*").from("tree AS #{self.class.table_name}")
     end
@@ -92,7 +152,9 @@ module WithRecursiveTree
         "tree.path || #{self.class.table_name}.#{self.class.with_recursive_tree_primary_key} || '/'"
       end
 
-      recursive_query = self.class.joins("JOIN tree ON #{self.class.table_name}.#{self.class.with_recursive_tree_foreign_key} = tree.#{self.class.with_recursive_tree_primary_key}").select("#{self.class.table_name}.*, #{recursive_path} AS path, depth + 1 AS depth")
+      scope_condition = self.class.with_recursive_tree_foreign_key_type.present? ? {"#{self.class.table_name}.#{self.class.with_recursive_tree_foreign_key_type}" => self.class.name} : nil
+
+      recursive_query = self.class.joins("JOIN tree ON #{self.class.table_name}.#{self.class.with_recursive_tree_foreign_key} = tree.#{self.class.with_recursive_tree_primary_key}").select("#{self.class.table_name}.*, #{recursive_path} AS path, depth + 1 AS depth").where scope_condition
 
       unless defined?(ActiveRecord::ConnectionAdapters::MySQL)
         recursive_query = recursive_query.order(self.class.with_recursive_tree_order)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: with_recursive_tree
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Patricio Mac Adden
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-25 00:00:00.000000000 Z
+date: 2025-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord