acts_as_ordered_tree 0.0.7 → 1.0.3

data/.gitignore

@@ -2,3 +2,7 @@
 .bundle
 Gemfile.lock
 pkg/*
+.idea/*
+coverage/*
+.rbx/*
+gemfiles/*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Appraisals

@@ -0,0 +1,11 @@
+appraise "rails3.0" do
+  gem "activerecord", "~> 3.0.0"
+end
+
+appraise "rails3.1" do
+  gem "activerecord", "~> 3.1.0"
+end
+
+appraise "rails3.2" do
+  gem "activerecord", "~> 3.2.0"
+end

data/Gemfile

@@ -1,4 +1,8 @@
 source "http://rubygems.org"
 
 # Specify your gem's dependencies in acts_as_ordered_tree.gemspec
-gemspec
+gemspec
+
+gem "sqlite3", :platforms => :ruby
+gem "activerecord-jdbcsqlite3-adapter", :platforms => :jruby
+gem "simplecov", :platform => :ruby_19

data/README.md

@@ -1,12 +1,12 @@
 # Acts As Ordered Tree
 WARNING! THIS GEM IS NOT COMPATIBLE WITH <a href="http://ordered-tree.rubyforge.org">ordered_tree gem</a>.
 
-Specify this `acts_as` extension if you want to model an ordered tree structure by providing a parent association, a children
-association and a sort column. For proper use you should have a foreign key column, which by default is called `parent_id`, and
-a sort column, which by default is called `position`.
+Specify this `acts_as` extension if you want to model an ordered tree structure ([adjacency list hierarchical structure](http://www.sqlsummit.com/AdjacencyList.htm)) by providing a parent association, a children association and a sort column. For proper use you should have a foreign key column, which by default is called `parent_id`, and a sort column, which is by default called `position`.
+
+This extension is mostly compatible with [`awesome_nested_set`](https://github.com/collectiveidea/awesome_nested_set/) gem
 
 ## Requirements
-Gem depends on `active_record >= 3`.
+Gem depends on `active_record >= 3`. We test it with `rails-3.0`, `rails-3.1`, `rails-3.2` and with `ruby-1.9.3`, `ruby-1.9.2`, `ruby-1.8.7`, `jruby-1.6.7` and `rubinius-2.0`.
 
 ## Installation
 Install it via rubygems:
@@ -15,12 +15,32 @@ Install it via rubygems:
 gem install acts_as_ordered_tree
 ```
 
-Gem depends on `acts_as_tree` and `acts_as_list` gems.
+## Usage
+
+To make use of `acts_as_ordered_tree`, your model needs to have 2 fields: parent_id and position. You can also have an optional fields: depth and children_count:
+```ruby
+class CreateCategories < ActiveRecord::Migration
+  def self.up
+    create_table :categories do |t|
+      t.integer :company_id
+      t.string  :name
+      t.integer :parent_id # this is mandatory
+      t.integer :position # this is mandatory
+      t.integer :depth # this is optional
+      t.integer :children_count # this is optional
+    end
+  end
+
+  def self.down
+    drop_table :categories
+  end
+end
+```
 
 Setup your model:
 
 ```ruby
-class Node < ActiveRecord::Base
+class Category < ActiveRecord::Base
   acts_as_ordered_tree
 
   # gem introduces new ActiveRecord callbacks:
@@ -31,7 +51,8 @@ class Node < ActiveRecord::Base
 end
 ```
 
-## Example
+Now you can use `acts_as_ordered_tree` features:
+
 ```ruby
 # root
 #  \_ child1
@@ -39,12 +60,12 @@ end
 #       \_ subchild2
 
 
-root = Node.create(:name => "root")
+root = Category.create(:name => "root")
 child1 = root.children.create(:name => "child1")
 subchild1 = child1.children.create("name" => "subchild1")
 subchild2 = child1.children.create("name" => "subchild2")
 
-Node.roots # => [root]
+Category.roots # => [root]
 
 root.root? # => true
 root.parent # => nil
@@ -70,4 +91,17 @@ subchild1.move_to_bottom_of(child1)
 subchild1.move_to_child_of(root)
 subchild1.move_lower
 subchild1.move_higher
-```
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## TODO
+1. Fix README typos and grammatical errors (english speaking contributors are welcomed)
+2. Add moar examples and docs.
+3. Implement converter from other structures (nested_set, closure_tree)

data/Rakefile

@@ -1 +1,5 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "appraisal"
+
+RSpec::Core::RakeTask.new(:spec)

data/acts_as_ordered_tree.gemspec

@@ -5,8 +5,8 @@ require "acts_as_ordered_tree/version"
 Gem::Specification.new do |s|
   s.name        = "acts_as_ordered_tree"
   s.version     = ActsAsOrderedTree::VERSION
-  s.authors     = ["Alexei Mikhailov"]
-  s.email       = ["amikhailov83@gmail.com"]
+  s.authors     = ["Alexei Mikhailov", "Vladimir Kuznetsov"]
+  s.email       = %w(amikhailov83@gmail.com kv86@mail.ru)
   s.homepage    = "https://github.com/take-five/acts_as_ordered_tree"
   s.summary     = %q{ActiveRecord extension for sorted adjacency lists support}
 
@@ -15,15 +15,16 @@ Gem::Specification.new do |s|
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.require_paths = %w(lib)
 
-  s.add_dependency "activesupport", "~> 3"
-  s.add_dependency "activerecord", "~> 3"
-  s.add_dependency "acts_as_tree", "~> 0.1"
-  s.add_dependency "acts_as_list", "~> 0.1"
+  s.add_dependency "activerecord", ">= 3.0.0"
 
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "simplecov"
-  s.add_development_dependency "sqlite3"
-  s.add_development_dependency "bundler"
+  s.add_development_dependency "bundler", ">= 1.0"
+  s.add_development_dependency "rails", ">= 3.0.0"
+  s.add_development_dependency "rspec", ">= 2.11"
+  s.add_development_dependency "rspec-rails", ">= 2.11"
+  s.add_development_dependency "shoulda-matchers", ">= 1.2.0"
+  s.add_development_dependency "factory_girl", "< 3"
+  s.add_development_dependency "factory_girl_rails", "< 3"
+  s.add_development_dependency "appraisal", ">= 0.4.0"
 end

data/lib/acts_as_ordered_tree.rb

@@ -1,52 +1,117 @@
-require "enumerator"
-
 require "active_record"
-require "acts_as_list"
-require "acts_as_tree"
-
 require "acts_as_ordered_tree/version"
-require "acts_as_ordered_tree/iterator"
-require "acts_as_ordered_tree/tree"
-require "acts_as_ordered_tree/list"
+require "acts_as_ordered_tree/class_methods"
+require "acts_as_ordered_tree/fake_scope"
+require "acts_as_ordered_tree/instance_methods"
+require "acts_as_ordered_tree/validators"
 
 module ActsAsOrderedTree
+  # == Usage
+  #   class Category < ActiveRecord::Base
+  #     acts_as_ordered_tree :parent_column => :parent_id,
+  #                          :position_column => :position,
+  #                          :depth_column => :depth,
+  #                          :counter_cache => :children_count
+  #   end
   def acts_as_ordered_tree(options = {})
-    configuration = configure_ordered_tree(options)
+    options = {
+      :parent_column   => :parent_id,
+      :position_column => :position,
+      :depth_column    => :depth
+    }.merge(options)
+
+    class_attribute :acts_as_ordered_tree_options, :instance_writer => false
+    self.acts_as_ordered_tree_options = options
+
+    acts_as_ordered_tree_options[:depth_column] = nil unless
+        columns_hash.include?(acts_as_ordered_tree_options[:depth_column].to_s)
+
+    extend  Columns
+    include Columns
+
+    has_many_children_options = {
+      :class_name    => name,
+      :foreign_key   => options[:parent_column],
+      :order         => options[:position_column],
+      :inverse_of    => (:parent unless options[:polymorphic])
+    }
+
+    [:before_add, :after_add, :before_remove, :after_remove].each do |callback|
+      has_many_children_options[callback] = options[callback] if options.key?(callback)
+    end
+
+    if scope_column_names.any?
+      has_many_children_options[:conditions] = proc do
+        [scope_column_names.map { |c| "#{c} = ?" }.join(' AND '),
+         scope_column_names.map { |c| self[c] }]
+      end
+    end
+
+    # create associations
+    has_many   :children, has_many_children_options
+    belongs_to :parent,
+               :class_name => name,
+               :foreign_key => options[:parent_column],
+               :counter_cache => options[:counter_cache],
+               :inverse_of => (:children unless options[:polymorphic])
+
+    define_model_callbacks :move, :reorder
+
+    include ClassMethods
+    include InstanceMethods
+
+    # protect position&depth from mass-assignment
+    attr_protected depth_column, position_column
+
+    if depth_column
+      before_create :set_depth!
+      before_save   :set_depth!, :if => "#{parent_column}_changed?".to_sym
+      around_move   :update_descendants_depth
+    end
+
+    if children_counter_cache_column
+      around_move :update_counter_cache
+    end
 
-    acts_as_tree :foreign_key => parent_column,
-                 :order => position_column,
-                 :counter_cache => configuration[:counter_cache]
+    unless scope_column_names.empty?
+      before_save :set_scope!, :unless => :root?
+      validates_with Validators::ScopeValidator, :on => :update, :unless => :root?
+    end
 
-    acts_as_list :column => position_column,
-                 :scope => parent_column
+    after_save :move_to_root, :unless => [position_column, parent_column]
+    after_save 'move_to_child_of(parent)', :if => parent_column, :unless => position_column
+    after_save "move_to_child_with_index(parent, #{position_column})",
+               :if => "#{position_column} && (#{position_column}_changed? || #{parent_column}_changed?)"
 
-    # acts_as_tree creates ugly associations
-    # patch them
-    children = reflect_on_association :children
-    children.options[:order] = quoted_position_column
+    before_destroy :destroy_descendants
+    after_destroy "decrement_lower_positions(#{parent_column}_was, #{position_column}_was)", :if => position_column
 
-    include ActsAsOrderedTree::Tree
-    include ActsAsOrderedTree::List
+    # setup validations
+    validates_with Validators::CyclicReferenceValidator, :on => :update, :if => :parent
   end # def acts_as_ordered_tree
 
-  private
-  # Add ordered_tree configuration readers
-  def configure_ordered_tree(options = {}) #:nodoc:
-    configuration = { :foreign_key  => :parent_id ,
-                      :order        => :position  }
-    configuration.update(options) if options.is_a?(Hash)
+  # Mixed into both classes and instances to provide easy access to the column names
+  module Columns
+    def parent_column
+      acts_as_ordered_tree_options[:parent_column]
+    end
 
-    class_attribute :parent_column, :position_column
+    def position_column
+      acts_as_ordered_tree_options[:position_column]
+    end
 
-    self.parent_column   = configuration[:foreign_key].to_sym
-    self.position_column = configuration[:order].to_sym
+    def depth_column
+      acts_as_ordered_tree_options[:depth_column] || nil
+    end
 
-    configuration
-  end # def configure_ordered_tree
+    def children_counter_cache_column
+      acts_as_ordered_tree_options[:counter_cache] || nil
+    end
 
-  def quoted_position_column #:nodoc:
-    [quoted_table_name, connection.quote_column_name(position_column)].join('.')
-  end # def quoted_position_column
+    def scope_column_names
+      Array(acts_as_ordered_tree_options[:scope]).compact
+    end
+  end
 end # module ActsAsOrderedTree
 
 ActiveRecord::Base.extend(ActsAsOrderedTree)

data/lib/acts_as_ordered_tree/class_methods.rb

@@ -0,0 +1,29 @@
+module ActsAsOrderedTree
+  module ClassMethods
+    extend ActiveSupport::Concern
+
+    included do
+      scope :preorder, order(arel_table[position_column].asc)
+      scope :roots, where(arel_table[parent_column].eq(nil)).preorder
+
+      # add +leaves+ scope only if counter_cache column present
+      scope :leaves, where(arel_table[children_counter_cache_column].eq(0)) if
+          children_counter_cache?
+
+      # when default value for counter_cache is absent we should set it manually
+      before_create "self.#{children_counter_cache_column} = 0" if children_counter_cache?
+    end
+
+    module ClassMethods
+      # Returns the first root
+      def root
+        roots.first
+      end
+
+      private
+      def children_counter_cache? #:nodoc:
+        children_counter_cache_column && columns_hash.key?(children_counter_cache_column.to_s)
+      end
+    end # module ClassMethods
+  end # module ClassMethods
+end # module ActsAsOrderedTree

data/lib/acts_as_ordered_tree/fake_scope.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+module ActsAsOrderedTree
+  class FakeScope < ActiveRecord::Relation
+    # create fake relation, with loaded records
+    #
+    # == Usage
+    #   FakeScope.new(Category.where(:id => 1), [record])
+    #   FakeScope.new(Category, [record]) { where(:id => 1) }
+    #   FakeScope.new(Category, [record], :where => {:id => 1}, :order => "id desc")
+    def initialize(relation, records, conditions = {})
+      relation = relation.scoped if relation.is_a?(Class)
+
+      conditions.each do |method, arg|
+        relation = relation.send(method, arg)
+      end
+
+      super(relation.klass, relation.table)
+
+      # copy instance variables from real relation
+      relation.instance_variables.each do |ivar|
+        instance_variable_set(ivar, relation.instance_variable_get(ivar))
+      end
+
+      @loaded  = true
+      @records = records
+    end
+  end
+end

data/lib/acts_as_ordered_tree/instance_methods.rb

@@ -0,0 +1,375 @@
+# coding: utf-8
+module ActsAsOrderedTree
+  module InstanceMethods
+    extend ActiveSupport::Concern
+
+    # Returns true if this is a root node.
+    def root?
+      self[parent_column].nil?
+    end
+
+    # Returns true if this is the end of a branch.
+    def leaf?
+      persisted? && if children_counter_cache_column
+        self[children_counter_cache_column] == 0
+      else
+        children.count == 0
+      end
+    end
+
+    def branch?
+      !leaf?
+    end
+
+    # Returns true is this is a child node
+    def child?
+      !root?
+    end
+
+    # Returns root (not really fast operation)
+    def root
+      root? ? self : parent.root
+    end
+
+    # Returns the array of all parents and self starting from root
+    def self_and_ancestors
+      # 1. recursively load ancestors
+      nodes = []
+      node = self
+
+      while node
+        nodes << node
+        node = node.parent
+      end
+
+      # 2. first ancestor is a root
+      nodes.reverse!
+
+      # 3. create fake scope
+      ActsAsOrderedTree::FakeScope.new(self.class, nodes, :where => {:id => nodes.map(&:id)})
+    end
+
+    # Returns the array of all parents starting from root
+    def ancestors
+      records = self_and_ancestors - [self]
+
+      scope = self_and_ancestors.where(arel[:id].not_eq(id))
+      ActsAsOrderedTree::FakeScope.new(scope, records)
+    end
+
+    # Returns the array of all children of the parent, including self
+    def self_and_siblings
+      ordered_tree_scope.where(parent_column => self[parent_column])
+    end
+
+    # Returns the array of all children of the parent, except self
+    def siblings
+      self_and_siblings.where(arel[:id].not_eq(id))
+    end
+
+    def level
+      if depth_column
+        # cached result becomes invalid when parent is changed
+        if new_record? ||
+            changed_attributes.include?(parent_column.to_s) ||
+            self[depth_column].blank?
+          self[depth_column] = compute_level
+        else
+          self[depth_column]
+        end
+      else
+        compute_level
+      end
+    end
+
+    # Returns a set of all of its children and nested children.
+    # A little bit tricky. use RDBMS with recursive queries support (PostgreSQL)
+    def descendants
+      records = fetch_self_and_descendants - [self]
+
+      ActsAsOrderedTree::FakeScope.new self.class, records, :where => {:id => records.map(&:id)}
+    end
+
+    # Returns a set of itself and all of its nested children
+    def self_and_descendants
+      records = fetch_self_and_descendants
+
+      ActsAsOrderedTree::FakeScope.new self.class, records, :where => {:id => records.map(&:id)}
+    end
+
+    def is_descendant_of?(other)
+      ancestors.include? other
+    end
+
+    def is_or_is_descendant_of?(other)
+      self == other || is_descendant_of?(other)
+    end
+
+    def is_ancestor_of?(other)
+      other.is_descendant_of? self
+    end
+
+    def is_or_is_ancestor_of?(other)
+      other.is_or_is_descendant_of? self
+    end
+
+    # Return +true+ if this object is the first in the list.
+    def first?
+      self[position_column] <= 1
+    end
+
+    # Return +true+ if this object is the last in the list.
+    def last?
+      !right_sibling
+    end
+
+    # Returns a left (upper) sibling of the node
+    def left_sibling
+      siblings.
+          where( arel[position_column].lt(self[position_column]) ).
+          reorder( arel[position_column].desc ).
+          first
+    end
+    alias higher_item left_sibling
+
+    # Returns a right (lower) sibling of the node
+    def right_sibling
+      siblings.
+          where( arel[position_column].gt(self[position_column]) ).
+          reorder( arel[position_column].asc ).
+          first
+    end
+    alias lower_item right_sibling
+
+    # Insert the item at the given position (defaults to the top position of 1).
+    # +acts_as_list+ compatability
+    def insert_at(position = 1)
+      move_to_child_with_index(parent, position - 1)
+    end
+
+    # Shorthand method for finding the left sibling and moving to the left of it.
+    def move_left
+      move_to_left_of left_sibling
+    end
+    alias move_higher move_left
+
+    # Shorthand method for finding the right sibling and moving to the right of it.
+    def move_right
+      move_to_right_of right_sibling
+    end
+    alias move_lower move_right
+
+    # Move the node to the left of another node
+    def move_to_left_of(node)
+      move_to node, :left
+    end
+    alias move_to_above_of move_to_left_of
+
+    # Move the node to the left of another node
+    def move_to_right_of(node)
+      move_to node, :right
+    end
+    alias move_to_bottom_of move_to_right_of
+
+    # Move the node to the child of another node
+    def move_to_child_of(node)
+      move_to node, :child
+    end
+
+    # Move the node to the child of another node with specify index
+    def move_to_child_with_index(node, index)
+      raise ActiveRecord::ActiveRecordError, "index cant be nil" unless index
+      new_siblings = node.try(:children) || self.class.roots.delete_if { |root_node| root_node == self }
+
+      if new_siblings.empty?
+        node ? move_to_child_of(node) : move_to_root
+      elsif new_siblings.count <= index
+        move_to_right_of(new_siblings.last)
+      elsif
+        index >= 0 ? move_to_left_of(new_siblings[index]) : move_to_right_of(new_siblings[index])
+      end
+    end
+
+    # Move the node to root nodes
+    def move_to_root
+      move_to nil, :root
+    end
+
+    # Returns +true+ it is possible to move node to left/right/child of +target+
+    def move_possible?(target)
+      same_scope?(target) && !is_or_is_ancestor_of?(target)
+    end
+
+    # Check if other model is in the same scope
+    def same_scope?(other)
+      scope_column_names.empty? || scope_column_names.all? do |attr|
+        self[attr] == other[attr]
+      end
+    end
+
+    private
+    # reloads relevant ordered_tree columns
+    def reload_node #:nodoc:
+      reload(
+        :select => [parent_column,
+                    position_column,
+                    depth_column,
+                    children_counter_cache_column].compact,
+        :lock => true
+      )
+    end
+
+    def compute_level #:nodoc:
+      ancestors.count
+    end
+
+    def compute_ordered_tree_columns(target, pos) #:nodoc:
+      case pos
+        when :root  then
+          parent_id = nil
+          position = if root? && self[position_column]
+            # already root node
+            self[position_column]
+          else
+            ordered_tree_scope.roots.maximum(position_column).try(:succ) || 1
+          end
+          depth = 0
+        when :left  then
+          parent_id = target[parent_column]
+          position = target[position_column]
+          position -= 1 if target[parent_column] == send("#{parent_column}_was") && target[position_column] > position_was # right
+          depth = target.level
+        when :right then
+          parent_id = target[parent_column]
+          position = target[position_column]
+          position += 1 if target[parent_column] != send("#{parent_column}_was") || target[position_column] < position_was # left
+          depth = target.level
+        when :child then
+          parent_id = target.id
+          position = if self[parent_column] == parent_id && self[position_column]
+            # already children of target node
+            self[position_column]
+          else
+            target.children.maximum(position_column).try(:succ) || 1
+          end
+          depth = target.level + 1
+        else raise ActiveRecord::ActiveRecordError, "Position should be :child, :left, :right or :root ('#{pos}' received)."
+      end
+      return parent_id, position, depth
+    end
+
+    # This method do real node movements
+    def move_to(target, pos) #:nodoc:
+      if target.is_a? self.class.base_class
+        target.reload
+      elsif pos != :root && target
+        # load object if node is not an object
+        target = self.class.find(target)
+      end
+
+      unless pos == :root || target && move_possible?(target)
+        raise ActiveRecord::ActiveRecordError, "Impossible move"
+      end
+
+      position_was = send "#{position_column}_was".intern
+      parent_id_was = send "#{parent_column}_was".intern
+      parent_id, position, depth = compute_ordered_tree_columns(target, pos)
+
+      # nothing changed - quit
+      return if parent_id == parent_id_was && position == position_was
+
+      update = proc do
+        decrement_lower_positions parent_id_was, position_was if position_was
+        increment_lower_positions parent_id, position
+
+        columns = {parent_column => parent_id, position_column => position}
+        columns[depth_column] = depth if depth_column
+
+        ordered_tree_scope.update_all(columns, :id => id)
+        reload_node
+      end
+
+      move_kind = case
+        when id_was && parent_id != parent_id_was then :move
+        when id_was && position  != position_was  then :reorder
+        else nil
+      end
+
+      if move_kind
+        run_callbacks move_kind, &update
+      else
+        update.call
+      end
+    end
+
+    def decrement_lower_positions(parent_id, position) #:nodoc:
+      conditions = arel[parent_column].eq(parent_id).and(arel[position_column].gt(position))
+
+      ordered_tree_scope.update_all "#{position_column} = #{position_column} - 1", conditions
+    end
+
+    def increment_lower_positions(parent_id, position) #:nodoc:
+      conditions = arel[parent_column].eq(parent_id).and(arel[position_column].gteq(position))
+
+      ordered_tree_scope.update_all "#{position_column} = #{position_column} + 1", conditions
+    end
+
+    # recursively load descendants
+    def fetch_self_and_descendants #:nodoc:
+      @self_and_descendants ||= [self] + children.map { |child| [child, child.descendants] }.flatten
+    end
+
+    def set_depth! #:nodoc:
+      self[depth_column] = compute_level
+    end
+
+    def set_scope! #:nodoc:
+      scope_column_names.each do |column|
+        self[column] = parent[column]
+      end
+    end
+
+    def destroy_descendants #:nodoc:
+      descendants.delete_all
+      # flush memoization
+      @self_and_descendants = nil
+    end
+
+    def update_descendants_depth #:nodoc:
+      depth_was = self[depth_column]
+
+      yield
+
+      diff = self[depth_column] - depth_was
+      if diff != 0
+        sign = diff > 0 ? "+" : "-"
+        # update categories set depth = depth - 1 where id in (...)
+        descendants.update_all(["#{depth_column} = #{depth_column} #{sign} ?", diff.abs])
+      end
+    end
+
+    def update_counter_cache #:nodoc:
+      parent_id_was = self[parent_column]
+
+      yield
+
+      parent_id_new = self[parent_column]
+      unless parent_id_new == parent_id_was
+        self.class.increment_counter(children_counter_cache_column, parent_id_new) if parent_id_new
+        self.class.decrement_counter(children_counter_cache_column, parent_id_was) if parent_id_was
+      end
+    end
+
+    def arel #:nodoc:
+      self.class.arel_table
+    end
+
+    def ordered_tree_scope
+      if scope_column_names.empty?
+        self.class.base_class.scoped
+      else
+        self.class.base_class.where Hash[scope_column_names.map { |column| [column, self[column]] }]
+      end
+    end
+  end # module InstanceMethods
+end # module ActsAsOrderedTree