kamal-ancestry 1.2.4

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Stefan Kroes
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,305 @@
+= 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.
+
+= Installation
+
+To apply Ancestry to any ActiveRecord model, follow these simple steps:
+
+1. Install
+   - <b>Rails 2</b>
+     - Add to config/environment.rb: <b>config.gem 'ancestry'</b>
+     - Install required gems: <b>sudo rake gems:install</b>
+   - <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>
+
+Your model is now a tree!
+
+= Using acts_as_tree instead of has_ancestry
+
+In version 1.2.0 the <b>acts_as_tree</b> method was <b>renamed to has_ancestry</b> in order to allow usage of both the acts_as_tree gem and the ancestry gem in a single application. To not break backwards compatibility, the has_ancestry method is aliased with acts_as_tree if ActiveRecord::Base does not respond to acts_as_tree. acts_as_tree will continue to be supported in the future as I personally prefer it.
+
+= Organising records into a tree
+
+You can use the parent attribute to organise your records into a tree. If you have the id of the record you want to use as a parent and don't want to fetch it, you can also use parent_id. Like any virtual model attributes, parent and parent_id can be set using parent= and parent_id= on a record or by including them in the hash passed to new, create, create!, update_attributes and update_attributes!. For example:
+
+  TreeNode.create! :name => 'Stinky', :parent => TreeNode.create!(:name => 'Squeeky')
+
+You can also create children through the children relation on a node:
+
+  node.children.create :name => 'Stinky'
+
+= Navigating your tree
+
+To navigate an Ancestry model, use the following methods on any instance / record:
+
+  parent           Returns the parent of the record, nil for a root node
+  parent_id        Returns the id of the parent of the record, nil for a root node
+  root             Returns the root of the tree the record is in, self for a root node
+  root_id          Returns the id of the root of the tree the record is in
+  is_root?         Returns true if the record is a root node, false otherwise
+  ancestor_ids     Returns a list of ancestor ids, starting with the root id and ending with the parent id
+  ancestors        Scopes the model on ancestors of the record
+  path_ids         Returns a list the path ids, starting with the root id and ending with the node's own id
+  path             Scopes model on path records of the record
+  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
+  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
+  descendants      Scopes the model on direct and indirect children of the record
+  descendant_ids   Returns a list of a descendant ids
+  subtree          Scopes the model on descendants and itself
+  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 
+
+The has_ancestry methods supports the following options:
+
+  :ancestry_column       Pass in a symbol to store ancestry in a different column
+  :orphan_strategy       Instruct Ancestry what to do with children of a node that is destroyed:
+                         :destroy   All children are destroyed as well (default)
+                         :rootify   The children of the destroyed node become root nodes
+                         :restrict  An AncestryException is raised if any children exist
+  :cache_depth           Cache the depth of each node in the 'ancestry_depth' column (default: false)
+                         If you turn depth_caching on for an existing model:
+                         - Migrate: add_column [table], :ancestry_depth, :integer, :default => 0
+                         - Build cache: TreeNode.rebuild_depth_cache!
+  :depth_cache_column    Pass in a symbol to store depth cache in a different column
+  :primary_key_format    Supply a regular expression that matches the format of your primary key.
+                         By default, primary keys only match integers ([0-9]+).
+
+= (Named) Scopes
+
+Where possible, the navigation methods return scopes instead of records, this means additional ordering, conditions, limits, etc. can be applied and that the result can be either retrieved, counted or checked for existence. For example:
+
+  node.children.exists?(:name => 'Mary')
+  node.subtree.all(:order => :name, :limit => 10).each do; ...; end
+  node.descendants.count
+
+For convenience, a couple of named scopes are included at the class level:
+
+  roots                   Root nodes
+  ancestors_of(node)      Ancestors of node, node can be either a record or an id
+  children_of(node)       Children of node, node can be either a record or an id
+  descendants_of(node)    Descendants of node, node can be either a record or an id
+  subtree_of(node)        Subtree of node, node can be either a record or an id
+  siblings_of(node)       Siblings of node, node can be either a record or an id
+
+Thanks to some convenient rails magic, it is even possible to create nodes through the children and siblings scopes:
+
+  node.children.create
+  node.siblings.create!
+  TestNode.children_of(node_id).new
+  TestNode.siblings_of(node_id).create
+
+= Selecting nodes by depth
+
+When depth caching is enabled (see has_ancestry options), five more named scopes can be used to select nodes on their depth:
+
+  before_depth(depth)     Return nodes that are less deep than depth (node.depth < depth)
+  to_depth(depth)         Return nodes up to a certain depth (node.depth <= depth)
+  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)
+  node.subtree.to_depth(5)          Subtree of node to an absolute depth of 5
+  node.descendants(:at_depth => 2)  Descendant of node, at depth node.depth + 2 (grandchildren)
+  node.descendants.at_depth(10)     Descendants of node at an absolute depth of 10
+  node.ancestors.to_depth(3)        The oldest 4 ancestors of node (its root and 3 more)
+  node.path(:from_depth => -2)      The node's grandparent, parent and the node itself
+
+  node.ancestors(:from_depth => -6, :to_depth => -4)
+  node.path.from_depth(3).to_depth(4)
+  node.descendants(:from_depth => 2, :to_depth => 4)
+  node.subtree.from_depth(10).to_depth(12)
+
+Please note that depth constraints cannot be passed to ancestor_ids and path_ids. The reason for this is that both these relations can be fetched directly from the ancestry column without performing a database query. It would require an entirely different method of applying the depth constraints which isn't worth the effort of implementing. You can use ancestors(depth_options).map(&:id) or ancestor_ids.slice(min_depth..max_depth) instead.
+
+= STI support
+
+Ancestry works fine with STI. Just create a STI inheritance hierarchy and build an Ancestry tree from the different classes/models. All Ancestry relations that where described above will return nodes of any model type. If you do only want nodes of a specific subclass you'll have to add a condition on type for that.
+
+= Arrangement
+
+Ancestry can arrange an entire subtree into nested hashes for easy navigation after retrieval from the database.  TreeNode.arrange could for example return:
+
+  { #<TreeNode id: 100018, name: "Stinky", ancestry: nil>
+    => { #<TreeNode id: 100019, name: "Crunchy", ancestry: "100018">
+      => { #<TreeNode id: 100020, name: "Squeeky", ancestry: "100018/100019">
+        => {}
+      }
+    }
+  }
+
+The arrange method also works on a scoped class, for example:
+
+  TreeNode.find_by_name('Crunchy').subtree.arrange
+
+The arrange method takes ActiveRecord find options. If you want your hashes to be ordered, you should pass the order to the arrange method instead of to the scope. This only works for Ruby 1.9 and later since before that hashes weren't ordered. For example:
+
+  TreeNode.find_by_name('Crunchy').subtree.arrange(:order => :name)
+
+= Migrating from plugin that uses parent_id column
+
+Most current tree plugins use a parent_id column (has_ancestry, awesome_nested_set, better_nested_set, acts_as_nested_set). With ancestry its easy to migrate from any of these plugins, to do so, use the build_ancestry_from_parent_ids! method on your ancestry model. These steps provide a more detailed explanation:
+
+1. Add ancestry column to your table
+   - 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>
+
+2. Remove old tree plugin or gem and add in Ancestry
+   - Remove plugin: rm -Rf vendor/plugins/[old plugin]
+   - 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>
+
+4. Generate ancestry columns
+   - In './script.console': <b>[model].build_ancestry_from_parent_ids!</b>
+   - Make sure it worked ok: <b>[model].check_ancestry_integrity!</b>
+
+5. Change your code
+   - Most tree calls will probably work fine with ancestry
+   - Others must be changed or proxied
+   - Check if all your data is intact and all tests pass
+
+6. Drop parent_id column:
+   - Create migration: <b>rails g migration remove_parent_id_from_[table]</b>
+   - Add to migration: <b>remove_column [table], :parent_id</b> (UP) / <b>add_column [table], :parent_id, :integer</b> (DOWN)
+   - Migrate your database: <b>rake db:migrate</b>
+
+= 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. 
+
+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!.
+
+For example, from IRB:
+
+  >> stinky = TreeNode.create :name => 'Stinky'
+  $  #<TreeNode id: 1, name: "Stinky", ancestry: nil>
+  >> squeeky = TreeNode.create :name => 'Squeeky', :parent => stinky
+  $  #<TreeNode id: 2, name: "Squeeky", ancestry: "1">
+  >> stinky.update_attribute :parent, squeeky
+  $  true
+  >> TreeNode.all
+  $  [#<TreeNode id: 1, name: "Stinky", ancestry: "1/2">, #<TreeNode id: 2, name: "Squeeky", ancestry: "1/2/1">]
+  >> TreeNode.check_ancestry_integrity!
+  !! Ancestry::AncestryIntegrityException: Conflicting parent id in node 1: 2 for node 1, expecting nil
+  >> TreeNode.restore_ancestry_integrity!
+  $  [#<TreeNode id: 1, name: "Stinky", ancestry: 2>, #<TreeNode id: 2, name: "Squeeky", ancestry: nil>]
+
+Additionally, if you think something is wrong with your depth cache:
+
+  >> TreeNode.rebuild_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 and type 'rake'. You can pass rake style options for ActiveRecord version to test against (e.g. ar=3.0.1) and database to test against (e.g. db=mysql). The test suite is located in test/has_ancestry_test.rb.
+
+= Internals
+
+As can be seen in the previous section, Ancestry stores a path from the root to the parent for every node. This is a variation on the materialised path database pattern. It allows Ancestry to fetch any relation (siblings, descendants, etc.) in a single sql query without the complicated algorithms and incomprehensibility associated with left and right values. Additionally, any inserts, deletes and updates only affect nodes within the affected node's own subtree.
+
+In the example above, the ancestry column is created as a string. This puts a limitation on the depth of the tree of about 40 or 50 levels, which I think may be enough for most users. To increase the maximum depth of the tree, increase the size of the string that is being used or change it to a text to remove the limitation entirely. Changing it to a text will however decrease performance because an index cannot be put on the column in that case.
+
+The materialised path pattern requires Ancestry to use a 'like' condition in order to fetch descendants. 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 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

data/ancestry.gemspec

@@ -0,0 +1,26 @@
+Gem::Specification.new do |s|
+  s.name        = 'kamal-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.version = '1.2.4'
+
+  s.author   = 'Stefan Kroes'
+  s.email    = 's.a.kroes@gmail.com'
+  s.homepage = 'http://github.com/stefankroes/ancestry'
+
+  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', 
+    'README.rdoc'
+  ]
+  
+  s.add_dependency 'activerecord', '>= 2.2.2'
+end

data/init.rb

@@ -0,0 +1 @@
+require 'ancestry'

data/install.rb

@@ -0,0 +1 @@
+puts "Thank you for installing Ancestry. You can visit http://github.com/stefankroes/ancestry to read the documentation."

data/lib/ancestry.rb

@@ -0,0 +1 @@
+require 'ancestry/has_ancestry'

data/lib/ancestry/class_methods.rb

@@ -0,0 +1,137 @@
+module Ancestry
+  module ClassMethods
+    # Fetch tree node if necessary
+    def to_node object
+      if object.is_a?(self.base_class) then object else find(object) end
+    end 
+    
+    # Scope on relative depth options
+    def scope_depth depth_options, depth
+      depth_options.inject(self.base_class) do |scope, option|
+        scope_name, relative_depth = option
+        if [:before_depth, :to_depth, :at_depth, :from_depth, :after_depth].include? scope_name
+          scope.send scope_name, depth + relative_depth
+        else
+          raise Ancestry::AncestryException.new("Unknown depth option: #{scope_name}.")
+        end
+      end
+    end
+
+    # Orphan strategy writer
+    def orphan_strategy= orphan_strategy
+      # Check value of orphan strategy, only rootify, restrict or destroy is allowed
+      if [:rootify, :restrict, :destroy].include? orphan_strategy
+        class_variable_set :@@orphan_strategy, orphan_strategy
+      else
+        raise Ancestry::AncestryException.new("Invalid orphan strategy, valid ones are :rootify, :restrict and :destroy.")
+      end
+    end
+    
+    # Arrangement
+    def arrange options = {}
+      scope =
+        if options[:order].nil?
+          self.base_class.ordered_by_ancestry
+        else
+          self.base_class.ordered_by_ancestry_and options.delete(:order)
+        end
+      # Get all nodes ordered by ancestry and start sorting them into an empty hash
+      scope.all(options).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
+      end
+    end
+
+    # Integrity checking
+    def check_ancestry_integrity! options = {}
+      parents = {}
+      exceptions = [] if options[:report] == :list
+      # For each node ...
+      self.base_class.all.each do |node|
+        begin
+          # ... check validity of ancestry column
+          if !node.valid? and !node.errors[node.class.ancestry_column].blank?
+            raise Ancestry::AncestryIntegrityException.new "Invalid format for ancestry column of node #{node.id}: #{node.read_attribute node.ancestry_column}."
+          end
+          # ... check that all ancestors exist
+          node.ancestor_ids.each do |ancestor_id|
+            unless exists? ancestor_id
+              raise Ancestry::AncestryIntegrityException.new "Reference to non-existent node in node #{node.id}: #{ancestor_id}."
+            end
+          end
+          # ... check that all node parents are consistent with values observed earlier
+          node.path_ids.zip([nil] + node.path_ids).each do |node_id, parent_id|
+            parents[node_id] = parent_id unless parents.has_key? node_id
+            unless parents[node_id] == parent_id
+              raise Ancestry::AncestryIntegrityException.new "Conflicting parent id found in node #{node.id}: #{parent_id || 'nil'} for node #{node_id} while expecting #{parents[node_id] || 'nil'}"
+            end
+          end
+        rescue Ancestry::AncestryIntegrityException => integrity_exception
+          case options[:report]
+            when :list then exceptions << integrity_exception
+            when :echo then puts integrity_exception
+            else raise integrity_exception
+          end
+        end
+      end
+      exceptions if options[:report] == :list
+    end
+
+    # Integrity restoration
+    def restore_ancestry_integrity!
+      parents = {}
+      # For each node ...
+      self.base_class.all.each do |node|
+        # ... set its ancestry to nil if invalid
+        if node.errors[node.class.ancestry_column].blank?
+          node.without_ancestry_callbacks do
+            node.update_attribute node.ancestry_column, nil
+          end
+        end
+        # ... save parent of this node in parents array if it exists
+        parents[node.id] = node.parent_id if exists? node.parent_id
+
+        # Reset parent id in array to nil if it introduces a cycle
+        parent = parents[node.id]
+        until parent.nil? || parent == node.id
+          parent = parents[parent]
+        end
+        parents[node.id] = nil if parent == node.id 
+      end
+      # For each node ...
+      self.base_class.all.each do |node|
+        # ... rebuild ancestry from parents array
+        ancestry, parent = nil, parents[node.id]
+        until parent.nil?
+          ancestry, parent = if ancestry.nil? then parent else "#{parent}/#{ancestry}" end, parents[parent]
+        end
+        node.without_ancestry_callbacks do
+          node.update_attribute node.ancestry_column, 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.base_class.all(:conditions => {self.base_class.parent_column => parent_id}).each do |node|
+        node.without_ancestry_callbacks do
+          node.update_attribute ancestry_column, ancestry
+        end
+        build_ancestry_from_parent_ids! node.id, if ancestry.nil? then "#{node.id}" else "#{ancestry}/#{node.id}" 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.base_class.all.each do |node|
+        node.update_attribute depth_cache_column, node.depth
+      end
+    end
+  end
+end

data/lib/ancestry/exceptions.rb

@@ -0,0 +1,7 @@
+module Ancestry
+  class AncestryException < RuntimeError
+  end
+
+  class AncestryIntegrityException < AncestryException
+  end
+end

data/lib/ancestry/has_ancestry.rb

@@ -0,0 +1,93 @@
+require 'ancestry/class_methods'
+require 'ancestry/instance_methods'
+require 'ancestry/exceptions'
+
+class << ActiveRecord::Base
+  def has_ancestry options = {}
+    # 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, :parent_column, :orphan_strategy, :cache_depth, :depth_cache_column, :primary_key_format].include? key
+        raise Ancestry::AncestryException.new("Unknown option for has_ancestry: #{key.inspect} => #{value.inspect}.")
+      end
+    end
+    
+    # Include instance methods
+    include Ancestry::InstanceMethods
+
+    # Include dynamic class methods
+    extend Ancestry::ClassMethods
+
+    # Create ancestry column accessor and set to option or default
+    cattr_accessor :ancestry_column
+    self.ancestry_column = options[:ancestry_column] || :ancestry
+    #
+    # Create parent column accessor and set to option or default
+    cattr_accessor :parent_column
+    self.parent_column = options[:parent_column] || :parent_id
+
+    # Create orphan strategy accessor and set to option or default (writer comes from DynamicClassMethods)
+    cattr_reader :orphan_strategy
+    self.orphan_strategy = options[:orphan_strategy] || :destroy
+
+    # Save self as base class (for STI)
+    cattr_accessor :base_class
+    self.base_class = self
+    
+    # Validate format of ancestry column value
+    primary_key_format = options[:primary_key_format] || /[0-9]+/
+    validates_format_of ancestry_column, :with => /\A#{primary_key_format.source}(\/#{primary_key_format.source})*\Z/, :allow_nil => true
+
+    # Validate that the ancestor ids don't include own id
+    validate :ancestry_exclude_self
+    
+    # Save ActiveRecord version
+    self.cattr_accessor :rails_3
+    self.rails_3 = defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::MAJOR >= 3
+    
+    # Workaround to support Rails 2
+    scope_method = if rails_3 then :scope else :named_scope end
+
+    # Named scopes
+    send scope_method, :roots, :conditions => {ancestry_column => nil}
+    send scope_method, :ancestors_of, lambda { |object| {:conditions => to_node(object).ancestor_conditions} }
+    send scope_method, :children_of, lambda { |object| {:conditions => to_node(object).child_conditions} }
+    send scope_method, :descendants_of, lambda { |object| {:conditions => to_node(object).descendant_conditions} }
+    send scope_method, :subtree_of, lambda { |object| {:conditions => to_node(object).subtree_conditions} }
+    send scope_method, :siblings_of, lambda { |object| {:conditions => to_node(object).sibling_conditions} }
+    send scope_method, :ordered_by_ancestry, :order => "(case when #{ancestry_column} is null then 0 else 1 end), #{ancestry_column}"
+    send scope_method, :ordered_by_ancestry_and, lambda { |order| {:order => "(case when #{ancestry_column} is null then 0 else 1 end), #{ancestry_column}, #{order}"} }
+    
+    # Update descendants with new ancestry before save
+    before_save :update_descendants_with_new_ancestry
+
+    # Apply orphan strategy before destroy
+    before_destroy :apply_orphan_strategy
+
+    # Create ancestry column accessor and set to option or default
+    if options[:cache_depth]
+      # Create accessor for column name and set to option or default
+      self.cattr_accessor :depth_cache_column
+      self.depth_cache_column = options[:depth_cache_column] || :ancestry_depth
+
+      # Cache depth in depth cache column before save
+      before_validation :cache_depth
+
+      # 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|
+      send scope_method, scope_name, lambda { |depth|
+        raise Ancestry::AncestryException.new("Named scope '#{scope_name}' is only available when depth caching is enabled.") unless options[:cache_depth]
+        {:conditions => ["#{depth_cache_column} #{operator} ?", depth]}
+      }
+    end
+  end
+  
+  # Alias has_ancestry with acts_as_tree, if it's available.
+  if !respond_to?(:acts_as_tree)
+    alias_method :acts_as_tree, :has_ancestry
+  end
+end

data/lib/ancestry/instance_methods.rb

@@ -0,0 +1,232 @@
+module Ancestry
+  module InstanceMethods
+    # Validate that the ancestors don't include itself
+    def ancestry_exclude_self
+      add_error_to_base "#{self.class.name.humanize} cannot be a descendant of itself." if ancestor_ids.include? self.id
+    end
+
+    # Update descendants with new ancestry
+    def update_descendants_with_new_ancestry
+      # Skip this if callbacks are disabled
+      unless ancestry_callbacks_disabled?
+        # If node is valid, not a new record and ancestry was updated ...
+        if changed.include?(self.base_class.ancestry_column.to_s) && !new_record? && valid?
+          # ... for each descendant ...
+          descendants.each do |descendant|
+            # ... replace old ancestry with new ancestry
+            descendant.without_ancestry_callbacks do
+              descendant.update_attribute(
+                self.base_class.ancestry_column,
+                descendant.read_attribute(descendant.class.ancestry_column).gsub(
+                  /^#{self.child_ancestry}/,
+                  if read_attribute(self.class.ancestry_column).blank? then id.to_s else "#{read_attribute self.class.ancestry_column }/#{id}" end
+                )
+              )
+            end
+          end
+        end
+      end
+    end
+
+    # Apply orphan strategy
+    def apply_orphan_strategy
+      # Skip this if callbacks are disabled
+      unless ancestry_callbacks_disabled?
+        # If this isn't a new record ...
+        unless new_record?
+          # ... make al children root if orphan strategy is rootify
+          if self.base_class.orphan_strategy == :rootify
+            descendants.each do |descendant|
+              descendant.without_ancestry_callbacks do
+                descendant.update_attribute descendant.class.ancestry_column, (if descendant.ancestry == child_ancestry then nil else descendant.ancestry.gsub(/^#{child_ancestry}\//, '') end)
+              end
+            end
+          # ... destroy all descendants if orphan strategy is destroy
+          elsif self.base_class.orphan_strategy == :destroy
+            descendants.all.each do |descendant|
+              descendant.without_ancestry_callbacks do
+                descendant.destroy
+              end
+            end
+          # ... throw an exception if it has children and orphan strategy is restrict
+          elsif self.base_class.orphan_strategy == :restrict
+            raise Ancestry::AncestryException.new('Cannot delete record because it has descendants.') unless is_childless?
+          end
+        end
+      end
+    end
+
+    # The ancestry value for this record's children
+    def child_ancestry
+      # New records cannot have children
+      raise Ancestry::AncestryException.new('No child ancestry for new record. Save record before performing tree operations.') if new_record?
+
+      if self.send("#{self.base_class.ancestry_column}_was").blank? then id.to_s else "#{self.send "#{self.base_class.ancestry_column}_was"}/#{id}" end
+    end
+
+    # Ancestors
+    def ancestor_ids
+      read_attribute(self.base_class.ancestry_column).to_s.split('/').map { |id| cast_primary_key(id) }
+    end
+
+    def ancestor_conditions
+      {self.base_class.primary_key => ancestor_ids}
+    end
+
+    def ancestors depth_options = {}
+      self.base_class.scope_depth(depth_options, depth).ordered_by_ancestry.scoped :conditions => ancestor_conditions
+    end
+
+    def path_ids
+      ancestor_ids + [id]
+    end
+
+    def path_conditions
+      {self.base_class.primary_key => path_ids}
+    end
+
+    def path depth_options = {}
+      self.base_class.scope_depth(depth_options, depth).ordered_by_ancestry.scoped :conditions => path_conditions
+    end
+
+    def depth
+      ancestor_ids.size
+    end
+
+    def cache_depth
+      write_attribute self.base_class.depth_cache_column, depth
+    end
+
+    # Parent
+    def parent= parent
+      write_attribute(self.base_class.ancestry_column, if parent.blank? then nil else parent.child_ancestry end)
+    end
+
+    def parent_id= parent_id
+      self.parent = if parent_id.blank? then nil else self.base_class.find(parent_id) end
+    end
+
+    def parent_id
+      if ancestor_ids.empty? then nil else ancestor_ids.last end
+    end
+
+    def parent
+      if parent_id.blank? then nil else self.base_class.find(parent_id) end
+    end
+
+    # Root
+    def root_id
+      if ancestor_ids.empty? then id else ancestor_ids.first end
+    end
+
+    def root
+      if root_id == id then self else self.base_class.find(root_id) end
+    end
+
+    def is_root?
+      read_attribute(self.base_class.ancestry_column).blank?
+    end
+
+    # Children
+    def child_conditions
+      {self.base_class.ancestry_column => child_ancestry}
+    end
+
+    def children
+      self.base_class.scoped :conditions => child_conditions
+    end
+
+    def child_ids
+      children.all(:select => self.base_class.primary_key).map(&self.base_class.primary_key.to_sym)
+    end
+
+    def has_children?
+      self.children.exists?({})
+    end
+
+    def is_childless?
+      !has_children?
+    end
+
+    # Siblings
+    def sibling_conditions
+      {self.base_class.ancestry_column => read_attribute(self.base_class.ancestry_column)}
+    end
+
+    def siblings
+      self.base_class.scoped :conditions => sibling_conditions
+    end
+
+    def sibling_ids
+       siblings.all(:select => self.base_class.primary_key).collect(&self.base_class.primary_key.to_sym)
+    end
+
+    def has_siblings?
+      self.siblings.count > 1
+    end
+
+    def is_only_child?
+      !has_siblings?
+    end
+
+    # Descendants
+    def descendant_conditions
+      ["#{self.base_class.ancestry_column} like ? or #{self.base_class.ancestry_column} = ?", "#{child_ancestry}/%", child_ancestry]
+    end
+
+    def descendants depth_options = {}
+      self.base_class.ordered_by_ancestry.scope_depth(depth_options, depth).scoped :conditions => descendant_conditions
+    end
+
+    def descendant_ids depth_options = {}
+      descendants(depth_options).all(:select => self.base_class.primary_key).collect(&self.base_class.primary_key.to_sym)
+    end
+
+    # Subtree
+    def subtree_conditions
+      ["#{self.base_class.primary_key} = ? or #{self.base_class.ancestry_column} like ? or #{self.base_class.ancestry_column} = ?", self.id, "#{child_ancestry}/%", child_ancestry]
+    end
+
+    def subtree depth_options = {}
+      self.base_class.ordered_by_ancestry.scope_depth(depth_options, depth).scoped :conditions => subtree_conditions
+    end
+
+    def subtree_ids depth_options = {}
+      subtree(depth_options).all(:select => self.base_class.primary_key).collect(&self.base_class.primary_key.to_sym)
+    end
+
+    # Callback disabling
+    def without_ancestry_callbacks
+      @disable_ancestry_callbacks = true
+      yield
+      @disable_ancestry_callbacks = false
+    end
+
+    def ancestry_callbacks_disabled?
+      !!@disable_ancestry_callbacks
+    end
+
+  private
+
+    # Workaround to support Rails 2
+    def add_error_to_base error
+      if rails_3
+        errors[:base] << error
+      else
+        errors.add_to_base error
+      end
+    end
+
+    def cast_primary_key(key)
+      if primary_key_type == :string
+        key
+      else
+        key.to_i
+      end
+    end
+
+    def primary_key_type
+      @primary_key_type ||= column_for_attribute(self.class.primary_key).type
+    end
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: kamal-ancestry
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 2
+  - 4
+  version: 1.2.4
+platform: ruby
+authors: 
+- Stefan Kroes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-31 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 2
+        - 2
+        version: 2.2.2
+  type: :runtime
+  version_requirements: *id001
+description: Organise ActiveRecord model into a tree structure
+email: s.a.kroes@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+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
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/stefankroes/ancestry
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+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.
+test_files: []
+