mongo_mapper_tree 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Joel Junström, Oktavilla
+
+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,44 @@
+= mongo_mapper_tree
+
+This is an modernized version of mongo_mapper_acts_as_tree (https://github.com/ramdiv/mongo_mapper_acts_as_tree)
+In it's essence it's an implementation of a tree structure for MongoMapper, think acts as tree but for mongodb.
+
+
+== Installation
+
+Install as gem
+
+  gem install mongo_mapper_tree
+
+== Usage
+
+Enable the tree functionality by declaring acts_as_tree on your model
+
+  class Category
+    include MongoMapper::Document
+    plugin  MongoMapper::Plugins::Tree
+
+    key :name, String
+  end
+
+This adds class_attributes called parent_id_field, path_field, depth_field, tree_order and tree_search_class.
+
+  parent_id_field, path_field and depth_field overrides the default field names
+  tree_order controls the order (format :field_name.[asc|desc])
+  tree_search_class expects a Class that is a MongoMapper::Document to be used for search
+
+Check test_tree.rb and test_search_class.rb for examples.
+
+== 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.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2011 Joel Junström. See LICENSE for details.

data/lib/locale/en.yml

@@ -0,0 +1,5 @@
+en:
+  mongo_mapper:
+    errors:
+      messages:
+        cyclic: "Can't be children of a descendant"

data/lib/mongo_mapper/plugins/tree.rb

@@ -0,0 +1,160 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Tree
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def roots
+          self.where(parent_id_field => nil).sort(tree_order).all
+        end
+      end
+
+      module InstanceMethods
+        def tree_search_class
+          self.class.tree_search_class
+        end
+
+        def will_save_tree
+          if parent && self.descendants.include?(parent)
+            errors.add(:base, :cyclic)
+          end
+        end
+
+        def fix_position(opts = {})
+          if parent.nil?
+            self[parent_id_field] = nil
+            self[path_field] = []
+            self[depth_field] = 0
+          elsif !!opts[:force] || self.changes.include?(parent_id_field)
+            @_will_move = true
+            self[path_field]  = parent[path_field] + [parent._id]
+            self[depth_field] = parent[depth_field] + 1
+          end
+        end
+
+        def fix_position!
+          fix_position(:force => true)
+          save
+        end
+
+        def root?
+          self[parent_id_field].nil?
+        end
+
+        def root
+          self[path_field].first.nil? ? self : tree_search_class.find(self[path_field].first)
+        end
+
+        def ancestors
+          return [] if root?
+          tree_search_class.find(self[path_field])
+        end
+
+        def self_and_ancestors
+          ancestors << self
+        end
+
+        def siblings
+          tree_search_class.where({
+            :_id => { "$ne" => self._id },
+            parent_id_field => self[parent_id_field]
+          }).sort(tree_order).all
+        end
+
+        def self_and_siblings
+          tree_search_class.where({
+            parent_id_field => self[parent_id_field]
+          }).sort(tree_order).all
+        end
+
+        def children
+          tree_search_class.where(parent_id_field => self._id).sort(tree_order).all
+        end
+
+        def descendants
+          return [] if new_record?
+          tree_search_class.where(path_field => self._id).sort(tree_order).all
+        end
+
+        def self_and_descendants
+          [self] + self.descendants
+        end
+
+        def is_ancestor_of?(other)
+          other[path_field].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[path_field].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[parent_id_field] == self[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
+            self.children.each do |child|
+              child.fix_position!
+            end
+            @_will_move = true
+          end
+        end
+
+        def destroy_descendants
+          tree_search_class.destroy(self.descendants.map(&:_id))
+        end
+      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 :parent_id_field
+        self.parent_id_field ||= "parent_id"
+
+        class_attribute :path_field
+        self.path_field ||= "path"
+
+        class_attribute :depth_field
+        self.depth_field ||= "depth"
+
+        class_attribute :tree_order
+
+        key parent_id_field, ObjectId
+        key path_field, Array, :default => [], :index => true
+        key depth_field, Integer, :default => 0
+
+        belongs_to :parent, :class => tree_search_class
+
+        validate         :will_save_tree
+        after_validation :fix_position
+        after_save       :move_children
+        before_destroy   :destroy_descendants
+      end
+    end
+  end
+end

data/lib/mongo_mapper_tree.rb

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

data/lib/version.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+module MongoMapperTree
+  Version = '0.0.1'
+end

data/test/helper.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'database_cleaner'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'mongo_mapper_tree'
+
+MongoMapper.database = "mongo_mapper_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,6 @@
+class Category
+  include MongoMapper::Document
+  plugin MongoMapper::Plugins::Tree
+
+  key :name, String
+end

data/test/models/ordered_category.rb

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

data/test/models/shapes.rb

@@ -0,0 +1,10 @@
+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

data/test/test_order.rb

@@ -0,0 +1,26 @@
+require 'helper'
+class TestMongomapperActsAsTree < Test::Unit::TestCase
+  context "Ordered tree" do
+    setup do
+      @root_1     = OrderedCategory.create(:name => "Root 1", :value => 2)
+      @child_1    = OrderedCategory.create(:name => "Child 1", :parent => @root_1, :value => 1)
+      @child_2    = OrderedCategory.create(:name => "Child 2", :parent => @root_1, :value => 9)
+      @child_2_1  = OrderedCategory.create(:name => "Child 2.1", :parent => @child_2, :value => 2)
+      @child_3    = OrderedCategory.create(:name => "Child 3", :parent => @root_1, :value => 5)
+      @root_2     = OrderedCategory.create(:name => "Root 2", :value => 1)
+    end
+
+    should "be in order" do
+      assert_equal OrderedCategory.roots, [@root_2, @root_1]
+
+      assert_equal @root_1.children, [@child_1, @child_3, @child_2]
+
+      assert_equal @root_1.descendants, [@child_1, @child_2_1, @child_3, @child_2]
+      assert_equal @root_1.self_and_descendants, [@root_1, @child_1, @child_2_1, @child_3, @child_2]
+
+      assert_equal @child_2.siblings, [@child_1, @child_3]
+      assert_equal @child_2.self_and_siblings, [@child_1, @child_3, @child_2]
+      assert_equal @root_1.self_and_siblings, [@root_2, @root_1]
+    end
+  end
+end

data/test/test_search_class.rb

@@ -0,0 +1,90 @@
+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
+      assert_equal [@circle, @square], @shape.children
+    end
+
+    should("return shape as parent of circle") { assert_equal @shape, @circle.parent }
+    should("return shape as parent of square") { assert_equal @shape, @square.parent }
+
+    should("return square as exclusive sibling of circle") { assert_equal [@square], @circle.siblings }
+    should "return self and square as inclusive siblings of circle" do
+      assert_equal [@circle, @square], @circle.self_and_siblings
+    end
+
+    should("return circle as exclusive sibling of square") { assert_equal [@circle], @square.siblings }
+    should "return self and circle as inclusive siblings of square" do
+      assert_equal [@circle, @square], @square.self_and_siblings
+    end
+
+    should "return circle and square as exclusive descendants of shape" do
+      assert_equal [@circle, @square], @shape.descendants
+    end
+    should "return shape, circle and square as inclusive descendants of shape" do
+      assert_equal [@shape, @circle, @square], @shape.self_and_descendants
+    end
+
+    should("return shape as exclusive ancestor of circle") { assert_equal [@shape], @circle.ancestors }
+    should "return self and shape as inclusive ancestors of circle" do
+      assert_equal [@shape, @circle], @circle.self_and_ancestors
+    end
+
+    should("return shape as exclusive ancestor of square") { assert_equal [@shape], @square.ancestors }
+    should "return self and shape as inclusive ancestors of square" do
+      assert_equal [@shape, @square], @square.self_and_ancestors
+    end
+
+    should("return shape as root of circle") { assert_equal @shape, @square.root }
+    should("return shape as root of square") { assert_equal @shape, @circle.root }
+  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") { assert_equal [@circle], @shape.children }
+    should("return square as child of circle") { assert_equal [@square], @circle.children }
+    should("return circle as parent of square") { assert_equal @circle, @square.parent }
+    should("return shape as parent of circle") { assert_equal @shape, @circle.parent }
+
+    should "return circle and square as descendants of shape" do
+      assert_equal [@circle, @square], @shape.descendants
+    end
+
+    should("return square as descendant of circle") { assert_equal [@square], @circle.descendants }
+
+    should "return shape and circle as ancestors of square" do
+      assert_equal [@shape, @circle], @square.ancestors
+    end
+
+    should("return shape as ancestor of circle") { assert_equal [@shape], @circle.ancestors }
+
+    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_tree.rb

@@ -0,0 +1,157 @@
+require 'helper'
+class TestMongomapperActsAsTree < Test::Unit::TestCase
+  context "Tree" do
+    setup do
+      @root_1     = Category.create(:name => "Root 1")
+      @child_1    = Category.create(:name => "Child 1", :parent => @root_1)
+      @child_2    = Category.create(:name => "Child 2", :parent => @root_1)
+      @child_2_1  = Category.create(:name => "Child 2.1", :parent => @child_2)
+      @child_3    = Category.create(:name => "Child 3", :parent => @root_1)
+      @root_2     = Category.create(:name => "Root 2")
+    end
+
+    should "create node from id " do
+      assert Category.create(:name => "Child 2.2", :parent_id => @root_1.id).parent == @root_1
+    end
+
+    should "have roots" do
+      assert eql_arrays?(Category.roots, [@root_1, @root_2])
+    end
+
+    context "node" do
+      should "have a root" do
+        assert_equal @root_1.root, @root_1
+        assert_not_equal @root_1.root, @root_2.root
+        assert_equal @root_1, @child_2_1.root
+      end
+
+      should "have ancestors" do
+        assert_equal @root_1.ancestors, []
+        assert_equal @child_2_1.ancestors, [@root_1, @child_2]
+        assert_equal @root_1.self_and_ancestors, [@root_1]
+        assert_equal @child_2_1.self_and_ancestors, [@root_1, @child_2, @child_2_1]
+      end
+
+      should "have siblings" do
+        assert eql_arrays?(@root_1.siblings, [@root_2])
+        assert eql_arrays?(@child_2.siblings, [@child_1, @child_3])
+        assert eql_arrays?(@child_2_1.siblings, [])
+        assert eql_arrays?(@root_1.self_and_siblings, [@root_1, @root_2])
+        assert eql_arrays?(@child_2.self_and_siblings, [@child_1, @child_2, @child_3])
+        assert eql_arrays?(@child_2_1.self_and_siblings, [@child_2_1])
+      end
+
+      should "set depth" do
+        assert_equal 0, @root_1.depth
+        assert_equal 1, @child_1.depth
+        assert_equal 2, @child_2_1.depth
+      end
+
+      should "have children" do
+        assert @child_2_1.children.empty?
+        assert eql_arrays?(@root_1.children, [@child_1, @child_2, @child_3])
+      end
+
+      should "have descendants" do
+        assert eql_arrays?(@root_1.descendants, [@child_1, @child_2, @child_3, @child_2_1])
+        assert eql_arrays?(@child_2.descendants, [@child_2_1])
+        assert @child_2_1.descendants.empty?
+        assert eql_arrays?(@root_1.self_and_descendants, [@root_1, @child_1, @child_2, @child_3, @child_2_1])
+        assert eql_arrays?(@child_2.self_and_descendants, [@child_2, @child_2_1])
+        assert eql_arrays?(@child_2_1.self_and_descendants, [@child_2_1])
+      end
+
+      should "be able to tell if ancestor" do
+        assert @root_1.is_ancestor_of?(@child_1)
+        assert ! @root_2.is_ancestor_of?(@child_2_1)
+        assert ! @child_2.is_ancestor_of?(@child_2)
+
+        assert @root_1.is_or_is_ancestor_of?(@child_1)
+        assert ! @root_2.is_or_is_ancestor_of?(@child_2_1)
+        assert @child_2.is_or_is_ancestor_of?(@child_2)
+      end
+
+      should "be able to tell if descendant" do
+        assert ! @root_1.is_descendant_of?(@child_1)
+        assert @child_1.is_descendant_of?(@root_1)
+        assert ! @child_2.is_descendant_of?(@child_2)
+
+        assert ! @root_1.is_or_is_descendant_of?(@child_1)
+        assert @child_1.is_or_is_descendant_of?(@root_1)
+        assert @child_2.is_or_is_descendant_of?(@child_2)
+      end
+
+      should "be able to tell if sibling" do
+        assert ! @root_1.is_sibling_of?(@child_1)
+        assert ! @child_1.is_sibling_of?(@child_1)
+        assert ! @child_2.is_sibling_of?(@child_2)
+
+        assert ! @root_1.is_or_is_sibling_of?(@child_1)
+        assert @child_1.is_or_is_sibling_of?(@child_2)
+        assert @child_2.is_or_is_sibling_of?(@child_2)
+      end
+
+      context "when moving" do
+        should "recalculate path and depth" do
+          @child_3.parent = @child_2
+          @child_3.save
+
+          assert @child_2.is_or_is_ancestor_of?(@child_3)
+          assert @child_3.is_or_is_descendant_of?(@child_2)
+          assert @child_2.children.include?(@child_3)
+          assert @child_2.descendants.include?(@child_3)
+          assert @child_2_1.is_or_is_sibling_of?(@child_3)
+          assert_equal 2, @child_3.depth
+        end
+
+        should "move children on save" do
+          @child_2.parent = @root_2
+
+          assert ! @root_2.is_or_is_ancestor_of?(@child_2_1)
+          assert ! @child_2_1.is_or_is_descendant_of?(@root_2)
+          assert ! @root_2.descendants.include?(@child_2_1)
+
+          @child_2.save
+          @child_2_1.reload
+
+          assert @root_2.is_or_is_ancestor_of?(@child_2_1)
+          assert @child_2_1.is_or_is_descendant_of?(@root_2)
+          assert @root_2.descendants.include?(@child_2_1)
+        end
+
+        should "check against cyclic graph" do
+          @root_1.parent = @child_2_1
+          assert ! @root_1.valid?
+          assert_equal I18n.t(:'mongo_mapper.errors.messages.cyclic'), @root_1.errors[:base].first
+        end
+
+        should "be able to become root" do
+          @child_2.parent = nil
+          @child_2.save
+          @child_2.reload
+          assert_nil @child_2.parent
+          @child_2_1.reload
+          assert (@child_2_1.path == [@child_2.id])
+        end
+
+      end
+
+      should "destroy descendants when destroyed" do
+        @child_2.destroy
+        assert_nil Category.find(@child_2_1._id)
+      end
+    end
+
+    context "root node" do
+      should "not have a parent" do
+        assert_nil @root_1.parent
+      end
+    end
+
+    context "child_node" do
+      should "have a parent" do
+        assert_equal @child_2, @child_2_1.parent
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: mongo_mapper_tree
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Joel Junstr\xC3\xB6m"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-05 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongo_mapper
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.10"
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+description: An Acts As Tree like implementation for MongoMapper based on mongo_mapper_acts_as_tree
+email: 
+- joel.junstrom@oktavilla.se
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/locale/en.yml
+- lib/mongo_mapper/plugins/tree.rb
+- lib/mongo_mapper_tree.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_tree.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/Oktavilla/mongo_mapper_tree
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -4220793794743588163
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -4220793794743588163
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: An Acts As Tree like implementation 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_tree.rb