Ancestry

https://github.com/stefankroes/ancestry
Admin
Ancestry is a Ruby gem that allows ActiveRecord models to be organized into a tree hierarchy using...
Tokens:39,962
Snippets:378
Trust Score:6.5
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Gem and Generate Migration

Source: https://github.com/stefankroes/ancestry/blob/master/README.md

Run bundle install and generate the migration for the ancestry column.

```bash
$ bundle install
$ rails g migration add_ancestry_to_[table]
```

--------------------------------

### Manual Column Setup for Ltree (PostgreSQL)

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Manual migration setup for PostgreSQL using the ltree extension.

```ruby
enable_extension 'ltree'
t.column "ancestry", :ltree, null: false, default: ''
t.index "ancestry", using: :gist
```

--------------------------------

### Manual Column Setup for MySQL

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Manual migration setup for MySQL using utf8mb4_bin collation.

```ruby
t.string "ancestry", collation: 'utf8mb4_bin', null: false
t.index "ancestry"
```

--------------------------------

### Manual Column Setup for PostgreSQL

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Manual migration setup for PostgreSQL using C collation to ensure index usage.

```ruby
# C collation ensures LIKE uses the btree index
t.string "ancestry", collation: 'C', null: false
t.index "ancestry"
```

--------------------------------

### Manual Column Setup for SQLite

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Manual migration setup for SQLite, which uses binary comparison by default.

```ruby
# SQLite uses binary comparison by default — no collation needed
t.string "ancestry", null: false
t.index "ancestry"
```

--------------------------------

### Scope-delegating navigation examples

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/instance_methods.md

Examples of chaining scope-delegating methods with depth options to filter tree traversal results.

```ruby
node.ancestors(:from_depth => -6, :to_depth => -4)
node.path.from_depth(3).to_depth(4)
node.descendants(:from_depth => 2, :to_depth => 4).order(:name)
node.subtree.from_depth(10).to_depth(12)
```

--------------------------------

### Create table with ancestry configuration

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/migration.md

Example of configuring ancestry options during table creation.

```ruby
create_table :tree_nodes do |t|
  t.ancestry format: :materialized_path3, cache_depth: :virtual, parent: :virtual, counter_cache: true
end
```

--------------------------------

### Tree navigation usage examples

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

Examples of using tree navigation scopes with records or IDs, and creating records through a scope.

```ruby
TreeNode.descendants_of(node)       # record
TreeNode.descendants_of(node.id)    # id — equivalent
TreeNode.children_of(root).create!(name: 'Squeeky')  # creating through a scope
```

--------------------------------

### arrange(options = {}) usage

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

Example of using arrange on a subtree with an ordering option.

```ruby
TreeNode.find_by(name: 'Crunchy').subtree.arrange(order: :name)
# => { #<TreeNode id: 100019, ...> => { #<TreeNode id: 100020, ...> => {} } }
```

--------------------------------

### build_ancestry_from_parent_ids! usage

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

Example of calling the migration method to populate the ancestry column.

```ruby
Model.build_ancestry_from_parent_ids!
```

--------------------------------

### Usage examples for parent and root methods

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/instance_methods.md

Common operations for reparenting nodes and retrieving the root of a tree.

```ruby
node.parent = other_node        # reparent
node.parent_id = 42
node.parent_id = nil            # make root
root = node.root
```

--------------------------------

### Depth-based scope examples

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

Examples of class-level depth filtering, which require cache_depth or ancestry_depth_sql to be available.

```ruby
Model.before_depth(3)    # depth < 3
Model.to_depth(3)        # depth <= 3
Model.at_depth(2)        # depth == 2
Model.from_depth(2)      # depth >= 2
Model.after_depth(2)     # depth > 2
```

--------------------------------

### sort_by_ancestry usage examples

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

Examples of sorting nodes, including an optional tie-breaker block for sibling ordering.

```ruby
sorted = TreeNode.sort_by_ancestry(TreeNode.limit(100).to_a)
sorted = TreeNode.sort_by_ancestry(nodes) { |a, b| a.name <=> b.name }
```

--------------------------------

### Usage in Rails view

Source: https://github.com/stefankroes/ancestry/wiki/Nested-HTML-from-the-arrange-method

Examples of how to call the helper in a view, including basic usage, bootstrap styling, and sorting.

```ruby
# Normally this variable would be set from the controller, but for examples sake
# Lets pretend we have a Category model that has_ancestry
@categories = Category.where({:active => true}).arrange

# simple ul > li structure
<%= arranged_tree_as_list(@categories) do |category| %>
    # stuff that goes inside the <li></li> tags
    <%= link_to category.name, category_path(category) %>
<% end %>
     
# use bootstrap styling, as setup in the helper
<%= arranged_tree_as_list(@categories, {:list_style => :bootstrap_list_group}) do |category| %>
    # stuff that goes inside the <li></li> tags
    <%= link_to category.name, category_path(category) %>
<% end %>

# sort by category name and then id
<%= arranged_tree_as_list(@categories, {:sort_by => [:name, :id]}) do |category| %>
    # stuff that goes inside the <li></li> tags
    <%= link_to category.name, category_path(category) %>
<% end %>
```

--------------------------------

### Set Default Update Strategy

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/ancestry.md

Example of setting the global default update strategy to :sql.

```ruby
Ancestry.default_update_strategy = :sql
```

--------------------------------

### Create table with ltree format

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/migration.md

Example of using the ltree format, which requires the ltree extension in PostgreSQL.

```ruby
enable_extension 'ltree'
create_table :tree_nodes do |t|
  t.ancestry format: :ltree
end
```

--------------------------------

### arrange_serializable usage

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

Examples of using arrange_serializable with default and custom block serialization.

```ruby
TreeNode.arrange_serializable(order: :name)
TreeNode.arrange_serializable { |parent, children| { my_id: parent.id, my_children: children } }
```

--------------------------------

### Run Ancestry test suite

Source: https://github.com/stefankroes/ancestry/blob/master/README.md

Commands to clone the repository, configure the database, install dependencies, and execute tests using appraisal.

```bash
git clone git@github.com:stefankroes/ancestry.git
cd ancestry
cp test/database.example.yml test/database.yml
bundle
appraisal install
# all tests
appraisal rake test
# single test version (sqlite and rails 5.0)
appraisal sqlite3-ar-50 rake test
```

--------------------------------

### Calling arrange on a subtree

Source: https://github.com/stefankroes/ancestry/blob/master/README.md

Examples of calling the arrange method on a subtree, including an optional order parameter.

```ruby
TreeNode.find_by(:name => 'Crunchy').subtree.arrange
TreeNode.find_by(:name => 'Crunchy').subtree.arrange(:order => :name)
```

--------------------------------

### tree_view usage

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

Examples of using tree_view to print tree structures.

```ruby
TreeNode.tree_view(:name)          # prints, e.g. "Root\n |_ Child\n"
TreeNode.tree_view(:name) { |line| log(line) }
```

--------------------------------

### resolve_primary_key_format usage examples

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/has_ancestry.md

Demonstrates how to call resolve_primary_key_format on a model to retrieve regex patterns and integer-only flags.

```ruby
TreeNode.resolve_primary_key_format(:uuid)
# => ['[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}', false]
TreeNode.resolve_primary_key_format(:integer)
# => ['[0-9]+', true]
TreeNode.resolve_primary_key_format('[a-z0-9]{8}')
# => ['[a-z0-9]{8}', false]  # matches a letter → not integer-only
```

--------------------------------

### Set Default Primary Key Format

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/ancestry.md

Example of setting the global primary key format to :uuid.

```ruby
Ancestry.default_primary_key_format = :uuid
```

--------------------------------

### Eager Loading and Joining with Parent Cache

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Examples of using eager loading and joins enabled by the parent cache configuration.

```ruby
class TreeNode < ActiveRecord::Base
  has_ancestry parent: true
end

# Eager load parents to avoid N+1
TreeNode.where(depth: 2).includes(:parent)

# Eager load children
roots = TreeNode.roots.includes(:children)
roots.each { |r| r.children } # no extra queries

# Join queries
TreeNode.joins(:parent).where(parents_tree_nodes: { name: "Root" })
```

--------------------------------

### arrange_nodes(nodes, orphan_strategy: :destroy) usage

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

Example of using arrange_nodes with the :destroy orphan strategy.

```ruby
nodes = TreeNode.limit(10).to_a
hash = TreeNode.arrange_nodes(nodes, orphan_strategy: :destroy)
```

--------------------------------

### Rebuild Cache Methods

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

Examples of invoking the counter cache rebuild with verbose output and the SQL-based depth cache rebuild.

```ruby
Model.rebuild_counter_cache!(verbose: true)   # => Integer (rows fixed) or nil
Model.rebuild_depth_cache_sql!
```

--------------------------------

### Ruby implementation for chronological pagination

Source: https://github.com/stefankroes/ancestry/wiki/Pagination

Example of applying the chronological scope to a Rails model to facilitate pagination.

```ruby
@posts  = @topic.posts.chronological.paginate :page => params[:page]

class Post
  scope :chronological, -> { order("coalesce(ancestry,'0')||'/'|| id") }
end
```

--------------------------------

### Define Model Options with has_ancestry

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/configuration.md

Example of configuring a model with various options passed to the has_ancestry method.

```ruby
class TreeNode < ActiveRecord::Base
  has_ancestry
    ancestry_column: :ancestry,
    ancestry_format: :materialized_path3,   # or format: ...
    orphan_strategy: :adopt,
    cache_depth: :virtual,
    parent: :virtual,
    root: :virtual,
    counter_cache: true,
    touch: true,
    update_strategy: :sql,
    primary_key_format: :uuid,
    associations: true
end
```

--------------------------------

### Set Default Ancestry Format

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/ancestry.md

Example of configuring the ancestry format in a Rails initializer.

```ruby
# config/initializers/ancestry.rb
Ancestry.default_ancestry_format = :materialized_path3
```

--------------------------------

### Migrate Ancestry Collation

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Example migration to update the collation of an existing ancestry column.

```ruby
class FixAncestryCollation < ActiveRecord::Migration[7.0]
  def change
    remove_index :table, :ancestry
    change_column :table, :ancestry, :string, collation: 'C', null: false
    add_index :table, :ancestry
  end
end
```

--------------------------------

### Manual ancestry column setup by database adapter

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/migration.md

Defines the ancestry column and index for PostgreSQL, MySQL, and SQLite. Ensure the correct collation is used for each adapter as specified.

```ruby
# strategy: varies by adapter. PostgreSQL:
t.string "ancestry", collation: 'C', null: false
t.index "ancestry"

# MySQL:
t.string "ancestry", collation: 'utf8mb4_bin', null: false
t.index "ancestry"

# SQLite:
t.string "ancestry", null: false
t.index "ancestry"
```

--------------------------------

### Usage of acts_as_tree

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/has_ancestry.md

Example of using the acts_as_tree alias in an ActiveRecord model.

```ruby
class Page < ActiveRecord::Base
  acts_as_tree               # equivalent to has_ancestry
end
```

--------------------------------

### Controller setup for Suckerfish dropdown

Source: https://github.com/stefankroes/ancestry/wiki/Suckerfish

Defines the set_categories action and the suckerfish helper method to recursively generate nested HTML lists based on ancestry nodes.

```ruby
class AnyController < ActionController::Base
  before_action :set_categories
  helper_method :suckerfish

  def set_categories
    @categories = Category.where(ancestry: nil)
  end

  def suckerfish(node)
    fuc = lambda do |nodes|
      return "" if nodes.empty?
      return "<ul>" +
        nodes.inject("") do |string, (node, children)|
          string + "<li rel='#{node.id}'>" +
          "<a href=#{polymorphic_url(node)}>#{node.name}</a>" +
          fuc.call(children) +
          "</li>"
        end +
        "</ul>"
    end
    fuc.call(node.descendants.arrange)
  end
end
```

--------------------------------

### Configure ltree format in migration

Source: https://github.com/stefankroes/ancestry/blob/master/README.md

Example of enabling the ltree extension and defining an ancestry column with the :ltree format in a Rails migration.

```ruby
# ltree — GiST-indexed <@ operator
enable_extension 'ltree'
create_table :tree_nodes do |t|
  t.ancestry format: :ltree
end
```

--------------------------------

### ancestry_virtual migration usage

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/migration.md

Example of using ancestry_virtual within a change_table block to add virtual cache columns.

```ruby
change_table :nodes do |t|
  t.ancestry_virtual format: :materialized_path2, cache_depth: true, parent: true
end
```

--------------------------------

### Configure orphan_strategy :restrict

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/instance_methods.md

Example of configuring a model with the :restrict orphan strategy, which prevents deletion if the node has descendants.

```ruby
class TreeNode < ActiveRecord::Base
  has_ancestry orphan_strategy: :restrict
end

node.children.create!(name: 'Child')
node.destroy
# raises Ancestry::AncestryException: "Cannot delete record because it has descendants."
```

--------------------------------

### Suppress ancestry callbacks with without_ancestry_callbacks

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/instance_methods.md

Example of using without_ancestry_callbacks to suppress descendant rewrites during a bulk migration.

```ruby
# Suppress descendants rewrite during a bulk migration
node.without_ancestry_callbacks do
  node.update_attribute :ancestor_ids, new_ids
end
```

--------------------------------

### Catch Ancestry Exceptions

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/errors.md

Example of rescuing Ancestry exceptions in consumer code, which covers both base and integrity exceptions.

```ruby
begin
  node.destroy
rescue Ancestry::AncestryException => e
  # covers both classes — AncestryIntegrityException < AncestryException
  Rails.logger.error e.message
end
```

--------------------------------

### Add ancestry to an existing table

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/migration.md

Example of using change_table to add ancestry to an existing table in an ActiveRecord migration.

```ruby
class AddAncestryToTable < ActiveRecord::Migration[7.0]
  def change
    change_table(:table) do |t|
      t.ancestry
    end
  end
end
```

--------------------------------

### Run database migration

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Execute the migration to apply the changes to the database schema.

```bash
$ rake db:migrate
```

--------------------------------

### Configuration options for arranged_tree_as_list

Source: https://github.com/stefankroes/ancestry/wiki/Nested-HTML-from-the-arrange-method

List of available configuration keys for customizing the HTML list structure and styling.

```ruby
#### Configuration options
:list_type # the type of list to render (ul or ol)
:list_style # this is used for setting up some pre-formatted styles. Can be removed if not needed. 
:ul_class # applies given class(es) to all parent list groups (ul or ol)
:ul_class_top # applies given class(es) to parent list groups (ul or ol) of depth = 0
:ul_class_children # applies given class(es) to parent list group (ul or ol) of depth > 0
:li_class # applies given class(es) to all list items (li)
:li_class_top # applies given class(es) to list items (li) of depth = 0
:li_class_children # applies given class(es) to list items (li) of depth > 0
:sort_by # sort the hash by attributes of your ancestry object e.g. [:name] or [:order, :name]
```

--------------------------------

### Navigation instance methods

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/instance_methods.md

Methods for retrieving node hierarchy information such as parent, root, depth, and path IDs.

```ruby
def parent_id
  ancestor_ids.last if has_parent?
end
alias parent_id? ancestors?

def root_id
  has_parent? ? ancestor_ids.first : id
end

def depth
  ancestor_ids.size
end

def is_root?
  !has_parent?
end
alias root? is_root?

def path_ids
  ancestor_ids + [id]
end

def path_ids_before_last_save
  ancestor_ids_before_last_save + [id]
end

def path_ids_in_database
  ancestor_ids_in_database + [id]
end
```

--------------------------------

### Adapter Predicate Methods

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/adapter.md

Methods to check if the current or provided adapter matches PostgreSQL, MySQL, or SQLite.

```ruby
def pg?(adapter = current)
  PG.include?(adapter.to_s.downcase)
end

def mysql?(adapter = current)
  MYSQL.include?(adapter.to_s.downcase)
end

def sqlite?(adapter = current)
  SQLITE.include?(adapter.to_s.downcase)
end
```

--------------------------------

### arrange(options = {}) implementation

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

The implementation of the arrange method which organizes the entire tree into nested hashes.

```ruby
def arrange(options = {})
  if (order = options.delete(:order))
    arrange_nodes(ancestry_base_class.order(order).where(options))
  else
    arrange_nodes(ancestry_base_class.where(options))
  end
end
```

--------------------------------

### Ancestry::InstanceMethods public methods

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/instance_methods.md

List of public methods available in the Ancestry::InstanceMethods module.

```ruby
def validate_depth_of_descendants(depth_cache_column, depth_change)
def ancestry_sync_parent_cache(parent_cache_column, value, association_name = :parent)
def ancestry_sync_root_cache(root_cache_column, value, association_name = :root)
def ancestry_lookup_parent(association_name = :parent)
def ancestry_lookup_root(association_name = :root)
def add_root_cache_to_update_clause(update_clause, root_cache_column)
def add_depth_cache_to_update_clause(update_clause, depth_cache_column, depth_change)
def without_ancestry_callbacks
def ancestry_callbacks_disabled?
```

--------------------------------

### Option 3: Helper method

Source: https://github.com/stefankroes/ancestry/wiki/Creating-a-selectbox-for-a-form-using-ancestry

Uses a recursive helper method to generate options efficiently with a single SQL query.

```ruby
    <%= f.select :parent_id, @categories %>
```

```ruby
    @categories = ancestry_options(Category.scoped.arrange(:order => 'name')) {|i| "#{'-' * i.depth} #{i.name}" }

    def ancestry_options(items, &block)
      return ancestry_options(items){ |i| "#{'-' * i.depth} #{i.name}" } unless block_given?

      result = []
      items.map do |item, sub_items|
        result << [yield(item), item.id]
        #this is a recursive call:
        result += ancestry_options(sub_items, &block)
      end
      result
    end
```

--------------------------------

### Create children and siblings through relations

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/instance_methods.md

Demonstrates creating related nodes using children and siblings scopes.

```ruby
# created through relations
node.children.create(name: 'Stinky')
node.children.create!(name: 'Squishy')
node.siblings.create!(name: 'Squeeky')
```

--------------------------------

### Depth constraints validation

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/configuration.md

Example of using standard Rails validations to constrain tree depth when cache_depth is enabled.

```ruby
has_ancestry cache_depth: true
validates :ancestry_depth, numericality: { less_than_or_equal_to: 5 }
```

--------------------------------

### arrange_serializable(options = {}, nodes = nil, &block) implementation

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

The implementation of the arrange_serializable method for creating serializable nested structures.

```ruby
def arrange_serializable(options = {}, nodes = nil, &block)
  nodes = arrange(options) if nodes.nil?
  nodes.map do |parent, children|
    if block_given?
      yield parent, arrange_serializable(options, children, &block)
    else
      parent.serializable_hash.merge 'children' => arrange_serializable(options, children)
    end
  end
end
```

--------------------------------

### arrange(options = {})

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

Arranges the entire tree or a scoped subset into a nested hash structure.

```APIDOC
## arrange(options = {})

### Description
Arranges the entire tree into nested hashes. This method can also be called on a scoped class (e.g., `node.subtree.arrange`).

### Parameters
- **options** (Hash) - Optional - ActiveRecord find options; `:order` is extracted and applied to the query.

### Return
- **Hash** - A nested hash keyed by records, where values are hashes of children.
```

--------------------------------

### Migrate from :materialized_path to :materialized_path2

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Wraps existing paths with delimiters, converts root nodes from nil to '/', and sets the column to NOT NULL.

```ruby
klass = YourModel
# Wrap existing paths with delimiters: "1/2/3" → "/1/2/3/"
klass.where.not(ancestry: nil).update_all("ancestry = CONCAT('/', ancestry, '/')")
# Convert root nodes: nil → "/"
klass.where(ancestry: nil).update_all("ancestry = '/'")
change_column_null klass.table_name, :ancestry, false
```

--------------------------------

### Migrate from :materialized_path2 to :materialized_path3

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Strips the leading delimiter from existing paths and converts root nodes from '/' to empty strings.

```ruby
klass = YourModel
# Strip leading delimiter: "/1/2/3/" → "1/2/3/"
klass.where.not(ancestry: '/').update_all("ancestry = SUBSTRING(ancestry, 2)")
# Convert root nodes: "/" → ""
klass.where(ancestry: '/').update_all("ancestry = ''")
```

--------------------------------

### Option 4: Using arrange_as_array

Source: https://github.com/stefankroes/ancestry/wiki/Creating-a-selectbox-for-a-form-using-ancestry

Uses the arrange_as_array method to build a nested list and filter out invalid parents.

```ruby
  <%= f.collection_select :parent_id, @categories, :id, :name_for_selects, :include_blank => true %>
```

```ruby
class Category < ActiveRecord::Base
  has_ancestry

  def self.arrange_as_array(options={}, hash=nil)                                                                                                                                                            
    hash ||= arrange(options)

    arr = []
    hash.each do |node, children|
      arr << node
      arr += arrange_as_array(options, children) unless children.nil?
    end
    arr
  end

  def name_for_selects
    "#{'-' * depth} #{name}"
  end

  def possible_parents
    parents = Category.arrange_as_array(:order => 'name')
    return new_record? ? parents : parents - subtree
  end
end
```

```ruby
@categories = Category.arrange_as_array({:order => 'name'}, @category.possible_parents)
```

--------------------------------

### Option 2: Complicated ruby

Source: https://github.com/stefankroes/ancestry/wiki/Creating-a-selectbox-for-a-form-using-ancestry

A manual approach to sorting and formatting ancestry data for a selectbox.

```ruby
    <%= f.select :parent_id, @categories %>
```

```ruby
    @categories = Category.all.each { |c| c.ancestry = c.ancestry.to_s + (c.ancestry != nil ? "/" : '') + c.id.to_s 
      }.sort {|x,y| x.ancestry <=> y.ancestry 
      }.map{ |c| ["-" * (c.depth - 1) + c.name,c.id] 
      }.unshift(["-- none --", nil])
```

--------------------------------

### Advanced configuration options for has_ancestry

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/has_ancestry.md

Shows how to configure various ancestry options such as orphan strategies, caching, and primary key formats.

```ruby
class TreeNode < ActiveRecord::Base
  has_ancestry
    ancestry_format: :materialized_path3,
    orphan_strategy: :adopt,
    cache_depth: true,
    parent: true,
    root: true,
    counter_cache: 'children_count',
    touch: true,
    update_strategy: :sql,
    primary_key_format: :uuid
end
```

--------------------------------

### build_ancestry_from_parent_ids! implementation

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

The recursive implementation for building ancestry columns from a parent_id column.

```ruby
def build_ancestry_from_parent_ids!(column = :parent_id, parent_id = nil, ancestor_ids = [])
  unscoped_where do |scope|
    scope.where(column => parent_id).find_each do |node|
      node.without_ancestry_callbacks do
        node.update_attribute :ancestor_ids, ancestor_ids
      end
      build_ancestry_from_parent_ids! column, node.id, ancestor_ids + [node.id]
    end
  end
end
```

--------------------------------

### View implementation for Suckerfish dropdown

Source: https://github.com/stefankroes/ancestry/wiki/Suckerfish

Renders the top-level categories and calls the suckerfish helper to generate the nested dropdown markup.

```ruby
<ul id="nav-categories">
  <% @categories.each do |node| %>
    <li>
      <%= link_to node.name, node %>
      <%= suckerfish(node).html_safe %>
    </li>
  <% end %>
</ul>
```

--------------------------------

### Check ancestry integrity with report options

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/errors.md

Shows how to invoke check_ancestry_integrity! with different reporting strategies to handle integrity exceptions.

```ruby
TreeNode.check_ancestry_integrity!                  # raises AncestryIntegrityException
TreeNode.check_ancestry_integrity!(report: :list)   # => [AncestryIntegrityException, ...]
TreeNode.check_ancestry_integrity!(report: :echo)   # puts each message
```

--------------------------------

### Create Nodes via Scopes

Source: https://github.com/stefankroes/ancestry/blob/master/README.md

Nodes can be created or initialized directly through children and siblings scopes.

```ruby
node.children.create
node.siblings.create!
TestNode.children_of(node_id).new
TestNode.siblings_of(node_id).create
```

--------------------------------

### Handle Unknown Option Exception

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/errors.md

Demonstrates how an AncestryException is raised when an invalid option is passed to has_ancestry at class-definition time.

```ruby
# Raises at class-definition time, before any record is created
class TreeNode < ActiveRecord::Base
  has_ancestry misspelled_option: true
end
# => Ancestry::AncestryException: "Unknown option for has_ancestry:
#    :misspelled_option => true."

begin
  Class.new(ActiveRecord::Base) { has_ancestry(unknown: true) }
rescue Ancestry::AncestryException => e
  e.message                                  # the I18n message above
end
```

--------------------------------

### Depth scopes list

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/configuration.md

List of available depth scopes that can be used on any model regardless of cache_depth settings.

```text
roots, before_depth(d), to_depth(d), at_depth(d), from_depth(d), after_depth(d)
```

--------------------------------

### Option 1: Adding a cache

Source: https://github.com/stefankroes/ancestry/wiki/Creating-a-selectbox-for-a-form-using-ancestry

Implements a cache field to store the path of names for efficient sorting and display in a selectbox.

```ruby
    before_save :cache_ancestry
    def cache_ancestry
      self.names_depth_cache = path.map(&:name).join('/')
    end
```

```ruby
    @categories = Category.order(:names_depth_cache).map { |c| ["-" * c.depth + c.name,c.id] }
```

```ruby
    <%= f.select :parent_id, @categories %>
```

--------------------------------

### Define Ancestry Migration

Source: https://github.com/stefankroes/ancestry/blob/master/README.md

Use the t.ancestry helper in your migration file to set up the database column.

```ruby
class AddAncestryToTable < ActiveRecord::Migration[7.0]
  def change
    change_table(:table) do |t|
      t.ancestry
      # t.ancestry format: :materialized_path3, cache_depth: true, parent: true, counter_cache: true
    end
  end
end
```

--------------------------------

### tree_view(column, data = nil, &block) implementation

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

The implementation of the tree_view method for printing a visual representation of the tree.

```ruby
def tree_view(column, data = nil, &block)
  block ||= method(:puts)
  data ||= arrange
  data.each do |parent, children|
    if parent.depth == 0
      block.call parent[column]
    else
      num = parent.depth - 1
      indent = "   " * num
      block.call " #{"|" if parent.depth > 1}#{indent}|_ #{parent[column]}"
    end
    tree_view(column, children, &block) if children
  end
end
```

--------------------------------

### Database Adapter Constants

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/adapter.md

Constants defining the adapter names recognized for PostgreSQL, MySQL, and SQLite.

```ruby
PG     = %w(pg postgresql postgis).freeze
MYSQL  = %w(mysql mysql2 trilogy).freeze
SQLITE = %w(sqlite sqlite3).freeze
```

--------------------------------

### arrange_nodes(nodes, orphan_strategy: :rootify) implementation

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

The implementation of the arrange_nodes method, which handles tree arrangement with specific orphan strategies.

```ruby
def arrange_nodes(nodes, orphan_strategy: :rootify)
  node_ids = Set.new(nodes.map(&:id))
  index = Hash.new { |h, k| h[k] = {} }

  if orphan_strategy == :rootify
    nodes.each_with_object({}) do |node, arranged|
      index[node.parent_id][node] = children = index[node.id]
      arranged[node] = children unless node_ids.include?(node.parent_id)
    end
  else
    nodes.each_with_object({}) do |node, arranged|
      index[node.parent_id][node] = children = index[node.id]
      if node.parent_id.nil?
        arranged[node] = children
      elsif !node_ids.include?(node.parent_id)
        case orphan_strategy
        when :destroy
          # silently drop orphaned nodes and their children
        when :restrict
          raise Ancestry::AncestryException, I18n.t("ancestry.cannot_delete_descendants")
        end
      end
    end
  end
end
```

--------------------------------

### Implement parent setter and getter with association

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/instance_methods.md

Setter and getter methods for parent association, utilizing ancestor_ids for path management.

```ruby
def parent=(parent)
  self.ancestor_ids = parent ? parent.path_ids : []
  association(:parent).target = parent
end

def parent_id=(new_parent_id)
  self.parent = new_parent_id.present? ? unscoped_find(new_parent_id) : nil
end

def parent
  ancestry_lookup_parent if has_parent?
end
```

--------------------------------

### Configure Global Ancestry Defaults

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/configuration.md

Set global configuration options in an initializer, such as config/initializers/ancestry.rb, to override default gem behavior.

```ruby
# config/initializers/ancestry.rb
Ancestry.default_ancestry_format = :materialized_path3
Ancestry.default_update_strategy = :sql
Ancestry.default_primary_key_format = :uuid
```

--------------------------------

### resolve_primary_key_format implementation

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/has_ancestry.md

Defines the primary key formats and the logic to resolve them from symbols or custom regex strings.

```ruby
PRIMARY_KEY_FORMATS = {
  integer: ['[0-9]+', true],
  uuid:    ['[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}', false],
  string:  ['[a-zA-Z0-9_-]+', false],
}.freeze

def resolve_primary_key_format(value)
  return PRIMARY_KEY_FORMATS[value] if PRIMARY_KEY_FORMATS.key?(value)

  # Infer from custom regex: if it can match a letter, it's not integer-only
  [value, !Regexp.new(value).match?("a")]
end
```

--------------------------------

### Set global default_primary_key_format in Initializer

Source: https://github.com/stefankroes/ancestry/wiki/Usage-with-UUID's

Configure the default primary key format globally in an initializer to avoid repeating the option in every model.

```ruby
# config/initializer/ancestry.rb
Ancestry.default_primary_key_format = '[\w-]{36}

# app/models/model.rb
class Model < ActiveRecord::Base
  has_ancestry
end
```

--------------------------------

### Ancestry::InstanceMethodsBuilder.build method signature

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/instance_methods.md

The build method generates a memoized module containing the instance API for an ancestry model. It accepts various configuration parameters to customize the behavior of the generated methods.

```ruby
def self.build(format_module, column, root, primary_key: :id, integer_pk: nil, depth_cache_column: nil, counter_cache_column: nil, parent_cache_column: nil, root_cache_column: nil, parent_association: false, root_association: false)
```

--------------------------------

### tree_view(column, data = nil, &block)

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

Prints a visual representation of the tree structure to the console or a provided block.

```APIDOC
## tree_view(column, data = nil, &block)

### Description
Recursively prints the tree structure based on a specific column attribute. Defaults to printing to standard output.

### Parameters
- **column** (Symbol) - Required - The attribute of the node to print.
- **data** (Hash) - Optional - Pre-arranged hash; defaults to `arrange`.
- **&block** (Proc) - Optional - A callable to handle the output; defaults to `Kernel#puts`.
```

--------------------------------

### build_ancestry_from_parent_ids!(column = :parent_id, parent_id = nil, ancestor_ids = [])

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

A migration utility that populates the ancestry column based on an existing parent_id column using a depth-first approach.

```APIDOC
## build_ancestry_from_parent_ids!(column = :parent_id, parent_id = nil, ancestor_ids = [])

### Description
Fills the ancestry column from an old parent_id column. This is typically used as a migration aid.

### Parameters
- **column** (Symbol) - Optional - The pre-existing parent id column (default :parent_id).
- **parent_id** (Integer) - Optional - Internal recursion state.
- **ancestor_ids** (Array) - Optional - Internal recursion state.

### Example
```ruby
Model.build_ancestry_from_parent_ids!
```
```

--------------------------------

### arrange_serializable(options = {}, nodes = nil, &block)

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/class_methods.md

Arranges the tree into a serializable nested array structure.

```APIDOC
## arrange_serializable(options = {}, nodes = nil, &block)

### Description
Returns a nested array structure suitable for serialization. Each element is either a hash containing the node's attributes and a 'children' key, or the result of the provided block.

### Parameters
- **options** (Hash) - Optional - Passed to `arrange`.
- **nodes** (Hash) - Optional - Pre-arranged hash.
- **&block** (Proc) - Optional - A block to customize the serialization of each node.

### Return
- **Array** - A nested array structure.
```

--------------------------------

### Handling invalid has_ancestry options

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/has_ancestry.md

Demonstrates that invalid options raise an Ancestry::AncestryException and shows how to handle them programmatically.

```ruby
# Invalid options raise Ancestry::AncestryException at class-definition time
class TreeNode < ActiveRecord::Base
  has_ancestry typo: true
end
# => Ancestry::AncestryException: "Unknown option for has_ancestry: :typo => true."

# To handle it programmatically, wrap the class body:
klass = begin
  Class.new(ActiveRecord::Base) { has_ancestry typo: true }
rescue Ancestry::AncestryException => e
  Rails.logger.error(e.message)
  Class.new(ActiveRecord::Base) { has_ancestry }  # fall back to defaults
end
```

--------------------------------

### Configure Update Strategy

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Defines how descendant records are updated during reparenting. The :sql strategy is recommended for large trees to improve performance.

```ruby
has_ancestry update_strategy: :ruby    # default — loads each descendant, fires callbacks
has_ancestry update_strategy: :sql     # single SQL statement, no callbacks on descendants
```

--------------------------------

### Define root and delimiter for MaterializedPath

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/format_modules.md

The root method returns the serialized value for an empty ancestry, and the delimiter method returns the character used to separate IDs.

```ruby
# MaterializedPath
def self.root
  nil
end

DELIMITER = '/'.freeze

def self.delimiter
  DELIMITER
end
```

--------------------------------

### Implement generate, parse, and parse_integer for MaterializedPath

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/format_modules.md

These methods handle the conversion between arrays of ancestor IDs and the serialized format used in the database.

```ruby
# MaterializedPath
def self.generate(ancestor_ids)
  if ancestor_ids.present? && ancestor_ids.any?
    ancestor_ids.join(DELIMITER)
  else
    root
  end
end

def self.parse(obj)
  return [] if obj.nil? || obj == root

  obj.split(DELIMITER)
end

def self.parse_integer(obj)
  return [] if obj.nil? || obj == root

  obj.split(DELIMITER).map!(&:to_i)
end
```

--------------------------------

### Generate migration to remove parent_id

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Run this command to generate a migration file for removing the legacy parent_id column.

```bash
$ rails g migration remove_parent_id_from_[table]
```

--------------------------------

### Create Tree Nodes

Source: https://github.com/stefankroes/ancestry/blob/master/README.md

Use parent attributes to organize records into a tree structure.

```ruby
TreeNode.create! :name => 'Stinky', :parent => TreeNode.create!(:name => 'Squeeky')
```

--------------------------------

### AncestryHelper implementation

Source: https://github.com/stefankroes/ancestry/wiki/Nested-HTML-from-the-arrange-method

The helper method definition for rendering an arranged ancestry hash as a nested list.

```ruby
# app/helpers/ancestry_helper.rb
module AncestryHelper
  # arranged as tree expects 3 arguments. The hash from has_ancestry.arrange() method, 
  # options, and a render block
  def arranged_tree_as_list(hash, options = {}, &block)

    options = {
      :list_type            => :ul,
      :list_style           => '', 
      :ul_class             => [],
      :ul_class_top         => [],
      :ul_class_children    => [],
      :li_class             => [],
      :li_class_top         => [],
      :li_class_children    => [],
      :sort_by              => []
    }.merge(options)

    # setup any custom list styles you want to use here. An example is excluded
    # to render bootstrap style list groups. This is used to keep from recoding the same
    # options on different lists
    case options[:list_style]
      when :bootstrap_list_group
        options[:ul_class] << ['list-group']
        options[:li_class] << ['list-group-item']
    end
    options[:list_style] = ''

    output = ''

    # sort the hash key based on sort_by options array
    unless options[:sort_by].empty?
      hash = Hash[hash.sort_by{|k, v| options[:sort_by].collect {|sort| k.send(sort)} } ]
    end

    current_depth = 0
    # and here... we... go...
    hash.each do |object, children|

        li_classes = options[:li_class]  
              
        if object.depth == 0
          li_classes += options[:li_class_top]
        else
          li_classes += options[:li_class_children]
        end 
               
        if children.size > 0
          output << content_tag(:li, capture(object, &block) + arranged_tree_as_list(children, options, &block).html_safe,  :class => li_classes)
        else
          output << content_tag(:li, capture(object, &block), :class => li_classes).html_safe
          current_depth = object.depth
        end

    end

    unless output.blank?
      
      ul_classes = options[:ul_class]
      
      if current_depth == 0
        ul_classes += options[:ul_class_top]
      else
        ul_classes += options[:ul_class_children]
      end      
      
      output = content_tag(options[:list_type], output.html_safe, :class => ul_classes)
    end
    
    return output.html_safe
     
  end

end
```

--------------------------------

### Populate ancestry column from parent_ids

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Use these commands in the rails console to build the ancestry structure from existing parent_id columns and verify integrity.

```ruby
Model.build_ancestry_from_parent_ids!
# Model.rebuild_depth_cache!
Model.check_ancestry_integrity!
```

--------------------------------

### Migrate from :materialized_path to :materialized_path3

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Updates existing ancestry paths by appending a delimiter, converting root nodes from nil to empty strings, and setting the column to NOT NULL.

```ruby
klass = YourModel
# Append delimiter: "1/2/3" → "1/2/3/"
klass.where.not(ancestry: nil).update_all("ancestry = CONCAT(ancestry, '/')")
# Convert root nodes: nil → ""
klass.where(ancestry: nil).update_all("ancestry = ''")
change_column_null klass.table_name, :ancestry, false
```

--------------------------------

### Ancestry::HasAncestry.ancestry_format_module implementation

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/has_ancestry.md

Maps a format symbol to the corresponding module that implements serialization and SQL logic.

```ruby
def self.ancestry_format_module(ancestry_format)
  ancestry_format ||= Ancestry.default_ancestry_format
  case ancestry_format
  when :materialized_path2
    Ancestry::MaterializedPath2
  when :materialized_path3
    Ancestry::MaterializedPath3
  when :ltree
    Ancestry::Ltree
  when :array
    Ancestry::MaterializedPathArray
  else
    Ancestry::MaterializedPath
  end
end
```

--------------------------------

### Set Primary Key Format

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Specifies the format of the primary key. Custom regex patterns are also supported.

```ruby
has_ancestry primary_key_format: :integer   # default
has_ancestry primary_key_format: :uuid      # UUIDs
has_ancestry primary_key_format: :string    # alphanumeric string ids
```

```ruby
has_ancestry primary_key_format: '[a-z0-9]{8}'
```

--------------------------------

### Rebuild cache methods

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/configuration.md

Methods to rebuild internal caches after bulk imports or direct SQL changes that bypass callbacks.

```ruby
Model.rebuild_depth_cache!          Model.rebuild_depth_cache_sql!
Model.rebuild_parent_id_cache!      Model.rebuild_parent_id_cache_sql!
Model.rebuild_root_id_cache!        Model.rebuild_root_id_cache_sql!
Model.rebuild_counter_cache!(verbose: true)   # returns count of fixed rows when verbose
```

--------------------------------

### Configure Counter Cache

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Enable the counter cache to track the number of children. You can use the default column name or specify a custom one.

```ruby
has_ancestry counter_cache: true                # column: children_count
has_ancestry counter_cache: :num_children       # custom column name
```

--------------------------------

### Enable Touch Ancestors

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Configures the model to touch all ancestors when a node changes, triggering callbacks for cache invalidation.

```ruby
has_ancestry touch: true
```

--------------------------------

### Configure acts_as_list with ancestry scope

Source: https://github.com/stefankroes/ancestry/wiki/Integrating-with-acts_as_list

Define the acts_as_list scope as an array containing :ancestry to ensure proper SQL generation for ancestry values.

```ruby
class Page < ActiveRecord::Base
  has_ancestry
  acts_as_list scope: [:ancestry]
end
```

--------------------------------

### Predicate instance methods

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/instance_methods.md

Methods for checking relationships between nodes, such as ancestor, descendant, or subtree membership. All methods return a Boolean.

```ruby
def ancestor_of?(node)
  node.ancestor_ids.include?(id)
end

def parent_of?(node)
  id == node.parent_id
end

def child_of?(node)
  parent_id == node.id
end

def root_of?(node)
  id == node.root_id
end

def descendant_of?(node)
  ancestor_ids.include?(node.id)
end

def indirect_of?(node)
  ancestor_ids[0..-2].include?(node.id)
end

def in_subtree_of?(node)
  id == node.id || descendant_of?(node)
end
```

--------------------------------

### SQL Concatenation Helper

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/adapter.md

Generates a SQL fragment for string concatenation, using || for SQLite and CONCAT() for other adapters.

```ruby
def concat(adapter, *args)
  sqlite?(adapter) ? args.join('||') : "CONCAT(#{args.join(', ')})"
end
```

```ruby
Ancestry::Adapter.concat(Ancestry::Adapter.current, "nodes.ancestry", "'/'", "nodes.id")
# MySQL/PG:  CONCAT(nodes.ancestry, '/', nodes.id)
# SQLite:    nodes.ancestry || '/' || nodes.id
```

--------------------------------

### Configure Ancestry Class Attributes

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/ancestry.md

The implementation of class-level defaults for update strategy, ancestry format, and primary key format within lib/ancestry.rb.

```ruby
# lib/ancestry.rb
module Ancestry
  @@default_update_strategy = :ruby
  @@default_ancestry_format = :materialized_path
  @@default_primary_key_format = :integer

  def self.default_update_strategy
    @@default_update_strategy
  end

  def self.default_update_strategy=(value)
    @@default_update_strategy = value
  end

  def self.default_ancestry_format
    @@default_ancestry_format
  end

  def self.default_ancestry_format=(value)
    @@default_ancestry_format = value
  end

  def self.default_primary_key_format
    @@default_primary_key_format
  end

  def self.default_primary_key_format=(value)
    @@default_primary_key_format = value
  end

  def self.deprecator
    @deprecator ||= ActiveSupport::Deprecation.new(nil, "ancestry")
  end
end
```

--------------------------------

### Apply Relative Depth Options

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Use relative depth options on navigation methods. Note that these constraints cannot be passed to ancestor_ids or path_ids.

```ruby
node.descendants(:from_depth => 2, :to_depth => 4)
node.ancestors(:from_depth => -6, :to_depth => -4)
node.path.from_depth(3).to_depth(4)
node.subtree.from_depth(10).to_depth(12)
```

--------------------------------

### Configure Depth Cache

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Options for enabling depth caching, which supports depth-based filtering and scopes.

```ruby
has_ancestry cache_depth: true               # callback-maintained, column: ancestry_depth
has_ancestry cache_depth: :virtual           # database-generated column (recommended)
has_ancestry cache_depth: :my_depth_column   # custom column name
```

--------------------------------

### Ancestry migration helper definition

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/migration.md

The signature for the ancestry migration helper method.

```ruby
def ancestry(column = :ancestry, format: nil, collation: nil, primary_key_format: nil, cache_depth: false, parent: false, root: false, counter_cache: false)
```

--------------------------------

### Use Depth Scopes

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Query nodes based on their depth level. Enabling cache_depth is recommended for production to avoid per-row SQL calculations.

```ruby
Model.at_depth(2)         # depth == 2
Model.before_depth(3)     # depth < 3
Model.to_depth(3)         # depth <= 3
Model.from_depth(2)       # depth >= 2
Model.after_depth(2)      # depth > 2
```

--------------------------------

### Configure Parent Cache and Associations

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Options for enabling parent caching, which defines belongs_to :parent and has_many :children associations.

```ruby
has_ancestry parent: :virtual    # recommended — database-generated parent_id
has_ancestry parent: true        # callback-maintained parent_id
```

--------------------------------

### Using arrange_serializable for JSON output

Source: https://github.com/stefankroes/ancestry/blob/master/README.md

The arrange_serializable method returns a hash of arrays, which is useful for JSON serialization. It supports custom blocks for serialization logic.

```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,
     my_children: children
  }
end
```

--------------------------------

### Configure Root Cache

Source: https://github.com/stefankroes/ancestry/blob/master/CONFIGURATION.md

Options for enabling root caching, which defines a belongs_to :root association.

```ruby
has_ancestry root: :virtual     # database-generated root_id (PostgreSQL, SQLite)
has_ancestry root: true         # callback-maintained root_id
```

--------------------------------

### Current Adapter Detection

Source: https://github.com/stefankroes/ancestry/blob/master/_autodocs/api-reference/adapter.md

Retrieves the active connection's adapter name.

```ruby
def current
  ActiveRecord::Base.connection.adapter_name
end
```
Tokens:
Raw