mongestry 0.5.5

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,20 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+
+gem 'bson_ext'
+gem 'mongoid'
+
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "yard", "~> 0.6.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.2"
+  gem "rcov", ">= 0"
+  gem 'linecache19', '0.5.11'
+  gem 'ruby-debug19'
+end

data/Gemfile.lock

@@ -0,0 +1,64 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.7)
+      activesupport (= 3.0.7)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activesupport (3.0.7)
+    archive-tar-minitar (0.5.2)
+    bson (1.3.1)
+    bson_ext (1.3.1)
+    builder (2.1.2)
+    columnize (0.3.2)
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    i18n (0.5.0)
+    jeweler (1.6.2)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    linecache19 (0.5.11)
+      ruby_core_source (>= 0.1.4)
+    mongo (1.3.1)
+      bson (>= 1.3.1)
+    mongoid (2.0.2)
+      activemodel (~> 3.0)
+      mongo (~> 1.3)
+      tzinfo (~> 0.3.22)
+    rake (0.9.2)
+    rcov (0.9.9)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+    tzinfo (0.3.27)
+    yard (0.6.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bson_ext
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.2)
+  linecache19 (= 0.5.11)
+  mongoid
+  rcov
+  rspec (~> 2.3.0)
+  ruby-debug19
+  yard (~> 0.6.0)

data/LICENSE.txt

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2011 DailyDeal
+
+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,161 @@
+= Mongestry
+
+Mongestry is a gem that allows the records of a Mongoid model to be organized as a tree structure (or hierarchy). It uses a single, intuitively formatted database column, using a variation on the materialised path pattern. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single query. Additional features are scopes, depth caching, depth constraints, easy migration from similar plugins/gems.
+
+Mongestry is inspired by the famous {Ancestry}[https://github.com/stefankroes/ancestry] gem by {Stefan Kroes}[https://github.com/stefankroes]. It implements most of its functionality but lacks some. So be prepared.
+
+= Installation
+
+To apply Mongestry to any Mongoid model, follow these simple steps:
+
+== Gem installation
+
+Add Mongestry to your app's Gemfile:
+
+    gem 'mongestry'
+
+Install required gems:
+
+    bundle install
+
+Add mongestry to your model via the following declarative line:
+
+    has_mongestry
+
+== Example
+
+    class TreeNode
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      field :name, type: String
+
+      has_mongestry
+    end
+
+Your model is now a tree!
+
+= Organizing records into a tree
+
+You can use the parent attribute to organize your records into a tree. If you have the id of the record you want to use as a parent and don't want to fetch it, you can also use parent_id. Like any virtual model attributes, parent and parent_id can be set using parent= and parent_id= on a record or by including them in the hash passed to new, create, create!. For example:
+
+    TreeNode.create! :name => 'Stinky', :parent => TreeNode.create!(:name => 'Squeeky')
+
+As of now you can <b>NOT</b> create children through the children relation on a node, so be patient, this will come in an upcoming release.
+
+= Navigating your tree
+
+To navigate a Mongestry model, use the following methods on any instance / record:
+
+  parent           Returns the parent of the record, nil for a root node
+  parent_id        Returns the id of the parent of the record, nil for a root node
+  root             Returns the root of the tree the record is in, self for a root node
+  root_id          Returns the id of the root of the tree the record is in
+  is_root?         Returns true if the record is a root node, false otherwise
+  ancestor_ids     Returns a list of ancestor ids, starting with the root id and ending with the parent id
+  ancestors        Scopes the model on ancestors of the record
+  children         Scopes the model on children of the record
+  child_ids        Returns a list of child ids
+  has_children?    Returns true if the record has any children, false otherwise
+  is_childless?    Returns true is the record has no childen, false otherwise
+  siblings         Scopes the model on siblings of the record, the record itself is included
+  sibling_ids      Returns a list of sibling ids
+  has_siblings?    Returns true if the record's parent has more than one child
+  is_only_child?   Returns true if the record is the only child of its parent
+  descendants      Scopes the model on direct and indirect children of the record
+  descendant_ids   Returns a list of a descendant ids
+  subtree          Scopes the model on descendants and itself
+  subtree_ids      Returns a list of all ids in the record's subtree
+  depth            Return the depth of the node, root nodes are at depth 0
+
+= Options for has_mongestry
+
+Currently there are none.
+
+= Scopes
+
+Where possible, the navigation methods return scopes instead of records, this means additional ordering, conditions, limits, etc. can be applied and that the result can be either retrieved, counted or checked for existence. For example:
+
+    node.children.exists?(:name => 'Mary')
+    node.subtree.all(:order => :name, :limit => 10).each do; ...; end
+    node.descendants.count
+
+For convenience, a couple of named scopes are included at the class level:
+
+    roots                   # Root nodes
+    ancestors_of(node)      # Ancestors of node, node can be either a record or an id
+    children_of(node)       # Children of node, node can be either a record or an id
+    descendants_of(node)    # Descendants of node, node can be either a record or an id
+    subtree_of(node)        # Subtree of node, node can be either a record or an id
+    siblings_of(node)       # Siblings of node, node can be either a record or an id
+
+== Selecting nodes by depth
+
+In Mongestry depth caching is enabled by default. Therefore five more scopes can be used to select nodes on their depth:
+
+    before_depth(depth)     # Return nodes that are less deep than depth (node.depth < depth)
+    to_depth(depth)         # Return nodes up to a certain depth (node.depth <= depth)
+    at_depth(depth)         # Return nodes that are at depth (node.depth == depth)
+    from_depth(depth)       # Return nodes starting from a certain depth (node.depth >= depth)
+    after_depth(depth)      # Return nodes that are deeper than depth (node.depth > depth)
+
+The depth scopes are also available through calls to descendants, descendant_ids, subtree, subtree_ids, path and ancestors. In this case, depth values are interpreted relatively. Some examples:
+
+    node.subtree(:to_depth => 2)      # Subtree of node, to a depth of node.depth + 2 (self, children and grandchildren)
+    node.subtree.to_depth(5)          # Subtree of node to an absolute depth of 5
+    node.descendants(:at_depth => 2)  # Descendant of node, at depth node.depth + 2 (grandchildren)
+    node.descendants.at_depth(10)     # Descendants of node at an absolute depth of 10
+    node.ancestors.to_depth(3)        # The oldest 4 ancestors of node (its root and 3 more)
+
+    node.ancestors(:from_depth => -6, :to_depth => -4)
+    node.descendants(:from_depth => 2, :to_depth => 4)
+    node.subtree.from_depth(10).to_depth(12)
+
+Please note that depth constraints cannot be passed to ancestor_ids and path_ids. The reason for this is that both these relations can be fetched directly from the ancestry column without performing a database query. It would require an entirely different method of applying the depth constraints which isn't worth the effort of implementing. You can use ancestors(depth_options).map(&:id) or ancestor_ids.slice(min_depth..max_depth) instead.
+
+= Tests
+
+The Mongestry gem comes with a RSpec test suite consisting of about 190+ assertions in about 45+ tests. It takes about 0.2 seconds to run on MongoDB. To run it yourself check out the repository from GitHub, check and fix <em>spec/support/connection.rb</em> to your needs and type:
+
+    rake
+
+= Internals
+
+As can be seen in the previous section, Mongestry stores a path from the root to the parent for every node. This is a variation on the materialised path database pattern. It allows Mongestry to fetch any relation (siblings, descendants, etc.) in a single db request without the complicated algorithms and incomprehensibility associated with left and right values. Additionally, any inserts, deletes and updates only affect nodes within the affected node's own subtree.
+
+In the example above, the ancestry field is created as a string. This puts a limitation on the depth of the tree of about 40 or 50 levels, which I think may be enough for most users. To increase the maximum depth of the tree, increase the size of the string that is being used or change it to a text to remove the limitation entirely. Changing it to a text will however decrease performance because an index cannot be put on the column in that case.
+
+= Limitations
+
+Mongestry was created with Rails3 and Ruby >= 1.9.2 in mind. Sorry. You need Rails2 or Ruby prior to 1.9 support? Feel free to fork, fix and request a pull.
+
+= Missing Features
+
+Compared to {Ancestry}[https://github.com/stefankroes/ancestry] there are some missing features.
+
+- Creation of nodes through relational scopes
+- Integrity checking
+- options for <em>has_mongestry</em> (don't know if we need any)
+- STI support
+- arrangement
+- sorting by ancestry
+- migration from other plugins
+- integrity checking and fixing
+- Rails2 support
+- support for Ruby versions < 1.9
+- instance methods: path, path_ids
+
+= Contributing to Mongestry
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so we can cherry-pick around it.
+
+= Copyright
+
+Copyright (c) 2011 DailyDeal GmbH. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "mongestry"
+  gem.homepage = "http://github.com/DailyDeal/mongestry"
+  gem.license = "MIT"
+  gem.summary = %Q{Mongestry is Ancestry for Mongo}
+  gem.description = %Q{Mongestry is Ancestry for Mongo, build for ORM Mongoid}
+  gem.email = %q{jan.roesner@dailydeal.de lars.kluge@dailydeal.de}
+  gem.authors = ["Jan Roesner", "Lars Kluge"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.5.5

data/lib/mongestry.rb

@@ -0,0 +1,214 @@
+module Mongestry
+
+  class << self.class.superclass
+    def has_mongestry
+      include Mongestry::InstanceMethods
+      field :ancestry, type: String
+      index :ancestry
+      field :persisted_depth, type: Integer
+      before_create :build_ancestry
+    end
+  end
+
+  module InstanceMethods
+
+    def self.included base
+      base.extend Mongestry::ClassMethods
+    end
+
+    def build_ancestry
+      raise "Either parent or parent_id can be given, not both at once" if self.attributes.keys.include?("parent") and self.attributes.keys.include?("parent_id")
+      return unless self.respond_to?(:parent) or self.respond_to?(:parent_id)
+
+      parent = self.class.object_for(self.attributes["parent"] || self.attributes["parent_id"])
+
+      self.ancestry = nil unless parent
+      self.ancestry = parent.ancestry.nil? ? parent.id.to_s : parent.ancestry.to_s + "/#{parent.id.to_s}" if parent
+      self.persisted_depth = parent.depth + 1 rescue 0
+
+      self.attributes.delete("parent")
+      self.attributes.delete("parent_id")
+    end
+
+    # Returns a list of ancestor ids, starting with the root id and ending with the parent id
+    def ancestor_ids
+      self.ancestry.split('/').collect{ |s| BSON::ObjectId.from_string s }
+    end
+
+    # Scopes the model on ancestors of the record
+    def ancestors
+      return [] if self.is_root?
+      self.class.where(_id: {"$in" => self.ancestor_ids})
+    end
+
+    # Returns the parent of the record, nil for a root node
+    def parent
+      self.class.where(_id: self.ancestry.split('/').last).first rescue nil
+    end
+
+    # Returns the id of the parent of the record, nil for a root node
+    def parent_id
+      self.parent.id rescue nil
+    end
+
+    # Returns the root of the tree the record is in, self for a root node
+    def root
+      return self unless self.ancestry
+      self.class.where(_id: self.ancestry.split('/').first).first
+    end
+
+    # Returns the id of the root of the tree the record is in
+    def root_id
+      self.root.id
+    end
+
+    # Returns true if the record is a root node, false otherwise
+    def is_root?
+      self.ancestry.nil?
+    end
+
+    # Scopes the model on children of the record
+    def children
+      case self.is_root?
+      when true
+        self.class.where(:ancestry => self.ancestry.to_s + "#{self.id.to_s}")
+      else
+        self.class.where(:ancestry => self.ancestry.to_s + "/#{self.id.to_s}")
+      end
+    end
+
+    # Returns a list of child ids
+    def child_ids
+      self.children.map(&:id)
+    end
+
+    # Returns true if the record has any children, false otherwise
+    def has_children?
+      !self.children.to_a.blank?
+    end
+
+    # Returns true if the record has no childen, false otherwise
+    def is_childless?
+      !self.has_children?
+    end
+
+    # Scopes the model on siblings of the record, the record itself is included
+    def siblings
+      self.class.where(:ancestry => self.ancestry.to_s).and(:_id => {'$ne' => self.id})
+    end
+
+    # Returns a list of sibling ids
+    def sibling_ids
+      self.siblings.map(&:id)
+    end
+
+    # Returns true if the record's parent has more than one child
+    def has_siblings?
+      self.siblings.present?
+    end
+
+    # Returns true if the record is the only child of its parent
+    def is_only_child?
+      !self.has_siblings?
+    end
+
+    # Scopes the model on direct and indirect children of the record
+    def descendants
+      expression = self.is_root? ? self.id.to_s : (self.ancestry + "/#{self.id.to_s}").split('/').join('\/')
+      self.class.where(:ancestry => Regexp.new(expression))
+    end
+
+    # Returns a list of a descendant ids
+    def descendant_ids
+      self.descendants.map(&:id)
+    end
+
+    # Scopes the model on descendants and itself
+    def subtree
+      self.class.where(_id: {"$in" => self.descendant_ids.push(self.id)})
+    end
+
+    # Returns a list of all ids in the record's subtree
+    def subtree_ids
+      self.subtree.map(&:id)
+    end
+
+    # Return the depth of the node, root nodes are at depth 0
+    def depth
+      self.ancestry.split('/').size rescue 0
+    end
+
+  end
+
+  module ClassMethods
+
+    def object_for identifier
+      return nil if identifier == ""
+      case identifier
+      when BSON::ObjectId
+        self.find identifier
+      when String
+        self.find(BSON::ObjectId.from_string(identifier))
+      when self
+        identifier
+      end
+    end
+
+    #Root nodes
+    def roots
+      self.where(ancestry: nil)
+    end
+
+    # Ancestors of node, node can be either a record or an id
+    def ancestors_of node
+      node.ancestors
+    end
+
+    # Children of node, node can be either a record or an id
+    def children_of node
+      node.children
+    end
+
+    # Descendants of node, node can be either a record or an id
+    def descendants_of node
+      node.descendants
+    end
+
+    # Subtree of node, node can be either a record or an id
+    def subtree_of node
+      node.subtree
+    end
+
+    # Siblings of node, node can be either a record or an id
+    def siblings_of node
+      node.siblings
+    end
+
+    # Return nodes that are less deep than depth (node.depth < depth)
+    def before_depth depth
+      self.where(persisted_depth: {"$lt" => depth})
+    end
+
+    # Return nodes up to a certain depth (node.depth <= depth)
+    def to_depth depth
+      self.where(persisted_depth: {"$lte" => depth})
+    end
+
+    # Return nodes that are at depth (node.depth == depth)
+    def at_depth depth
+      self.where(persisted_depth: depth)
+    end
+
+    # Return nodes starting from a certain depth (node.depth >= depth)
+    def from_depth depth
+      self.where(persisted_depth: {"$gte" => depth})
+    end
+
+    # Return nodes that are deeper than depth (node.depth > depth)
+    def after_depth depth
+      self.where(persisted_depth: {"$gt" => depth})
+    end
+
+  end
+
+end

data/mongestry.gemspec

@@ -0,0 +1,78 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mongestry}
+  s.version = "0.5.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jan Roesner", "Lars Kluge"]
+  s.date = %q{2011-07-20}
+  s.description = %q{Mongestry is Ancestry for Mongo, build for ORM Mongoid}
+  s.email = %q{jan.roesner@dailydeal.de lars.kluge@dailydeal.de}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/mongestry.rb",
+    "mongestry.gemspec",
+    "spec/mongestry_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/support/category.rb",
+    "spec/support/connection.rb"
+  ]
+  s.homepage = %q{http://github.com/DailyDeal/mongestry}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Mongestry is Ancestry for Mongo}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<bson_ext>, [">= 0"])
+      s.add_runtime_dependency(%q<mongoid>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<yard>, ["~> 0.6.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<linecache19>, ["= 0.5.11"])
+      s.add_development_dependency(%q<ruby-debug19>, [">= 0"])
+    else
+      s.add_dependency(%q<bson_ext>, [">= 0"])
+      s.add_dependency(%q<mongoid>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<yard>, ["~> 0.6.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<linecache19>, ["= 0.5.11"])
+      s.add_dependency(%q<ruby-debug19>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<bson_ext>, [">= 0"])
+    s.add_dependency(%q<mongoid>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<yard>, ["~> 0.6.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<linecache19>, ["= 0.5.11"])
+    s.add_dependency(%q<ruby-debug19>, [">= 0"])
+  end
+end
+

data/spec/mongestry_spec.rb

@@ -0,0 +1,450 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+def initialize_country_tree
+  @root        = Category.create!(name: "Root",        persisted_depth: 0)
+  @germany     = Category.create!(name: "Germany",     persisted_depth: 1, ancestry: "#{@root.id}")
+  @switzerland = Category.create!(name: "Switzerland", persisted_depth: 1, ancestry: "#{@root.id}")
+  @austria     = Category.create!(name: "Austria",     persisted_depth: 1, ancestry: "#{@root.id}")
+  @berlin      = Category.create!(name: "Berlin",      persisted_depth: 2, ancestry: "#{@root.id}/#{@germany.id}")
+  @munich      = Category.create!(name: "Munich",      persisted_depth: 2, ancestry: "#{@root.id}/#{@germany.id}")
+  @hamburg     = Category.create!(name: "Hamburg",     persisted_depth: 2, ancestry: "#{@root.id}/#{@germany.id}")
+  @bern        = Category.create!(name: "Bern",        persisted_depth: 2, ancestry: "#{@root.id}/#{@switzerland.id}")
+  @zurich      = Category.create!(name: "Zurich",      persisted_depth: 2, ancestry: "#{@root.id}/#{@switzerland.id}")
+  @vienna      = Category.create!(name: "Vienna",      persisted_depth: 2, ancestry: "#{@root.id}/#{@austria.id}")
+  @graz        = Category.create!(name: "Graz",        persisted_depth: 2, ancestry: "#{@root.id}/#{@austria.id}")
+  @pankow      = Category.create!(name: "Pankow",      persisted_depth: 3, ancestry: "#{@root.id}/#{@germany.id}/#{@berlin.id}")
+end
+
+describe "Mongestry" do
+  context "with fixed tree" do
+
+    before :all do
+      Category.destroy_all
+      initialize_country_tree
+      Category.class_eval{ has_mongestry }
+    end
+
+    describe '#has_mongestry' do
+
+      it 'should include instance methods into class where invoked' do
+        class Foo
+          include Mongoid::Document
+          has_mongestry
+        end
+
+        [:build_ancestry, :ancestor_ids, :ancestors, :parent, :parent_id, :root, :root_id, :is_root?, :children, :child_ids, :has_children?, :is_childless?, :siblings, :sibling_ids, :has_siblings?, :is_only_child?, :descendants, :descendant_ids, :subtree, :subtree_ids, :depth].each do |method|
+          Foo.new.respond_to?(method).should be_true
+        end
+
+      end
+
+      it 'should include class methods into class where invoked' do
+        class Bar
+          include Mongoid::Document
+          has_mongestry
+        end
+
+        [:roots, :ancestors_of, :children_of, :descendants_of, :subtree_of, :siblings_of, :before_depth, :to_depth, :at_depth, :from_depth, :after_depth, :object_for].each do |method|
+          Bar.respond_to?(method).should be_true
+        end
+      end
+    end
+
+    describe '#ancestor_ids' do
+      it 'should return the ancestor_ids of the given node' do
+        ids = Category.where(name:"Pankow").first.ancestor_ids
+
+        ids.size.should == 3
+        ids.include?(@berlin.id).should  be_true
+        ids.include?(@germany.id).should be_true
+        ids.include?(@root.id).should    be_true
+      end
+    end
+
+    describe '#ancestors' do
+      it 'should return ancestors of the given node scoped' do
+        ancestors = Category.where(name:"Pankow").first.ancestors.to_a
+
+        ancestors.size.should == 3
+        ancestors.include?(@berlin).should  be_true
+        ancestors.include?(@germany).should be_true
+        ancestors.include?(@root).should    be_true
+      end
+
+      it 'should return an empty array if called on a root category' do
+        ancestors = Category.where(name: "Root").first.ancestors.to_a
+        ancestors.size.should == 0
+      end
+    end
+
+    describe '#parent' do
+      it 'should return the given nodes parent' do
+        Category.where(name: "Germany").first.parent.should == @root
+        Category.where(name: "Pankow").first.parent.should  == @berlin
+        Category.roots.first.parent.should be_nil
+      end
+    end
+
+    describe '#parent_id' do
+      it 'should return the given nodes parents id' do
+        Category.where(name: "Germany").first.parent_id.should == @root.id
+        Category.where(name: "Pankow").first.parent_id.should  == @berlin.id
+        Category.roots.first.parent_id.should be_nil
+      end
+    end
+
+    describe '#root' do
+      it 'should return the root of the tree of the given node' do
+        Category.where(name: "Pankow").first.root.should  eql @root
+        Category.where(name: "Berlin").first.root.should  eql @root
+        Category.where(name: "Germany").first.root.should eql @root
+        Category.where(name: "Root").first.root.should    eql @root
+      end
+    end
+
+    describe '#root_id' do
+      it 'should return the id of the root of the tree of the given node' do
+        Category.where(name: "Pankow").first.root_id.should  eql @root.id
+        Category.where(name: "Berlin").first.root_id.should  eql @root.id
+        Category.where(name: "Germany").first.root_id.should eql @root.id
+        Category.where(name: "Root").first.root_id.should    eql @root.id
+      end
+    end
+
+    describe '#is_root?' do
+      it 'should return true if given node is a root' do
+        Category.where(name: "Root").first.is_root?.should be_true
+      end
+      it 'should return false if given node is no root' do
+        Category.where(name: "Pankow").first.is_root?.should  be_false
+        Category.where(name: "Germany").first.is_root?.should be_false
+        Category.where(name: "Berlin").first.is_root?.should  be_false
+        Category.where(name: "Bern").first.is_root?.should    be_false
+      end
+    end
+
+    describe '#children' do
+      it 'should return the given nodes children scoped' do
+        children_scope = Category.where(name: "Germany").first.children
+        children_scope.is_a?(Mongoid::Criteria).should     be_true
+        children_scope.count.should                        == 3
+        children_scope.to_a.include?(@berlin).should       be_true
+        children_scope.to_a.include?(@hamburg).should      be_true
+        children_scope.to_a.include?(@munich).should       be_true
+      end
+    end
+
+    describe '#child_ids' do
+      it 'should return the given nodes childs ids' do
+        ids = Category.where(name: "Germany").first.child_ids
+        ids.count.should                      == 3
+        ids.include?(@berlin.id).should       be_true
+        ids.include?(@hamburg.id).should      be_true
+        ids.include?(@munich.id).should       be_true
+      end
+    end
+
+    describe '#has_children?' do
+      it 'should return true if given node has children' do
+        Category.where(name: "Root").first.has_children?.should    be_true
+        Category.where(name: "Germany").first.has_children?.should be_true
+        Category.where(name: "Berlin").first.has_children?.should  be_true
+      end
+      it 'should return false if given node has no children' do
+        Category.where(name: "Pankow").first.has_children?.should be_false
+        Category.where(name: "Bern").first.has_children?.should   be_false
+        Category.where(name: "Zurich").first.has_children?.should be_false
+      end
+    end
+
+    describe '#is_childless?' do
+      it 'should return true if given node has no children' do
+        Category.where(name: "Root").first.is_childless?.should    be_false
+        Category.where(name: "Germany").first.is_childless?.should be_false
+        Category.where(name: "Berlin").first.is_childless?.should  be_false
+      end
+      it 'should return false if given node has children' do
+        Category.where(name: "Pankow").first.is_childless?.should be_true
+        Category.where(name: "Bern").first.is_childless?.should   be_true
+        Category.where(name: "Zurich").first.is_childless?.should be_true
+      end
+    end
+
+    describe '#siblings' do
+      it 'should return the given nodes siblings scoped' do
+        siblings_scope = Category.where(name: "Berlin").first.siblings
+        siblings_scope.is_a?(Mongoid::Criteria).should be_true
+        siblings_scope.to_a.size.should == 2
+        siblings_scope.to_a.include?(@hamburg).should  be_true
+        siblings_scope.to_a.include?(@munich).should   be_true
+      end
+    end
+
+    describe '#sibling_ids' do
+      it 'should return the given nodes siblings ids' do
+        ids = Category.where(name: "Berlin").first.sibling_ids
+        ids.size.should == 2
+        ids.include?(@hamburg.id).should  be_true
+        ids.include?(@munich.id).should   be_true
+      end
+    end
+
+    describe '#has_siblings?' do
+      it 'should return true if given node has siblings' do
+        Category.where(name: "Berlin").first.has_siblings?.should  be_true
+        Category.where(name: "Bern").first.has_siblings?.should    be_true
+        Category.where(name: "Germany").first.has_siblings?.should be_true
+      end
+      it 'should return false if given node has no siblings' do
+        Category.where(name: "Root").first.has_siblings?.should   be_false
+        Category.where(name: "Pankow").first.has_siblings?.should be_false
+      end
+    end
+
+    describe '#is_only_child?' do
+      it 'should return true if given node has no siblings' do
+        Category.where(name: "Berlin").first.is_only_child?.should  be_false
+        Category.where(name: "Bern").first.is_only_child?.should    be_false
+        Category.where(name: "Germany").first.is_only_child?.should be_false
+      end
+      it 'should return false if given node has siblings' do
+        Category.where(name: "Root").first.is_only_child?.should   be_true
+        Category.where(name: "Pankow").first.is_only_child?.should be_true
+      end
+    end
+
+    describe '#descendants' do
+      it 'should return the given nodes descendants scoped' do
+        desc_scope = Category.where(name: "Germany").first.descendants
+        desc_scope.is_a?(Mongoid::Criteria).should be_true
+        desc_scope.to_a.size.should == 4
+        desc_scope.to_a.include?(@berlin).should   be_true
+        desc_scope.to_a.include?(@hamburg).should  be_true
+        desc_scope.to_a.include?(@munich).should   be_true
+        desc_scope.to_a.include?(@pankow).should   be_true
+      end
+    end
+
+    describe '#descendant_ids' do
+      it 'should return the given nodes descendants ids' do
+        ids = Category.where(name: "Germany").first.descendant_ids
+        ids.size.should == 4
+        ids.include?(@berlin.id).should   be_true
+        ids.include?(@hamburg.id).should  be_true
+        ids.include?(@munich.id).should   be_true
+        ids.include?(@pankow.id).should   be_true
+      end
+    end
+
+    describe '#subtree' do
+      it 'should return the given nodes subtree including the node itself' do
+        subtree_scope = Category.where(name: "Germany").first.subtree
+        subtree_scope.is_a?(Mongoid::Criteria).should be_true
+        subtree_scope.to_a.size.should == 5
+        subtree_scope.to_a.include?(@germany).should  be_true
+        subtree_scope.to_a.include?(@berlin).should   be_true
+        subtree_scope.to_a.include?(@hamburg).should  be_true
+        subtree_scope.to_a.include?(@munich).should   be_true
+        subtree_scope.to_a.include?(@pankow).should   be_true
+      end
+    end
+
+    describe '#subtree_ids' do
+      it 'should return the ids of the given nodes subtree including the code itself' do
+        ids = Category.where(name: "Germany").first.subtree_ids
+        ids.size.should == 5
+        ids.include?(@germany.id).should  be_true
+        ids.include?(@berlin.id).should   be_true
+        ids.include?(@hamburg.id).should  be_true
+        ids.include?(@munich.id).should   be_true
+        ids.include?(@pankow.id).should   be_true
+      end
+    end
+
+    describe '#depth' do
+      it 'should return the computed depth of the given node' do
+        Category.all.each do |category|
+          category.depth.should == category.persisted_depth
+        end
+      end
+    end
+
+    describe '#object_for' do
+      it 'should return the correct object if object was given' do
+        Category.object_for(Category.where(name: "Berlin").first).should      == @berlin
+        Category.object_for(Category.where(name: "Germany").first).should     == @germany
+        Category.object_for(Category.where(name: "Root").first).should        == @root
+      end
+      it 'should return the correct object if object_id was given as BSON::ObjectId' do
+        Category.object_for(Category.where(name: "Berlin").first.id).should      == @berlin
+        Category.object_for(Category.where(name: "Germany").first.id).should     == @germany
+        Category.object_for(Category.where(name: "Root").first.id).should        == @root
+      end
+      it 'should return the correct object if object_id was given as String' do
+        Category.object_for(Category.where(name: "Berlin").first.id.to_s).should      == @berlin
+        Category.object_for(Category.where(name: "Germany").first.id.to_s).should     == @germany
+        Category.object_for(Category.where(name: "Root").first.id.to_s).should        == @root
+      end
+      it 'should return nil in case an empty string is given as object_id' do
+        Category.object_for("").should be_nil
+      end
+    end
+
+    describe '#roots' do
+      it 'should return all available roots scoped' do
+        roots_scope = Category.roots
+        roots_scope.is_a?(Mongoid::Criteria).should be_true
+        roots_scope.to_a.size.should == 1
+        roots_scope.to_a.include?(@root).should be_true
+      end
+    end
+
+    describe '#ancestors_of node' do
+      it 'should return the given nodes ancestors scoped' do
+        anc_scope = Category.ancestors_of(Category.where(name: "Pankow").first)
+        anc_scope.is_a?(Mongoid::Criteria).should be_true
+        anc_scope.to_a.size.should == 3
+        anc_scope.to_a.include?(@berlin).should   be_true
+        anc_scope.to_a.include?(@germany).should  be_true
+        anc_scope.to_a.include?(@root).should     be_true
+      end
+    end
+
+    describe '#children_of node' do
+      it 'should return the given nodes children scoped' do
+        child_scope = Category.children_of(Category.where(name: "Germany").first)
+        child_scope.is_a?(Mongoid::Criteria).should be_true
+        child_scope.to_a.size.should == 3
+        child_scope.to_a.include?(@berlin).should   be_true
+        child_scope.to_a.include?(@hamburg).should  be_true
+        child_scope.to_a.include?(@munich).should   be_true
+      end
+    end
+
+    describe '#descendants_of node' do
+      it 'should return the given nodes descendants scoped' do
+        desc_scope = Category.descendants_of(Category.where(name: "Germany").first)
+        desc_scope.is_a?(Mongoid::Criteria).should be_true
+        desc_scope.to_a.size.should == 4
+        desc_scope.to_a.include?(@berlin).should   be_true
+        desc_scope.to_a.include?(@munich).should   be_true
+        desc_scope.to_a.include?(@hamburg).should  be_true
+        desc_scope.to_a.include?(@pankow).should   be_true
+      end
+    end
+
+    describe '#subtree_of node' do
+      it 'should return the given nodes subtree scoped' do
+        subtree_scope = Category.subtree_of(Category.where(name: "Germany").first)
+        subtree_scope.is_a?(Mongoid::Criteria).should be_true
+        subtree_scope.to_a.size.should == 5
+        subtree_scope.to_a.include?(@germany).should  be_true
+        subtree_scope.to_a.include?(@berlin).should   be_true
+        subtree_scope.to_a.include?(@munich).should   be_true
+        subtree_scope.to_a.include?(@hamburg).should  be_true
+        subtree_scope.to_a.include?(@pankow).should   be_true
+      end
+    end
+
+    describe '#siblings_of node' do
+      it 'should return the given nodes siblings scoped' do
+        siblings_scope = Category.siblings_of(Category.where(name: "Berlin").first)
+        siblings_scope.is_a?(Mongoid::Criteria).should be_true
+        siblings_scope.to_a.size.should == 2
+        siblings_scope.to_a.include?(@hamburg).should  be_true
+        siblings_scope.to_a.include?(@munich).should   be_true
+      end
+    end
+
+    describe '#before_depth depth' do
+      it 'should return a scope finding objects with a depth less than given depth' do
+        amounts = { 0 => 0, 1 => 1, 2 => 4, 3 => 11, 4 => 12 }
+        0.upto(3) do |depth|
+          Category.before_depth(depth).size.should == amounts[depth]
+          Category.before_depth(depth).each do |category|
+            category.persisted_depth.should < depth
+          end
+        end
+      end
+    end
+
+    describe '#to_depth depth' do
+      it 'should return a scope finding objects with a depth less or equal than given depth' do
+        amounts = { 0 => 1, 1 => 4, 2 => 11, 3 => 12 }
+        0.upto(3) do |depth|
+          Category.to_depth(depth).size.should == amounts[depth]
+          Category.before_depth(depth).each do |category|
+            category.persisted_depth.should <= depth
+          end
+        end
+      end
+    end
+
+    describe '#at_depth depth' do
+      it 'should return a scope finding objects with that exact given depth' do
+        amounts = { 0 => 1, 1 => 3, 2 => 7, 3 => 1 }
+        0.upto(3) do |depth|
+          Category.at_depth(depth).size.should == amounts[depth]
+          Category.at_depth(depth).each do |category|
+            category.persisted_depth.should == depth
+          end
+        end
+      end
+    end
+
+    describe '#from_depth depth' do
+      it 'should return a scope finding objects with a depth greater or equal than given depth' do
+        amounts = { 0 => 12, 1 => 11, 2 => 8, 3 => 1 }
+        0.upto(3) do |depth|
+          Category.from_depth(depth).size.should == amounts[depth]
+          Category.from_depth(depth).each do |category|
+            category.persisted_depth.should >= depth
+          end
+        end
+      end
+    end
+
+    describe '#after_depth depth' do
+      it 'should return a scope finding objects with a depth greater than given depth' do
+        amounts = { 0 => 11, 1 => 8, 2 => 1, 3 => 0 }
+        0.upto(3) do |depth|
+          Category.after_depth(depth).size.should == amounts[depth]
+          Category.after_depth(depth).each do |category|
+            category.persisted_depth.should > depth
+          end
+        end
+      end
+    end
+  end
+
+  context "with new nodes" do
+    describe '#build_ancestry' do
+      it 'should raise an error in case parent and parent_id were given' do
+        lambda{ Category.create(name: "Error", parent: Category.first, parent_id: Category.first.id) }.should raise_error "Either parent or parent_id can be given, not both at once"
+      end
+
+      it 'should set the ancestry string' do
+        category = Category.create!(name: "Correct country", parent: Category.where(name: "Root").first)
+        category.reload.ancestry.should == Category.where(name: "Root").first.id.to_s
+        category = Category.create!(name: "Correct country2", parent_id: Category.where(name: "Root").first.id)
+        category.reload.ancestry.should == Category.where(name: "Root").first.id.to_s
+      end
+
+      it 'should set persisted depth' do
+        category = Category.create!(name: "Depth test", parent: Category.where(name: "Pankow").first)
+        category.reload.persisted_depth.should == 4
+        category = Category.create!(name: "Depth test2", parent: Category.where(name: "Root").first)
+        category.reload.persisted_depth.should == 1
+      end
+
+      it 'should not persist the parent object when given' do
+        category = Category.create!(name: "Persistence test", parent: Category.where(name: "Root").first)
+        category.reload.attributes.keys.include?(:parent).should be_false
+      end
+      it 'should not persist the parent_id when given' do
+        category = Category.create!(name: "Persistence test2", parent: Category.where(name: "Root").first)
+        category.reload.attributes.keys.include?(:parent_id).should be_false
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'mongoid'
+require File.expand_path(File.dirname(__FILE__) + "/support/connection")
+require File.expand_path(File.dirname(__FILE__) + "/support/category")
+require 'rspec'
+require 'mongestry'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/support/category.rb

@@ -0,0 +1,10 @@
+require 'mongestry'
+
+class Category
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  field :name, type: String
+  field :persisted_depth, type: Integer
+  field :ancestry, type: String
+end

data/spec/support/connection.rb

@@ -0,0 +1,3 @@
+Mongoid.configure do |config|
+ config.master = Mongo::Connection.new('localhost', 27017).db('mongestry_test')
+end

metadata

@@ -0,0 +1,206 @@
+--- !ruby/object:Gem::Specification 
+name: mongestry
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 5
+  version: 0.5.5
+platform: ruby
+authors: 
+- Jan Roesner
+- Lars Kluge
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-20 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: yard
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 0
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 6
+        - 2
+        version: 1.6.2
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: linecache19
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 11
+        version: 0.5.11
+  type: :development
+  prerelease: false
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug19
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id009
+description: Mongestry is Ancestry for Mongo, build for ORM Mongoid
+email: jan.roesner@dailydeal.de lars.kluge@dailydeal.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/mongestry.rb
+- mongestry.gemspec
+- spec/mongestry_spec.rb
+- spec/spec_helper.rb
+- spec/support/category.rb
+- spec/support/connection.rb
+has_rdoc: true
+homepage: http://github.com/DailyDeal/mongestry
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 4258898673227910918
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Mongestry is Ancestry for Mongo
+test_files: []
+