ancestry 3.0.7 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5962b504410b75525481574c43d8122fc4f4607e1c56f8827bbc565a7704adb6
-  data.tar.gz: 51c13aec4d355421c4e095804890c58eba3a8a774ce9286e3eaf28351ac22a11
+  metadata.gz: 9455bbdda28f2f0084ff4b1e96af32ca5d6b3efe40ae062c51f75b3fee84fb30
+  data.tar.gz: 5b06653e17bbe2a238c4d49d9147dd79f2156c33432298290b5b17da190ce203
 SHA512:
-  metadata.gz: b6dc1d80c7a77fc1f97232634d11e188863d25e7e9da3f74654ada7f4d3fc2951c6962b4f2b516476772eecce98f66db7c4625298465d2f9de4a7d2f17ff2553
-  data.tar.gz: 7199de05c78a159e1e1924de1331617a9cc06d4f1403bd82f88a8da5e7f0c127343c1b905bfb714ba2e0e88c285fb9694f467eda9c56af4089db2077fe5c1da2
+  metadata.gz: 4cb481c338a78cd5c294a40ccc43ccbad27232cc0a646b4827fd2446ad3d3fd626410f4a35d3b9361b367c2474ba229113aa191ba7799ddcc7930b1d29eab106
+  data.tar.gz: 6876e974e00c0ee4c5bb4ea4facbfb9ce12fe04eebfab2bc4623d6a74c9591781d3945b4999437054a81fb1ea82a656822c679e38c434541173ee7d192d664dc

data/README.md

@@ -4,12 +4,12 @@
 
 Ancestry is a gem that allows the records of a Ruby on Rails
 ActiveRecord model to be organised as a tree structure (or hierarchy). It uses
-a single database column, using the materialised path pattern. It exposes all the standard tree structure
-relations (ancestors, parent, root, children, siblings, descendants) and all
-of them can be fetched in a single SQL query. Additional features are STI
+a single database column, employing the materialised path pattern. It exposes all the standard tree structure
+relations (ancestors, parent, root, children, siblings, descendants) and allows all
+of them to be fetched in a single SQL query. Additional features are STI
 support, scopes, depth caching, depth constraints, easy migration from older
 gems, integrity checking, integrity restoration, arrangement of
-(sub)tree into hashes and different strategies for dealing with orphaned
+(sub)trees into hashes, and various strategies for dealing with orphaned
 records.
 
 NOTE:
@@ -55,7 +55,7 @@ $ rake db:migrate
 
 
 ## Add ancestry to your model
-* Add to [app/models/](model).rb:
+* Add to app/models/[model.rb]:
 
 ```ruby
 # app/models/[model.rb]
@@ -69,9 +69,9 @@ Your model is now a tree!
 
 # Using acts_as_tree instead of has_ancestry
 
-In version 1.2.0 the **acts_as_tree** method was **renamed to has_ancestry**
+In version 1.2.0, the **acts_as_tree** method was **renamed to has_ancestry**
 in order to allow usage of both the acts_as_tree gem and the ancestry gem in a
-single application. method `acts_as_tree` will continue to be supported in the future.
+single application. The `acts_as_tree` method will continue to be supported in the future.
 
 # Organising records into a tree
 
@@ -107,13 +107,13 @@ To navigate an Ancestry model, use the following instance methods:
 |`ancestors?`       |true if the record has ancestors (aka not a root node)|
 |`ancestor_ids`     |ancestor ids of the record|
 |`path`             |path of the record, starting with the root and ending with self|
-|`path_ids`         |a list the path ids, starting with the root id and ending with the node's own id|
+|`path_ids`         |a list of the path ids, starting with the root id and ending with the node's own id|
 |`children`         |direct children of the record|
 |`child_ids`        |direct children's ids|
 |`has_parent?`    <br/> `ancestors?` |true if the record has a parent, false otherwise|
 |`has_children?`  <br/> `children?`  |true if the record has any children, false otherwise|
 |`is_childless?`  <br/> `childless?` |true is the record has no children, false otherwise|
-|`siblings`         |siblings of the record, the record itself is included*|
+|`siblings`         |siblings of the record, including the record itself*|
 |`sibling_ids`      |sibling ids|
 |`has_siblings?`  <br/> `siblings?`   |true if the record's parent has more than one child|
 |`is_only_child?` <br/> `only_child?` |true if the record is the only child of its parent|
@@ -123,7 +123,7 @@ To navigate an Ancestry model, use the following instance methods:
 |`indirect_ids`     |indirect children's ids of the record|
 |`subtree`          |the model on descendants and itself|
 |`subtree_ids`      |a list of all ids in the record's subtree|
-|`depth`            |the depth of the node, root nodes are at depth 0|
+|`depth`            |the depth of the node (root nodes are at depth 0)|
 
 \*   If the record is a root, other root records are considered siblings
 \*   Siblings returns the record itself
@@ -139,6 +139,57 @@ There are also instance methods to determine the relationship between 2 nodes:
 |`descendant_of?(node)` | node is one of this record's ancestors|
 |`indirect_of?(node)` | node is one of this record's ancestors but not a parent|
 
+## Visual guide for navigation
+
+In all examples the node with the large border is the reference node, the node
+from which the navigation method is invoked. The yellow nodes are the nodes
+returned by the method.
+
+<table>
+  <tr>
+    <td>
+      <p align="center">parent</p>
+      <img src="img/parent.png" alt="parent"/>
+    </td>
+    <td>
+      <p align="center">root</p>
+      <img src="img/root.png" alt="root"/>
+    </td>
+    <td>
+      <p align="center">ancestors</p>
+      <img src="img/ancestors.png" alt="ancestors"/>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <p align="center">path</p>
+      <img src="img/path.png" alt="path"/>
+    </td>
+    <td>
+      <p align="center">children</p>
+      <img src="img/children.png" alt="children"/>
+    </td>
+    <td>
+      <p align="center">siblings</p>
+      <img src="img/siblings.png" alt="siblings"/>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <p align="center">descendants</p>
+      <img src="img/descendants.png" alt="descendants"/>
+    </td>
+    <td>
+      <p align="center">indirects</p>
+      <img src="img/indirects.png" alt="indirects"/>
+    </td>
+    <td>
+      <p align="center">subtree</p>
+      <img src="img/subtree.png" alt="subtree"/>
+    </td>
+  </tr>
+</table>
+
 # Options for `has_ancestry`
 
 The has_ancestry method supports the following options:
@@ -148,23 +199,23 @@ The has_ancestry method supports the following options:
                            :destroy   All children are destroyed as well (default)
                            :rootify   The children of the destroyed node become root nodes
                            :restrict  An AncestryException is raised if any children exist
-                           :adopt     The orphan subtree is added to the parent of the deleted node.
-                                      If the deleted node is Root, then rootify the orphan subtree.
+                           :adopt     The orphan subtree is added to the parent of the deleted node
+                                      If the deleted node is Root, then rootify the orphan subtree
     :cache_depth           Cache the depth of each node in the 'ancestry_depth' column (default: false)
                            If you turn depth_caching on for an existing model:
                            - Migrate: add_column [table], :ancestry_depth, :integer, :default => 0
                            - Build cache: TreeNode.rebuild_depth_cache!
     :depth_cache_column    Pass in a symbol to store depth cache in a different column
-    :primary_key_format    Supply a regular expression that matches the format of your primary key.
-                           By default, primary keys only match integers ([0-9]+).
+    :primary_key_format    Supply a regular expression that matches the format of your primary key
+                           By default, primary keys only match integers ([0-9]+)
     :touch                 Instruct Ancestry to touch the ancestors of a node when it changes, to
                            invalidate nested key-based caches. (default: false)
 
 # (Named) Scopes
 
-Where possible, the navigation methods return scopes instead of records, this
+Where possible, the navigation methods return scopes instead of records. This
 means additional ordering, conditions, limits, etc. can be applied and that
-the result can be either retrieved, counted or checked for existence. For
+the result can be either retrieved, counted, or checked for existence. For
 example:
 
 ```ruby
@@ -237,7 +288,7 @@ on type for that.
 # Arrangement
 
 Ancestry can arrange an entire subtree into nested hashes for easy navigation
-after retrieval from the database.  TreeNode.arrange could for example return:
+after retrieval from the database.  `TreeNode.arrange` could for example return:
 
 ```ruby
 {
@@ -250,14 +301,14 @@ after retrieval from the database.  TreeNode.arrange could for example return:
 }
 ```
 
-The arrange method also works on a scoped class, for example:
+The `arrange` method also works on a scoped class, for example:
 
 ```ruby
 TreeNode.find_by_name('Crunchy').subtree.arrange
 ```
 
-The arrange method takes `ActiveRecord` find options. If you want your hashes to
-be ordered, you should pass the order to the arrange method instead of to the
+The `arrange` method takes `ActiveRecord` find options. If you want your hashes to
+be ordered, you should pass the order to the `arrange` method instead of to the
 scope. example:
 
 ```ruby
@@ -266,7 +317,7 @@ TreeNode.find_by_name('Crunchy').subtree.arrange(:order => :name)
 
 To get the arranged nodes as a nested array of hashes for serialization:
 
-TreeNode.arrange_serializable
+`TreeNode.arrange_serializable`
 
 ```ruby
 [
@@ -299,15 +350,15 @@ TreeNode.arrange_serializable do |parent, children|
 end
 ```
 
-The result of arrange_serializable can easily be serialized to json with
+The result of `arrange_serializable` can easily be serialized to json with
 `to_json`, or some other format:
 
 ```
 TreeNode.arrange_serializable.to_json
 ```
 
-You can also pass the order to the arrange_serializable method just as you can
-pass it to the arrange method:
+You can also pass the order to the `arrange_serializable` method just as you can
+pass it to the `arrange` method:
 
 ```
 TreeNode.arrange_serializable(:order => :name)
@@ -329,8 +380,8 @@ the order of siblings depends on their order in the original array.
 
 Most current tree plugins use a parent_id column (has_ancestry,
 awesome_nested_set, better_nested_set, acts_as_nested_set). With ancestry it is
-easy to migrate from any of these plugins, to do so, use the
-build_ancestry_from_parent_ids! method on your ancestry model. These steps
+easy to migrate from any of these plugins. To do so, use the
+`build_ancestry_from_parent_ids!` method on your ancestry model. These steps
 provide a more detailed explanation:
 
 1.  Add ancestry column to your table
@@ -352,7 +403,7 @@ provide a more detailed explanation:
 
 
 4.  Generate ancestry columns
-    *   In './script.console': **[model].build_ancestry_from_parent_ids!**
+    *   In 'rails console': **[model].build_ancestry_from_parent_ids!**
     *   Make sure it worked ok: **[model].check_ancestry_integrity!**
 
 
@@ -371,14 +422,14 @@ provide a more detailed explanation:
 
 I don't see any way Ancestry tree integrity could get compromised without
 explicitly setting cyclic parents or invalid ancestry and circumventing
-validation with update_attribute, if you do, please let me know.
+validation with update_attribute. If you do, please let me know.
 
 Ancestry includes some methods for detecting integrity problems and restoring
-integrity just to be sure. To check integrity use:
-[Model].check_ancestry_integrity!. An AncestryIntegrityException will be
+integrity just to be sure. To check integrity, use:
+`[Model].check_ancestry_integrity!`. An AncestryIntegrityException will be
 raised if there are any problems. You can also specify :report => :list to
 return an array of exceptions or :report => :echo to echo any error messages.
-To restore integrity use: [Model].restore_ancestry_integrity!.
+To restore integrity use: `[Model].restore_ancestry_integrity!`.
 
 For example, from IRB:
 

data/ancestry.gemspec

@@ -42,12 +42,10 @@ EOF
     'README.md'
   ]
   
-  s.required_ruby_version     = '>= 1.8.7'
-  s.add_runtime_dependency 'activerecord', '>= 3.2.0'
-  s.add_development_dependency 'rdoc'
-  s.add_development_dependency 'yard'
-  s.add_development_dependency 'rake',      '~> 10.0'
-  s.add_development_dependency 'test-unit'
+  s.required_ruby_version     = '>= 2.0.0'
+  s.add_runtime_dependency 'activerecord', '>= 4.2.0'
+  s.add_development_dependency 'appraisal'
   s.add_development_dependency 'minitest'
-  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'rake',      '~> 13.0'
+  s.add_development_dependency 'yard'
 end

data/lib/ancestry.rb

@@ -6,5 +6,4 @@ require_relative 'ancestry/has_ancestry'
 require_relative 'ancestry/materialized_path'
 
 module Ancestry
-  ANCESTRY_PATTERN = /\A[0-9]+(\/[0-9]+)*\Z/
 end

data/lib/ancestry/class_methods.rb

@@ -2,7 +2,11 @@ module Ancestry
   module ClassMethods
     # Fetch tree node if necessary
     def to_node object
-      if object.is_a?(self.ancestry_base_class) then object else unscoped_where{|scope| scope.find object} end
+      if object.is_a?(self.ancestry_base_class)
+        object
+      else
+        unscoped_where { |scope| scope.find(object.try(primary_key) || object) }
+      end
     end
 
     # Scope on relative depth options
@@ -129,7 +133,7 @@ module Ancestry
 
     # Integrity restoration
     def restore_ancestry_integrity!
-      parents = {}
+      parent_ids = {}
       # Wrap the whole thing in a transaction ...
       self.ancestry_base_class.transaction do
         unscoped_where do |scope|
@@ -138,29 +142,29 @@ module Ancestry
             # ... set its ancestry to nil if invalid
             if !node.valid? and !node.errors[node.class.ancestry_column].blank?
               node.without_ancestry_callbacks do
-                node.update_attribute node.ancestry_column, nil
+                node.update_attribute :ancestor_ids, []
               end
             end
-            # ... save parent of this node in parents array if it exists
-            parents[node.id] = node.parent_id if exists? node.parent_id
+            # ... save parent id of this node in parent_ids array if it exists
+            parent_ids[node.id] = node.parent_id if exists? node.parent_id
 
             # Reset parent id in array to nil if it introduces a cycle
-            parent = parents[node.id]
-            until parent.nil? || parent == node.id
-              parent = parents[parent]
+            parent_id = parent_ids[node.id]
+            until parent_id.nil? || parent_id == node.id
+              parent_id = parent_ids[parent_id]
             end
-            parents[node.id] = nil if parent == node.id
+            parent_ids[node.id] = nil if parent_id == node.id
           end
 
           # For each node ...
           scope.find_each do |node|
-            # ... rebuild ancestry from parents array
-            ancestry, parent = nil, parents[node.id]
-            until parent.nil?
-              ancestry, parent = if ancestry.nil? then parent else "#{parent}/#{ancestry}" end, parents[parent]
+            # ... rebuild ancestry from parent_ids array
+            ancestor_ids, parent_id = [], parent_ids[node.id]
+            until parent_id.nil?
+              ancestor_ids, parent_id = [parent_id] + ancestor_ids, parent_ids[parent_id]
             end
             node.without_ancestry_callbacks do
-              node.update_attribute node.ancestry_column, ancestry
+              node.update_attribute :ancestor_ids, ancestor_ids
             end
           end
         end
@@ -168,13 +172,13 @@ module Ancestry
     end
 
     # Build ancestry from parent id's for migration purposes
-    def build_ancestry_from_parent_ids! parent_id = nil, ancestry = nil
+    def build_ancestry_from_parent_ids! column=:parent_id, parent_id = nil, ancestor_ids = []
       unscoped_where do |scope|
-        scope.where(:parent_id => parent_id).find_each do |node|
+        scope.where(column => parent_id).find_each do |node|
           node.without_ancestry_callbacks do
-            node.update_attribute ancestry_column, ancestry
+            node.update_attribute :ancestor_ids, ancestor_ids
           end
-          build_ancestry_from_parent_ids! node.id, if ancestry.nil? then "#{node.id}" else "#{ancestry}/#{node.id}" end
+          build_ancestry_from_parent_ids! column, node.id, ancestor_ids + [node.id]
         end
       end
     end

data/lib/ancestry/has_ancestry.rb

@@ -4,7 +4,7 @@ module Ancestry
       # Check options
       raise Ancestry::AncestryException.new("Options for has_ancestry must be in a hash.") unless options.is_a? Hash
       options.each do |key, value|
-        unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :touch, :counter_cache].include? key
+        unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :touch, :counter_cache, :primary_key_format].include? key
           raise Ancestry::AncestryException.new("Unknown option for has_ancestry: #{key.inspect} => #{value.inspect}.")
         end
       end
@@ -27,6 +27,7 @@ module Ancestry
       # Include dynamic class methods
       extend Ancestry::ClassMethods
 
+      validates_format_of self.ancestry_column, :with => derive_ancestry_pattern(options[:primary_key_format]), :allow_nil => true
       extend Ancestry::MaterializedPath
 
       # Create orphan strategy accessor and set to option or default (writer comes from DynamicClassMethods)
@@ -36,27 +37,6 @@ module Ancestry
       # Validate that the ancestor ids don't include own id
       validate :ancestry_exclude_self
 
-      # Named scopes
-      scope :roots, lambda { where(root_conditions) }
-      scope :ancestors_of, lambda { |object| where(ancestor_conditions(object)) }
-      scope :children_of, lambda { |object| where(child_conditions(object)) }
-      scope :indirects_of, lambda { |object| where(indirect_conditions(object)) }
-      scope :descendants_of, lambda { |object| where(descendant_conditions(object)) }
-      scope :subtree_of, lambda { |object| where(subtree_conditions(object)) }
-      scope :siblings_of, lambda { |object| where(sibling_conditions(object)) }
-      scope :ordered_by_ancestry, Proc.new { |order|
-        if %w(mysql mysql2 sqlite sqlite3 postgresql).include?(connection.adapter_name.downcase) && ActiveRecord::VERSION::MAJOR >= 5
-          reorder(
-            Arel::Nodes::Ascending.new(Arel::Nodes::NamedFunction.new('COALESCE', [arel_table[ancestry_column], Arel.sql("''")])),
-            order
-          )
-        else
-          reorder(Arel.sql("(CASE WHEN #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)} IS NULL THEN 0 ELSE 1 END), #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)}"), order)
-        end
-      }
-      scope :ordered_by_ancestry_and, Proc.new { |order| ordered_by_ancestry(order) }
-      scope :path_of, lambda { |object| to_node(object).path }
-
       # Update descendants with new ancestry before save
       before_save :update_descendants_with_new_ancestry
 
@@ -114,6 +94,18 @@ module Ancestry
       return super if defined?(super)
       has_ancestry(*args)
     end
+
+    private
+
+    def derive_ancestry_pattern(primary_key_format, delimiter = '/')
+      primary_key_format ||= '[0-9]+'
+
+      if primary_key_format.to_s.include?('\A')
+        primary_key_format
+      else
+        /\A#{primary_key_format}(#{delimiter}#{primary_key_format})*\Z/
+      end
+    end
   end
 end
 

data/lib/ancestry/instance_methods.rb

@@ -1,11 +1,8 @@
 module Ancestry
   module InstanceMethods
-    BEFORE_LAST_SAVE_SUFFIX = ActiveRecord::VERSION::STRING >= '5.1.0' ? '_before_last_save' : '_was'
-    IN_DATABASE_SUFFIX = ActiveRecord::VERSION::STRING >= '5.1.0' ? '_in_database' : '_was'
-
     # Validate that the ancestors don't include itself
     def ancestry_exclude_self
-      errors.add(:base, "#{self.class.name.humanize} cannot be a descendant of itself.") if ancestor_ids.include? self.id
+      errors.add(:base, "#{self.class.model_name.human} cannot be a descendant of itself.") if ancestor_ids.include? self.id
     end
 
     # Update descendants with new ancestry (before save)
@@ -16,15 +13,8 @@ module Ancestry
         unscoped_descendants.each do |descendant|
           # ... replace old ancestry with new ancestry
           descendant.without_ancestry_callbacks do
-            descendant.update_attribute(
-              self.ancestry_base_class.ancestry_column,
-              descendant.read_attribute(descendant.class.ancestry_column).gsub(
-                # child_ancestry_was
-                /^#{self.child_ancestry}/,
-                # future child_ancestry
-                if ancestors? then "#{read_attribute self.class.ancestry_column }/#{id}" else id.to_s end
-              )
-            )
+            new_ancestor_ids = path_ids + (descendant.ancestor_ids - path_ids_in_database)
+            descendant.update_attribute(:ancestor_ids, new_ancestor_ids)
           end
         end
       end
@@ -37,13 +27,7 @@ module Ancestry
         when :rootify # make all children root if orphan strategy is rootify
           unscoped_descendants.each do |descendant|
             descendant.without_ancestry_callbacks do
-              new_ancestry = if descendant.ancestry == child_ancestry
-                nil
-              else
-                # child_ancestry did not change so child_ancestry_was will work here
-                descendant.ancestry.gsub(/^#{child_ancestry}\//, '')
-              end
-              descendant.update_attribute descendant.class.ancestry_column, new_ancestry
+              descendant.update_attribute :ancestor_ids, descendant.ancestor_ids - path_ids
             end
           end
         when :destroy # destroy all descendants if orphan strategy is destroy
@@ -55,10 +39,7 @@ module Ancestry
         when :adopt # make child elements of this node, child of its parent
           descendants.each do |descendant|
             descendant.without_ancestry_callbacks do
-              new_ancestry = descendant.ancestor_ids.delete_if { |x| x == self.id }.join("/")
-              # check for empty string if it's then set to nil
-              new_ancestry = nil if new_ancestry.empty?
-              descendant.update_attribute descendant.class.ancestry_column, new_ancestry || nil
+              descendant.update_attribute :ancestor_ids, descendant.ancestor_ids.delete_if { |x| x == self.id }
             end
           end
         when :restrict # throw an exception if it has children
@@ -79,19 +60,6 @@ module Ancestry
       end
     end
 
-    # The ancestry value for this record's children (before save)
-    # This is technically child_ancestry_was
-    def child_ancestry
-      # New records cannot have children
-      raise Ancestry::AncestryException.new('No child ancestry for new record. Save record before performing tree operations.') if new_record?
-
-      if self.send("#{self.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}").blank?
-        id.to_s
-      else
-        "#{self.send "#{self.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}"}/#{id}"
-      end
-    end
-
     # Counter Cache
     def increase_parent_counter_cache
       self.class.increment_counter _counter_cache_column, parent_id
@@ -133,8 +101,7 @@ module Ancestry
     # Ancestors
 
     def ancestors?
-      # ancestor_ids.present?
-      read_attribute(self.ancestry_base_class.ancestry_column).present?
+      ancestor_ids.present?
     end
     alias :has_parent? :ancestors?
 
@@ -149,50 +116,21 @@ module Ancestry
       end
     end
 
-    def ancestor_ids
-      parse_ancestry_column(read_attribute(self.ancestry_base_class.ancestry_column))
-    end
-
-    def ancestor_conditions
-      self.ancestry_base_class.ancestor_conditions(self)
-    end
-
     def ancestors depth_options = {}
       return self.ancestry_base_class.none unless ancestors?
-      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.where ancestor_conditions
-    end
-
-    # deprecate
-    def ancestor_was_conditions
-      {primary_key_with_table => ancestor_ids_before_last_save}
-    end
-
-    # deprecated - probably don't want to use anymore
-    def ancestor_ids_was
-      parse_ancestry_column(send("#{self.ancestry_base_class.ancestry_column}_was"))
-    end
-
-    def ancestor_ids_before_last_save
-      parse_ancestry_column(send("#{self.ancestry_base_class.ancestry_column}#{BEFORE_LAST_SAVE_SUFFIX}"))
-    end
-
-    def parent_id_before_last_save
-      ancestry_was = send("#{self.ancestry_base_class.ancestry_column}#{BEFORE_LAST_SAVE_SUFFIX}")
-      return unless ancestry_was.present?
-
-      ancestry_was.split(ANCESTRY_DELIMITER).last.to_i
+      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.ancestors_of(self)
     end
 
     def path_ids
       ancestor_ids + [id]
     end
 
-    def path_conditions
-      self.ancestry_base_class.path_conditions(self)
+    def path_ids_in_database
+      ancestor_ids_in_database + [id]
     end
 
     def path depth_options = {}
-      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.where path_conditions
+      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.inpath_of(self)
     end
 
     def depth
@@ -212,7 +150,7 @@ module Ancestry
     # currently parent= does not work in after save callbacks
     # assuming that parent hasn't changed
     def parent= parent
-      write_attribute(self.ancestry_base_class.ancestry_column, if parent.nil? then nil else parent.child_ancestry end)
+      self.ancestor_ids = parent ? parent.path_ids : []
     end
 
     def parent_id= new_parent_id
@@ -222,15 +160,12 @@ module Ancestry
     def parent_id
       ancestor_ids.last if ancestors?
     end
+    alias :parent_id? :ancestors?
 
     def parent
       unscoped_find(parent_id) if ancestors?
     end
 
-    def parent_id?
-      ancestors?
-    end
-
     def parent_of?(node)
       self.id == node.parent_id
     end
@@ -246,7 +181,7 @@ module Ancestry
     end
 
     def is_root?
-      read_attribute(self.ancestry_base_class.ancestry_column).blank?
+      !ancestors?
     end
     alias :root? :is_root?
 
@@ -256,12 +191,8 @@ module Ancestry
 
     # Children
 
-    def child_conditions
-      self.ancestry_base_class.child_conditions(self)
-    end
-
     def children
-      self.ancestry_base_class.where child_conditions
+      self.ancestry_base_class.children_of(self)
     end
 
     def child_ids
@@ -284,14 +215,11 @@ module Ancestry
 
     # Siblings
 
-    def sibling_conditions
-      self.ancestry_base_class.sibling_conditions(self)
-    end
-
     def siblings
-      self.ancestry_base_class.where sibling_conditions
+      self.ancestry_base_class.siblings_of(self)
     end
 
+    # NOTE: includes self
     def sibling_ids
       siblings.pluck(self.ancestry_base_class.primary_key)
     end
@@ -307,17 +235,13 @@ module Ancestry
     alias_method :only_child?, :is_only_child?
 
     def sibling_of?(node)
-      self.ancestry == node.ancestry
+      self.ancestor_ids == node.ancestor_ids
     end
 
     # Descendants
 
-    def descendant_conditions
-      self.ancestry_base_class.descendant_conditions(self)
-    end
-
     def descendants depth_options = {}
-      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).where descendant_conditions
+      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).descendants_of(self)
     end
 
     def descendant_ids depth_options = {}
@@ -330,12 +254,8 @@ module Ancestry
 
     # Indirects
 
-    def indirect_conditions
-      self.ancestry_base_class.indirect_conditions(self)
-    end
-
     def indirects depth_options = {}
-      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).where indirect_conditions
+      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).indirects_of(self)
     end
 
     def indirect_ids depth_options = {}
@@ -348,12 +268,8 @@ module Ancestry
 
     # Subtree
 
-    def subtree_conditions
-      self.ancestry_base_class.subtree_conditions(self)
-    end
-
     def subtree depth_options = {}
-      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).where subtree_conditions
+      self.ancestry_base_class.ordered_by_ancestry.scope_depth(depth_options, depth).subtree_of(self)
     end
 
     def subtree_ids depth_options = {}
@@ -373,17 +289,9 @@ module Ancestry
     end
 
   private
-    ANCESTRY_DELIMITER = '/'.freeze
-
-    def parse_ancestry_column obj
-      return [] unless obj
-      obj_ids = obj.split(ANCESTRY_DELIMITER)
-      self.class.primary_key_is_an_integer? ? obj_ids.map!(&:to_i) : obj_ids
-    end
-
     def unscoped_descendants
       unscoped_where do |scope|
-        scope.where descendant_conditions
+        scope.where self.ancestry_base_class.descendant_conditions(self)
       end
     end
 

data/lib/ancestry/materialized_path.rb

@@ -1,44 +1,56 @@
 module Ancestry
   module MaterializedPath
+    BEFORE_LAST_SAVE_SUFFIX = ActiveRecord::VERSION::STRING >= '5.1.0' ? '_before_last_save'.freeze : '_was'.freeze
+    IN_DATABASE_SUFFIX = ActiveRecord::VERSION::STRING >= '5.1.0' ? '_in_database'.freeze : '_was'.freeze
+    ANCESTRY_DELIMITER='/'.freeze
+
     def self.extended(base)
-      base.validates_format_of base.ancestry_column, :with => Ancestry::ANCESTRY_PATTERN, :allow_nil => true
       base.send(:include, InstanceMethods)
     end
 
-    def root_conditions
-      arel_table[ancestry_column].eq(nil)
+    def path_of(object)
+      to_node(object).path
+    end
+
+    def roots
+      where(arel_table[ancestry_column].eq(nil))
     end
 
-    def ancestor_conditions(object)
+    def ancestors_of(object)
       t = arel_table
       node = to_node(object)
-      t[primary_key].in(node.ancestor_ids)
+      where(t[primary_key].in(node.ancestor_ids))
     end
 
-    def path_conditions(object)
+    def inpath_of(object)
       t = arel_table
       node = to_node(object)
-      t[primary_key].in(node.path_ids)
+      where(t[primary_key].in(node.path_ids))
     end
 
-    def child_conditions(object)
+    def children_of(object)
       t = arel_table
       node = to_node(object)
-      t[ancestry_column].eq(node.child_ancestry)
+      where(t[ancestry_column].eq(node.child_ancestry))
     end
 
     # indirect = anyone who is a descendant, but not a child
-    def indirect_conditions(object)
+    def indirects_of(object)
       t = arel_table
       node = to_node(object)
       # rails has case sensitive matching.
       if ActiveRecord::VERSION::MAJOR >= 5
-        t[ancestry_column].matches("#{node.child_ancestry}/%", nil, true)
+        where(t[ancestry_column].matches("#{node.child_ancestry}/%", nil, true))
       else
-        t[ancestry_column].matches("#{node.child_ancestry}/%")
+        where(t[ancestry_column].matches("#{node.child_ancestry}/%"))
       end
     end
 
+    def descendants_of(object)
+      where(descendant_conditions(object))
+    end
+
+    # deprecated
     def descendant_conditions(object)
       t = arel_table
       node = to_node(object)
@@ -50,23 +62,94 @@ module Ancestry
       end
     end
 
-    def subtree_conditions(object)
+    def subtree_of(object)
       t = arel_table
       node = to_node(object)
-      descendant_conditions(node).or(t[primary_key].eq(node.id))
+      where(descendant_conditions(node).or(t[primary_key].eq(node.id)))
     end
 
-    def sibling_conditions(object)
+    def siblings_of(object)
       t = arel_table
       node = to_node(object)
-      t[ancestry_column].eq(node[ancestry_column])
+      where(t[ancestry_column].eq(node[ancestry_column]))
+    end
+
+    def ordered_by_ancestry(order = nil)
+      if %w(mysql mysql2 sqlite sqlite3).include?(connection.adapter_name.downcase)
+        reorder(arel_table[ancestry_column], order)
+      elsif %w(postgresql).include?(connection.adapter_name.downcase) && ActiveRecord::VERSION::STRING >= "6.1"
+        reorder(Arel::Nodes.new(arel_table[ancestry_column]).nulls_first)
+      else
+        reorder(
+          Arel::Nodes::Ascending.new(Arel::Nodes::NamedFunction.new('COALESCE', [arel_table[ancestry_column], Arel.sql("''")])),
+          order
+        )
+      end
+    end
+
+    def ordered_by_ancestry_and(order)
+      ordered_by_ancestry(order)
     end
 
     module InstanceMethods
+
       # Validates the ancestry, but can also be applied if validation is bypassed to determine if children should be affected
       def sane_ancestry?
         ancestry_value = read_attribute(self.ancestry_base_class.ancestry_column)
-        ancestry_value.nil? || (ancestry_value.to_s =~ Ancestry::ANCESTRY_PATTERN && !ancestor_ids.include?(self.id))
+        (ancestry_value.nil? || !ancestor_ids.include?(self.id)) && valid?
+      end
+
+      # optimization - better to go directly to column and avoid parsing
+      def ancestors?
+        read_attribute(self.ancestry_base_class.ancestry_column).present?
+      end
+      alias :has_parent? :ancestors?
+
+      def ancestor_ids=(value)
+        col = self.ancestry_base_class.ancestry_column
+        value.present? ? write_attribute(col, value.join(ANCESTRY_DELIMITER)) : write_attribute(col, nil)
+      end
+
+      def ancestor_ids
+        parse_ancestry_column(read_attribute(self.ancestry_base_class.ancestry_column))
+      end
+
+      def ancestor_ids_in_database
+        parse_ancestry_column(send("#{self.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}"))
+      end
+
+      def ancestor_ids_before_last_save
+        parse_ancestry_column(send("#{self.ancestry_base_class.ancestry_column}#{BEFORE_LAST_SAVE_SUFFIX}"))
+      end
+
+      def parent_id_before_last_save
+        ancestry_was = send("#{self.ancestry_base_class.ancestry_column}#{BEFORE_LAST_SAVE_SUFFIX}")
+        return unless ancestry_was.present?
+
+        parse_ancestry_column(ancestry_was).last
+      end
+
+      # optimization - better to go directly to column and avoid parsing
+      def sibling_of?(node)
+        self.read_attribute(self.ancestry_base_class.ancestry_column) == node.read_attribute(self.ancestry_base_class.ancestry_column)
+      end
+
+      # private (public so class methods can find it)
+      # The ancestry value for this record's children (before save)
+      # This is technically child_ancestry_was
+      def child_ancestry
+        # New records cannot have children
+        raise Ancestry::AncestryException.new('No child ancestry for new record. Save record before performing tree operations.') if new_record?
+        path_was = self.send("#{self.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}")
+        path_was.blank? ? id.to_s : "#{path_was}/#{id}"
+      end
+
+      private
+
+      def parse_ancestry_column obj
+        return [] unless obj
+        obj_ids = obj.split(ANCESTRY_DELIMITER)
+        self.class.primary_key_is_an_integer? ? obj_ids.map!(&:to_i) : obj_ids
       end
     end
   end

data/lib/ancestry/version.rb

@@ -1,3 +1,3 @@
 module Ancestry
-  VERSION = "3.0.7"
+  VERSION = "3.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ancestry
 version: !ruby/object:Gem::Version
-  version: 3.0.7
+  version: 3.1.0
 platform: ruby
 authors:
 - Stefan Kroes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-06 00:00:00.000000000 Z
+date: 2020-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -17,16 +17,16 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 4.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 4.2.0
 - !ruby/object:Gem::Dependency
-  name: rdoc
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -40,7 +40,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -59,44 +59,16 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -150,7 +122,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="