ancestry 4.2.0 → 4.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82bcd1895093ab9b569806ef05fc307fc2ca9ab53ffeb09199bd66fe3672ecfb
-  data.tar.gz: fe7d0d356641658be2953309c27dd28a42e81ed569690cc5e26b2721b1aa6a37
+  metadata.gz: 1628363389f64272d25675e727b155ba36c221404a95fc7d7d41de12b2185614
+  data.tar.gz: 2a76d777929b18efa86bde34b969f11ab58c3f44424e82c97e69ef8f348d1c96
 SHA512:
-  metadata.gz: f33384a1114d865662be0133c532249be0e7ea438a66e469947b3aaba3172378ae50309e02c4f219c1f161281a9e060bff6087a496850c26351fd83348627e79
-  data.tar.gz: 2a6cb3fb28f6c9a8228b522c590c2125c4e31056a97ac6a6cda96ea4152725fe89e375b59c894091ebcd3d5be36ad18b348c6691211bc6bea2b0a49502c9f423
+  metadata.gz: 5ece87f9d1577748ffbaaf8617afdc4bf4094f653300b4a2df043a5f16822b267da877f0689b7d792f5f2174f1b4e1b41333e89c0e9dc23c388af30712267953
+  data.tar.gz: a12ce97c69b384100eecf3a347dcd3fea0abb60193c71b0e6a83d667c8f6a4cfdeba7e401e743bf95cf59f4d87ddc550d63b258ac294dd057ca7c518f1c8540f

data/CHANGELOG.md

@@ -3,6 +3,23 @@
 Doing our best at supporting [SemVer](http://semver.org/) with
 a nice looking [Changelog](http://keepachangelog.com).
 
+## Version [4.3.1] <sub><sup>2023-03-19</sub></sup>
+* Fix: added back fields that were removed in #589 [#637](https://github.com/stefankroes/ancestry/pull/637) (thx @znz)
+  - ancestor_ids_in_database
+  - parent_id_in_database
+
+## Version [4.3.0] <sub><sup>2023-03-09</sub></sup>
+
+* Fix: materialized_path2 strategy [#597](https://github.com/stefankroes/ancestry/pull/597) (thx @kshnurov)
+* Fix: descendants ancestry is now updated in after_update callbacks [#589](https://github.com/stefankroes/ancestry/pull/589) (thx @kshnurov)
+* Document updated grammar [#594](https://github.com/stefankroes/ancestry/pull/594) (thx @omarr-gamal)
+* Documented `update_strategy` [#588](https://github.com/stefankroes/ancestry/pull/588) (thx @victorfgs)
+* Fix: fixed has_parent? when non-default primary id [#585](https://github.com/stefankroes/ancestry/pull/585) (thx @Zhong-z)
+* Documented column collation and testing [#601](https://github.com/stefankroes/ancestry/pull/601) [#607](https://github.com/stefankroes/ancestry/pull/607) (thx @kshnurov)
+* Added initializer with default_ancestry_format [#612](https://github.com/stefankroes/ancestry/pull/612) [#613](https://github.com/stefankroes/ancestry/pull/613)
+* ruby 3.2 support [#596](https://github.com/stefankroes/ancestry/pull/596) (thx @petergoldstein)
+* arrange is 3x faster and uses 20-30x less memory [#415](https://github.com/stefankroes/ancestry/pull/415)
+
 ## Version [4.2.0] <sub><sup>2022-06-09</sub></sup>
 
 * added strategy: materialized_path2 [#571](https://github.com/stefankroes/ancestry/pull/571)
@@ -270,7 +287,8 @@ Missed 2 commits (which are feature adds)
 * Validations
 
 
-[HEAD]: https://github.com/stefankroes/ancestry/compare/v4.2.0...HEAD
+[HEAD]: https://github.com/stefankroes/ancestry/compare/v4.3.0...HEAD
+[4.3.0]: https://github.com/stefankroes/ancestry/compare/v4.2.0...v4.3.0
 [4.2.0]: https://github.com/stefankroes/ancestry/compare/v4.1.0...v4.2.0
 [4.1.0]: https://github.com/stefankroes/ancestry/compare/v4.0.0...v4.1.0
 [4.0.0]: https://github.com/stefankroes/ancestry/compare/v3.2.1...v4.0.0

data/README.md

@@ -2,29 +2,58 @@
 
 # Ancestry
 
-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 employs
-the materialised path pattern and exposes all the standard tree structure
-relations (ancestors, parent, root, children, siblings, descendants), allowing all
-of them to be fetched in a single SQL query. Additional features include STI
-support, scopes, depth caching, depth constraints, easy migration from older
-gems, integrity checking, integrity restoration, arrangement of
-(sub)trees into hashes, and various strategies for dealing with orphaned
-records.
-
-NOTE:
+## Overview
+
+Ancestry is a gem that allows rails ActiveRecord models to be organized as
+a tree structure (or hierarchy). It employs the materialized path pattern
+which allows operations to be performed efficiently.
+
+# Features
+
+There are a few common ways of storing hierarchical data in a database:
+materialized path, closure tree table, adjacency lists, nested sets, and adjacency list with recursive queries.
+
+## Features from Materialized Path
+
+- Store hierarchy in an easy to understand format. (e.g.: `/1/2/3/`)
+- Store hierarchy in the original table with no additional tables.
+- Single SQL queries for relations (`ancestors`, `parent`, `root`, `children`, `siblings`, `descendants`)
+- Single query for creating records.
+- Moving/deleting nodes only affect child nodes (rather than updating all nodes in the tree)
+
+## Features from Ancestry gem Implementation
+
+- relations are implemented as `scopes`
+- `STI` support
+- Arrangement of subtrees into hashes
+- Multiple strategies for querying materialized_path
+- Multiple strategies for dealing with orphaned records
+- depth caching
+- depth constraints
+- counter caches
+- Multiple strategies for moving nodes
+- Easy migration from `parent_id` based gems
+- Integrity checking
+- Integrity restoration
+- Most queries use indexes on `id` or `ancestry` column. (e.g.: `LIKE '#{ancestry}/%'`)
+
+Since a Btree index has a limitaton of 2704 characters for the `ancestry` column,
+the maximum depth of an ancestry tree is 900 items at most. If ids are 4 digits long,
+then the max depth is 540 items.
+
+When using `STI` all classes are returned from the scopes unless you specify otherwise using `where(:type => "ChildClass")`.
+
+## Supported Rails versions
 
 - Ancestry 2.x supports Rails 4.1 and earlier
 - Ancestry 3.x supports Rails 5.0 and 4.2
-- Ancestry 4.0 only supports rails 5.0 and higher
+- Ancestry 4.x only supports rails 5.2 and higher
 
 # Installation
 
-Follow these simple steps to apply Ancestry to any ActiveRecord model:
+Follow these steps to apply Ancestry to any ActiveRecord model:
 
-## Install
-
-* Add to Gemfile:
+## Add to Gemfile
 
 ```ruby
 # Gemfile
@@ -32,73 +61,68 @@ Follow these simple steps to apply Ancestry to any ActiveRecord model:
 gem 'ancestry'
 ```
 
-* Install required gems:
-
 ```bash
 $ bundle install
 ```
 
-
 ## Add ancestry column to your table
-* Create migration:
 
 ```bash
-$ rails g migration add_ancestry_to_[table] ancestry:string:index
-# or use different column name of your choosing. e.g. name:
-# rails g migration add_name_to_[people] name:string:index
+$ rails g migration add_[ancestry]_to_[table] ancestry:string:index
+```
+
+```ruby
+class AddAncestryToTable < ActiveRecord::Migration[6.1]
+  def change
+    change_table(:table) do |t|
+      # postgrel
+      t.string "ancestry", collation: 'C', null: false
+      t.index "ancestry"
+      # mysql
+      t.string "ancestry", collation: 'utf8mb4_bin', null: false
+      t.index "ancestry"
+    end
+  end
+end
 ```
 
-*   Migrate your database:
+There are additional options for the columns in [Ancestry Database Columnl](#ancestry-database-column) and
+an explanation for `opclass` and `collation`.
 
 ```bash
 $ rake db:migrate
 ```
 
-Depending upon your comfort with databases, you may want to create the column
-with `C` or `POSIX` encoding. This is a more primitive encoding and just compares
-bytes. Since this column will just contains numbers and slashes, it works much
-better. It also works better for the uuid case as well.
-
-Alternatively, if you create a [`text_pattern_ops`](https://www.postgresql.org/docs/current/indexes-opclass.html) index for your postgresql column, subtree selection will use an efficient index for you regardless of whether you created the column with `POSIX` encoding.
+## Configure ancestry defaults
 
-If you opt out of this, and are trying to run tests on postgres, you may need to
-set the environment variable `COLLATE_SYMBOLS=false`. Sorry to say that a discussion
-on this topic is out of scope. The important take away is postgres sort order is
-not consistent across operating systems but other databases do not have this same
-issue.
+```ruby
+# config/initializers/ancestry.rb
 
-NOTE: A Btree index (as is recommended) has a limitaton of 2704 characters for the ancestry column. This means you can't have an tree with a depth that is too great (~> 900 items at most).
+# use the newer format
+Ancestry.default_ancestry_format = :materialized_path2
+# Ancestry.default_update_strategy = :sql
+```
 
 ## Add ancestry to your model
-* Add to app/models/[model.rb]:
 
 ```ruby
 # app/models/[model.rb]
 
 class [Model] < ActiveRecord::Base
-   has_ancestry # or alternatively as below:
-   # has_ancestry ancestry_column: :name ## if you've used a different column name
+   has_ancestry
 end
 ```
 
 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 order to allow usage of both the acts_as_tree gem and the ancestry gem in a
-single application. The `acts_as_tree` method will continue to be supported in the future.
-
 # Organising records into a tree
 
-You can use the parent attribute to organise your records into a tree. If you
-have the id of the record you want to use as a parent and don't want to fetch
-it, you can also use parent_id. Like any virtual model attributes, parent and
-parent_id can be set using parent= and parent_id= on a record or by including
-them in the hash passed to new, create, create!, update_attributes and
-update_attributes!. For example:
+You can use `parent_id` and `parent` to add a node into a tree. They can be
+set as attributes or passed into methods like `new`, `create`, and `update`.
 
-`TreeNode.create! :name => 'Stinky', :parent => TreeNode.create!(:name => 'Squeeky')`.
+```ruby
+TreeNode.create! :name => 'Stinky', :parent => TreeNode.create!(:name => 'Squeeky')
+```
 
 Children can be created through the children relation on a node: `node.children.create :name => 'Stinky'`.
 
@@ -127,31 +151,47 @@ The yellow nodes are those returned by the method.
 |`has_siblings?`                |                                                     |                                 |
 |`sibling_of?(node)`            |                                                     |                                 |
 
+When using `STI` all classes are returned from the scopes unless you specify otherwise using `where(:type => "ChildClass")`.
+
 <sup id="fn1">1. [other root records are considered siblings]<a href="#ref1" title="Jump back to footnote 1.">↩</a></sup>
 
-# `has_ancestry` options
+# has_ancestry options
 
-The has_ancestry method supports the following options:
+The `has_ancestry` method supports the following options:
 
-    :ancestry_column       Pass in a symbol to store ancestry in a different column
+    :ancestry_column       Column name to store ancestry
+                           'ancestry' (default)
+    :ancestry_format       Format for ancestry column (see Ancestry Formats section):
+                           :materialized_path (default)     1/2/3, root nodes ancestry=nil
+                           :materialized_path2 (preferred) /1/2/3/, root nodes ancestry=/
     :orphan_strategy       Instruct Ancestry what to do with children of a node that is destroyed:
                            :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
-    :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]+)
-    :touch                 Instruct Ancestry to touch the ancestors of a node when it changes, to
-                           invalidate nested key-based caches. (default: false)
-    :counter_cache         Boolean whether to create counter cache column accessor. 
-                           Default column name is `children_count`. 
-                           Pass symbol to use different column name (default: false)
+    :cache_depth           Cache the depth of each node (See Depth Cache section)
+                           false (default)
+
+    :depth_cache_column    column name to store depth cache
+                           'ancestry_depth' (default)
+    :primary_key_format    regular expression that matches the format of the primary key
+                           '[0-9]+'           (default) integer ids
+                           '[-A-Fa-f0-9]{36}'           UUIDs
+    :touch                 Instruct Ancestry to touch the ancestors of a node when it changes
+                           false (default) don't invalide nested key-based caches
+    :counter_cache         Whether to create counter cache column accessor.
+                           false (default) don't store a counter cache
+                           true            store counter cache in `children_count`.
+                           String          name of column to store counter cache.
+    :update_strategy       Choose the strategy to update descendants nodes
+                           :ruby (default) All descendants are updated using the ruby algorithm.
+                                           This triggers update callbacks for each descendant node
+                           :sql            All descendants are updated using a single SQL statement.
+                                           This strategy does not trigger update callbacks for the descendants.
+                                           This strategy is available only for PostgreSql implementations
+
+Legacy configuration using `acts_as_tree` is still available. Ancestry defers to `acts_as_tree` if that gem is installed.
 
 # (Named) Scopes
 
@@ -183,7 +223,7 @@ It is possible thanks to some convenient rails magic to create nodes through the
 
 # Selecting nodes by depth
 
-With depth caching enabled (see has_ancestry options), an additional five named
+With depth caching enabled (see [has_ancestry options](#has_ancestry-options)), an additional five named
 scopes can be used to select nodes by depth:
 
     before_depth(depth)     Return nodes that are less deep than depth (node.depth < depth)
@@ -203,16 +243,13 @@ can be fetched directly from the ancestry column without needing a query. Use
     node.descendants(:from_depth => 2, :to_depth => 4)
     node.subtree.from_depth(10).to_depth(12)
 
-# STI support
-
-To use with STI: create a STI inheritance hierarchy and build a tree from the different
-classes/models. All Ancestry relations that were described above will return nodes of any model type. If
-you do only want nodes of a specific subclass, a type condition is required.
-
 # Arrangement
 
+## `arrange`
+
 A subtree can be arranged into nested hashes for easy navigation after database retrieval.
-`TreeNode.arrange` could, for instance, return:
+
+The resulting format is a hash of hashes
 
 ```ruby
 {
@@ -225,24 +262,22 @@ A subtree can be arranged into nested hashes for easy navigation after database
 }
 ```
 
-The `arrange` method can work on a scoped class (`TreeNode.find_by(:name => 'Crunchy').subtree.arrange`),
-and can take ActiveRecord find options. If you want ordered hashes, pass the order to the method instead of
-the scope as follows:
-
-`TreeNode.find_by(:name => 'Crunchy').subtree.arrange(:order => :name)`.
+There are many ways to call `arrange`:
 
-The `arrange_serializable` method returns the arranged nodes as a nested array of hashes. Order
-can be passed in the same fashion as to the `arrange` method:
-`TreeNode.arrange_serializable(:order => :name)` The result can easily be serialized to json with `to_json`
-or other formats. You can also supply your own serialization logic with blocks.
-
-Using `ActiveModel` serializers:
+```ruby
+TreeNode.find_by(:name => 'Crunchy').subtree.arrange
+TreeNode.find_by(:name => 'Crunchy').subtree.arrange(:order => :name)
+```
 
-`TreeNode.arrange_serializable { |parent, children| MySerializer.new(parent, children: children) }`.
+## `arrange_serializable`
 
-Or plain hashes:
+If a hash of arrays is preferred, `arrange_serializable` can be used. The results
+work well with `to_json`.
 
 ```ruby
+TreeNode.arrange_serializable(:order => :name)
+# use an active model serializer
+TreeNode.arrange_serializable { |parent, children| MySerializer.new(parent, children: children) }
 TreeNode.arrange_serializable do |parent, children|
   {
      my_id: parent.id,
@@ -254,54 +289,232 @@ end
 # Sorting
 
 The `sort_by_ancestry` class method: `TreeNode.sort_by_ancestry(array_of_nodes)` can be used
-to sort an array of nodes as if traversing in preorder. (Note that since materialised path
+to sort an array of nodes as if traversing in preorder. (Note that since materialized path
 trees do not support ordering within a rank, the order of siblings is
 dependant upon their original array order.)
 
+
+# Ancestry Database Column
+
+## Collation Indexes
+
+Sorry, using collation or index operator classes makes this a little complicated. The
+root of the issue is that in order to use indexes, the ancestry column needs to
+compare strings using ascii rules.
+
+It is well known that `LIKE '/1/2/%'` will use an index because the wildchard (i.e.: `%`)
+is on the right hand side of the `LIKE`. While that is true for ascii strings, it is not
+necessarily true for unicode. Since ancestry only uses ascii characters, telling the database
+this constraint will optimize the `LIKE` statemens.
+
+## Collation Sorting
+
+As of 2018, standard unicode collation ignores punctuation for sorting. This ignores
+the ancestry delimiter (i.e.: `/`) and returns data in the wrong order. The exception
+being Postgres on a mac, which ignores proper unicode collation and instead uses
+ISO-8859-1 ordering (read: ascii sorting).
+
+Using the proper column storage and indexes will ensure that data is returned from the
+database in the correct order. It will also ensure that developers on Mac or Windows will
+get the same results as linux production servers, if that is your setup.
+
+## Migrating Collation
+
+If you are reading this and want to alter your table to add collation to an existing column,
+remember to drop existing indexes on the `ancestry` column and recreate them.
+
+## ancestry_format materialized_path and nulls
+
+If you are using the legacy `ancestry_format` of `:materialized_path`, then you need to the
+collum to allow `nulls`. Change the column create accordingly: `null: true`.
+
+Chances are, you can ignore this section as you most likely want to use `:materialized_path2`.
+
+## Postgres Storage Options
+
+### ascii field collation
+
+The currently suggested way to create a postgres field is using `'C'` collation:
+
+```ruby
+t.string "ancestry", collation: 'C', null: false
+t.index "ancestry"
+```
+
+### ascii index
+
+If you need to use a standard collation (e.g.: `en_US`), then use an ascii index:
+
+```ruby
+t.string "ancestry", null: false
+t.index  "ancestry", opclass: :varchar_pattern_ops
+```
+
+This option is mostly there for users who have an existing ancestry column and are more
+comfortable tweaking indexes rather than altering the ancestry column.
+
+### binary column
+
+When the column is binary, the database doesn't convert strings using locales.
+Rails will convert the strings and send byte arrays to the database.
+At this time, this option is not suggested. The sql is not as readable, and currently
+this does not support the `:sql` update_strategy.
+
+```ruby
+t.binary "ancestry", limit: 3000, null: false
+t.index  "ancestry"
+```
+You may be able to alter the database to gain some readability:
+
+```SQL
+ALTER DATABASE dbname SET bytea_output to 'escape';
+```
+
+## Mysql Storage options
+
+### ascii field collation
+
+The currently suggested way to create a postgres field is using `'C'` collation:
+
+```ruby
+t.string "ancestry", collation: 'utf8mb4_bin', null: false
+t.index "ancestry"
+```
+
+### binary collation
+
+Collation of `binary` acts much the same way as the `binary` column:
+
+```ruby
+t.string "ancestry", collate: 'binary', limit: 3000, null: false
+t.index  "ancestry"
+```
+
+### binary column
+
+```ruby
+t.binary "ancestry", limit: 3000, null: false
+t.index  "ancestry"
+```
+
+### ascii character set
+
+Mysql supports per column character sets. Using a character set of `ascii` will
+set this up.
+
+```SQL
+ALTER TABLE table
+  ADD COLUMN ancestry VARCHAR(2700) CHARACTER SET ascii;
+```
+
+# Ancestry Formats
+
+You can choose from 2 ancestry formats:
+
+- `:materialized_path` - legacy format (currently the default for backwards compatibility reasons)
+- `:materialized_path2` - newer format. Use this if it is a new column
+
+```
+:materialized_path    1/2/3,  root nodes ancestry=nil
+    descendants SQL: ancestry LIKE '1/2/3/%' OR ancestry = '1/2/3'
+:materialized_path2  /1/2/3/, root nodes ancestry=/
+    descendants SQL: ancestry LIKE '/1/2/3/%'
+```
+
+If you are unsure, choose `:materialized_path2`. It allows a not NULL column,
+faster descenant queries, has one less `OR` statement in the queries, and
+the path can be formed easily in a database query for added benefits.
+
+There is more discussion in [Internals](#internals) or [Migrating ancestry format](#migrate-ancestry-format)
+For migrating from `materialized_path` to `materialized_path2` see [Ancestry Column](#ancestry-column)
+
+## Migrating Ancestry Format
+
+To migrate from `materialized_path` to `materialized_path2`:
+
+```ruby
+klass = YourModel
+# set all child nodes
+klass.where.not(klass.arel_table[klass.ancestry_column].eq(nil)).update_all("#{klass.ancestry_column} = CONCAT('#{klass.ancestry_delimiter}', #{klass.ancestry_column}, '#{klass.ancestry_delimiter}')")
+# set all root nodes
+klass.where(klass.arel_table[klass.ancestry_column].eq(nil)).update_all("#{klass.ancestry_column} = '#{klass.ancestry_root}'")
+
+change_column_null klass.table_name, klass.ancestry_column, false
+```
+
 # Migrating from plugin that uses parent_id column
 
-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.
+It should be relatively simple to migrating from a plugin that uses a `parent_id`
+column, (e.g.: `awesome_nested_set`, `better_nested_set`, `acts_as_nested_set`).
 
-<details>
-<summary>Details</summary>
+When running the installation steps, also remove the old gem from your `Gemfile`,
+and remove the old gem's macros from the model.
 
-1.  Add ancestry column to your table
-    *   Create migration: **rails g migration [add_ancestry_to_](table)
-        ancestry:string**
-    *   Add index to migration: **add_index [table], :ancestry** (UP) /
-        **remove_index [table], :ancestry** (DOWN)
-    *   Migrate your database: **rake db:migrate**
+Then populate the `ancestry` column from rails console:
+
+```ruby
+Model.build_ancestry_from_parent_ids!
+# Model.rebuild_depth_cache!
+Model.check_ancestry_integrity!
+```
 
+It is time to run your code. Most tree methods should work fine with ancestry
+and hopefully your tests only require a few minor tweaks to get up and runnnig.
 
-2.  Remove old tree gem and add in Ancestry to Gemfile
-    *   See 'Installation' for more info on installing and configuring gems
+Once you are happy with how your app is running, remove the old `parent_id` column:
 
+```bash
+$ rails g migration remove_parent_id_from_[table]
+```
 
-3.  Change your model
-    *   Remove any macros required by old plugin/gem from
-        `[app/models/](model).rb`
-    *   Add to `[app/models/](model).rb`: `has_ancestry`
+```ruby
+class RemoveParentIdFromToTable < ActiveRecord::Migration[6.1]
+  def change
+    remove_column "table", "parent_id", type: :integer
+  end
+end
+```
 
+```bash
+$ rake db:migrate
+```
 
-4.  Generate ancestry columns
-    *   In rails console: **[model].build_ancestry_from_parent_ids!**
-    *   Make sure it worked ok: **[model].check_ancestry_integrity!**
+# Depth cache
 
+## Depth Cache Migration
 
-5.  Change your code
-    *   Most tree calls will probably work fine with ancestry
-    *   Others must be changed or proxied
-    *   Check if all your data is intact and all tests pass
+To add depth_caching to an existing model:
 
+## Add column
 
-6.  Drop parent_id column:
-    *   Create migration: `rails g migration [remove_parent_id_from_](table)`
-    *   Add to migration: `remove_column [table], :parent_id`
-    *   Migrate your database: `rake db:migrate`
-</details>
+```ruby
+class AddDepthCachToTable < ActiveRecord::Migration[6.1]
+  def change
+    change_table(:table) do |t|
+      t.integer "ancestry_depth", default: 0
+    end
+  end
+end
+```
+
+## Add ancestry to your model
+
+```ruby
+# app/models/[model.rb]
+
+class [Model] < ActiveRecord::Base
+   has_ancestry depth_cache: true
+end
+```
+
+## Update existing values
+
+Add a custom script or run from rails console.
+Some use migrations, but that can make the migration suite fragile. The command of interest is:
+
+```ruby
+Model.rebuild_depth_cache!
+```
 
 # Running Tests
 
@@ -317,26 +530,6 @@ appraisal rake test
 appraisal sqlite3-ar-50 rake test
 ```
 
-# Internals
-
-Ancestry stores a path from the root to the parent for every node.
-This is a variation on the materialised path database pattern.
-It allows Ancestry to fetch any relation (siblings,
-descendants, etc.) in a single SQL query without the complicated algorithms
-and incomprehensibility associated with left and right values. Additionally,
-any inserts, deletes and updates only affect nodes within the affected node's
-own subtree.
-
-In the example above, the `ancestry` column is created as a `string`. This puts a
-limitation on the depth of the tree of about 40 or 50 levels. To increase the
-maximum depth of the tree, increase the size of the `string` or use `text` to
-remove the limitation entirely. Changing it to a text will however decrease
-performance because an index cannot be put on the column in that case.
-
-The materialised path pattern requires Ancestry to use a 'like' condition in
-order to fetch descendants. The wild character (`%`) is on the right of the
-query, so indexes should be used.
-
 # Contributing and license
 
 Question? Bug report? Faulty/incomplete documentation? Feature request? Please

data/lib/ancestry/class_methods.rb

@@ -46,8 +46,10 @@ module Ancestry
       end
     end
 
-    # Arrange array of nodes into a nested hash of the form
-    # {node => children}, where children = {} if the node has no children
+    # arranges array of nodes to a hierarchical hash
+    #
+    # @param nodes [Array[Node]] nodes to be arranged
+    # @returns Hash{Node => {Node => {}, Node => {}}}
     # If a node's parent is not included, the node will be included as if it is a top level node
     def arrange_nodes(nodes)
       node_ids = Set.new(nodes.map(&:id))
@@ -60,6 +62,18 @@ module Ancestry
       end
     end
 
+    # convert a hash of the form {node => children} to an array of nodes, child first
+    #
+    # @param arranged [Hash{Node => {Node => {}, Node => {}}}] arranged nodes
+    # @returns [Array[Node]] array of nodes with the parent before the children
+    def flatten_arranged_nodes(arranged, nodes = [])
+      arranged.each do |node, children|
+        nodes << node
+        flatten_arranged_nodes(children, nodes) unless children.empty?
+      end
+      nodes
+    end
+
      # Arrangement to nested array for serialization
      # You can also supply your own serialization logic using blocks
      # also allows you to pass the order just as you can pass it to the arrange method
@@ -89,29 +103,21 @@ module Ancestry
     end
 
     # Pseudo-preordered array of nodes.  Children will always follow parents,
+    # This is deterministic unless the parents are missing *and* a sort block is specified
     def sort_by_ancestry(nodes, &block)
       arranged = nodes if nodes.is_a?(Hash)
 
       unless arranged
         presorted_nodes = nodes.sort do |a, b|
-          a_cestry, b_cestry = a.ancestry || '0', b.ancestry || '0'
-
-          if block_given? && a_cestry == b_cestry
-            yield a, b
-          else
-            a_cestry <=> b_cestry
-          end
+          rank = (a.ancestry || ' ') <=> (b.ancestry || ' ')
+          rank = yield(a, b) if rank == 0 && block_given?
+          rank
         end
 
         arranged = arrange_nodes(presorted_nodes)
       end
 
-      arranged.inject([]) do |sorted_nodes, pair|
-        node, children = pair
-        sorted_nodes << node
-        sorted_nodes += sort_by_ancestry(children, &block) unless children.blank?
-        sorted_nodes
-      end
+      flatten_arranged_nodes(arranged)
     end
 
     # Integrity checking

data/lib/ancestry/has_ancestry.rb

@@ -4,15 +4,25 @@ module Ancestry
       # Check options
       raise Ancestry::AncestryException.new(I18n.t("ancestry.option_must_be_hash")) unless options.is_a? Hash
       options.each do |key, value|
-        unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :touch, :counter_cache, :primary_key_format, :update_strategy, :strategy].include? key
+        unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :touch, :counter_cache, :primary_key_format, :update_strategy, :ancestry_format].include? key
           raise Ancestry::AncestryException.new(I18n.t("ancestry.unknown_option", key: key.inspect, value: value.inspect))
         end
       end
 
+      if options[:ancestry_format].present? && ![:materialized_path, :materialized_path2].include?( options[:ancestry_format] )
+        raise Ancestry::AncestryException.new(I18n.t("ancestry.unknown_format", value: options[:ancestry_format]))
+      end
+
       # Create ancestry column accessor and set to option or default
       cattr_accessor :ancestry_column
       self.ancestry_column = options[:ancestry_column] || :ancestry
 
+      cattr_accessor :ancestry_primary_key_format
+      self.ancestry_primary_key_format = options[:primary_key_format].presence || Ancestry.default_primary_key_format
+
+      cattr_accessor :ancestry_delimiter
+      self.ancestry_delimiter = '/'
+
       # Save self as base class (for STI)
       cattr_accessor :ancestry_base_class
       self.ancestry_base_class = self
@@ -27,14 +37,19 @@ module Ancestry
       # Include dynamic class methods
       extend Ancestry::ClassMethods
 
-      if options[:strategy] == :materialized_path2
-        validates_format_of self.ancestry_column, :with => derive_materialized2_pattern(options[:primary_key_format]), :allow_nil => false
+      cattr_accessor :ancestry_format
+      self.ancestry_format = options[:ancestry_format] || Ancestry.default_ancestry_format
+
+      if ancestry_format == :materialized_path2
         extend Ancestry::MaterializedPath2
       else
-        validates_format_of self.ancestry_column, :with => derive_materialized_pattern(options[:primary_key_format]), :allow_nil => true
         extend Ancestry::MaterializedPath
       end
 
+      attribute self.ancestry_column, default: self.ancestry_root
+
+      validates self.ancestry_column, ancestry_validation_options
+
       update_strategy = options[:update_strategy] || Ancestry.default_update_strategy
       include Ancestry::MaterializedPathPg if update_strategy == :sql
 
@@ -45,8 +60,8 @@ module Ancestry
       # Validate that the ancestor ids don't include own id
       validate :ancestry_exclude_self
 
-      # Update descendants with new ancestry before save
-      before_save :update_descendants_with_new_ancestry
+      # Update descendants with new ancestry after update
+      after_update :update_descendants_with_new_ancestry
 
       # Apply orphan strategy before destroy
       before_destroy :apply_orphan_strategy
@@ -68,12 +83,7 @@ module Ancestry
       # Create counter cache column accessor and set to option or default
       if options[:counter_cache]
         cattr_accessor :counter_cache_column
-
-        if options[:counter_cache] == true
-          self.counter_cache_column = :children_count
-        else
-          self.counter_cache_column = options[:counter_cache]
-        end
+        self.counter_cache_column = options[:counter_cache] == true ? 'children_count' : options[:counter_cache].to_s
 
         after_create :increase_parent_counter_cache, if: :has_parent?
         after_destroy :decrease_parent_counter_cache, if: :has_parent?
@@ -99,31 +109,10 @@ module Ancestry
       return super if defined?(super)
       has_ancestry(*args)
     end
-
-    private
-
-    def derive_materialized_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
-
-    def derive_materialized2_pattern(primary_key_format, delimiter = '/')
-      primary_key_format ||= '[0-9]+'
-
-      if primary_key_format.to_s.include?('\A')
-        primary_key_format
-      else
-        /\A#{delimiter}(#{primary_key_format}#{delimiter})*\Z/
-      end
-    end
   end
 end
 
+require 'active_support'
 ActiveSupport.on_load :active_record do
   extend Ancestry::HasAncestry
 end

data/lib/ancestry/instance_methods.rb

@@ -5,15 +5,15 @@ module Ancestry
       errors.add(:base, I18n.t("ancestry.exclude_self", class_name: self.class.name.humanize)) if ancestor_ids.include? self.id
     end
 
-    # Update descendants with new ancestry (before save)
+    # Update descendants with new ancestry (after update)
     def update_descendants_with_new_ancestry
       # If enabled and node is existing and ancestry was updated and the new ancestry is sane ...
       if !ancestry_callbacks_disabled? && !new_record? && ancestry_changed? && sane_ancestor_ids?
         # ... for each descendant ...
-        unscoped_descendants.each do |descendant|
+        unscoped_descendants_before_save.each do |descendant|
           # ... replace old ancestry with new ancestry
           descendant.without_ancestry_callbacks do
-            new_ancestor_ids = path_ids + (descendant.ancestor_ids - path_ids_in_database)
+            new_ancestor_ids = path_ids + (descendant.ancestor_ids - path_ids_before_last_save)
             descendant.update_attribute(:ancestor_ids, new_ancestor_ids)
           end
         end
@@ -62,7 +62,7 @@ module Ancestry
 
     # Counter Cache
     def increase_parent_counter_cache
-      self.ancestry_base_class.increment_counter _counter_cache_column, parent_id
+      self.ancestry_base_class.increment_counter counter_cache_column, parent_id
     end
 
     def decrease_parent_counter_cache
@@ -74,7 +74,7 @@ module Ancestry
       return if defined?(@_trigger_destroy_callback) && !@_trigger_destroy_callback
       return if ancestry_callbacks_disabled?
 
-      self.ancestry_base_class.decrement_counter _counter_cache_column, parent_id
+      self.ancestry_base_class.decrement_counter counter_cache_column, parent_id
     end
 
     def update_parent_counter_cache
@@ -83,14 +83,10 @@ module Ancestry
       return unless changed
 
       if parent_id_was = parent_id_before_last_save
-        self.ancestry_base_class.decrement_counter _counter_cache_column, parent_id_was
+        self.ancestry_base_class.decrement_counter counter_cache_column, parent_id_was
       end
 
-      parent_id && self.ancestry_base_class.increment_counter(_counter_cache_column, parent_id)
-    end
-
-    def _counter_cache_column
-      self.ancestry_base_class.counter_cache_column.to_s
+      parent_id && increase_parent_counter_cache
     end
 
     # Ancestors
@@ -133,8 +129,8 @@ module Ancestry
       ancestor_ids + [id]
     end
 
-    def path_ids_in_database
-      ancestor_ids_in_database + [id]
+    def path_ids_before_last_save
+      ancestor_ids_before_last_save + [id]
     end
 
     def path depth_options = {}
@@ -190,7 +186,7 @@ module Ancestry
 
     def root
       if has_parent?
-        unscoped_where { |scope| scope.find_by(id: root_id) } || self
+        unscoped_where { |scope| scope.find_by(scope.primary_key => root_id) } || self
       else
         self
       end
@@ -312,10 +308,16 @@ module Ancestry
       end
     end
 
+    def unscoped_descendants_before_save
+      unscoped_where do |scope|
+        scope.where self.ancestry_base_class.descendant_before_save_conditions(self)
+      end
+    end
+
     # works with after save context (hence before_last_save)
     def unscoped_current_and_previous_ancestors
       unscoped_where do |scope|
-        scope.where id: (ancestor_ids + ancestor_ids_before_last_save).uniq
+        scope.where scope.primary_key => (ancestor_ids + ancestor_ids_before_last_save).uniq
       end
     end
 

data/lib/ancestry/locales/en.yml

@@ -9,6 +9,7 @@ en:
 
     option_must_be_hash: "Options for has_ancestry must be in a hash."
     unknown_option: "Unknown option for has_ancestry: %{key} => %{value}."
+    unknown_format: "Unknown ancestry format: %{value}."
     named_scope_depth_cache: "Named scope '%{scope_name}' is only available when depth caching is enabled."
 
     exclude_self: "%{class_name} cannot be a descendant of itself."

data/lib/ancestry/materialized_path.rb

@@ -3,11 +3,6 @@ module Ancestry
   # root a=nil,id=1   children=id,id/%      == 1, 1/%
   # 3: a=1/2,id=3     children=a/id,a/id/%  == 1/2/3, 1/2/3/%
   module MaterializedPath
-    BEFORE_LAST_SAVE_SUFFIX = '_before_last_save'.freeze
-    IN_DATABASE_SUFFIX = '_in_database'.freeze
-    ANCESTRY_DELIMITER='/'.freeze
-    ROOT=nil
-
     def self.extended(base)
       base.send(:include, InstanceMethods)
     end
@@ -17,7 +12,7 @@ module Ancestry
     end
 
     def roots
-      where(arel_table[ancestry_column].eq(ROOT))
+      where(arel_table[ancestry_column].eq(ancestry_root))
     end
 
     def ancestors_of(object)
@@ -42,19 +37,26 @@ module Ancestry
     def indirects_of(object)
       t = arel_table
       node = to_node(object)
-      where(t[ancestry_column].matches("#{node.child_ancestry}#{ANCESTRY_DELIMITER}%", nil, true))
+      where(t[ancestry_column].matches("#{node.child_ancestry}#{ancestry_delimiter}%", nil, true))
     end
 
     def descendants_of(object)
-      node = to_node(object)
-      indirects_of(node).or(children_of(node))
+      where(descendant_conditions(object))
     end
 
-    # deprecated
-    def descendant_conditions(object)
+    def descendants_by_ancestry(ancestry)
       t = arel_table
+      t[ancestry_column].matches("#{ancestry}#{ancestry_delimiter}%", nil, true).or(t[ancestry_column].eq(ancestry))
+    end
+
+    def descendant_conditions(object)
       node = to_node(object)
-      t[ancestry_column].matches("#{node.child_ancestry}/%", nil, true).or(t[ancestry_column].eq(node.child_ancestry))
+      descendants_by_ancestry( node.child_ancestry )
+    end
+
+    def descendant_before_save_conditions(object)
+      node = to_node(object)
+      descendants_by_ancestry( node.child_ancestry_before_save )
     end
 
     def subtree_of(object)
@@ -86,16 +88,36 @@ module Ancestry
       ordered_by_ancestry(order)
     end
 
+    def ancestry_root
+      nil
+    end
+
+    private
+
+    def ancestry_validation_options
+      {
+        format: { with: ancestry_format_regexp },
+        allow_nil: ancestry_nil_allowed?
+      }
+    end
+
+    def ancestry_nil_allowed?
+      true
+    end
+
+    def ancestry_format_regexp
+      /\A#{ancestry_primary_key_format}(#{Regexp.escape(ancestry_delimiter)}#{ancestry_primary_key_format})*\z/.freeze
+    end
+
     module InstanceMethods
       # optimization - better to go directly to column and avoid parsing
       def ancestors?
-        read_attribute(self.ancestry_base_class.ancestry_column) != ROOT
+        read_attribute(self.ancestry_base_class.ancestry_column) != self.ancestry_base_class.ancestry_root
       end
       alias :has_parent? :ancestors?
 
       def ancestor_ids=(value)
-        col = self.ancestry_base_class.ancestry_column
-        value.present? ? write_attribute(col, generate_ancestry(value)) : write_attribute(col, ROOT)
+        write_attribute(self.ancestry_base_class.ancestry_column, generate_ancestry(value))
       end
 
       def ancestor_ids
@@ -103,18 +125,19 @@ module Ancestry
       end
 
       def ancestor_ids_in_database
-        parse_ancestry_column(send("#{self.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}"))
+        parse_ancestry_column(attribute_in_database(self.class.ancestry_column))
       end
 
       def ancestor_ids_before_last_save
-        parse_ancestry_column(send("#{self.ancestry_base_class.ancestry_column}#{BEFORE_LAST_SAVE_SUFFIX}"))
+        parse_ancestry_column(attribute_before_last_save(self.ancestry_base_class.ancestry_column))
       end
 
-      def parent_id_before_last_save
-        ancestry_was = send("#{self.ancestry_base_class.ancestry_column}#{BEFORE_LAST_SAVE_SUFFIX}")
-        return if ancestry_was == ROOT
+      def parent_id_in_database
+        parse_ancestry_column(attribute_in_database(self.class.ancestry_column)).last
+      end
 
-        parse_ancestry_column(ancestry_was).last
+      def parent_id_before_last_save
+        parse_ancestry_column(attribute_before_last_save(self.ancestry_base_class.ancestry_column)).last
       end
 
       # optimization - better to go directly to column and avoid parsing
@@ -128,18 +151,27 @@ module Ancestry
       def child_ancestry
         # New records cannot have children
         raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
-        path_was = self.send("#{self.ancestry_base_class.ancestry_column}#{IN_DATABASE_SUFFIX}")
-        path_was.blank? ? id.to_s : "#{path_was}#{ANCESTRY_DELIMITER}#{id}"
+        [attribute_in_database(self.ancestry_base_class.ancestry_column), id].compact.join(self.ancestry_base_class.ancestry_delimiter)
+      end
+
+      def child_ancestry_before_save
+        # New records cannot have children
+        raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
+        [attribute_before_last_save(self.ancestry_base_class.ancestry_column), id].compact.join(self.ancestry_base_class.ancestry_delimiter)
       end
 
       def parse_ancestry_column(obj)
-        return [] if obj == ROOT
-        obj_ids = obj.split(ANCESTRY_DELIMITER)
+        return [] if obj.nil? || obj == self.ancestry_base_class.ancestry_root
+        obj_ids = obj.split(self.ancestry_base_class.ancestry_delimiter).delete_if(&:blank?)
         self.class.primary_key_is_an_integer? ? obj_ids.map!(&:to_i) : obj_ids
       end
 
       def generate_ancestry(ancestor_ids)
-        ancestor_ids.join(ANCESTRY_DELIMITER)
+        if ancestor_ids.present? && ancestor_ids.any?
+          ancestor_ids.join(self.ancestry_base_class.ancestry_delimiter)
+        else
+          self.ancestry_base_class.ancestry_root
+        end
       end
     end
   end

data/lib/ancestry/materialized_path2.rb

@@ -1,53 +1,62 @@
 module Ancestry
   # store ancestry as /grandparent_id/parent_id/
-  # root: a=/,id=1    children=a.id/% == /1/%
-  # 3:    a=/1/2/,id=3 children=a.id/% == /1/2/3/%
-  module MaterializedPath2 < MaterializedPath
-    def indirects_of(object)
-      t = arel_table
-      node = to_node(object)
-      where(t[ancestry_column].matches("#{node.child_ancestry}%#{ANCESTRY_DELIMITER}%", nil, true))
-    end
+  # root: a=/,id=1    children=#{a}#{id}/% == /1/%
+  # 3:    a=/1/2/,id=3 children=#{a}#{id}/% == /1/2/3/%
+  module MaterializedPath2
+    include MaterializedPath
 
-    def subtree_of(object)
-      t = arel_table
-      node = to_node(object)
-      where(descendant_conditions(node).or(t[primary_key].eq(node.id)))
+    def self.extended(base)
+      base.send(:include, MaterializedPath::InstanceMethods)
+      base.send(:include, InstanceMethods)
     end
 
-    def siblings_of(object)
+    def indirects_of(object)
       t = arel_table
       node = to_node(object)
-      where(t[ancestry_column].eq(node[ancestry_column]))
+      where(t[ancestry_column].matches("#{node.child_ancestry}%#{ancestry_delimiter}%", nil, true))
     end
 
     def ordered_by_ancestry(order = nil)
       reorder(Arel::Nodes::Ascending.new(arel_table[ancestry_column]), order)
     end
 
-    # deprecated
-    def descendant_conditions(object)
-      t = arel_table
-      node = to_node(object)
-      t[ancestry_column].matches("#{node.child_ancestry}%", nil, true)
+    def descendants_by_ancestry(ancestry)
+      arel_table[ancestry_column].matches("#{ancestry}%", nil, true)
+    end
+
+    def ancestry_root
+      ancestry_delimiter
+    end
+
+    private
+
+    def ancestry_nil_allowed?
+      false
+    end
+
+    def ancestry_format_regexp
+      /\A#{Regexp.escape(ancestry_delimiter)}(#{ancestry_primary_key_format}#{Regexp.escape(ancestry_delimiter)})*\z/.freeze
     end
 
     module InstanceMethods
       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}#{id}#{ANCESTRY_DELIMITER}"
+        raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
+        "#{attribute_in_database(self.ancestry_base_class.ancestry_column)}#{id}#{self.ancestry_base_class.ancestry_delimiter}"
       end
 
-      def parse_ancestry_column(obj)
-        return [] if obj == ROOT
-        obj_ids = obj.split(ANCESTRY_DELIMITER).delete_if(&:blank?)
-        self.class.primary_key_is_an_integer? ? obj_ids.map!(&:to_i) : obj_ids
+      def child_ancestry_before_save
+        # New records cannot have children
+        raise Ancestry::AncestryException.new(I18n.t("ancestry.no_child_for_new_record")) if new_record?
+        "#{attribute_before_last_save(self.ancestry_base_class.ancestry_column)}#{id}#{self.ancestry_base_class.ancestry_delimiter}"
       end
 
       def generate_ancestry(ancestor_ids)
-        "#{ANCESTRY_DELIMITER}#{ancestor_ids.join(ANCESTRY_DELIMITER)}#{ANCESTRY_DELIMITER}"
+        if ancestor_ids.present? && ancestor_ids.any?
+          "#{self.ancestry_base_class.ancestry_delimiter}#{ancestor_ids.join(self.ancestry_base_class.ancestry_delimiter)}#{self.ancestry_base_class.ancestry_delimiter}"
+        else
+          self.ancestry_base_class.ancestry_root
+        end
       end
     end
   end

data/lib/ancestry/materialized_path_pg.rb

@@ -1,22 +1,22 @@
 module Ancestry
   module MaterializedPathPg
-    # Update descendants with new ancestry (before save)
+    # Update descendants with new ancestry (after update)
     def update_descendants_with_new_ancestry
       # If enabled and node is existing and ancestry was updated and the new ancestry is sane ...
       if !ancestry_callbacks_disabled? && !new_record? && ancestry_changed? && sane_ancestor_ids?
         ancestry_column = ancestry_base_class.ancestry_column
-        old_ancestry = path_ids_in_database.join(Ancestry::MaterializedPath::ANCESTRY_DELIMITER)
-        new_ancestry = path_ids.join(Ancestry::MaterializedPath::ANCESTRY_DELIMITER)
+        old_ancestry = generate_ancestry( path_ids_before_last_save )
+        new_ancestry = generate_ancestry( path_ids )
         update_clause = [
-          "#{ancestry_column} = regexp_replace(#{ancestry_column}, '^#{old_ancestry}', '#{new_ancestry}')"
+          "#{ancestry_column} = regexp_replace(#{ancestry_column}, '^#{Regexp.escape(old_ancestry)}', '#{new_ancestry}')"
         ]
 
         if ancestry_base_class.respond_to?(:depth_cache_column) && respond_to?(ancestry_base_class.depth_cache_column)
           depth_cache_column = ancestry_base_class.depth_cache_column.to_s
-          update_clause << "#{depth_cache_column} = length(regexp_replace(regexp_replace(ancestry, '^#{old_ancestry}', '#{new_ancestry}'), '\\d', '', 'g')) + 1"
+          update_clause << "#{depth_cache_column} = length(regexp_replace(regexp_replace(ancestry, '^#{Regexp.escape(old_ancestry)}', '#{new_ancestry}'), '[^#{ancestry_base_class.ancestry_delimiter}]', '', 'g')) #{ancestry_base_class.ancestry_format == :materialized_path2 ? '-' : '+'} 1"
         end
 
-        unscoped_descendants.update_all update_clause.join(', ')
+        unscoped_descendants_before_save.update_all update_clause.join(', ')
       end
     end
   end

data/lib/ancestry/version.rb

@@ -1,3 +1,3 @@
 module Ancestry
-  VERSION = '4.2.0'
+  VERSION = '4.3.1'
 end

data/lib/ancestry.rb

@@ -4,6 +4,7 @@ require_relative 'ancestry/instance_methods'
 require_relative 'ancestry/exceptions'
 require_relative 'ancestry/has_ancestry'
 require_relative 'ancestry/materialized_path'
+require_relative 'ancestry/materialized_path2'
 require_relative 'ancestry/materialized_path_pg'
 
 I18n.load_path += Dir[File.join(File.expand_path(File.dirname(__FILE__)),
@@ -11,6 +12,8 @@ I18n.load_path += Dir[File.join(File.expand_path(File.dirname(__FILE__)),
 
 module Ancestry
   @@default_update_strategy = :ruby
+  @@default_ancestry_format = :materialized_path
+  @@default_primary_key_format = '[0-9]+'
 
   # @!default_update_strategy
   #   @return [Symbol] the default strategy for updating ancestry
@@ -26,7 +29,6 @@ module Ancestry
   #
   #        Child records are updated in sql and callbacks will not get called.
   #        Associated records in memory will have the wrong ancestry value
-
   def self.default_update_strategy
     @@default_update_strategy
   end
@@ -34,4 +36,39 @@ module Ancestry
   def self.default_update_strategy=(value)
     @@default_update_strategy = value
   end
+
+  # @!default_ancestry_format
+  #   @return [Symbol] the default strategy for updating ancestry
+  #
+  # The value changes the default way that ancestry is stored in the database
+  #
+  #    :materialized_path (default and legacy)
+  #
+  #        Ancestry is of the form null (for no ancestors) and 1/2/ for children
+  #
+  #    :materialized_path2 (preferred)
+  #
+  #        Ancestry is of the form '/' (for no ancestors) and '/1/2/' for children
+  def self.default_ancestry_format
+    @@default_ancestry_format
+  end
+
+  def self.default_ancestry_format=(value)
+    @@default_ancestry_format = value
+  end
+
+  # @!default_primary_key_format
+  #   @return [Symbol] the regular expression representing the primary key
+  #
+  # The value represents the way the id looks for validation
+  #
+  #    '[0-9]+' (default) for integer ids
+  #    '[-A-Fa-f0-9]{36}'    for uuids (though you can find other regular expressions)
+  def self.default_primary_key_format
+    @@default_primary_key_format
+  end
+
+  def self.default_primary_key_format=(value)
+    @@default_primary_key_format = value
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ancestry
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.3.1
 platform: ruby
 authors:
 - Stefan Kroes
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-10 00:00:00.000000000 Z
+date: 2023-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -145,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: Organize ActiveRecord model into a tree structure