hierarchable 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c927f016abf308f6c0128f2162908afccb89f55b95495b3499ecfa6a6acdec56
-  data.tar.gz: 85724a8ec5e256a5251241f7dc5ef8539c2a041bf683834a6ac0081f02efd922
+  metadata.gz: f108839bd5cf2491856dfdcc1af95e0d50204f32e467c22bb3f4925d0028f5be
+  data.tar.gz: 2379a67ad164232c8efb8c33f8ca6117c6e51387feb39585b4e114ce16542736
 SHA512:
-  metadata.gz: 28f8b977db00b49eba24c634bcd19381fa631b519c1c371a4b8fdba15b9ac7475ce638a8e0f87c46f28caf1247abc783de1359d999f6f8343bd1d181f48548f4
-  data.tar.gz: 7515ea80776d9b60856f91374cedf3d50bfec3f32d572e06bdada94a72a64d64f940ce52b7fd56b1e625ab467885553d6b077d612ad49862f51106e27a6ea4de
+  metadata.gz: 88822385da9430f6183eafbc4873a7b3009461d733768453212c3abaf615bca2e318da1c36ac3fb9a4d46bdb072fcd07655069a9148a314212915e205f34baa0
+  data.tar.gz: bc9b0a309a1e31d7da843ff2ed5f1e75384f9812f63bde5d759018f72de51ebab45e8ea32d45f79cd7f12451d56b439bb69b32b2af0cbc06ee62eeab17ca7d44

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hierarchable (0.1.0)
+    hierarchable (0.2.1)
       activerecord (> 4.2.0)
       activesupport (> 4.2.0)
 

data/README.md

@@ -2,7 +2,9 @@
 
 [![CircleCI](https://dl.circleci.com/status-badge/img/gh/prschmid/hierarchable/tree/main.svg?style=shield)](https://dl.circleci.com/status-badge/redirect/gh/prschmid/hierarchable/tree/main)
 
-Cross model hierarchical (parent, child, sibling) relationship between ActiveRecord models.
+A simple way to define cross model hierarchical (parent, child, sibling) relationships between ActiveRecord models.
+
+The aim of this library is to efficiently create and store the ancestors of an object so that it is easy to generate things like breadcrumbs that require information about an object's ancestors that may span multiple models (e.g. `Project` and `Task`). It is designed in such a way that each object contains the ancestry information and that no joins need to be made to a separate table to get this ancestry information.
 
 ## Installation
 
@@ -43,28 +45,35 @@ t.references :hierarchy_parent,
 t.string :hierarchy_ancestors_path, index: true
 ```
 
-The `hierarchy_ancestors_path` column does contain all of the information that is in the `hierarchy_root` and `hierarchy_parent` columns, but those two columns are created for more efficient querying as the direct parent and the root are the most frequent parts of the hierarchy that are needed.
+If you aren't using UUIDs, then simply omit the `type: :uuid` from the two `references` definitions.
+
+Note, the `hierarchy_ancestors_path` column does contain all of the information that is in the `hierarchy_root` and `hierarchy_parent` columns, but those two columns are created for more efficient querying as the direct parent and the root are the most frequent parts of the hierarchy that are needed.
 
 ## Usage
 
+### Getting Started
+
 We will describe the usage using a simplistic Project and Task analogy where we assume that a Project can have many tasks. Given a class `Project` we can set it up as follows
 
 ```ruby
 class Project
   include Hierarchable
   hierarchable
+  # If desired, could explicitly setting the parent source to `nil`, but this is
+  # the same "under the hood"
+  # hierarchable parent_source: nil
 end
 ```
 
-This will set up the `Project` as the root of the hierarchy. This means that when we query for its root or parent, it will return "self". I.e.
+This will set up the `Project` as the root of the hierarchy. When a `Project` model is saved, it will not have any values for the hierarchy_root, hierarchy_parent, or hierarchy_ancestors_path. This is because for the root item as we are not guaranteed to have an ID for the object until after it is saved, and so there is no way for us to set these values in a consistent way across different use cases. This doesn't affect any of the usage of the library, it's just something to keep in mind.
 
 ```ruby
 project = Project.create!
 
-# These will be true (assuming the the ID of the project is the UUID xxxxxxxx-...)
-project.hierarchy_root == project
-project.hierarchy_parent == project
-project.hierarchy_ancestors_path == 'Project|xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
+# These will be true. 
+project.hierarchy_root == nil
+project.hierarchy_parent == nil
+project.hierarchy_ancestors_path == ''
 ```
 
 Now that we have a project configured, we can add tasks that have projects as a parent.
@@ -84,13 +93,11 @@ This will configure the hierarchy to look at the project association and use tha
 project = Project.create!
 task = Task.create!(project: project)
 
-# These will be true
+# These will be true (assuming that the xxxxxx and yyyyyy are the IDs for the
+# project and task respectively)
 task.hierarchy_root == project
 task.hierarchy_parent == project
-project.hierarchy_ancestors_path == 'Project|xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
-task.hierarchy_root == project
-task.hierarchy_parent == project
-task.hierarchy_ancestors_path == 'Project|xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/Task|yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy'
+task.hierarchy_ancestors_path == 'Project|xxxxxx/Task|yyyyyy'
 ```
 
 Now, let's assume that our tasks can also have other Tasks as subtasks. Once we do that, we need to ensure that the parent of a subtask is the task and not the project. For this we, can do something like the following:
@@ -122,17 +129,94 @@ task = Task.create!(project: project)
 sub_task = Task.create!(project: project, parent_task: task)
 
 # These will be true
-task.hierarchy_root == project
-task.hierarchy_parent == project
-project.hierarchy_ancestors_path == 'Project|xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
-task.hierarchy_root == project
-task.hierarchy_parent == project
-task.hierarchy_ancestors_path == 'Project|xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/Task|yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy'
 sub_task.hierarchy_root == project
 sub_task.hierarchy_parent == task
-sub_task.hierarchy_ancestors_path == 'Project|xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/Task|yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy/Task|zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz'
+sub_task.hierarchy_ancestors_path == 'Project|xxxxxx/Task|yyyyyy/Task|zzzzzz'
+```
+
+### Working with siblings and descendants of an object
+
+Let's continue with our `Project` and `Task` example from above and assume we have the following models:
+
+```ruby
+class Project
+  include Hierarchable
+  hierarchable
+end
+
+class Task
+  include Hierarchable
+  hierarchable parent_source: :project
+
+  belongs_to :project
+end
+
+class Milestone
+  include Hierarchable
+  hierarchable parent_source: :project
+
+  belongs_to :project
+end
+```
+
+Based on this setup, we can get all siblings and descendants of either a `Project` or `Task` as follows:
+
+```ruby
+project = Project.create!
+task = Task.create!(project: project)
+milestone = Milestone.create!(project: project)
+
+# Query for all Project objects that are siblings of this project.
+# Since the project is the root of the hierarchy, this will return no siblings
+project.hierarchy_siblings
+
+# Query for all objects (regardless of type) that are descendats of this project
+# In our example, this will return all Tasks and Milestones
+project.hierarchy_descendants
+
+# Query for all Project objects that are descendats of this project
+# In our example, this will return no results
+project.hierarchy_descendants(models: :this)
+
+# Query for all Task objects that are siblings of this task.
+# This will return all tasks and milestones that are part of the project
+task.hierarchy_siblings
 ```
 
+In order to figure out the potential descendants of an object we need to inspect the object and query all relations to to see if any of those have this object as an ancestor. In many cases these relations can be inferred correctly by getting all of the `has_many` relationships that a model has defined. To be safe and not return potential duplicate associations, the only associations that are automatically detected are the ones that are the pluralized form of the model name. 
+
+```ruby
+class Project
+  has_many :tasks
+  has_many :completed_tasks, -> { completed }, class_name: 'Task'
+  has_many :timestamps, class_name: 'MetricLibrary::Timestamp`
+end
+```
+
+In the `Project` model defined above, only the `:tasks` association will be used for finding descendants.
+
+However there are times when we need to manually add a child relation to be inspected. This can be done in one of two ways. The most common case is if we want to specify additional associations. This will take all of the associations that can be auto-detected and also add in the one provided.
+
+```ruby
+class SomeObject
+  include Hierarched
+  hierarched parent_source: :parent,
+             additional_descendant_associations: [:some_association]
+end
+```
+
+There may also be a case when we want exact control over what associations that should be used. In that case, we can specify it like this:
+
+```ruby
+class SomeObject
+  include Hierarched
+  hierarched parent_source: :parent,
+             descendant_associations: [:some_association]
+end
+```
+
+Note: For the use case that this library was designed (e.g. creating breadcrumbs) this was a limitation that was perfectly acceptible. In the future we may plan to letusers create an optional "ancestry" table to make this more efficient. Once this table exists, inserts and updates will be slower as an extra object will need to be managed, but queries descenants will be improved.
+
 ### Configuring the separators
 
 By default the separators to use for the path and records are `/` and `|` respectively. This means that a hierarchy path will look something like

data/lib/hierarchable/hierarchable.rb

@@ -69,12 +69,17 @@ module Hierarchable
   HIERARCHABLE_DEFAULT_RECORD_SEPARATOR = '|'
 
   class_methods do
+    # rubocop:disable Metrics/MethodLength
     def hierarchable(opts = {})
       class_attribute :hierarchable_config
 
       # Save the configuration
       self.hierarchable_config = {
         parent_source: opts.fetch(:parent_source, nil),
+        additional_descendant_associations: opts.fetch(
+          :additional_descendant_associations, []
+        ),
+        descendant_associations: opts.fetch(:descendant_associations, nil),
         path_separator: opts.fetch(
           :path_separator, HIERARCHABLE_DEFAULT_PATH_SEPARATOR
         ),
@@ -105,7 +110,7 @@ module Hierarchable
 
       before_create :set_hierarchy_ancestors_path
 
-      scope :descendants_of,
+      scope :hierarchy_descendants_of,
             lambda { |object|
               where(
                 'hierarchy_ancestors_path LIKE :hierarchy_ancestors_path',
@@ -113,10 +118,11 @@ module Hierarchable
               )
             }
 
-      scope :siblings_of,
+      scope :hierarchy_siblings_of,
             lambda { |object|
               where(
-                'hierarchy_parent_type=:parent_type AND hierarchy_parent_id=:parent_id',
+                'hierarchy_parent_type=:parent_type AND ' \
+                'hierarchy_parent_id=:parent_id',
                 parent_type: object.hierarchy_parent.class.name,
                 parent_id: object.hierarchy_parent.id
               )
@@ -125,9 +131,14 @@ module Hierarchable
       include InstanceMethods
     end
   end
+  # rubocop:enable Metrics/MethodLength
 
   # Instance methods to include
   module InstanceMethods
+    def hierarchy_root?
+      hierarchy_root.nil?
+    end
+
     def hierarchy_parent(raw: false)
       return hierarchy_parent_relationship if raw
 
@@ -152,6 +163,245 @@ module Hierarchable
       end
     end
 
+    # Get all of the ancestors models
+    #
+    # The `include_self` parameter can be set to decide where to start the
+    # the ancestry search. If set to `false` (default), then it will return
+    # all models found starting with the parent of this object. If set to
+    # `true`, then it will start with the currect object.
+    def hierarchy_ancestor_models(include_self: false)
+      return [] unless respond_to?(:hierarchy_ancestors_path)
+      return include_self ? [self.class] : [] if hierarchy_ancestors_path.blank?
+
+      models = hierarchy_ancestors_path.split(
+        hierarchable_config[:path_separator]
+      ).map do |ancestor|
+        ancestor_class, = \
+          ancestor.split(hierarchable_config[:record_separator])
+        ancestor_class.safe_constantize
+      end.uniq
+
+      models << self.class if include_self
+      models.uniq
+    end
+
+    # Get ancestors of the same type for an object.
+    #
+    # Using the `hierarchy_ancestors_path`, this will iteratively get all
+    # ancestor objects and return them as a list.
+    #
+    # If the `models` parameter is `:all` (default), then the result
+    # will contain objects of different types. E.g. if we have a Project,
+    # Task, and a Comment, the siblings of a Task may include both Tasks and
+    # Comments. If you only need this one particular model's data, then
+    # set `models` to `:this`. If you want to specify a specific list of models
+    # then that can be passed as a list (e.g. [MyModel1, MyModel2])
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def hierarchy_ancestors(include_self: false, models: :all)
+      return [] unless respond_to?(:hierarchy_ancestors_path)
+      return include_self ? [self] : [] if hierarchy_ancestors_path.blank?
+
+      ancestors = hierarchy_ancestors_path.split(
+        hierarchable_config[:path_separator]
+      ).map do |ancestor|
+        ancestor_class, ancestor_id = ancestor.split(
+          hierarchable_config[:record_separator]
+        )
+
+        next if ancestor_class != self.class.name && models != :all
+        next if models.is_a?(Array) && models.exclude?(ancestor_class)
+
+        ancestor_class.safe_constantize.find(ancestor_id)
+      end
+
+      ancestors.compact
+      ancestors << self if include_self
+      ancestors
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    # Get all of the models of the children that this object could have
+    #
+    # This is based on the models identified in the
+    # `hierarchy_descendant_associations` association
+    #
+    # The `include_self` parameter can be set to decide where to start the
+    # the children search. If set to `false` (default), then it will return
+    # all models found starting with the for all children. If set to
+    # `true`, then it will include the current object's class. Note, this
+    # parameter is added here for consistency, but in the case of children
+    # models, it is unlikely that `include_self` would be set to `true`
+    def hierarchy_children_models(include_self: false)
+      return [] unless respond_to?(:hierarchy_descendant_associations)
+      if hierarchy_descendant_associations.blank?
+        return include_self ? [self.class] : []
+      end
+
+      models = hierarchy_descendant_associations.map do |association|
+        self.association(association)
+            .reflection
+            .class_name
+            .safe_constantize
+      end
+
+      models << self.class if include_self
+      models.uniq
+    end
+
+    # Get all of the sibling models
+    #
+    # The `include_self` parameter can be set to decide what to include in the
+    # sibling models search. If set to `false` (default), then it will return
+    # all models other models that are siblings of the current object. If set to
+    # `true`, then it will also include the current object's class.
+    def hierarchy_sibling_models(include_self: false)
+      return [] unless respond_to?(:hierarchy_parent)
+      return include_self ? [self.class] : [] if hierarchy_parent.blank?
+
+      models = hierarchy_parent.hierarchy_children_models(include_self: false)
+      models << self.class if include_self
+      models.uniq
+    end
+
+    # Get siblings of the same type for an object.
+    #
+    # For a given object type, return all siblings as a hash such that the key
+    # is the model and the value is the list of siblings of that model.
+    #
+    # If the `models` parameter is `:all` (default), then the result
+    # will contain objects of different types. E.g. if we have a Project,
+    # Task, and a Comment, the siblings of a Task may include both Tasks and
+    # Comments. If you only need this one particular model's data, then
+    # set `models` to `:this`. If you want to specify a specific list of models
+    # then that can be passed as a list (e.g. [MyModel1, MyModel2])
+    def hierarchy_siblings(include_self: false, models: :all)
+      return {} unless respond_to?(:hierarchy_parent_id)
+
+      models = case models
+               when Array
+                 models
+               when :all
+                 hierarchy_sibling_models(include_self: true)
+               else
+                 [self.class]
+               end
+
+      result = {}
+      models.each do |model|
+        query = model.where(
+          hierarchy_parent_type: public_send(:hierarchy_parent_type),
+          hierarchy_parent_id: public_send(:hierarchy_parent_id)
+        )
+        query = query.where.not(id:) if model == self.class && !include_self
+        result[model] = query
+      end
+      result
+    end
+
+    # Get all of the descendant models for objects that are descendants of
+    # the current one.
+    #
+    # This will make use of the `hierarchy_descendant_associations` to find
+    # all models.
+    #
+    # Unlike `hierarchy_children_models` that only looks at the immediate
+    # children of an object, this  method will look at all descenants of the
+    # current object and find the models. In other words, this will follow
+    # all relationships of all children, and those children's children to
+    # get all models that could potentially be descendants of the current
+    # model.
+    #
+    # The `include_self` parameter can be set to decide where to start the
+    # the descentant search. If set to `false` (default), then it will return
+    # all models found starting with the children of this object. If set to
+    # `true`, then it will start with the currect object.
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def hierarchy_descendant_models(include_self: false)
+      return [] unless respond_to?(:hierarchy_descendant_associations)
+
+      if hierarchy_descendant_associations.blank?
+        return include_self ? [self.class] : []
+      end
+
+      models = []
+      models_to_analyze = [self.class]
+      until models_to_analyze.empty?
+
+        klass = models_to_analyze.pop
+        next if models.include?(klass)
+
+        obj = klass.new
+        next unless obj.respond_to?(:hierarchy_descendant_associations)
+
+        models_to_analyze += obj.hierarchy_children_models(include_self: false)
+
+        next if klass == self.class && !include_self
+
+        models << klass
+      end
+      models.uniq
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    # Get descendants for an object.
+    #
+    # The `include_self` parameter can be set to decide where to start the
+    # the descentant search. If set to `false` (default), then it will return
+    # all models found starting with the children of this object. If set to
+    # `true`, then it will start with the currect object.
+    #
+    # If the `models` parameter is `:all` (default), then the result
+    # will contain objects of different types. E.g. if we have a Project,
+    # Task, and a Comment, the siblings of a Task may include both Tasks and
+    # Comments. If you only need this one particular model's data, then
+    # set `models` to `:this`. If you want to specify a specific list of models
+    # then that can be passed as a list (e.g. [MyModel1, MyModel2])
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def hierarchy_descendants(include_self: false, models: :all)
+      return {} unless respond_to?(:hierarchy_ancestors_path)
+
+      models = case models
+               when Array
+                 models
+               when :all
+                 hierarchy_descendant_models(include_self: true)
+               else
+                 [self.class]
+               end
+
+      result = {}
+      models.each do |model|
+        query = if hierarchy_root?
+                  model.where(
+                    hierarchy_root_type: self.class.name,
+                    hierarchy_root_id: id
+                  )
+                else
+                  path = public_send(:hierarchy_full_path)
+                  model.where(
+                    'hierarchy_ancestors_path LIKE ?',
+                    "#{model.sanitize_sql_like(path)}%"
+                  )
+                end
+        if model == self.class
+          query = if include_self
+                    query.or(model.where(id:))
+                  else
+                    query.where.not(id:)
+                  end
+        end
+        result[model] = query
+      end
+      result
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+
     # Return the attribute name that links this object to its parent.
     #
     # This should return the name of the attribute/relation/etc either as a
@@ -168,6 +418,53 @@ module Hierarchable
       source.respond_to?(:call) ? source.call(self) : source
     end
 
+    # Return all of the `has_many` association names this class class has as a
+    # list of symbols.
+    #
+    # In order to be safe and not return potential duplicate associations,
+    # the only associations that are automatically
+    # detected are the ones that are the pluralized form of the model name.
+    # For example, if a model as the association `has_many :tasks`, there
+    # will need to be a Task model for this association to be kept.
+    #
+    # If there are some associations that need to be manually
+    # added, one simply needs to specify them when setting up the model.
+    #
+    # The most common case is if we want to specify additional associations.
+    # This will take all of the associations that can be auto-detected and
+    # also add in the one provided.
+    #
+    #   class A
+    #     include Hierarched
+    #     hierarched parent_source: :parent,
+    #                additional_descendant_associations: [:some_association]
+    #   end
+    #
+    # There may also be a case when we want exact control over what associations
+    # that should be used. In that case, we can specify it like this:
+    #
+    #   class A
+    #     include Hierarched
+    #     hierarched parent_source: :parent,
+    #                descendant_associations: [:some_association]
+    #   end
+    def hierarchy_descendant_associations
+      if hierarchable_config[:descendant_associations].present?
+        return hierarchable_config[:descendant_associations]
+      end
+
+      associations = \
+        self.class
+            .reflect_on_all_associations(:has_many)
+            .reject do |a|
+              a.name.to_s.singularize.camelcase.safe_constantize.nil?
+            end
+            .reject(&:through_reflection?)
+            .map(&:name)
+      associations += hierarchable_config[:additional_descendant_associations]
+      associations.uniq
+    end
+
     # Return the string representation of the current object in the format when
     # used as part of a hierarchy.
     #
@@ -199,7 +496,6 @@ module Hierarchable
     end
 
     # Return hierarchy path for given list of objects
-
     def hierarchy_path_for(objects)
       return '' if objects.blank?
 
@@ -241,89 +537,6 @@ module Hierarchable
       path
     end
 
-    # Get ancestors of the same type for an object.
-    #
-    # For a given object type, return all ancestors that have the same type.
-    # Note, since ancestors may be of different types, this may skip parts
-    # of the hierarchy if the particular ancestor happens to be of a different
-    # type.
-    def ancestors
-      return [] if !respond_to?(:hierarchy_ancestors_path) ||
-                   hierarchy_ancestors_path.blank?
-
-      a = hierarchy_ancestors_path.split(
-        hierarchable_config[:path_separator]
-      ).map do |ancestor|
-        ancestor_class, ancestor_id = ancestor.split(
-          hierarchable_config[:record_separator]
-        )
-
-        if ancestor_class == self.class.name
-          ancestor_class.safe_constantize.find(ancestor_id)
-        end
-      end
-      a.compact
-    end
-
-    # Return the list of all ancestor objects for the current object
-    #
-    # Using the `hierarchy_ancestors_path`, this will iteratively get all
-    # ancestor objects and return them as a list.
-    #
-    # As there may be ancestors of different types, this is not a single query
-    # and may return things of many different types. E.g. if we have a Project,
-    # Task, and a Comment, the ancestors of a coment may be the Task and the
-    # Project.
-    def all_ancestors
-      return [] if !respond_to?(:hierarchy_ancestors_path) ||
-                   hierarchy_ancestors_path.blank?
-
-      hierarchy_ancestors_path.split(
-        hierarchable_config[:path_separator]
-      ).map do |ancestor|
-        ancestor_class, ancestor_id = ancestor.split(
-          hierarchable_config[:record_separator]
-        )
-        ancestor_class.safe_constantize.find(ancestor_id)
-      end
-    end
-
-    # Get siblings of the same type for an object.
-    #
-    # For a given object type, return all siblings. Note, this DOES NOT return
-    # siblings of different types and those need to be queried separetly.
-    # equivalent to c.hierarchy_parent.children
-    #
-    # Params:
-    # +include_self+:: Whether or not to include self in the list.
-    #                  Default is true
-    def siblings(include_self: true)
-      # The method should always return relation, not an Array sometimes and
-      # Relation the other
-      return self.class.none unless respond_to?(:hierarchy_parent_id)
-
-      query = self.class.where(
-        hierarchy_parent_type: public_send(:hierarchy_parent_type),
-        hierarchy_parent_id: public_send(:hierarchy_parent_id)
-      )
-      query = query.where.not(id:) unless include_self
-      query
-    end
-
-    # Get all siblings of this object regardless of object type.
-    #
-    # This has yet to be implemented and would likely require a separate join
-    # table that has all of the data across all tables linked to the particular
-    # parent. I.e. a simple table that has parent, child in it that we could
-    # use to query.
-    #
-    # Params:
-    # +include_self+:: Whether or not to include self in the list.
-    #                  Default is true
-    def all_siblings
-      raise NotImplementedError
-    end
-
     protected
 
     # Set the hierarchy_parent of the current object.

data/lib/hierarchable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hierarchable
-  VERSION = '0.1.0'
+  VERSION = '0.2.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hierarchable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Patrick R. Schmid
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-22 00:00:00.000000000 Z
+date: 2022-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler