mm-tree 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Leif Ringstad
+
+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,121 @@
+= mm-tree
+
+This is a tree structure for MongoMapper documents that support rational numbers for positioning.
+Read about rational numbers in tree structures here: http://arxiv.org/pdf/0806.3115v1.pdf
+
+The reason for the changed implementation to use rational numbers is to be able to query a tree and get the tree structure by sorting on the rational number. It also makes it easy to query parts of a tree as well.
+
+Rational numbers is even better than left/right trees, as you can remove parts of a tree or a node without reordering the entire tree. It is a bit more complicated, but there are some really good benefits.
+
+{<img src="https://secure.travis-ci.org/leifcr/mm-tree.png?branch=master" alt="Build Status" />}[http://travis-ci.org/leifcr/mm-tree]
+
+== Installation
+
+I assume you are using bundler, so add this to your Gemfile:
+  gem 'mm-tree', :git => 'http://github.com/leifcr/mm-tree.git'
+
+== Usage
+
+Enable the tree functionality by adding the plugin on your model
+
+  class Category
+    include MongoMapper::Document
+    plugin  MongoMapper::Plugins::Tree
+
+    key :name, String
+  end
+
+*Note:* Rational numbers positioning is enabled by default!
+
+This adds one embedded tree_info (non-changeable) and the following class attributes:
+
+* _tree_parent_id_field_ overrides the field used for parent_id (default: parent_id)
+* _tree_search_class_ expects a Class that is a MongoMapper::Document to be used for search (So you can have one collection with inherited models and trees for each model, not conflicting with each other)
+* _tree_use_rational_numbers_ use rational numbers for sorting. set to false if you don't want it.
+* _tree_order_ controls the order if rational numbers aren't used (format :field_name.[asc|desc]), else it will sort by rational numbers.
+
+If you want to use explicit _tree_order_, you *have to* set _tree_use_rational_numbers_ to false.
+
+== Configuration Examples
+Not using rational numbers, sorting by name, and using a different ID field.
+  class Category
+    include MongoMapper::Document
+    plugin  MongoMapper::Plugins::Tree
+    self.tree_parent_id_field      = "my_super_parent_id"
+    self.tree_use_rational_numbers = false
+    self.tree_order                = :name.asc
+
+    key :name, String
+  end
+
+Using rational numbers, and using search classes to have inherited models in same collection but different trees:
+  class Shape
+    include MongoMapper::Document
+    plugin  MongoMapper::Plugins::Tree
+    self.tree_search_class = Shape
+
+    key :name, String
+  end
+
+  class Circle < Shape
+    self.tree_search_class = Circle
+  end
+
+  class Square < Shape
+    self.tree_search_class = Square
+  end
+
+Using rational numbers, and using search classes to have inherited models in same collection and same tree:
+  class Shape
+    include MongoMapper::Document
+    plugin  MongoMapper::Plugins::Tree
+    self.tree_search_class = Shape
+
+    key :name, String
+  end
+
+  class Circle < Shape
+  end
+
+  class Square < Shape
+  end
+
+== Example for moving parents
+To move a child node from one parent to another you can do either move to a specific rational number, or just set the parent. 
+
+= Move using parent
+  node_1      = Category.create(:name => "Node 1")
+  node_1_1    = Category.create(:name => "Node 1.1", :parent => @node_1)
+  node_2      = Category.create(:name => "Node 2")
+  node_1_1.parent = node_2
+  node_1_1.save
+  node_1_1.parent.name # => "Node 2"
+
+= Move using rational values (nv/dv)
+  node_1      = Category.create(:name => "Node 1")
+  node_1_1    = Category.create(:name => "Node 1.1", :parent => @node_1)
+  node_2      = Category.create(:name => "Node 2")
+  node_2.set_position(node_1_1.tree_info.nv, node_1_1.tree_info.dv) # move to position of node_1_1
+  node_2.save
+  node_2.siblings.first.name # => "Node 1.1"
+  node_2.parent.name # => "Node 1"
+  # Node 2 is now in front of Node 1.1 as it has taken node 1.1's place.
+
+Check test_order.rb, test_tree.rb and test_search_class.rb for more examples and details on usage.
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Send me a pull request, if you have features you like to see implemented.
+
+== Thanks
+_Jakob Vidmar_  (For the original MongoMapper Tree)
+_Joel Junström_ (I based this tree on his refactoring of Jakobs MongoMapper Tree)
+_MongoMapper devels_ (John Nunemaker, Brandon Keepers & others)
+
+== Copyright
+Original ideas are Copyright Jakob Vidmar and Joel Junström. Please see their github repositories for details
+Copyright (c) 2012 Leif Ringstad. 
+See LICENSE for details.

data/lib/locale/en.yml

@@ -0,0 +1,8 @@
+en:
+  mongo_mapper:
+    errors:
+      messages:
+        tree:
+          cyclic: "Can't be children of a descendant"
+          incorrect_parent_nv_dv: "Positional values doesn't match parent (check nv/dv values)"
+          search_class_mismatch: "Mismatch between search classes. Parent: %{parent_search_class} Node: %{node_search_class}. They must be equal"

data/lib/mm-tree.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+require 'mongo_mapper'
+I18n.load_path << File.expand_path('../locale/en.yml', __FILE__)
+require 'mongo_mapper/plugins/tree'
+require 'mongo_mapper/plugins/tree_info'

data/lib/mongo_mapper/plugins/tree.rb

@@ -0,0 +1,439 @@
+require 'pp'
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Tree
+      @@_disable_timestamp_count = 0
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def roots
+          self.where(tree_parent_id_field => nil).sort(tree_sort_order()).all
+        end
+
+        def position_from_nv_dv(nv, dv)
+          anc_tree_keys = ancestor_tree_keys(nv, dv)
+          (nv - anc_tree_keys[:nv]) / anc_tree_keys[:snv]
+        end
+
+        # returns ancestor nv, dv, snv, sdv values as hash
+        def ancestor_tree_keys(nv,dv)
+          numerator = nv
+          denominator = dv
+          ancnv = 0
+          ancdv = 1
+          ancsnv = 1
+          ancsdv = 0
+          rethash = {:nv => ancnv, :dv => ancdv, :snv => ancsnv, :sdv => ancsdv}
+          # make sure we break if we get root values! (numerator == 0 + denominator == 0)
+          #max_levels = 10
+          while ((ancnv < nv) && (ancdv < dv)) && ((numerator > 0) && (denominator > 0))# && (max_levels > 0)
+            #max_levels -= 1
+            div = numerator / denominator
+            mod = numerator % denominator
+            # set return values to previous values, as they are the parent values
+            rethash = {:nv => ancnv, :dv => ancdv, :snv => ancsnv, :sdv => ancsdv}
+
+            ancnv = ancnv + (div * ancsnv)
+            ancdv = ancdv + (div * ancsdv)
+            ancsnv = ancnv + ancsnv
+            ancsdv = ancdv + ancsdv
+
+            numerator = mod
+            if (numerator != 0)
+              denominator = denominator % mod
+              if denominator == 0
+                denominator = 1
+              end
+            end
+          end
+          return rethash
+        end #get_ancestor_keys(nv,dv)
+
+        def tree_sort_order
+          if !tree_use_rational_numbers
+            "#{tree_order} tree_info.depth.asc" 
+          else
+            "tree_info.nv_div_dv.asc"
+          end
+        end
+
+      end # Module ClassMethods
+
+      def initialize(*args)
+        @_will_move = false
+        @_set_nv_dv = false
+        if (self.tree_info == nil)
+          self.tree_info = TreeInfo.new
+        end
+        super
+      end
+
+
+      included do
+        # Tree search class will be used as the base from which to
+        # find tree objects. This is handy should you have a tree of objects that are of different types, but
+        # might be related through single table inheritance.
+        #
+        #   self.tree_search_class = Shape
+        #
+        # In the above example, you could have a working tree ofShape, Circle and Square types (assuming
+        # Circle and Square were subclasses of Shape). If you want to do the same thing and you don't provide
+        # tree_search_class, nesting mixed types will not work.
+        class_attribute :tree_search_class
+        self.tree_search_class ||= self
+
+        class_attribute :tree_parent_id_field
+        self.tree_parent_id_field ||= "parent_id"
+
+        class_attribute :tree_use_rational_numbers
+        self.tree_use_rational_numbers ||= true
+
+        class_attribute :tree_order
+
+        key tree_parent_id_field, ObjectId
+        one :tree_info
+# 
+#       An index for path field, left_field and right_field is recommended for faster queries.
+
+        belongs_to :parent, :class => tree_search_class
+
+# FIX VALIDATIONS... this is messy!
+        validate          :will_save_tree
+        
+        before_validation :set_nv_dv_if_missing
+
+        after_validation  :update_tree_info
+        after_save        :move_children
+        before_destroy    :destroy_descendants
+      end
+
+      def tree_search_class
+        self.class.tree_search_class
+      end
+
+      def will_save_tree
+        if parent
+          errors.add(:base, I18n.t(:cyclic, :scope => [:mongo_mapper, :errors, :messages, :tree])) if self.descendants.include?(parent)
+          if (parent.tree_search_class != self.tree_search_class)
+            errors.add(:base,  I18n.t(:search_class_mismatch, { \
+                :parent_search_class => parent.class.tree_search_class, \
+                :node_search_class => self.class.tree_search_class, \
+                :scope => [:mongo_mapper, :errors, :messages, :tree]})) 
+          end
+        end
+        if (self.tree_info.changes.include?("nv") && self.tree_info.changes.include?("dv") && self.changes.include?(tree_parent_id_field))
+          if !correct_parent?(self.tree_info.nv, self.tree_info.dv)
+            errors.add(:base, I18n.t(:cyclic, :scope => [:mongo_mapper, :errors, :messages, :tree]))
+          end
+        end
+      end
+
+      def update_tree_info
+        update_path();
+        update_nv_dv();
+      end
+
+      def update_path(opts = {})
+        if parent.nil?
+          self[tree_parent_id_field] = nil
+          self.tree_info.path = []
+          self.tree_info.depth = 0
+        elsif !!opts[:force] || self.changes.include?(tree_parent_id_field)
+          @_will_move = true
+          self.tree_info.path  = parent.tree_info.path + [parent._id] 
+          self.tree_info.depth = parent.tree_info.depth + 1
+        end
+      end
+
+      def update_path!
+        update_path(:force => true)
+      end
+
+      def set_position(nv, dv)
+        self.tree_info.nv = nv
+        self.tree_info.dv = dv
+      end
+
+    # TODO: what if we move parent without providing NV/DV??? NEED TO SUPPORT THAT AS WELL!
+    # Should calculate next free nv/dv and set that if parent has changed. (set values to "missing and call missing function should work")
+      def update_nv_dv(opts = {})
+        return if !tree_use_rational_numbers
+        if @_set_nv_dv == true
+          @_set_nv_dv = false
+          return
+        end
+        # if changes include both parent_id, tree_info.nv and tree_info.dv, 
+        # checking in validatioon that the parent is correct.
+        # if change is only nv/dv, check if parent is correct, move it...
+        if (self.tree_info.changes.include?("nv") && self.tree_info.changes.include?("dv"))
+          self.move_nv_dv(self.tree_info.nv, self.tree_info.dv)
+        elsif (self.changes.include?(tree_parent_id_field)) || opts[:force]
+          # only changed parent, needs to find next free position
+          # use function for "missing nv/dv"
+          # TODO CHECK THIS!!!! might only need self.has_siblings? instead of + 1
+          new_keys = self.next_keys_available(self[tree_parent_id_field], (self.has_siblings? + 1)) if !opts[:position]
+          new_keys = self.next_keys_available(self[tree_parent_id_field], (opts[:position] + 1)) if opts[:position]
+          self.move_nv_dv(new_keys[:nv], new_keys[:dv])
+        end
+      end
+
+      def update_nv_dv!(opts = {})
+        update_nv_dv({:force => true}.merge(opts))
+      end
+
+      # sets initial nv, dv, snv and sdv values
+      def set_nv_dv_if_missing
+        return if !tree_use_rational_numbers
+        if (self.tree_info.nv == 0 || self.tree_info.dv == 0 )
+          new_keys = self.next_keys_available(self[tree_parent_id_field], (self.has_siblings? + 1) )
+          self.tree_info.nv = new_keys[:nv]
+          self.tree_info.dv = new_keys[:dv]
+          self.tree_info.snv = new_keys[:snv]
+          self.tree_info.sdv = new_keys[:sdv]
+          self.tree_info.nv_div_dv = Float(new_keys[:nv]/Float(new_keys[:dv]))
+          @_set_nv_dv = true
+        end
+      end
+
+
+      # if conflcting item on new position, shift all siblings right and insertg
+      # can force move without updating conflicting siblings
+      def move_nv_dv(nv, dv, opts = {})
+        return if !tree_use_rational_numbers
+#        return
+        # nv_div_dv = Float(nv)/Float(dv)
+        # find nv_div_dv?
+        position = self.class.position_from_nv_dv(nv, dv)
+        if !self.root?
+          anc_keys = self.class.ancestor_tree_keys(nv, dv)
+          rnv = anc_keys[:nv] + ((position + 1) * anc_keys[:snv])
+          rdv = anc_keys[:dv] + ((position + 1) * anc_keys[:sdv])
+        else
+          rnv = position + 1
+          rdv = 1
+        end
+
+        # don't check for conflict if forced move
+        if (!opts[:ignore_conflict])
+          conflicting_sibling = tree_search_class.where("tree_info.nv" => nv).where("tree_info.dv" => dv).first
+          if (conflicting_sibling != nil) 
+            self.disable_timestamp_callback()
+            # find nv/dv to the right of conflict
+            # find position/count for this item
+            next_keys = conflicting_sibling.next_sibling_keys
+            conflicting_sibling.set_position(next_keys[:nv], next_keys[:dv])
+            conflicting_sibling.save
+            self.enable_timestamp_callback()
+          end
+        end
+
+        # shouldn't be any conflicting sibling now...
+        self.tree_info.nv = nv
+        self.tree_info.dv = dv
+        self.tree_info.snv = rnv
+        self.tree_info.sdv = rdv
+        self.tree_info.nv_div_dv = Float(self.tree_info.nv)/Float(self.tree_info.dv)
+        # as this is triggered from after_validation, save should be triggered by the caller.
+      end
+      # change this require ancestor data + position, 
+      # next position can be found using: self.has_siblings? + 1
+      # as when moving children, the sibling_count won't work
+      def next_keys_available(parent_id, position)
+        _parent = tree_search_class.where(:_id => parent_id).first
+        _parent = nil if ((_parent.nil?) || (_parent == []))
+        ancnv = 0
+        ancsnv = 1
+        ancdv = 1
+        ancsdv = 0
+        if _parent != nil
+          ancnv  = _parent.tree_info.nv
+          ancsnv = _parent.tree_info.snv
+          ancdv  = _parent.tree_info.dv
+          ancsdv = _parent.tree_info.sdv
+        end
+        if (position == 0) && (_parent.nil?)
+          rethash = {:nv => 1, :dv => 1, :snv => 2, :sdv => 1}
+        else 
+          # get values from sibling_count
+          _nv = ancnv + (position * ancsnv)
+          _dv = ancdv + (position * ancsdv)
+          rethash = {
+            :nv => _nv,
+            :dv => _dv,
+            :snv => ancnv + ((position + 1) * ancsnv),
+            :sdv => ancdv + ((position + 1) * ancsdv)
+          }
+        end
+        rethash
+      end
+
+      def next_sibling_keys
+        next_keys_available(self[tree_parent_id_field], self.class.position_from_nv_dv(self.tree_info.nv, self.tree_info.dv) +1)
+      end
+
+      # to save queries, this will calculate ancestor tree keys instead of query them
+      def ancestor_tree_keys
+        self.class.ancestor_tree_keys(self.tree_info.nv,self.tree_info.dv)
+      end
+
+      def query_ancestor_tree_keys
+        check_parent = tree_search_class.where(:_id => self[tree_parent_id_field]).first
+        return nil if (check_parent.nil? || check_parent == [])
+        rethash = {:nv => check_parent.tree_info.nv, 
+                   :dv => check_parent.tree_info.dv, 
+                   :snv => check_parent.tree_info.snv, 
+                   :sdv => check_parent.tree_info.sdv}
+      end
+
+      def tree_keys
+        { :nv => self.tree_info.nv, 
+          :dv => self.tree_info.dv, 
+          :snv => self.tree_info.snv, 
+          :sdv => self.tree_info.sdv}
+      end
+
+      # verifies parent keys from calculation and query
+      # this might not work for nested saves...
+      def correct_parent?(nv, dv)
+        # get nv/dv from parent
+        check_ancestor_keys = query_ancestor_tree_keys()
+        return false if (check_ancestor_keys == nil)
+        calc_ancestor_keys = self.class.ancestor_tree_keys(nv, dv)
+        if ( (calc_ancestor_keys[:nv] == check_ancestor_keys[:nv]) \
+          && (calc_ancestor_keys[:dv] == check_ancestor_keys[:dv]) \
+          && (calc_ancestor_keys[:snv] == check_ancestor_keys[:snv]) \
+          && (calc_ancestor_keys[:sdv] == check_ancestor_keys[:sdv]) \
+          )
+          return true
+        end
+      end
+
+      def disable_timestamp_callback
+        if self.respond_to?("updated_at")
+          @@_disable_timestamp_count += 1
+          self.class.skip_callback(:save, :before, :update_timestamps ) 
+        end
+      end
+
+      def enable_timestamp_callback
+        if self.respond_to?("updated_at")
+          @@_disable_timestamp_count -= 1
+          self.class.set_callback(:save, :before, :update_timestamps ) if @@_disable_timestamp_count <= 0
+        end
+      end
+
+      def root?
+        self[tree_parent_id_field].nil?
+      end
+
+      def root
+        self.tree_info.path.first.nil? ? self : tree_search_class.find(self.tree_info.path.first)
+      end
+
+      def ancestors
+        return [] if root?
+        tree_search_class.find(self.tree_info.path)
+      end
+
+      def self_and_ancestors
+        ancestors << self
+      end
+
+      def has_siblings?
+        tree_search_class.where(:_id => { "$ne" => self._id }) \
+                         .where(tree_parent_id_field => self[tree_parent_id_field]) \
+                         .sort(self.class.tree_sort_order()).count
+      end
+
+      def siblings
+        tree_search_class.where({
+          :_id => { "$ne" => self._id },
+          tree_parent_id_field => self[tree_parent_id_field]
+        }).sort(self.class.tree_sort_order()).all
+      end
+
+      def self_and_siblings
+        tree_search_class.where({
+          tree_parent_id_field => self[tree_parent_id_field]
+        }).sort(self.class.tree_sort_order()).all
+      end
+
+      def children?
+        return false if ((self.children == nil) || (self.children == []))
+        return true
+      end
+
+      def children
+        tree_search_class.where(tree_parent_id_field => self._id).sort(self.class.tree_sort_order()).all
+      end
+
+      def descendants
+        return [] if new_record?
+        tree_search_class.where("tree_info.path" => self._id).sort(self.class.tree_sort_order()).all
+      end
+
+      def self_and_descendants
+        [self] + self.descendants
+      end
+
+      def is_ancestor_of?(other)
+        other.tree_info.path.include?(self._id)
+      end
+
+      def is_or_is_ancestor_of?(other)
+        (other == self) or is_ancestor_of?(other)
+      end
+
+      def is_descendant_of?(other)
+        self.tree_info.path.include?(other._id)
+      end
+
+      def is_or_is_descendant_of?(other)
+        (other == self) or is_descendant_of?(other)
+      end
+
+      def is_sibling_of?(other)
+        (other != self) and (other[tree_parent_id_field] == self[tree_parent_id_field])
+      end
+
+      def is_or_is_sibling_of?(other)
+        (other == self) or is_sibling_of?(other)
+      end
+
+      def move_children
+        if @_will_move
+          @_will_move = false
+          _position = 0
+          self.disable_timestamp_callback()
+          self.children.each do |child|
+            child.update_path!
+            child.update_nv_dv!(:position => _position)
+            # puts "Update Child - #{child.name.inspect} #{child.changes.inspect}"
+            # puts "#{child.updated_at.to_f}"
+            child.save
+            child.reload
+            # puts "#{child.updated_at.to_f}"
+            child.save
+            child.reload
+            # puts "#{child.updated_at.to_f}"
+            child.reload
+            # puts "#{child.updated_at.to_f}"
+
+            _position += 1
+          end
+          self.enable_timestamp_callback()
+
+          # enable_tree_callbacks()
+          @_will_move = true
+        end
+      end
+
+      def destroy_descendants
+        tree_search_class.destroy(self.descendants.map(&:_id))
+      end
+
+    end # Module Tree
+  end # Module Plugins
+end # Module MongoMapper

data/lib/mongo_mapper/plugins/tree_info.rb

@@ -0,0 +1,18 @@
+class TreeInfo
+  include MongoMapper::EmbeddedDocument
+  plugin MongoMapper::Plugins::Dirty
+  attr_accessible :nv, :dv, :snv, :sdv, :path, :depth, :position #, :parent_id
+
+  key :nv, Integer, :default => 0
+  key :dv, Integer, :default => 0
+  key :nv_div_dv, Float, :default => 0
+  key :snv, Integer, :default => 0
+  key :sdv, Integer, :default => 0
+  key :path, Array, :typecast => 'ObjectId' # might need to be string instead?
+  key :depth, Integer
+  # key :position, Integer (might not use this?)
+  # key :parent_id, ObjectId
+
+  timestamps!
+
+end

data/lib/version.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+module MongoMapper
+  module Tree
+    Version = '0.1.0'
+  end
+end

data/test/helper.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'bundler/setup'
+# require 'test/unit'
+# require 'shoulda'
+# require 'database_cleaner'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'mm-tree'
+
+Bundler.require(:default, :test)
+
+MongoMapper.database = "mm-tree-test"
+
+Dir["#{File.dirname(__FILE__)}/models/*.rb"].each {|file| require file}
+
+DatabaseCleaner.strategy = :truncation
+
+class Test::Unit::TestCase
+  # Drop all collections after each test case.
+  def setup
+    DatabaseCleaner.start
+  end
+
+  def teardown
+    DatabaseCleaner.clean
+  end
+
+  # Make sure that each test case has a teardown
+  # method to clear the db after each test.
+  def inherited(base)
+    base.define_method setup do
+      super
+    end
+
+    base.define_method teardown do
+      super
+    end
+  end
+
+  def eql_arrays?(first, second)
+    first.collect(&:_id).to_set == second.collect(&:_id).to_set
+  end
+end

data/test/models/category.rb

@@ -0,0 +1,7 @@
+class Category
+  include MongoMapper::Document
+  plugin MongoMapper::Plugins::Tree
+
+  key :name, String
+  timestamps!
+end

data/test/models/ordered_category.rb

@@ -0,0 +1,10 @@
+class OrderedCategory
+  include MongoMapper::Document
+  plugin MongoMapper::Plugins::Tree
+
+  key :name,  String
+  key :value, Integer
+
+  self.tree_order = :value.asc
+  self.tree_use_rational_numbers = false
+end

data/test/models/shapes.rb

@@ -0,0 +1,18 @@
+class Shape
+  include MongoMapper::Document
+  plugin MongoMapper::Plugins::Tree
+  self.tree_search_class = Shape
+
+  key :name, String
+end
+
+class Circle < Shape; end
+class Square < Shape; end
+
+class Triangle < Shape
+  self.tree_search_class = Triangle
+end
+
+class Cube < Shape
+  self.tree_search_class = Cube
+end

data/test/test_order.rb

@@ -0,0 +1,41 @@
+require 'helper'
+class TestMongomapperActsAsTree < Test::Unit::TestCase
+  context "Ordered tree" do
+    setup do
+      @node_1       = OrderedCategory.create(:name => "Node 1", :value => 2)
+      @node_1_1     = OrderedCategory.create(:name => "Node 1", :parent => @node_1, :value => 1)
+      @node_1_2     = OrderedCategory.create(:name => "Node 1.2", :parent => @node_1, :value => 9)
+      @node_1_2_1   = OrderedCategory.create(:name => "Node 1.2.1", :parent => @node_1_2, :value => 2)
+      @node_1_3       = OrderedCategory.create(:name => "Node 1.3", :parent => @node_1, :value => 5)
+      @node_2       = OrderedCategory.create(:name => "Node 2", :value => 1)
+    end
+
+    should "root nodes should be in order" do
+      OrderedCategory.roots.should eql?([@node_2, @node_1])
+    end
+
+    should "Node 1 children should be in order" do
+      @node_1.children.should eql?([@node_1_1, @node_1_3, @node_1_2])
+    end
+
+    should "Node 1 descendants should be in order" do
+      @node_1.descendants.should eql?([@node_1_1, @node_1_3, @node_1_2, @node_1_2_1])
+    end
+
+    should "Node 1 self and descendants should be in order" do
+      @node_1.self_and_descendants.should eql?([@node_1, @node_1_1, @node_1_3, @node_1_2, @node_1_2_1])
+    end
+
+    should "Node 1.2 siblings should be in order" do
+      @node_1_2.siblings.should eql?([@node_1_1, @node_1_3])
+    end
+    
+    should "Node 1.2 self and siblings should be in order" do    
+      @node_1_2.self_and_siblings.should eql?([@node_1_1, @node_1_3, @node_1_2])
+    end
+
+    should "Node 1 self and siblings should be in order" do
+      @node_1.self_and_siblings.should eql?([@node_2, @node_1])
+    end
+  end
+end

data/test/test_search_class.rb

@@ -0,0 +1,120 @@
+require 'helper'
+
+class TestSearchScope < Test::Unit::TestCase
+  context "Simple, mixed type tree" do
+    setup do
+      shape = Shape.create(:name => "Root")
+      Circle.create(:name => "Circle", :parent => shape)
+      Square.create(:name => "Square", :parent => shape)
+    end
+
+    setup do
+      # We are loading from the database here because this process proves the point. If we never did it this
+      # way, there would be no reason to change the code.
+      @shape, @circle, @square = Shape.first, Circle.first, Square.first
+    end
+
+    should "return circle and square as children of shape" do
+      [@circle, @square].should == @shape.children
+    end
+
+    should("return shape as parent of circle") do
+      @shape.should == @circle.parent
+    end
+    should("return shape as parent of square") do
+      @shape.should == @square.parent
+    end
+
+    should("return square as exclusive sibling of circle") do
+      [@square].should ==@circle.siblings
+    end
+
+    should "return self and square as inclusive siblings of circle" do
+      [@circle, @square].should == @circle.self_and_siblings
+    end
+
+    should("return circle as exclusive sibling of square") do 
+      [@circle].should == @square.siblings
+    end
+    should "return self and circle as inclusive siblings of square" do
+      [@circle, @square].should == @square.self_and_siblings
+    end
+
+    should "return circle and square as exclusive descendants of shape" do
+      [@circle, @square].should == @shape.descendants
+    end
+    should "return shape, circle and square as inclusive descendants of shape" do
+      [@shape, @circle, @square].should == @shape.self_and_descendants
+    end
+
+    should("return shape as exclusive ancestor of circle") do
+      [@shape].should == @circle.ancestors
+    end
+
+    should "return self and shape as inclusive ancestors of circle" do
+      [@shape, @circle].should == @circle.self_and_ancestors
+    end
+
+    should("return shape as exclusive ancestor of square") do
+      [@shape].should == @square.ancestors
+    end
+    should "return self and shape as inclusive ancestors of square" do
+      [@shape, @square].should == @square.self_and_ancestors
+    end
+
+    should("return shape as root of circle") do
+      @shape.should == @square.root 
+    end
+    should("return shape as root of square") do
+      @shape.should == @circle.root 
+    end
+  end
+
+  context "A tree with mixed types on either side of a branch" do
+    setup do
+      shape = Shape.create(:name => "Root")
+      circle = Circle.create(:name => "Circle", :parent => shape)
+      Square.create(:name => "Square", :parent => circle)
+    end
+
+    setup do
+      @shape, @circle, @square = Shape.first, Circle.first, Square.first
+    end
+
+    should("return circle as child of shape")   do
+      [@circle].should == @shape.children
+    end
+    should("return square as child of circle")  do
+      [@square].should == @circle.children
+    end
+    should("return circle as parent of square") do
+      @circle.should == @square.parent
+    end
+    should("return shape as parent of circle")  do
+      @shape.should == @circle.parent
+    end
+
+    should "return circle and square as descendants of shape" do
+      [@circle, @square].should == @shape.descendants
+    end
+
+    should("return square as descendant of circle") do 
+      [@square].should == @circle.descendants
+    end
+
+    should "return shape and circle as ancestors of square" do
+      [@shape, @circle].should == @square.ancestors
+    end
+
+    should("return shape as ancestor of circle") do
+      [@shape].should == @circle.ancestors
+    end
+
+    should "destroy descendants of shape" do
+      @shape.destroy_descendants
+      assert_nil Shape.find(@circle._id)
+      assert_nil Shape.find(@square._id)
+    end
+  end
+
+end # TestSearchScope

data/test/test_search_class_multi.rb

@@ -0,0 +1,78 @@
+require 'helper'
+
+class TestSearchScope < Test::Unit::TestCase
+  context "Mixed type tree with unique search classes" do
+    setup do
+      @shape_1 = Shape.create(:name => "Shape 1")
+      @shape_1_1 = Shape.create(:name => "Shape 1.1", :parent => @shape_1)
+      @shape_1_2 = Shape.create(:name => "Shape 1.2", :parent => @shape_1)
+      @triangle_1 = Triangle.create(:name => "Triangle 1")
+      @triangle_1_1 = Triangle.create(:name => "Triangle 1.1", :parent => @triangle_1)
+      @triangle_1_2 = Triangle.create(:name => "Triangle 1.2", :parent => @triangle_1)
+      @cube_1 = Cube.create(:name => "Cube 1")
+      @cube_1_1 = Cube.create(:name => "Cube 1.1", :parent => @cube_1)
+      @cube_1_2 = Cube.create(:name => "Cube 1.2", :parent => @cube_1)
+      @cube_1_2_1 = Cube.create(:name => "Cube 1.2.1", :parent => @cube_1_2)
+      @cube_1_2_2 = Cube.create(:name => "Cube 1.2.2", :parent => @cube_1_2)
+      @cube_1_2_2_1 = Cube.create(:name => "Cube 1.2.2.1", :parent => @cube_1_2_1)
+    end
+
+    should "return cubes as children of cube_1" do
+      @cube_1.children.should == [@cube_1_1, @cube_1_2]
+    end
+
+    should "return two shapes as children of shape_1" do
+      @cube_1.children.count.should == 2
+    end
+
+    should "return triangles as children of triangles" do
+      @triangle_1.children.should == [@triangle_1_1, @triangle_1_2]
+    end
+
+    should "move a cube child within cubes" do
+      @cube_1_2_2.parent = @cube_1
+      @cube_1_2_2.save
+      @cube_1.reload
+      @cube_1_1.reload
+      @cube_1_2.reload
+      @cube_1_2_1.reload
+      @cube_1_2_2.reload
+      @cube_1_2_2_1.reload
+      @cube_1_1.siblings.should == [@cube_1_2, @cube_1_2_2]
+      @cube_1.descendants.should == [@cube_1_1, @cube_1_2, @cube_1_2_1, @cube_1_2_2, @cube_1_2_2_1]
+    end
+
+    should "not return any triangles or cubes descendants of shape_1" do
+      @shape_1.descendants.each do |ddant|
+        ddant.name.should_not =~ /Cube/
+        ddant.name.should_not =~ /Triangle/
+      end
+    end
+
+    should "return cube_1 as parent of cube_1_1" do
+      @cube_1_1.parent.should == @cube_1
+    end
+
+    should "return shape_1 as parent of shape_1_2" do
+      @shape_1_2.parent.should == @shape_1
+    end
+
+    should "not allow to set a cube_1 as child of triangle_1" do
+      # TODO: add validation that search class of parent and child is same
+      @cube_1.parent = @triangle_1
+      @cube_1.save
+      @cube_1.errors.count.should == 1 #should have an error
+      @cube_1.errors.each do |attribute, errmsg|
+        attribute.to_s.should == "base"
+        errmsg.should == ("Mismatch between search classes. Parent: Triangle Node: Cube. They must be equal")
+      end
+    end
+
+    should "destroy descendants of shape_1" do
+      @shape_1.destroy_descendants
+      Shape.find(@shape_1_2._id).should == nil
+      Shape.find(@shape_1_1._id).should == nil
+    end
+  end # context "Mixed type tree with unique search classes" do
+
+end # TestSearchScope

data/test/test_tree.rb

@@ -0,0 +1,296 @@
+require 'helper'
+class TestMongomapperActsAsTree < Test::Unit::TestCase
+  context "Tree" do
+    setup do
+      @node_1     = Category.create(:name => "Node 1")
+      @node_1_1    = Category.create(:name => "Node 1.1", :parent => @node_1)
+      @node_1_2    = Category.create(:name => "Node 1.2", :parent => @node_1)
+      @node_1_2_1  = Category.create(:name => "Node 1.2.1", :parent => @node_1_2)
+      @node_1_2_2  = Category.create(:name => "Node 1.2.2", :parent => @node_1_2)
+      @node_1_3    = Category.create(:name => "Node 1.3", :parent => @node_1)
+      #@node_4    = Category.create(:name => "Node 3", :parent => @node_1)
+      @node_2     = Category.create(:name => "Node 2")
+      @node_2_1    = Category.create(:name => "Node 2.1", :parent => @node_2)
+      @node_2_2    = Category.create(:name => "Node 2.2", :parent => @node_2)
+      @node_2_3    = Category.create(:name => "Node 2.3", :parent => @node_2)
+      @node_2_4    = Category.create(:name => "Node 2.4", :parent => @node_2)
+      @node_2_4_1  = Category.create(:name => "Node 2.4.1", :parent => @node_2_4)
+      @node_2_4_2  = Category.create(:name => "Node 2.4.2", :parent => @node_2_4)
+      @node_2_4_3  = Category.create(:name => "Node 2.4.3", :parent => @node_2_4)
+      @node_2_4_1_1  = Category.create(:name => "Node 2.4.1.1", :parent => @node_2_4_1)
+    end #setup do
+
+    should "create node from id " do
+      assert Category.create(:name => "Node 1.4", :parent_id => @node_1.id).parent == @node_1
+    end
+
+    should "have roots" do
+      Category.roots.should == [@node_1, @node_2]
+    end
+
+    context "node" do
+      should "have a root" do
+        @node_1.root.should == @node_1
+        @node_1.root.should_not == @node_2.root
+        @node_1.should == @node_1_2_1.root
+      end
+
+      should "have ancestors" do
+        @node_1.ancestors.should == []
+        @node_1_2_1.ancestors.should == [@node_1, @node_1_2]
+        @node_1.self_and_ancestors.should == [@node_1]
+        @node_1_2_1.self_and_ancestors.should == [@node_1, @node_1_2, @node_1_2_1]
+      end
+
+      should "have siblings" do
+        @node_1.siblings.should == [@node_2]
+        @node_1_2.siblings.should == [@node_1_1, @node_1_3]
+        @node_1_2_1.siblings.should == [@node_1_2_2]
+        @node_1.self_and_siblings.should == [@node_1, @node_2]
+        @node_1_2.self_and_siblings.should == [@node_1_1, @node_1_2, @node_1_3]
+        @node_1_2_1.self_and_siblings.should == [@node_1_2_1, @node_1_2_2]
+        @node_1_2_2.self_and_siblings.should == [@node_1_2_1, @node_1_2_2]
+      end
+
+      should "set depth" do
+        @node_1.tree_info.depth.should == 0
+        @node_1_1.tree_info.depth.should == 1
+        @node_1_2_1.tree_info.depth.should == 2
+      end
+
+      should "have children" do
+        assert @node_1_2_1.children.empty?
+        @node_1.children.should == [@node_1_1, @node_1_2, @node_1_3]
+      end
+
+      should "have descendants" do
+        @node_1.descendants.should == [@node_1_1, @node_1_2, @node_1_2_1, @node_1_2_2, @node_1_3]
+        @node_1_2.descendants.should == [@node_1_2_1, @node_1_2_2]
+        assert @node_1_2_1.descendants.empty?
+        @node_1.self_and_descendants.should == [@node_1, @node_1_1, @node_1_2, @node_1_2_1, @node_1_2_2, @node_1_3]
+        @node_1_2.self_and_descendants.should == [@node_1_2, @node_1_2_1, @node_1_2_2]
+        @node_1_2_1.self_and_descendants.should == [@node_1_2_1]
+      end
+
+      should "be able to tell if ancestor" do
+        assert @node_1.is_ancestor_of?(@node_1_1)
+        assert ! @node_2.is_ancestor_of?(@node_1_2_1)
+        assert ! @node_1_2.is_ancestor_of?(@node_1_2)
+
+        assert @node_1.is_or_is_ancestor_of?(@node_1_1)
+        assert ! @node_2.is_or_is_ancestor_of?(@node_1_2_1)
+        assert @node_1_2.is_or_is_ancestor_of?(@node_1_2)
+      end
+
+      should "be able to tell if descendant" do
+        assert ! @node_1.is_descendant_of?(@node_1_1)
+        assert @node_1_1.is_descendant_of?(@node_1)
+        assert ! @node_1_2.is_descendant_of?(@node_1_2)
+
+        assert ! @node_1.is_or_is_descendant_of?(@node_1_1)
+        assert @node_1_1.is_or_is_descendant_of?(@node_1)
+        assert @node_1_2.is_or_is_descendant_of?(@node_1_2)
+      end
+
+      should "be able to tell if sibling" do
+        assert ! @node_1.is_sibling_of?(@node_1_1)
+        assert ! @node_1_1.is_sibling_of?(@node_1_1)
+        assert ! @node_1_2.is_sibling_of?(@node_1_2)
+
+        assert ! @node_1.is_or_is_sibling_of?(@node_1_1)
+        assert @node_1_1.is_or_is_sibling_of?(@node_1_2)
+        assert @node_1_2.is_or_is_sibling_of?(@node_1_2)
+      end
+
+      should "destroy descendants when destroyed" do
+        @node_1_2.destroy
+        assert_nil Category.find(@node_1_2_1._id)
+      end
+
+      context "when moving" do
+        should "recalculate path and depth" do
+          @node_1_3.parent = @node_1_2
+          @node_1_3.save
+
+          assert @node_1_2.is_or_is_ancestor_of?(@node_1_3)
+          assert @node_1_3.is_or_is_descendant_of?(@node_1_2)
+          assert @node_1_2.children.include?(@node_1_3)
+          assert @node_1_2.descendants.include?(@node_1_3)
+          assert @node_1_2_1.is_or_is_sibling_of?(@node_1_3)
+          assert @node_1_2_2.is_or_is_sibling_of?(@node_1_3)
+          @node_1_3.tree_info.depth.should == 2
+        end
+
+        should "move children on save" do
+          @node_1_2.parent = @node_2
+
+          assert ! @node_2.is_or_is_ancestor_of?(@node_1_2_1)
+          assert ! @node_1_2_1.is_or_is_descendant_of?(@node_2)
+          assert ! @node_2.descendants.include?(@node_1_2_1)
+
+          @node_1_2.save
+          @node_1_2_1.reload
+
+          assert @node_2.is_or_is_ancestor_of?(@node_1_2_1)
+          assert @node_1_2_1.is_or_is_descendant_of?(@node_2)
+          assert @node_2.descendants.include?(@node_1_2_1)
+        end
+
+        should "move children on save and don't touch timestamps for children" do
+          @node_2_4.parent = @node_1
+
+          before_created_at_2_4_1   = @node_2_4_1.created_at
+          before_updated_at_2_4_1   = @node_2_4_1.updated_at
+          before_created_at_2_4_1_1 = @node_2_4_1_1.created_at
+          before_updated_at_2_4_1_1 = @node_2_4_1_1.updated_at
+
+          Timecop.freeze(Time.now + 2.seconds) do
+            @node_2_4.save
+          end
+          @node_2_4_1.reload
+
+          # until mongo_mapper implements timefix, do
+          @node_2_4_1.created_at.to_f.should be_close(before_created_at_2_4_1.to_f, 0.001)
+          @node_2_4_1.updated_at.to_f.should be_close(before_updated_at_2_4_1.to_f, 0.001)
+          # @node_2_4_1_1.created_at.to_f.should be_close(before_created_at_2_4_1_1.to_f, 0.001)
+          # @node_2_4_1_1.updated_at.to_f.should be_close(before_updated_at_2_4_1_1.to_f, 0.001)
+
+          # when mongo_mapper implements timefix:
+          # @node_2_4_1.created_at.should eql?(before_created_at_2_4_1)
+          # @node_2_4_1.updated_at.should eql?(before_updated_at_2_4_1)
+          # @node_2_4_1_1.created_at.should be_close(before_created_at_2_4_1_1)
+          # @node_2_4_1_1.updated_at.should be_close(before_updated_at_2_4_1_1)
+
+        end
+
+        should "check against cyclic graph" do
+          @node_1.parent = @node_1_2_1
+          @node_1.save
+          @node_1.valid?.should == false
+          I18n.t(:'mongo_mapper.errors.messages.tree.cyclic').should == @node_1.errors[:base].first
+        end
+
+        should "be able to become root" do
+          @node_1_2.parent = nil
+          @node_1_2.save
+          @node_1_2.reload
+          assert_nil @node_1_2.parent
+          @node_1_2_1.reload
+          assert (@node_1_2_1.tree_info.path == [@node_1_2.id])
+        end
+      end # context "when moving" do
+    end # context "node" do
+
+    context "root node" do
+      should "not have a parent" do
+        assert_nil @node_1.parent
+      end
+    end
+
+    context "node_node" do
+      should "have a parent" do
+        assert_equal @node_1_2, @node_1_2_1.parent
+      end
+    end
+
+    context "node (keys)" do
+      should "find keys from id" do
+        assert Category.find(@node_1._id).tree_keys == @node_1.tree_keys, "Query doesn't match created object #{@node_1.name}"
+        assert Category.find(@node_2_4_1_1._id).tree_keys == @node_2_4_1_1.tree_keys, "Query doesn't match created object #{@node_2_4_1_1.name}"
+      end
+
+      should "have correct keys" do
+        @node_1.tree_keys.should        == Hash[:nv => 1, :dv => 1, :snv => 2, :sdv => 1]
+        @node_2.tree_keys.should        == Hash[:nv => 2, :dv => 1, :snv => 3, :sdv => 1]
+        @node_2_1.tree_keys.should      == Hash[:nv => 5, :dv => 2, :snv => 8, :sdv => 3]
+        @node_1_3.tree_keys.should      == Hash[:nv => 7, :dv => 4, :snv => 9, :sdv => 5]
+        @node_2_4.tree_keys.should      == Hash[:nv => 14, :dv => 5, :snv => 17, :sdv => 6]
+        @node_2_4_1.tree_keys.should    == Hash[:nv => 31, :dv => 11, :snv => 48, :sdv => 17]
+        @node_2_4_3.tree_keys.should    == Hash[:nv => 65, :dv => 23, :snv => 82, :sdv => 29]
+        @node_2_4_1_1.tree_keys.should  == Hash[:nv => 79, :dv => 28, :snv => 127, :sdv => 45]
+      end
+
+      should "find and calculate ancestor keys from given keys" do
+        assert Category.ancestor_tree_keys(@node_1.tree_info.nv, @node_1.tree_info.dv) == Hash[:nv => 0, :dv => 1, :snv => 1, :sdv => 0], "Ancestor keys for #{@node_1.name} is wrong"
+        assert Category.ancestor_tree_keys(@node_2_1.tree_info.nv, @node_2_1.tree_info.dv) == @node_2.tree_keys(), "Ancestor keys for #{@node_2_1.name} is not matching keys for #{@node_2.name}"
+        assert Category.ancestor_tree_keys(@node_2_2.tree_info.nv, @node_2_2.tree_info.dv) == @node_2.tree_keys(), "Ancestor keys for #{@node_2_2.name} is not matching keys for #{@node_2.name}"
+        assert Category.ancestor_tree_keys(@node_2_4_1.tree_info.nv, @node_2_4_1.tree_info.dv) == @node_2_4.tree_keys(), "Ancestor keys for #{@node_2_4_1.name} is not matching keys for #{@node_2_4.name}"
+        assert Category.ancestor_tree_keys(@node_2_4_1_1.tree_info.nv, @node_2_4_1_1.tree_info.dv) == @node_2_4_1.tree_keys(), "Ancestor keys for #{@node_2_4_1_1.name} is not matching keys for #{@node_2_4_1.name}"
+      end
+
+      should "find positions from given keys" do
+        assert Category.position_from_nv_dv(@node_1.tree_info.nv, @node_1.tree_info.dv) == 1,             "Wrong position for #{@node_1.name}, got #{Category.position_from_nv_dv(@node_1.tree_info.nv, @node_1.tree_info.dv)}, expected: 1"
+        assert Category.position_from_nv_dv(@node_2_1.tree_info.nv, @node_2_1.tree_info.dv) == 1,         "Wrong position for #{@node_2_1.name}, got #{Category.position_from_nv_dv(@node_2_1.tree_info.nv, @node_2_1.tree_info.dv)}, expected: 1"
+        assert Category.position_from_nv_dv(@node_2_2.tree_info.nv, @node_2_2.tree_info.dv) == 2,         "Wrong position for #{@node_2_2.name}, got #{Category.position_from_nv_dv(@node_2_2.tree_info.nv, @node_2_2.tree_info.dv)}, expected: 2"
+        assert Category.position_from_nv_dv(@node_2_3.tree_info.nv, @node_2_3.tree_info.dv) == 3,         "Wrong position for #{@node_2_3.name}, got #{Category.position_from_nv_dv(@node_2_3.tree_info.nv, @node_2_3.tree_info.dv)}, expected: 3"
+        assert Category.position_from_nv_dv(@node_2_4.tree_info.nv, @node_2_4.tree_info.dv) == 4,         "Wrong position for #{@node_2_4.name}, got #{Category.position_from_nv_dv(@node_2_4.tree_info.nv, @node_2_4.tree_info.dv)}, expected: 4"
+        assert Category.position_from_nv_dv(@node_2_4_1.tree_info.nv, @node_2_4_1.tree_info.dv) == 1,     "Wrong position for #{@node_2_4_1.name}, got #{Category.position_from_nv_dv(@node_2_4_1.tree_info.nv, @node_2_4_1.tree_info.dv)}, expected: 1"
+        assert Category.position_from_nv_dv(@node_2_4_1_1.tree_info.nv, @node_2_4_1_1.tree_info.dv) == 1, "Wrong position for #{@node_2_4_1_1.name}, got #{Category.position_from_nv_dv(@node_2_4_1_1.tree_info.nv, @node_2_4_1_1.tree_info.dv)}, expected: 1"
+      end
+
+      should "verify ancestor keys" do
+        assert @node_1_2.ancestor_tree_keys()     == @node_1.tree_keys(),     "#{@node_1_2.name} ancestor keys doesn't match #{@node_1.name} tree keys"
+        assert @node_1_2_1.ancestor_tree_keys()   == @node_1_2.tree_keys(),   "#{@node_1_2_1.name} ancestor keys doesn't match #{@node_1_2.name} tree keys"
+        assert @node_2_4_1_1.ancestor_tree_keys() == @node_2_4_1.tree_keys(), "#{@node_2_4_1_1.name} ancestor keys doesn't match #{@node_2_4_1.name} tree keys"
+      end
+
+      should "move to new specific nv, dv location and move conflicting items" do
+        assert @node_2_4.ancestor_tree_keys() == @node_2.tree_keys(), "Before move: #{@node_2_4.name} ancestor keys should match #{@node_2.name} got: #{@node_2_4.ancestor_tree_keys()} expected: #{@node_2.tree_keys()}"
+        assert @node_2_4_1.tree_info.depth == 2, "Before move: Depth of #{@node_2_4_1.name} should be 2"
+        old_1_2_keys = @node_1_2.tree_keys()
+        new_node_1_2_keys = @node_1_2.next_sibling_keys
+        @node_2_4.set_position(@node_1_2.tree_info.nv, @node_1_2.tree_info.dv)
+        @node_2_4.save
+        @node_1_2.reload
+        @node_2_4.reload
+        @node_2_4_1.reload
+
+        assert @node_1_2.tree_keys() != old_1_2_keys, "After move: #{@node_1_2.name} should have moved to new position, got #{@node_1_2.tree_keys} expected: #{new_node_1_2_keys}"
+        assert @node_1_2.tree_keys() == new_node_1_2_keys, "After move: #{@node_1_2.name} should have moved to new position, got #{@node_1_2.tree_keys} expected: #{new_node_1_2_keys}"
+        assert @node_2_4.tree_keys() == old_1_2_keys, "After move: #{@node_2_4.name} should have taken #{@node_1_2.name}'s position, got: #{@node_2_4.tree_keys}, expected: #{old_1_2_keys}"
+        assert @node_2_4_1.ancestor_tree_keys()   == @node_2_4.tree_keys(),   "After move: #{@node_2_4_1.name} ancestor keys should match #{@node_2_4.name} got: #{@node_2_4_1.ancestor_tree_keys()} expected: #{@node_2_4.tree_keys()}"
+      end
+
+      should "move @node_2_4 to root position" do
+        assert @node_2_4.ancestor_tree_keys() == @node_2.tree_keys(), "Before move: #{@node_2_4.name} ancestor keys should match #{@node_2.name} got: #{@node_2_4.ancestor_tree_keys()} expected: #{@node_2.tree_keys()}"
+        assert @node_2_4_1.tree_info.depth == 2, "Before move: Depth of #{@node_2_4_1.name} should be 2"
+        @node_2_4.parent = nil
+        @node_2_4.save
+        @node_2_4.reload
+        assert @node_2_4.root?, "#{@node_2_4.name} is not root"
+        assert @node_2_4.tree_keys()          == @node_2.next_sibling_keys(),     "After move: #{@node_2_4.name} keys should match keys #{@node_2.name} sibling keys. got: #{@node_2_4.tree_keys()} expected: #{@node_2.next_sibling_keys()}" 
+        assert @node_2_4.ancestor_tree_keys() == Hash[:nv => 0, :dv => 1, :snv => 1, :sdv => 0],     "After move: #{@node_2_4.name} ancestor keys should match root keys. got: #{@node_2_4.ancestor_tree_keys()} expected: #{Hash[:nv => 0, :dv => 1, :snv => 1, :sdv => 0]}"
+      # TODO: OVERRIDE RELOAD TO LOAD ALL CHILDREN IN MEMORY/CACHE/ASSOCS
+        @node_2_4_1.reload
+        assert @node_2_4_1.tree_info.path.count == 1, "After move:  Path length of #{@node_2_4_1.name} should only be 1"
+        assert @node_2_4_1.tree_info.depth == 1, "After move: Depth of #{@node_2_4_1.name} should be 1"
+        assert @node_2_4_1.ancestor_tree_keys()   == @node_2_4.tree_keys(),   "After move: #{@node_2_4_1.name} ancestor keys should match #{@node_2_4.name} got: #{@node_2_4_1.ancestor_tree_keys()} expected: #{@node_2_4.tree_keys()}"
+      # TODO: OVERRIDE RELOAD TO LOAD ALL CHILDREN IN MEMORY/CACHE/ASSOCS
+        @node_2_4_1_1.reload
+        assert @node_2_4_1_1.ancestor_tree_keys() == @node_2_4_1.tree_keys(), "After move: #{@node_2_4_1_1.name} ancestor keys should match #{@node_2_4_1.name} got: #{@node_2_4_1_1.ancestor_tree_keys()} expected: #{@node_2_4_1.tree_keys()}"
+      end
+      
+      should "should have changed nv/dv after changing parent (id)" do
+        old_keys = @node_1_2.tree_keys()
+        @node_1_2.parent = @node_2
+        # before saved
+        assert @node_1_2.ancestor_tree_keys() == @node_1.tree_keys(), "Before move: #{@node_1_2.name} ancestor keys should match #{@node_1.name} got: #{@node_1_2.ancestor_tree_keys()} expected: #{@node_1.tree_keys()}"
+        assert @node_1_2_1.ancestor_tree_keys() == @node_1_2.tree_keys(), "Before move #{@node_1_2_1.name} ancestor keys should match #{@node_1_2.name} got: #{@node_1_2_1.ancestor_tree_keys()} expected: #{@node_1_2.tree_keys()}"
+
+        @node_1_2.save
+        @node_1_2.reload
+        @node_1_2_1.reload
+
+        assert @node_1_2.tree_keys() != old_keys, "#{@node_1_2} keys should not be same as old"
+        assert @node_1_2.ancestor_tree_keys() == @node_2.tree_keys(), "After move: #{@node_1_2.name} ancestor keys should match #{@node_2.name} got: #{@node_1_2.ancestor_tree_keys()} expected: #{@node_2.tree_keys()}"
+        # should still be able to find correct keys for child of moved item
+        assert @node_1_2_1.ancestor_tree_keys() == @node_1_2.tree_keys(), "After move #{@node_1_2_1.name} ancestor keys should match #{@node_1_2.name} got: #{@node_1_2_1.ancestor_tree_keys()} expected: #{@node_1_2.tree_keys()}"
+      end
+    end # tree keys
+
+    should "rekey the entire treestructre" do
+      # TODO
+    end
+
+  end #Context "Tree" do
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: mm-tree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Leif Ringstad
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongo_mapper
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+description: Tree structure for MongoMapper with rational number sorting
+email:
+- leifcr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/locale/en.yml
+- lib/mm-tree.rb
+- lib/mongo_mapper/plugins/tree.rb
+- lib/mongo_mapper/plugins/tree_info.rb
+- lib/version.rb
+- test/helper.rb
+- test/models/category.rb
+- test/models/ordered_category.rb
+- test/models/shapes.rb
+- test/test_order.rb
+- test/test_search_class.rb
+- test/test_search_class_multi.rb
+- test/test_tree.rb
+- LICENSE
+- README.rdoc
+homepage: http://github.com/leifcr/mm-tree
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Tree structure for MongoMapper
+test_files:
+- test/helper.rb
+- test/models/category.rb
+- test/models/ordered_category.rb
+- test/models/shapes.rb
+- test/test_order.rb
+- test/test_search_class.rb
+- test/test_search_class_multi.rb
+- test/test_tree.rb