mongoid_nested_set 0.1.0

data/.document

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

data/.rspec

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

data/Gemfile

@@ -0,0 +1,19 @@
+source "http://rubygems.org"
+
+gem "mongoid", ">= 2.0.0.beta.20"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.1"
+  gem "rcov", ">= 0"
+  gem 'rspec-core'
+end
+
+group :test do
+  gem 'rspec-expectations'
+  gem 'rr'
+  gem 'remarkable_mongoid'
+  gem 'database_cleaner'
+end

data/Gemfile.lock

@@ -0,0 +1,59 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activesupport (3.0.3)
+    bson (1.1.4)
+    builder (2.1.2)
+    database_cleaner (0.6.0)
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    i18n (0.5.0)
+    jeweler (1.5.1)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    mongo (1.1.4)
+      bson (>= 1.1.1)
+    mongoid (2.0.0.beta.20)
+      activemodel (~> 3.0)
+      mongo (~> 1.1)
+      tzinfo (~> 0.3.22)
+      will_paginate (~> 3.0.pre)
+    rake (0.8.7)
+    rcov (0.9.9)
+    remarkable (4.0.0.alpha4)
+      rspec (>= 2.0.0.alpha11)
+    remarkable_activemodel (4.0.0.alpha4)
+      remarkable (~> 4.0.0.alpha4)
+      rspec (>= 2.0.0.alpha11)
+    remarkable_mongoid (0.5.0)
+      remarkable_activemodel (>= 4.0.0.alpha2)
+    rr (1.0.2)
+    rspec (2.2.0)
+      rspec-core (~> 2.2)
+      rspec-expectations (~> 2.2)
+      rspec-mocks (~> 2.2)
+    rspec-core (2.2.1)
+    rspec-expectations (2.2.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.2.0)
+    tzinfo (0.3.23)
+    will_paginate (3.0.pre2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  database_cleaner
+  jeweler (~> 1.5.1)
+  mongoid (>= 2.0.0.beta.20)
+  rcov
+  remarkable_mongoid
+  rr
+  rspec-core
+  rspec-expectations

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Brandon Turner
+
+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.markdown

@@ -0,0 +1,147 @@
+Mongoid Nested Set
+==================
+
+Mongoid Nested Set is an implementation of the nested set pattern for Mongoid.
+It is a port of [AwesomeNestedSet for ActiveRecord](https://github.com/galetahub/awesome_nested_set).
+It supports Mongoid 2 and Rails 3.
+
+Nested Set represents hierarchies of trees in MongoDB using references rather
+than embedded documents.  A tree is stored as a flat list of documents in a
+collection.  Nested Set allows quick, ordered queries of nodes and their
+descendants.  Tree modification is more costly.  The nested set pattern is
+ideal for models that are read more frequently than modified.
+
+For more on the nested set pattern: <http://en.wikipedia.org/wiki/Nested_set_model>
+
+
+## Installation
+
+Install as Gem
+
+    gem install mongoid_nested_set
+
+via Gemfile
+
+    gem 'mongoid_nested_set', '0.1.0'
+
+
+## Usage
+
+To start using Mongoid Nested Set, just declare `acts_as_nested_set` on your
+model:
+
+    class Category
+        include Mongoid::Document
+        acts_as_nested_set
+    end
+
+### Creating a root node
+
+    root = Category.create(:name => 'Root Category')
+
+### Inserting a node
+
+    child1 = root.children.create(:name => 'Child Category #1')
+
+    child2 = Category.create(:name => 'Child Category #2')
+    root.children << child2
+
+### Deleting a node
+
+    child1.destroy
+
+Descendants of a destroyed nodes will also be deleted.  By default, descendant's
+`destroy` method will not be called.  To enable calling descendant's `destroy`
+method:
+
+    class Category
+        include Mongoid::Document
+        acts_as_nested_set :dependent => :destroy
+    end
+
+### Moving a node
+
+Several methods exist for moving nodes:
+
+* move\_left
+* move\_right
+* move\_to\_left\_of(other_node)
+* move\_to\_right\_of(other_node)
+* move\_to\_child\_of(other_node)
+* move\_to\_root
+
+
+### Scopes
+
+Scopes restrict what is considered a list.  This is commonly used to represent multiple trees
+(or multiple roots) in a single collection.
+
+    class Category
+        include Mongoid::Document
+        acts_as_nested_set :scope => :root_id
+    end
+
+### Conversion from other trees
+
+Coming from acts_as_tree or adjacency list system where you only have parent_id?
+No problem.  Simply add `acts_as_nested_set` and run:
+
+    Category.rebuild!
+
+Your tree will be converted to a valid nested set.
+
+
+### Outline Numbering
+
+Mongoid Nested Set can manage outline numbers (e.g. 1.3.2) for your documents if
+you wish.  Simply add `:outline_number_field`:
+
+    acts_as_nested_set, :outline_number_field => 'number'
+
+Your documents will now include a `number` field (you can call it anything you
+wish) that will contain outline numbers.
+
+Don't like the outline numbers format?  Simply override `outline_number_seperator`,
+`build_outline_number`, or `outline_number_sequence` in your model classes.  For
+example:
+
+    class Category
+        include Mongoid::Document
+        acts_as_nested_set :scope => :root_id, :outline_number_field => 'number'
+
+        # Use a dash instead of a dot for outline numbers
+        # e.g. 1-3-2
+        def outline_number_seperator
+            '-'
+        end
+
+        # Use 0-based indexing instead of 1-based indexing
+        # e.g. 1.0
+        def outline_number_sequence(prev_siblings)
+            prev_siblings.count
+        end
+    end
+
+
+## References
+
+You can learn more about nested sets at:
+
+<http://en.wikipedia.org/wiki/Nested_set_model>  
+<http://dev.mysql.com/tech-resources/articles/hierarchical-data.html>
+
+
+## Contributing to mongoid\_nested\_set
+
+* 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 I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2010 Brandon Turner. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,47 @@
+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 = "mongoid_nested_set"
+  gem.homepage = "http://github.com/thinkwell/mongoid_nested_set"
+  gem.license = "MIT"
+  gem.summary = %Q{Nested set based tree implementation for Mongoid}
+  gem.description = %Q{Fully featured tree implementation for Mongoid using the nested set model}
+  gem.email = "bturner@bltweb.net"
+  gem.authors = ["Brandon Turner"]
+
+  gem.add_runtime_dependency('mongoid', '>= 2.0.0.beta.20')
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+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 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "mongoid_nested_set #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/mongoid_nested_set.rb

@@ -0,0 +1,40 @@
+
+require 'mongoid_nested_set/remove_order_by'
+
+# This acts provides Nested Set functionality.  Nested Set is a smart way to implement
+# an _ordered_ tree, with the added feature that you can select the children and all of
+# their descendants with a single query.  The drawback is that insertion or move need
+# multiple queries.  But everything is done here by this module!
+#
+# Nested sets are appropriate each time you want either an ordered tree (menus,
+# commercial categories) or an efficient way of querying big trees (threaded posts).
+#
+# == API
+#
+# Method names are aligned with acts_as_tree as much as possible to make replacement
+# from one by another easier.
+#
+#   item.children.create(:name => 'child1')
+#
+module Mongoid
+  module Acts
+    module NestedSet
+      require 'mongoid_nested_set/base'
+      autoload :Document,      'mongoid_nested_set/document'
+      autoload :Fields,        'mongoid_nested_set/fields'
+      autoload :Rebuild,       'mongoid_nested_set/rebuild'
+      autoload :Relations,     'mongoid_nested_set/relations'
+      autoload :Update,        'mongoid_nested_set/update'
+      autoload :Validation,    'mongoid_nested_set/validation'
+      autoload :OutlineNumber, 'mongoid_nested_set/outline_number'
+
+      def self.included(base)
+        base.extend(Base)
+      end
+    end
+  end
+end
+
+
+# Enable the acts_as_nested_set method
+Mongoid::Document::ClassMethods.send(:include, Mongoid::Acts::NestedSet::Base)

data/lib/mongoid_nested_set/base.rb

@@ -0,0 +1,90 @@
+module Mongoid::Acts::NestedSet
+
+  module Base
+
+    # Configuration options are:
+    #
+    # * +:parent_field+ - field name to use for keeping the parent id (default: parent_id)
+    # * +:left_field+ - field name for left boundary data, default 'lft'
+    # * +:right_field+ - field name for right boundary data, default 'rgt'
+    # * +:outline_number_field+ - field name for the number field, default nil.  If set,
+    #   the value will be used as a field name to keep track of each node's
+    #   "outline number" (e.g. 1.2.5).
+    # * +:scope+ - restricts what is to be considered a list.  Given a symbol, it'll attach
+    #   "_id" (if it hasn't been already) and use that as the foreign key restriction.  You
+    #   can also pass an array to scope by multiple attributes
+    # * +:dependent+ - behavior for cascading destroy.  If set to :destroy, all the child
+    #   objects are destroyed alongside this object by calling their destroy method.  If set
+    #   to :delete_all (default), all the child objects are deleted without calling their
+    #   destroy method.
+    # * +:klass+ - class to use for queries (defaults to self)
+    #
+    # See Mongoid::Acts::NestedSet::ClassMethods for a list of class methods and
+    # Mongoid::Acts::NestedSet::InstanceMethods for a list of instance methods added to
+    # acts_as_nested_set models
+    def acts_as_nested_set(options = {})
+      options = {
+        :parent_field => 'parent_id',
+        :left_field => 'lft',
+        :right_field => 'rgt',
+        :outline_number_field => nil,
+        :dependent => :delete_all, # or :destroy
+        :klass => self,
+      }.merge(options)
+
+      if options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/
+        options[:scope] = "#{options[:scope]}_id".intern
+      end
+
+      class_attribute :acts_as_nested_set_options, :instance_writer => false
+      self.acts_as_nested_set_options = options
+
+      unless self.is_a?(Document::ClassMethods)
+        include Document
+        include OutlineNumber if outline_number_field_name
+
+        field left_field_name, :type => Integer
+        field right_field_name, :type => Integer
+        field outline_number_field_name if outline_number_field_name
+        field :depth, :type => Integer
+
+        references_many :children, :class_name => self.name, :foreign_key => parent_field_name, :inverse_of => :parent, :default_order => criteria.asc(left_field_name)
+        referenced_in   :parent,   :class_name => self.name, :foreign_key => parent_field_name
+
+        attr_accessor :skip_before_destroy
+
+        if accessible_attributes.blank?
+          attr_protected left_field_name.intern, right_field_name.intern
+        end
+
+        define_callbacks :move, :terminator => "result == false"
+
+        before_create  :set_default_left_and_right
+        before_save    :store_new_parent
+        after_save     :move_to_new_parent
+        before_destroy :destroy_descendants
+
+        # no assignment to structure fields
+        [left_field_name, right_field_name].each do |field|
+          module_eval <<-"end_eval", __FILE__, __LINE__
+                  def #{field}=(x)
+                    raise NameError, "Unauthorized assignment to #{field}: it's an internal field handled by acts_as_nested_set code, use move_to_* methods instead.", "#{field}"
+                  end
+          end_eval
+        end
+
+        scope :roots, lambda {
+          where(parent_field_name => nil).asc(left_field_name)
+        }
+        scope :leaves, lambda {
+          where("this.#{quoted_right_field_name} - this.#{quoted_left_field_name} == 1").asc(left_field_name)
+        }
+        scope :with_depth, lambda { |level|
+          where(:depth => level).asc(left_field_name)
+        }
+
+      end
+    end
+  end
+
+end

data/lib/mongoid_nested_set/document.rb

@@ -0,0 +1,207 @@
+module Mongoid::Acts::NestedSet
+
+  module Document
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+
+
+    module ClassMethods
+
+      include Rebuild
+      include Validation
+      include Fields
+
+      # Returns the first root
+      def root
+        roots.first
+      end
+
+
+      def scope_condition_by_options(options)
+        h = {}
+        scope_string = Array(acts_as_nested_set_options[:scope]).reject{|s| !options.has_key?(s) }.each do |c|
+          h[c] = options[c]
+        end
+        h
+      end
+
+
+      # Iterates over tree elements and determines the current level in the tree.
+      # Only accepts default ordering, ordering by an other field than lft
+      # does not work.  This method is much more efficient then calling level
+      # because it doesn't require any additional database queries.
+      # This method does not used the cached depth field.
+      #
+      # Example:
+      #   Category.each_with_level(Category.root.self_and_descendants) do |o, level|
+      #
+      def each_with_level(objects)
+        offset = nil
+        path = [nil]
+        objects.each do |o|
+          if offset == nil
+            offset = o.parent_id.nil? ? 0 : o.parent.level
+          end
+          if o.parent_id != path.last
+            # we are on a new level, did we descend or ascend?
+            if path.include?(o.parent_id)
+              # remove wrong tailing path elements
+              path.pop while path.last != o.parent_id
+            else
+              path << o.parent_id
+            end
+          end
+          yield(o, path.length - 1 + offset)
+        end
+      end
+
+
+      # Provides a chainable relation to select all descendants of a set of records,
+      # excluding the record set itself.
+      # Similar to parent.descendants, except this allows you to find all descendants
+      # of a set of nodes, rather than being restricted to find the descendants of only
+      # a single node.
+      #
+      # Example:
+      #   parents = Category.roots.all
+      #   parents_descendants = Category.where(:deleted => false).descendants_of(parents)
+      #
+      def descendants_of(parents)
+        # TODO: Add root or scope?
+        conditions = parents.map do |parent|
+          {left_field_name => {"$gt" => parent.left}, right_field_name => {"$lt" => parent.right}}
+        end
+        where("$or" => conditions)
+      end
+
+
+      def before_move(*args, &block)
+        set_callback :move, :before, *args, &block
+      end
+
+
+      def after_move(*args, &block)
+        set_callback :move, :after, *args, &block
+      end
+
+    end
+
+
+
+
+    module InstanceMethods
+
+      include Comparable
+      include Relations
+      include Update
+      include Fields
+
+      # Value fo the parent field
+      def parent_id
+        self[parent_field_name]
+      end
+
+
+      # Value of the left field
+      def left
+        self[left_field_name]
+      end
+
+
+      # Value of the right field
+      def right
+        self[right_field_name]
+      end
+
+
+      # Returns true if this is a root node
+      def root?
+        parent_id.nil?
+      end
+
+
+      # Returns true if this is a leaf node
+      def leaf?
+        #!new_record? && right - left == 1
+        right - left == 1
+      end
+
+
+      # Returns true if this is a child node
+      def child?
+        !parent_id.nil?
+      end
+
+
+      # Returns true if depth is supported
+      def depth?
+        true
+      end
+
+
+      # Returns true if outline numbering is supported
+      def outline_numbering?
+        !!outline_number_field_name
+      end
+
+
+      # order by left field
+      def <=>(x)
+        left <=> x.left
+      end
+
+
+      # Redefine to act like active record
+      def ==(comparison_object)
+        comparison_object.equal?(self) ||
+          (comparison_object.instance_of?(scope_class) &&
+           comparison_object.id == id &&
+           !comparison_object.new_record?)
+      end
+
+
+      # Check if other model is in the same scope
+      def same_scope?(other)
+        Array(acts_as_nested_set_options[:scope]).all? do |attr|
+          self.send(attr) == other.send(attr)
+        end
+      end
+
+
+      def to_text
+        self_and_descendants.map do |node|
+          "#('*'*(node.level+1)} #{node.id} #{node.to_s} (#{node.parent_id}, #{node.left}, #{node.right})"
+        end.join("\n")
+      end
+
+
+      # All nested set queries should use this nested_set_scope, which performs finds
+      # using the :scope declared in the acts_as_nested_set declaration
+      def nested_set_scope
+        scopes = Array(acts_as_nested_set_options[:scope])
+        conditions = scopes.inject({}) do |conditions,attr|
+          conditions.merge attr => self[attr]
+        end unless scopes.empty?
+        scope_class.criteria.where(conditions).asc(left_field_name)
+      end
+
+
+
+      protected
+
+      def without_self(scope)
+        scope.where(:_id.ne => self.id)
+      end
+
+
+      # reload left, right, and parent
+      def reload_nested_set
+        reload
+      end
+
+    end
+  end # Document
+end # Mongoid::Acts::NestedSet