Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Version 1.2.0

  • Loading branch information...
commit ecea76f4c02582f5224efb8f3b3391ed1b8bad1c 1 parent 6e03a82
@stefankroes stefankroes authored
View
39 README.rdoc
@@ -21,10 +21,14 @@ To apply Ancestry to any ActiveRecord model, follow these simple steps:
- Migrate your database: <b>rake db:migrate</b>
3. Add ancestry to your model
- - Add to app/models/[model].rb: <b>acts_as_tree</b>
+ - 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:
@@ -62,9 +66,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 acts_as_tree
+= Options for has_ancestry
-The acts_as_tree methods supports the following options:
+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:
@@ -91,6 +95,7 @@ For convenience, a couple of named scopes are included at the class level:
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:
@@ -102,7 +107,7 @@ Thanks to some convenient rails magic, it is even possible to create nodes throu
= Selecting nodes by depth
-When depth caching is enabled (see acts_as_tree options), five more named scopes can be used to select nodes on their 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)
@@ -146,9 +151,13 @@ 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 (acts_as_tree, 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:
+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>./script/generate migration add_ancestry_to_[table] ancestry:string</b>
@@ -163,7 +172,7 @@ Most current tree plugins use a parent_id column (acts_as_tree, awesome_nested_s
3. Change your model
- Remove any macros required by old plugin/gem from app/models/[model].rb
- - Add to app/models/[model].rb: <b>acts_as_tree</b>
+ - 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>
@@ -206,7 +215,7 @@ 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, install Ancestry as a plugin into a Rails application, go to the ancestry folder and type 'rake'. The test suite is located in 'test/acts_as_tree_test.rb'.
+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, install Ancestry as a plugin into a Rails application, go to the ancestry folder and type 'rake'. The test suite is located in 'test/has_ancestry_test.rb'.
= Internals
@@ -218,8 +227,18 @@ The materialised path pattern requires Ancestry to use a 'like' condition in ord
= Version history
-The latest and recommended version of ancestry is 1.1.4. 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.
-
+The latest and recommended version of ancestry is 1.2.0. 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.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)
@@ -248,7 +267,7 @@ The latest and recommended version of ancestry is 1.1.4. The three numbers of ea
- 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 appliction, this change is not considered as breaking backwards compatibility and the major version wasn't bumped.
+ - 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
View
4 ancestry.gemspec
@@ -5,8 +5,8 @@ Gem::Specification.new do |s|
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.1.4'
- s.date = '2009-11-07'
+ s.version = '1.2.0'
+ s.date = '2010-01-27'
s.author = 'Stefan Kroes'
s.email = 's.a.kroes@gmail.com'
View
2  lib/ancestry.rb
@@ -1 +1 @@
-require 'ancestry/acts_as_tree'
+require 'ancestry/has_ancestry'
View
426 lib/ancestry/acts_as_tree.rb
@@ -1,426 +0,0 @@
-module Ancestry
- class AncestryException < RuntimeError
- end
-
- class AncestryIntegrityException < AncestryException
- end
-
- def self.included base
- base.send :extend, ClassMethods
- end
-
- module ClassMethods
- def acts_as_tree options = {}
- # Check options
- raise AncestryException.new("Options for acts_as_tree 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
- raise AncestryException.new("Unknown option for acts_as_tree: #{key.inspect} => #{value.inspect}.")
- end
- end
-
- # Include instance methods
- send :include, InstanceMethods
-
- # Include dynamic class methods
- send :extend, DynamicClassMethods
-
- # Create ancestry column accessor and set to option or default
- self.cattr_accessor :ancestry_column
- self.ancestry_column = options[:ancestry_column] || :ancestry
-
- # Create orphan strategy accessor and set to option or default (writer comes from DynamicClassMethods)
- self.cattr_reader :orphan_strategy
- self.orphan_strategy = options[:orphan_strategy] || :destroy
-
- # Save self as base class (for STI)
- self.cattr_accessor :base_class
- self.base_class = self
-
- # Validate format of ancestry column value
- validates_format_of ancestry_column, :with => /\A[0-9]+(\/[0-9]+)*\Z/, :allow_nil => true
-
- # Validate that the ancestor ids don't include own id
- validate :ancestry_exclude_self
-
- # Named scopes
- named_scope :roots, :conditions => {ancestry_column => nil}
- named_scope :ancestors_of, lambda { |object| {:conditions => to_node(object).ancestor_conditions} }
- named_scope :children_of, lambda { |object| {:conditions => to_node(object).child_conditions} }
- named_scope :descendants_of, lambda { |object| {:conditions => to_node(object).descendant_conditions} }
- named_scope :siblings_of, lambda { |object| {:conditions => to_node(object).sibling_conditions} }
- named_scope :ordered_by_ancestry, :order => "#{ancestry_column} is not null, #{ancestry_column}"
-
- # 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
- named_scope :before_depth, lambda { |depth|
- raise AncestryException.new("Named scope 'before_depth' is only available when depth caching is enabled.") unless options[:cache_depth]
- {:conditions => ["#{depth_cache_column} < ?", depth]}
- }
- named_scope :to_depth, lambda { |depth|
- raise AncestryException.new("Named scope 'to_depth' is only available when depth caching is enabled.") unless options[:cache_depth]
- {:conditions => ["#{depth_cache_column} <= ?", depth]}
- }
- named_scope :at_depth, lambda { |depth|
- raise AncestryException.new("Named scope 'at_depth' is only available when depth caching is enabled.") unless options[:cache_depth]
- {:conditions => ["#{depth_cache_column} = ?", depth]}
- }
- named_scope :from_depth, lambda { |depth|
- raise AncestryException.new("Named scope 'from_depth' is only available when depth caching is enabled.") unless options[:cache_depth]
- {:conditions => ["#{depth_cache_column} >= ?", depth]}
- }
- named_scope :after_depth, lambda { |depth|
- raise AncestryException.new("Named scope 'after_depth' is only available when depth caching is enabled.") unless options[:cache_depth]
- {:conditions => ["#{depth_cache_column} > ?", depth]}
- }
- end
- end
-
- module DynamicClassMethods
- # 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 AncestryException.new("Invalid orphan strategy, valid ones are :rootify, :restrict and :destroy.")
- end
- end
-
- # Arrangement
- def arrange
- # Get all nodes ordered by ancestry and start sorting them into an empty hash
- self.base_class.ordered_by_ancestry.all.inject({}) 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] = {}; arranged_nodes
- end
- end
-
- # Integrity checking
- def check_ancestry_integrity!
- parents = {}
- # For each node ...
- self.base_class.all.each do |node|
- # ... check validity of ancestry column
- if !node.valid? and node.errors.invalid?(node.class.ancestry_column)
- raise 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 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 AncestryIntegrityException.new("Conflicting parent id in node #{node.id}: #{parent_id || 'nil'} for node #{node_id}, expecting #{parents[node_id] || 'nil'}")
- end
- end
- end
- 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.invalid? node.class.ancestry_column
- node.without_ancestry_callbacks do
- node.update_attributes :ancestry => 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_attributes 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 => {:parent_id => 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
-
- module InstanceMethods
- # Validate that the ancestors don't include itself
- def ancestry_exclude_self
- errors.add_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_attributes(
- 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_attributes 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(&:to_i)
- 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
- end
-end
-
-ActiveRecord::Base.send :include, Ancestry
View
127 lib/ancestry/class_methods.rb
@@ -0,0 +1,127 @@
+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({}) 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] = {}; arranged_nodes
+ end
+ end
+
+ # Integrity checking
+ def check_ancestry_integrity!
+ parents = {}
+ # For each node ...
+ self.base_class.all.each do |node|
+ # ... check validity of ancestry column
+ if !node.valid? and node.errors.invalid?(node.class.ancestry_column)
+ 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 in node #{node.id}: #{parent_id || 'nil'} for node #{node_id}, expecting #{parents[node_id] || 'nil'}")
+ end
+ end
+ end
+ 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.invalid? node.class.ancestry_column
+ node.without_ancestry_callbacks do
+ node.update_attributes :ancestry => 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_attributes 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 => {:parent_id => 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
View
7 lib/ancestry/exceptions.rb
@@ -0,0 +1,7 @@
+module Ancestry
+ class AncestryException < RuntimeError
+ end
+
+ class AncestryIntegrityException < AncestryException
+ end
+end
View
81 lib/ancestry/has_ancestry.rb
@@ -0,0 +1,81 @@
+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, :orphan_strategy, :cache_depth, :depth_cache_column].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 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
+ validates_format_of ancestry_column, :with => /\A[0-9]+(\/[0-9]+)*\Z/, :allow_nil => true
+
+ # Validate that the ancestor ids don't include own id
+ validate :ancestry_exclude_self
+
+ # Named scopes
+ named_scope :roots, :conditions => {ancestry_column => nil}
+ named_scope :ancestors_of, lambda { |object| {:conditions => to_node(object).ancestor_conditions} }
+ named_scope :children_of, lambda { |object| {:conditions => to_node(object).child_conditions} }
+ named_scope :descendants_of, lambda { |object| {:conditions => to_node(object).descendant_conditions} }
+ named_scope :subtree_of, lambda { |object| {:conditions => to_node(object).subtree_conditions} }
+ named_scope :siblings_of, lambda { |object| {:conditions => to_node(object).sibling_conditions} }
+ named_scope :ordered_by_ancestry, :order => "(case when #{ancestry_column} is null then 0 else 1 end), #{ancestry_column}"
+ named_scope :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|
+ named_scope 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
View
209 lib/ancestry/instance_methods.rb
@@ -0,0 +1,209 @@
+module Ancestry
+ module InstanceMethods
+ # Validate that the ancestors don't include itself
+ def ancestry_exclude_self
+ errors.add_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_attributes(
+ 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_attributes 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(&:to_i)
+ 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
+ end
+end
View
53 test/acts_as_tree_test.rb → test/has_ancestry_test.rb
@@ -1,11 +1,17 @@
require File.dirname(__FILE__) + '/test_helper.rb'
+# Setup the required models for all test cases
+
class TestNode < ActiveRecord::Base
- acts_as_tree :cache_depth => true, :depth_cache_column => :depth_cache
+ has_ancestry :cache_depth => true, :depth_cache_column => :depth_cache
end
class AlternativeTestNode < ActiveRecord::Base
- acts_as_tree :ancestry_column => :alternative_ancestry, :orphan_strategy => :rootify
+ has_ancestry :ancestry_column => :alternative_ancestry, :orphan_strategy => :rootify
+end
+
+class ActsAsTreeTestNode < ActiveRecord::Base
+ acts_as_tree
end
class ParentIdTestNode < ActiveRecord::Base
@@ -71,7 +77,7 @@ def test_setting_invalid_orphan_strategy
end
def test_setup_test_nodes
- [TestNode, AlternativeTestNode].each do |model|
+ [TestNode, AlternativeTestNode, ActsAsTreeTestNode].each do |model|
roots = setup_test_nodes model, 3, 3
assert_equal Array, roots.class
assert_equal 3, roots.length
@@ -211,6 +217,9 @@ def test_named_scopes
# Assertions for descendants_of named scope
assert_equal test_node.descendants, TestNode.descendants_of(test_node)
assert_equal test_node.descendants, TestNode.descendants_of(test_node.id)
+ # Assertions for subtree_of named scope
+ assert_equal test_node.subtree, TestNode.subtree_of(test_node)
+ assert_equal test_node.subtree, TestNode.subtree_of(test_node.id)
# Assertions for siblings_of named scope
assert_equal test_node.siblings, TestNode.siblings_of(test_node)
assert_equal test_node.siblings, TestNode.siblings_of(test_node.id)
@@ -427,12 +436,12 @@ def test_depth_scopes_unavailable
end
end
- def test_invalid_acts_as_tree_options
+ def test_invalid_has_ancestry_options
assert_raise Ancestry::AncestryException do
- Class.new(ActiveRecord::Base).acts_as_tree :this_option_doesnt_exist => 42
+ Class.new(ActiveRecord::Base).has_ancestry :this_option_doesnt_exist => 42
end
assert_raise Ancestry::AncestryException do
- Class.new(ActiveRecord::Base).acts_as_tree :not_a_hash
+ Class.new(ActiveRecord::Base).has_ancestry :not_a_hash
end
end
@@ -448,7 +457,7 @@ def test_build_ancestry_from_parent_ids
# Assert all nodes where created
assert_equal 156, ParentIdTestNode.count
- ParentIdTestNode.acts_as_tree
+ ParentIdTestNode.has_ancestry
ParentIdTestNode.build_ancestry_from_parent_ids!
# Assert ancestry integirty
@@ -477,7 +486,7 @@ def test_build_ancestry_from_parent_ids
def test_rebuild_depth_cache
setup_test_nodes TestNode, 3, 3
- TestNode.find_by_sql("update test_nodes set depth_cache = null;")
+ TestNode.connection.execute("update test_nodes set depth_cache = null;")
# Assert cache was emptied correctly
TestNode.all.each do |test_node|
@@ -568,4 +577,32 @@ def test_sti_support
assert_equal [node1, node2, node3, node4], node5.ancestors
assert_equal [node1, node2, node3, node4, node5], node5.path
end
+
+ def test_arrange_order_option
+ # In Ruby versions before 1.9 hashes aren't ordered so this doesn't make sense
+ unless RUBY_VERSION =~ /^1\.8/
+ roots = setup_test_nodes TestNode, 3, 3
+ descending_nodes_lvl0 = TestNode.arrange :order => 'id desc'
+ ascending_nodes_lvl0 = TestNode.arrange :order => 'id asc'
+
+ descending_nodes_lvl0.keys.zip(ascending_nodes_lvl0.keys.reverse).each do |descending_node, ascending_node|
+ assert_equal descending_node, ascending_node
+ descending_nodes_lvl1 = descending_nodes_lvl0[descending_node]
+ ascending_nodes_lvl1 = ascending_nodes_lvl0[ascending_node]
+ descending_nodes_lvl1.keys.zip(ascending_nodes_lvl1.keys.reverse).each do |descending_node, ascending_node|
+ assert_equal descending_node, ascending_node
+ descending_nodes_lvl2 = descending_nodes_lvl1[descending_node]
+ ascending_nodes_lvl2 = ascending_nodes_lvl1[ascending_node]
+ descending_nodes_lvl2.keys.zip(ascending_nodes_lvl2.keys.reverse).each do |descending_node, ascending_node|
+ assert_equal descending_node, ascending_node
+ descending_nodes_lvl3 = descending_nodes_lvl2[descending_node]
+ ascending_nodes_lvl3 = ascending_nodes_lvl2[ascending_node]
+ descending_nodes_lvl3.keys.zip(ascending_nodes_lvl3.keys.reverse).each do |descending_node, ascending_node|
+ assert_equal descending_node, ascending_node
+ end
+ end
+ end
+ end
+ end
+ end
end
View
4 test/schema.rb
@@ -17,4 +17,8 @@
t.string :ancestry
t.integer :parent_id
end
+
+ create_table :acts_as_tree_test_nodes, :force => true do |t|
+ t.string :ancestry
+ end
end
Please sign in to comment.
Something went wrong with that request. Please try again.