ancestry 2.0.0 → 2.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 005c1204eb8018577673e708da755c1e8b0ae388
+  data.tar.gz: 7f55187582a5d94339dd86e972ec9070c9cf1fed
+SHA512:
+  metadata.gz: 568208af2c3eb95eca4b71ceed135c72743370ff60e7d1209f5b1a5ef7557ef379680ccdf5a83dc5b80323a403c422d3b14501b41fc0d01557a53d4d04170a51
+  data.tar.gz: 1b8c1b91c87573b7d9e611df92bb185bbb9712964a3dc0f64ccda3bde6c17fe11dd358212bdbb2f76645915723a66d179570ee4eb1ef630f96558f1f1ea043d9

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Stefan Kroes
+Copyright (c) 2016 Stefan Kroes
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,3 +1,8 @@
+{<img src="https://travis-ci.org/stefankroes/ancestry.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/stefankroes/ancestry]
+{<img src="https://coveralls.io/repos/stefankroes/ancestry/badge.svg" alt="Coverage Status" />}[https://coveralls.io/r/stefankroes/ancestry]
+{<img src="https://badges.gitter.im/Join Chat.svg" alt="Gitter" />}[https://gitter.im/stefankroes/ancestry?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge]
+{<img src="https://hakiri.io/github/stefankroes/ancestry/master.svg" alt="Security" />}[https://hakiri.io/github/stefankroes/ancestry/master]
+
 = Ancestry
 
 Ancestry is a gem/plugin that allows the records of a Ruby on Rails ActiveRecord model to be organised as a tree structure (or hierarchy). It uses a single, intuitively formatted database column, using a variation on the materialised path pattern. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single SQL query. Additional features are STI support, scopes, depth caching, depth constraints, easy migration from older plugins/gems, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.
@@ -6,20 +11,51 @@ Ancestry is a gem/plugin that allows the records of a Ruby on Rails ActiveRecord
 
 To apply Ancestry to any ActiveRecord model, follow these simple steps:
 
-1. Install
-   - <b>Rails 2</b>
-     - See 1-3-stable branch
-   - <b>Rails 3</b>
-     - Add to Gemfile: <b>gem 'ancestry'</b>
-     - Install required gems: <b>bundle install</b>
-
-2. Add ancestry column to your table
-   - Create migration: <b>rails g migration add_ancestry_to_[table] ancestry:string</b>
-   - Add index to migration: <b>add_index [table], :ancestry</b> (UP) / <b>remove_index [table], :ancestry</b> (DOWN)
-   - Migrate your database: <b>rake db:migrate</b>
-
-3. Add ancestry to your model
-   - Add to app/models/[model].rb: <b>has_ancestry</b>
+== Install
+=== Rails 2
+- See 1-3-stable branch
+=== Rails 3 and 4
+- Add to Gemfile:
+   # Gemfile
+
+   gem 'ancestry'
+- Install required gems:
+   $ bundle install
+
+== Add ancestry column to your table
+- Create migration:
+   $ rails g migration add_ancestry_to_[table] ancestry:string
+- Add index to migration:
+   # db/migrate/[date]_add_ancestry_to_[table].rb
+
+   class AddAncestryTo[Table] < ActiveRecord::Migration
+      # Rails 4 Syntax
+      def change
+         add_column [table], :ancestry, :string
+         add_index [table], :ancestry
+      end
+
+      # Rails 3 Syntax
+      def up
+         add_column [table], :ancestry, :string
+         add_index [table], :ancestry
+      end
+
+      def down
+         remove_column [table], :ancestry
+         remove_index [table], :ancestry
+      end
+
+- Migrate your database:
+   $ rake db:migrate
+
+== Add ancestry to your model
+- Add to app/models/[model].rb:
+   # app/models/[model.rb]
+
+   class [Model] < ActiveRecord::Base
+      has_ancestry
+   end
 
 Your model is now a tree!
 
@@ -53,8 +89,8 @@ To navigate an Ancestry model, use the following methods on any instance / recor
   children         Scopes the model on children of the record
   child_ids        Returns a list of child ids
   has_children?    Returns true if the record has any children, false otherwise
-  is_childless?    Returns true is the record has no childen, false otherwise
-  siblings         Scopes the model on siblings of the record, the record itself is included
+  is_childless?    Returns true is the record has no children, false otherwise
+  siblings         Scopes the model on siblings of the record, the record itself is included*
   sibling_ids      Returns a list of sibling ids
   has_siblings?    Returns true if the record's parent has more than one child
   is_only_child?   Returns true if the record is the only child of its parent
@@ -64,7 +100,9 @@ To navigate an Ancestry model, use the following methods on any instance / recor
   subtree_ids      Returns a list of all ids in the record's subtree
   depth            Return the depth of the node, root nodes are at depth 0
 
-= Options for has_ancestry 
+* If the record is a root, other root records are considered siblings
+
+= Options for has_ancestry
 
 The has_ancestry methods supports the following options:
 
@@ -73,7 +111,8 @@ The has_ancestry methods supports the following options:
                          :destroy   All children are destroyed as well (default)
                          :rootify   The children of the destroyed node become root nodes
                          :restrict  An AncestryException is raised if any children exist
-                         :adopt     The orphan subtree is added to the parent of the deleted node.If the deleted node is Root, then rootify the orphan subtree.
+                         :adopt     The orphan subtree is added to the parent of the deleted node.
+                                    If the deleted node is Root, then rootify the orphan subtree.
   :cache_depth           Cache the depth of each node in the 'ancestry_depth' column (default: false)
                          If you turn depth_caching on for an existing model:
                          - Migrate: add_column [table], :ancestry_depth, :integer, :default => 0
@@ -81,6 +120,8 @@ The has_ancestry methods supports the following options:
   :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)
 
 = (Named) Scopes
 
@@ -115,7 +156,7 @@ When depth caching is enabled (see has_ancestry options), five more named scopes
   at_depth(depth)         Return nodes that are at depth (node.depth == depth)
   from_depth(depth)       Return nodes starting from a certain depth (node.depth >= depth)
   after_depth(depth)      Return nodes that are deeper than depth (node.depth > depth)
-  
+
 The depth scopes are also available through calls to descendants, descendant_ids, subtree, subtree_ids, path and ancestors. In this case, depth values are interpreted relatively. Some examples:
 
   node.subtree(:to_depth => 2)      Subtree of node, to a depth of node.depth + 2 (self, children and grandchildren)
@@ -156,10 +197,47 @@ The arrange method takes ActiveRecord find options. If you want your hashes to b
 
   TreeNode.find_by_name('Crunchy').subtree.arrange(:order => :name)
 
+To get the arranged nodes as a nested array of hashes for serialization:
+
+  TreeNode.arrange_serializable
+
+  [
+    {
+      "ancestry" => nil, "id" => 1, "children" => [
+        { "ancestry" => "1", "id" => 2, "children" => [] }
+      ]
+    }
+  ]
+
+You can also supply your own serialization logic using blocks:
+
+For example, using Active Model Serializers:
+
+  TreeNode.arrange_serializable do |parent, children|
+    MySerializer.new(parent, children: children)
+  end
+
+Or plain hashes:
+
+  TreeNode.arrange_serializable do |parent, children|
+    {
+       my_id: parent.id
+       my_children: children
+    }
+  end
+
+The result of arrange_serializable can easily be serialized to json with 'to_json', or some other format:
+
+  TreeNode.arrange_serializable.to_json
+
+You can also pass the order to the arrange_serializable method just as you can pass it to the arrange method:
+
+  TreeNode.arrange_serializable(:order => :name)
+
 = Sorting
 
 If you just want to sort an array of nodes as if you were traversing them in preorder, you can use the sort_by_ancestry class method:
-  
+
   TreeNode.sort_by_ancestry(array_of_nodes)
 
 Note that since materialised path trees don't support ordering within a rank, the order of siblings depends on their order in the original array.
@@ -178,7 +256,7 @@ Most current tree plugins use a parent_id column (has_ancestry, awesome_nested_s
    - Remove gem config line from environment.rb: config.gem [old gem]
    - Add Ancestry to environment.rb: config.gem :ancestry
    - See 'Installation' for more info on installing and configuring gems
-  
+
 3. Change your model
    - Remove any macros required by old plugin/gem from app/models/[model].rb
    - Add to app/models/[model].rb: <b>has_ancestry</b>
@@ -199,7 +277,7 @@ Most current tree plugins use a parent_id column (has_ancestry, awesome_nested_s
 
 = Integrity checking and restoration
 
-I don't see any way Ancestry tree integrity could get compromised without explicitly setting cyclic parents or invalid ancestry and circumventing validation with update_attribute, if you do, please let me know. 
+I don't see any way Ancestry tree integrity could get compromised without explicitly setting cyclic parents or invalid ancestry and circumventing validation with update_attribute, if you do, please let me know.
 
 Ancestry includes some methods for detecting integrity problems and restoring integrity just to be sure. To check integrity use: [Model].check_ancestry_integrity!. An AncestryIntegrityException will be raised if there are any problems. You can also specify :report => :list to return an array of exceptions or :report => :echo to echo any error messages. To restore integrity use: [Model].restore_ancestry_integrity!.
 
@@ -224,18 +302,16 @@ Additionally, if you think something is wrong with your depth cache:
 
 = Tests
 
-The Ancestry gem comes with a unit test suite consisting of about 1800 assertions in about 30 tests. It takes about 10 seconds to run on sqlite. To run it yourself:
-- check out the repository from GitHub
-- copy test/database.example.yml to test/database.yml
-- run <tt>bundle</tt>
-- run <tt>rake [test]</tt>
-
-You can pass an environment variable for the database to test against (e.g. db=mysql). By default, the test suite runs against the latest activerecord version. You can run agains activerecord 3-0 or 3-1 as follows:
-- run <tt>bundle --gemfile Gemfile.rails-<version></tt>
-- run <tt>rake [test] BUNDLE_GEMFILE=Gemfile.rails-<version></tt>
+The Ancestry gem comes with a unit test suite consisting of about 1900 assertions in about 50 tests. It takes about 10 seconds to run on sqlite. It is run against three databases (sqlite3, mysql and postgresql) and four versions of Activerecord (3.0, 3.1, 3.2 and 4.0) using Appraisals. To run it yourself:
+- Check out the repository from GitHub
+- Copy test/database.example.yml to test/database.yml
+- Run <tt>bundle</tt>
+- Run <tt>appraisal install</tt>
+- Run <tt>appraisal rake test</tt>
 
-To run the test suite multiple times against several databases and all supported activerecord versions, run <tt>rake test_all</tt>
-The test suite is located in test/has_ancestry_test.rb.
+You can also run against a specific database and specific version of Activerecord:
+- Run the above commands, except for the last one
+- Run <tt>appraisal sqlite3-ar-32 rake test</tt> (to test against sqlite3 and Activerecord 3.2)
 
 = Internals
 
@@ -245,101 +321,10 @@ In the example above, the ancestry column is created as a string. This puts a li
 
 The materialised path pattern requires Ancestry to use a 'like' condition in order to fetch descendants. This should not be particularly slow however since the the condition never starts with a wildcard which allows the DBMS to use the column index. If you have any data on performance with a large number of records, please drop me line.
 
-= Version history
-
-The latest version of ancestry is recommended. The three numbers of each version numbers are respectively the major, minor and patch versions. We started with major version 1 because it looks so much better and ancestry was already quite mature and complete when it was published. The major version is only bumped when backwards compatibility is broken. The minor version is bumped when new features are added. The patch version is bumped when bugs are fixed.
-
-- Version 2.0.0 (2013-05-17)
-  - Removed rails 2 compatibility
-  - Added table name to condition constructing methods (thx aflatter)
-  - Fix depth_cache not being updated when moving up to ancestors (thx scottatron)
-  - add alias :root? to existing is_root? (thx divineforest)
-  - Add block to sort_by_ancestry (thx Iliya)
-  - Add attribute query method for parent_id (thx sj26)
-  - Fixed and tested for rails 4 (thx adammck, Nihad, Systho, Philippe, e.a.)
-  - Fixed overwriting ActiveRecord::Base.base_class (thx Rozhnov)
-  - New adopt strategy (thx unknown)
-  - Many more improvements
-- Version 1.3.0 (2012-05-04)
-  - Ancestry now ignores default scopes when moving or destroying nodes, ensuring tree consistency
-  - Changed ActiveRecord dependency to 2.3.14
-- Version 1.2.5 (2012-03-15)
-  - Fixed warnings: "parenthesize argument(s) for future version"
-  - Fixed a bug in the restore_ancestry_integrity! method (thx Arthur Holstvoogd)
-- Version 1.2.4 (2011-04-22)
-  - Prepended table names to column names in queries (thx raelik)
-  - Better check to see if acts_as_tree can be overloaded (thx jims)
-  - Performance inprovements (thx kueda)
-- Version 1.2.3 (2010-10-28)
-  - Fixed error with determining ActiveRecord version
-  - Added option to specify :primary_key_format (thanks goes to rolftimmermans)
-- Version 1.2.2 (2010-10-24)
-  - Fixed all deprecation warnings for rails 3.0.X
-  - Added :report option to check_ancestry_integrity!
-  - Changed ActiveRecord dependency to 2.2.2
-  - Tested and fixed for ruby 1.8.7 and 1.9.2
-  - Changed usage of update_attributes to update_attribute to allow ancestry column protection
-- Version 1.2.0 (2009-11-07)
-  - Removed some duplication in has_ancestry
-  - Cleaned up plugin pattern according to http://yehudakatz.com/2009/11/12/better-ruby-idioms/
-  - Moved parts of ancestry into seperate files
-  - Made it possible to pass options into the arrange method
-  - Renamed acts_as_tree to has_ancestry
-  - Aliased has_ancestry as acts_as_tree if acts_as_tree is available
-  - Added subtree_of scope
-  - Updated ordered_by_ancestry scope to support Microsoft SQL Server
-  - Added empty hash as parameter to exists? calls for older ActiveRecord versions
-- Version 1.1.4 (2009-11-07)
-  - Thanks to a patch from tom taylor, Ancestry now works with different primary keys
-- Version 1.1.3 (2009-11-01)
-  - Fixed a pretty bad bug where several operations took far too many queries
-- Version 1.1.2 (2009-10-29)
-  - Added validation for depth cache column
-  - Added STI support (reported broken)
-- Version 1.1.1 (2009-10-28)
-  - Fixed some parentheses warnings that where reported
-  - Fixed a reported issue with arrangement
-  - Fixed issues with ancestors and path order on postgres
-  - Added ordered_by_ancestry scope (needed to fix issues)
-- Version 1.1.0 (2009-10-22)
-  - Depth caching (and cache rebuilding)
-  - Depth method for nodes
-  - Named scopes for selecting by depth
-  - Relative depth options for tree navigation methods: 
-    - ancestors
-    - path
-    - descendants
-    - descendant_ids
-    - subtree
-    - subtree_ids
-  - Updated README
-  - Easy migration from existing plugins/gems
-  - acts_as_tree checks unknown options
-  - acts_as_tree checks that options are hash
-  - Added a bang (!) to the integrity functions
-    - Since these functions should only be used from ./script/console and not from your application, this change is not considered as breaking backwards compatibility and the major version wasn't bumped.
-  - Updated install script to point to documentation
-  - Removed rails specific init
-  - Removed uninstall script
-- Version 1.0.0 (2009-10-16)
-  - Initial version
-  - Tree building
-  - Tree navigation
-  - Integrity checking / restoration
-  - Arrangement
-  - Orphan strategies
-  - Subtree movement
-  - Named scopes
-  - Validations
-
-= Future work
-
-I will try to keep Ancestry up to date with changing versions of Rails and Ruby and also with any bug reports I might receive. I will implement new features on request as I see fit. One thing I definitely want to do soon is some proper performance testing.
-
-= Contact and copyright
-
-Bug report? Faulty/incomplete documentation? Feature request? Please post an issue on 'http://github.com/stefankroes/ancestry/issues'. Please also contact me at s.a.kroes[at]gmail.com if it's urgent.
-
-Question? Contact me at s.a.kroes[at]gmail.com, make sure you read the documentation.
-
-Copyright (c) 2009 Stefan Kroes, released under the MIT license
+= Contributing and license
+
+I will try to keep Ancestry up to date with changing versions of Rails and Ruby and also with any bug reports I might receive. I will implement new features on request as I see fit and have time.
+
+Question? Bug report? Faulty/incomplete documentation? Feature request? Please post an issue on 'http://github.com/stefankroes/ancestry/issues'. Make sure you have read the documentation and you have included tests and documentation with any pull request.
+
+Copyright (c) 2016 Stefan Kroes, released under the MIT license

data/ancestry.gemspec

@@ -1,26 +1,45 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+require 'ancestry/version'
+
 Gem::Specification.new do |s|
   s.name        = 'ancestry'
-  s.description = 'Organise ActiveRecord model into a tree structure'
-  s.summary     = 'Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.'
+  s.summary     = 'Organize ActiveRecord model into a tree structure'
+  s.description = <<-EOF
+  Ancestry allows the records of a ActiveRecord model to be organized in a tree
+  structure, using a single, intuitively formatted database column. It exposes
+  all the standard tree structure relations (ancestors, parent, root, children,
+  siblings, descendants) and all of them can be fetched in a single sql query.
+  Additional features are named_scopes, integrity checking, integrity restoration,
+  arrangement of (sub)tree into hashes and different strategies for dealing with
+  orphaned records.
+EOF
 
-  s.version = '2.0.0'
+  s.version = Ancestry::VERSION
 
   s.author   = 'Stefan Kroes'
   s.email    = 's.a.kroes@gmail.com'
   s.homepage = 'http://github.com/stefankroes/ancestry'
+  s.license  = 'MIT'
 
   s.files = [
-    'ancestry.gemspec', 
-    'init.rb', 
-    'install.rb', 
-    'lib/ancestry.rb', 
-    'lib/ancestry/has_ancestry.rb', 
-    'lib/ancestry/exceptions.rb', 
-    'lib/ancestry/class_methods.rb', 
-    'lib/ancestry/instance_methods.rb', 
-    'MIT-LICENSE', 
+    'ancestry.gemspec',
+    'init.rb',
+    'install.rb',
+    'lib/ancestry.rb',
+    'lib/ancestry/has_ancestry.rb',
+    'lib/ancestry/exceptions.rb',
+    'lib/ancestry/class_methods.rb',
+    'lib/ancestry/instance_methods.rb',
+    'MIT-LICENSE',
     'README.rdoc'
   ]
   
-  s.add_dependency 'activerecord', '>= 3.0.0'
+  s.required_ruby_version     = '>= 1.8.7'
+  s.add_runtime_dependency 'activerecord', '>= 3.0.0'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'rake',      '~> 10.0'
+  s.add_development_dependency 'test-unit'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'sqlite3'
 end

data/lib/ancestry/class_methods.rb

@@ -3,8 +3,8 @@ module Ancestry
     # Fetch tree node if necessary
     def to_node object
       if object.is_a?(self.ancestry_base_class) then object else find(object) end
-    end 
-    
+    end
+
     # Scope on relative depth options
     def scope_depth depth_options, depth
       depth_options.inject(self.ancestry_base_class) do |scope, option|
@@ -26,7 +26,7 @@ module Ancestry
         raise Ancestry::AncestryException.new("Invalid orphan strategy, valid ones are :rootify,:adopt, :restrict and :destroy.")
       end
     end
-    
+
     # Arrangement
     def arrange options = {}
       scope =
@@ -38,43 +38,60 @@ module Ancestry
       # Get all nodes ordered by ancestry and start sorting them into an empty hash
       arrange_nodes scope.where(options)
     end
-    
-    # Arrange array of nodes into a nested hash of the form 
+
+    # Arrange array of nodes into a nested hash of the form
     # {node => children}, where children = {} if the node has no children
     def arrange_nodes(nodes)
-      # Get all nodes ordered by ancestry and start sorting them into an empty hash
-      nodes.inject(ActiveSupport::OrderedHash.new) do |arranged_nodes, node|
-        # Find the insertion point for that node by going through its ancestors
-        node.ancestor_ids.inject(arranged_nodes) do |insertion_point, ancestor_id|
-          insertion_point.each do |parent, children|
-            # Change the insertion point to children if node is a descendant of this parent
-            insertion_point = children if ancestor_id == parent.id
-          end
-          insertion_point
-        end[node] = ActiveSupport::OrderedHash.new
-        arranged_nodes
+      arranged = ActiveSupport::OrderedHash.new
+      min_depth = Float::INFINITY
+      index = Hash.new { |h, k| h[k] = ActiveSupport::OrderedHash.new }
+
+      nodes.each do |node|
+        children = index[node.id]
+        index[node.parent_id][node] = children
+
+        depth = node.depth
+        if depth < min_depth
+          min_depth = depth
+          arranged.clear
+        end
+        arranged[node] = children if depth == min_depth
+      end
+
+      arranged
+    end
+
+     # Arrangement to nested array
+    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
-    
-    # Pseudo-preordered array of nodes.  Children will always follow parents, 
+
+    # Pseudo-preordered array of nodes.  Children will always follow parents,
     # for ordering nodes within a rank provide block, eg. Node.sort_by_ancestry(Node.all) {|a, b| a.rank <=> b.rank}.
     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
         end
-        
+
         arranged = arrange_nodes(presorted_nodes)
       end
-      
+
       arranged.inject([]) do |sorted_nodes, pair|
         node, children = pair
         sorted_nodes << node
@@ -87,8 +104,8 @@ module Ancestry
     def check_ancestry_integrity! options = {}
       parents = {}
       exceptions = [] if options[:report] == :list
-      
-      self.ancestry_base_class.unscoped do 
+
+      self.ancestry_base_class.unscoped do
         # For each node ...
         self.ancestry_base_class.find_each do |node|
           begin
@@ -126,7 +143,7 @@ module Ancestry
       parents = {}
       # Wrap the whole thing in a transaction ...
       self.ancestry_base_class.transaction do
-        self.ancestry_base_class.unscoped do 
+        self.ancestry_base_class.unscoped do
           # For each node ...
           self.ancestry_base_class.find_each do |node|
             # ... set its ancestry to nil if invalid
@@ -143,9 +160,9 @@ module Ancestry
             until parent.nil? || parent == node.id
               parent = parents[parent]
             end
-            parents[node.id] = nil if parent == node.id 
+            parents[node.id] = nil if parent == node.id
           end
-          
+
           # For each node ...
           self.ancestry_base_class.find_each do |node|
             # ... rebuild ancestry from parents array
@@ -160,10 +177,10 @@ module Ancestry
         end
       end
     end
-    
+
     # Build ancestry from parent id's for migration purposes
     def build_ancestry_from_parent_ids! parent_id = nil, ancestry = nil
-      self.ancestry_base_class.unscoped do 
+      self.ancestry_base_class.unscoped do
         self.ancestry_base_class.where(:parent_id => parent_id).find_each do |node|
           node.without_ancestry_callbacks do
             node.update_attribute ancestry_column, ancestry
@@ -172,14 +189,16 @@ module Ancestry
         end
       end
     end
-    
+
     # Rebuild depth cache if it got corrupted or if depth caching was just turned on
     def rebuild_depth_cache!
       raise Ancestry::AncestryException.new("Cannot rebuild depth cache for model without depth caching.") unless respond_to? :depth_cache_column
-      
-      self.ancestry_base_class.unscoped do 
-        self.ancestry_base_class.find_each do |node|
-          node.update_attribute depth_cache_column, node.depth
+
+      self.ancestry_base_class.transaction do
+        self.ancestry_base_class.unscoped do
+          self.ancestry_base_class.find_each do |node|
+            node.update_attribute depth_cache_column, node.depth
+          end
         end
       end
     end

data/lib/ancestry/has_ancestry.rb

@@ -3,11 +3,11 @@ class << ActiveRecord::Base
     # Check options
     raise Ancestry::AncestryException.new("Options for has_ancestry must be in a hash.") unless options.is_a? Hash
     options.each do |key, value|
-      unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column].include? key
+      unless [:ancestry_column, :orphan_strategy, :cache_depth, :depth_cache_column, :touch].include? key
         raise Ancestry::AncestryException.new("Unknown option for has_ancestry: #{key.inspect} => #{value.inspect}.")
       end
     end
-    
+
     # Include instance methods
     include Ancestry::InstanceMethods
 
@@ -25,13 +25,17 @@ class << ActiveRecord::Base
     # Save self as base class (for STI)
     cattr_accessor :ancestry_base_class
     self.ancestry_base_class = self
-    
+
+    # Touch ancestors after updating
+    cattr_accessor :touch_ancestors
+    self.touch_ancestors = options[:touch] || false
+
     # Validate format of ancestry column value
     validates_format_of ancestry_column, :with => Ancestry::ANCESTRY_PATTERN, :allow_nil => true
 
     # Validate that the ancestor ids don't include own id
     validate :ancestry_exclude_self
-    
+
     # Named scopes
     scope :roots, lambda { where(ancestry_column => nil) }
     scope :ancestors_of, lambda { |object| where(to_node(object).ancestor_conditions) }
@@ -39,9 +43,24 @@ class << ActiveRecord::Base
     scope :descendants_of, lambda { |object| where(to_node(object).descendant_conditions) }
     scope :subtree_of, lambda { |object| where(to_node(object).subtree_conditions) }
     scope :siblings_of, lambda { |object| where(to_node(object).sibling_conditions) }
-    scope :ordered_by_ancestry, lambda { reorder("(case when #{table_name}.#{ancestry_column} is null then 0 else 1 end), #{table_name}.#{ancestry_column}") }
-    scope :ordered_by_ancestry_and, lambda { |order| reorder("(case when #{table_name}.#{ancestry_column} is null then 0 else 1 end), #{table_name}.#{ancestry_column}, #{order}") }
-    
+    scope :ordered_by_ancestry, lambda {
+      if %w(mysql mysql2 sqlite postgresql).include?(connection.adapter_name.downcase) &&
+        defined?(ActiveRecord.version) && ActiveRecord.version.to_s >= "5"
+        reorder("coalesce(#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)}, '')")
+      else
+        reorder("(CASE WHEN #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)} IS NULL THEN 0 ELSE 1 END), #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)}")
+      end
+    }
+    scope :ordered_by_ancestry_and, lambda { |order|
+      if %w(mysql mysql2 sqlite postgresql).include?(connection.adapter_name.downcase) &&
+        defined?(ActiveRecord.version) && ActiveRecord.version.to_s >= "5"
+        reorder("coalesce(#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)}, ''), #{order}")
+      else
+        reorder("(CASE WHEN #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)} IS NULL THEN 0 ELSE 1 END), #{connection.quote_table_name(table_name)}.#{connection.quote_column_name(ancestry_column)}, #{order}")
+      end
+    }
+    scope :path_of, lambda { |object| to_node(object).path }
+
     # Update descendants with new ancestry before save
     before_save :update_descendants_with_new_ancestry
 
@@ -61,7 +80,7 @@ class << ActiveRecord::Base
       # Validate depth column
       validates_numericality_of depth_cache_column, :greater_than_or_equal_to => 0, :only_integer => true, :allow_nil => false
     end
-    
+
     # Create named scopes for depth
     {:before_depth => '<', :to_depth => '<=', :at_depth => '=', :from_depth => '>=', :after_depth => '>'}.each do |scope_name, operator|
       scope scope_name, lambda { |depth|
@@ -69,10 +88,17 @@ class << ActiveRecord::Base
         where("#{depth_cache_column} #{operator} ?", depth)
       }
     end
+
+    after_touch :touch_ancestors_callback
+    after_destroy :touch_ancestors_callback
+    after_save :touch_ancestors_callback, if: :changed?
   end
-  
-  # Alias has_ancestry with acts_as_tree, if it's available.
-  if !defined?(ActsAsTree) 
-    alias_method :acts_as_tree, :has_ancestry
+end
+
+ActiveSupport.on_load :active_record do
+  if not(ActiveRecord::Base.respond_to?(:acts_as_tree))
+    class << ActiveRecord::Base
+      alias_method :acts_as_tree, :has_ancestry
+    end
   end
 end

data/lib/ancestry/instance_methods.rb

@@ -53,6 +53,8 @@ module Ancestry
             descendants.each do |descendant|
               descendant.without_ancestry_callbacks do
                 new_ancestry = descendant.ancestor_ids.delete_if { |x| x == self.id }.join("/")
+                # check for empty string if it's then set to nil
+                new_ancestry = nil if new_ancestry.empty?
                 descendant.update_attribute descendant.class.ancestry_column, new_ancestry || nil
               end
             end
@@ -64,6 +66,25 @@ module Ancestry
       end
     end
 
+    # Touch each of this record's ancestors
+    def touch_ancestors_callback
+
+      # Skip this if callbacks are disabled
+      unless ancestry_callbacks_disabled?
+
+        # Only touch if the option is enabled
+        if self.ancestry_base_class.touch_ancestors
+
+          # Touch each of the old *and* new ancestors
+          self.class.where(id: (ancestor_ids + ancestor_ids_was).uniq).each do |ancestor|
+            ancestor.without_ancestry_callbacks do
+              ancestor.touch
+            end
+          end
+        end
+      end
+    end
+
     # The ancestry value for this record's children
     def child_ancestry
       # New records cannot have children
@@ -73,20 +94,34 @@ module Ancestry
     end
 
     # Ancestors
+
     def ancestry_changed?
       changed.include?(self.ancestry_base_class.ancestry_column.to_s)
     end
 
+    def parse_ancestry_column obj
+      obj.to_s.split('/').map { |id| cast_primary_key(id) }
+    end
+
     def ancestor_ids
-      read_attribute(self.ancestry_base_class.ancestry_column).to_s.split('/').map { |id| cast_primary_key(id) }
+      parse_ancestry_column(read_attribute(self.ancestry_base_class.ancestry_column))
     end
 
     def ancestor_conditions
-      {primary_key_with_table => ancestor_ids}
+      t = get_arel_table
+      t[get_primary_key_column].in(ancestor_ids)
     end
 
     def ancestors depth_options = {}
-      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.where  ancestor_conditions
+      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.where ancestor_conditions
+    end
+
+    def ancestor_was_conditions
+      {primary_key_with_table => ancestor_ids_was}
+    end
+
+    def ancestor_ids_was
+      parse_ancestry_column(changed_attributes[self.ancestry_base_class.ancestry_column.to_s])
     end
 
     def path_ids
@@ -94,11 +129,12 @@ module Ancestry
     end
 
     def path_conditions
-      {primary_key_with_table => path_ids}
+      t = get_arel_table
+      t[get_primary_key_column].in(path_ids)
     end
 
     def path depth_options = {}
-      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.where  path_conditions
+      self.ancestry_base_class.scope_depth(depth_options, depth).ordered_by_ancestry.where path_conditions
     end
 
     def depth
@@ -109,7 +145,12 @@ module Ancestry
       write_attribute self.ancestry_base_class.depth_cache_column, depth
     end
 
+    def ancestor_of?(node)
+      node.ancestor_ids.include?(self.id)
+    end
+
     # Parent
+
     def parent= parent
       write_attribute(self.ancestry_base_class.ancestry_column, if parent.nil? then nil else parent.child_ancestry end)
     end
@@ -130,7 +171,12 @@ module Ancestry
       parent_id.present?
     end
 
+    def parent_of?(node)
+      self.id == node.parent_id
+    end
+
     # Root
+
     def root_id
       if ancestor_ids.empty? then id else ancestor_ids.first end
     end
@@ -144,9 +190,15 @@ module Ancestry
     end
     alias :root? :is_root?
 
+    def root_of?(node)
+      self.id == node.root_id
+    end
+
     # Children
+
     def child_conditions
-      {ancestry_column_with_table => child_ancestry}
+      t = get_arel_table
+      t[get_ancestry_column].eq(child_ancestry)
     end
 
     def children
@@ -160,14 +212,22 @@ module Ancestry
     def has_children?
       self.children.exists?({})
     end
+    alias_method :children?, :has_children?
 
     def is_childless?
       !has_children?
     end
+    alias_method :childless?, :is_childless?
+
+    def child_of?(node)
+      self.parent_id == node.id
+    end
 
     # Siblings
+
     def sibling_conditions
-      {ancestry_column_with_table => read_attribute(self.ancestry_base_class.ancestry_column)}
+      t = get_arel_table
+      t[get_ancestry_column].eq(read_attribute(self.ancestry_base_class.ancestry_column))
     end
 
     def siblings
@@ -181,14 +241,27 @@ module Ancestry
     def has_siblings?
       self.siblings.count > 1
     end
+    alias_method :siblings?, :has_siblings?
 
     def is_only_child?
       !has_siblings?
     end
+    alias_method :only_child?, :is_only_child?
+
+    def sibling_of?(node)
+      self.ancestry == node.ancestry
+    end
 
     # Descendants
+
     def descendant_conditions
-      ["#{ancestry_column_with_table} like ? or #{ancestry_column_with_table} = ?", "#{child_ancestry}/%", child_ancestry]
+      t = get_arel_table
+      # rails has case sensitive matching.
+      if defined?(ActiveRecord.version) && ActiveRecord.version.to_s >= "5"
+        t[get_ancestry_column].matches("#{child_ancestry}/%", nil, true).or(t[get_ancestry_column].eq(child_ancestry))
+      else
+        t[get_ancestry_column].matches("#{child_ancestry}/%").or(t[get_ancestry_column].eq(child_ancestry))
+      end
     end
 
     def descendants depth_options = {}
@@ -199,9 +272,15 @@ module Ancestry
       descendants(depth_options).select(self.ancestry_base_class.primary_key).collect(&self.ancestry_base_class.primary_key.to_sym)
     end
 
+    def descendant_of?(node)
+      ancestor_ids.include?(node.id)
+    end
+
     # Subtree
+
     def subtree_conditions
-      ["#{primary_key_with_table} = ? or #{ancestry_column_with_table} like ? or #{ancestry_column_with_table} = ?", self.id, "#{child_ancestry}/%", child_ancestry]
+      t = get_arel_table
+      descendant_conditions.or(t[get_primary_key_column].eq(self.id))
     end
 
     def subtree depth_options = {}
@@ -213,6 +292,7 @@ module Ancestry
     end
 
     # Callback disabling
+
     def without_ancestry_callbacks
       @disable_ancestry_callbacks = true
       yield
@@ -220,13 +300,13 @@ module Ancestry
     end
 
     def ancestry_callbacks_disabled?
-      !!@disable_ancestry_callbacks
+      defined?(@disable_ancestry_callbacks) && @disable_ancestry_callbacks
     end
 
   private
 
     def cast_primary_key(key)
-      if primary_key_type == :string
+      if [:string, :uuid, :text].include? primary_key_type
         key
       else
         key.to_i
@@ -236,28 +316,33 @@ module Ancestry
     def primary_key_type
       @primary_key_type ||= column_for_attribute(self.class.primary_key).type
     end
+
     def unscoped_descendants
       self.ancestry_base_class.unscoped do
         self.ancestry_base_class.where descendant_conditions
       end
     end
 
-    # basically validates the ancestry, but also applied if validation is
-    # bypassed to determine if chidren should be affected
+    # Validates the ancestry, but can also be applied if validation is bypassed to determine if children should be affected
     def sane_ancestry?
-      ancestry.nil? || (ancestry.to_s =~ Ancestry::ANCESTRY_PATTERN && !ancestor_ids.include?(self.id))
+      ancestry_value = read_attribute(self.ancestry_base_class.ancestry_column)
+      ancestry_value.nil? || (ancestry_value.to_s =~ Ancestry::ANCESTRY_PATTERN && !ancestor_ids.include?(self.id))
     end
 
     def unscoped_find id
       self.ancestry_base_class.unscoped { self.ancestry_base_class.find(id) }
     end
 
-    def primary_key_with_table
-      "#{self.ancestry_base_class.table_name}.#{self.ancestry_base_class.primary_key}"
+    def get_arel_table
+      self.ancestry_base_class.arel_table
+    end
+
+    def get_primary_key_column
+      self.ancestry_base_class.primary_key.to_sym
     end
 
-    def ancestry_column_with_table
-      "#{self.ancestry_base_class.table_name}.#{self.ancestry_base_class.ancestry_column}"
+    def get_ancestry_column
+      self.ancestry_base_class.ancestry_column.to_sym
     end
   end
 end

data/lib/ancestry.rb

@@ -1,7 +1,7 @@
-require File.join(File.expand_path(File.dirname(__FILE__)), 'ancestry/class_methods')
-require File.join(File.expand_path(File.dirname(__FILE__)), 'ancestry/instance_methods')
-require File.join(File.expand_path(File.dirname(__FILE__)), 'ancestry/exceptions')
-require File.join(File.expand_path(File.dirname(__FILE__)), 'ancestry/has_ancestry')
+require_relative 'ancestry/class_methods'
+require_relative 'ancestry/instance_methods'
+require_relative 'ancestry/exceptions'
+require_relative 'ancestry/has_ancestry'
 
 module Ancestry
   ANCESTRY_PATTERN = /\A[0-9]+(\/[0-9]+)*\Z/

metadata

@@ -1,76 +1,144 @@
 --- !ruby/object:Gem::Specification
 name: ancestry
 version: !ruby/object:Gem::Version
-  version: 2.0.0
-  prerelease: 
+  version: 2.2.2
 platform: ruby
 authors:
 - Stefan Kroes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-17 00:00:00.000000000 Z
+date: 2016-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
-description: Organise ActiveRecord model into a tree structure
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+    Ancestry allows the records of a ActiveRecord model to be organized in a tree
+    structure, using a single, intuitively formatted database column. It exposes
+    all the standard tree structure relations (ancestors, parent, root, children,
+    siblings, descendants) and all of them can be fetched in a single sql query.
+    Additional features are named_scopes, integrity checking, integrity restoration,
+    arrangement of (sub)tree into hashes and different strategies for dealing with
+    orphaned records.
 email: s.a.kroes@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- MIT-LICENSE
+- README.rdoc
 - ancestry.gemspec
 - init.rb
 - install.rb
 - lib/ancestry.rb
-- lib/ancestry/has_ancestry.rb
-- lib/ancestry/exceptions.rb
 - lib/ancestry/class_methods.rb
+- lib/ancestry/exceptions.rb
+- lib/ancestry/has_ancestry.rb
 - lib/ancestry/instance_methods.rb
-- MIT-LICENSE
-- README.rdoc
 homepage: http://github.com/stefankroes/ancestry
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.5.1
 signing_key: 
-specification_version: 3
-summary: Ancestry allows the records of a ActiveRecord model to be organised in a
-  tree structure, using a single, intuitively formatted database column. It exposes
-  all the standard tree structure relations (ancestors, parent, root, children, siblings,
-  descendants) and all of them can be fetched in a single sql query. Additional features
-  are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree
-  into hashes and different strategies for dealing with orphaned records.
+specification_version: 4
+summary: Organize ActiveRecord model into a tree structure
 test_files: []
-has_rdoc: