glebtv-mongoid_nested_set 0.3.0

data/lib/mongoid_nested_set/outline_number.rb

@@ -0,0 +1,122 @@
+module Mongoid::Acts::NestedSet
+
+  module OutlineNumber
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+
+    module ClassMethods
+
+      # Iterates over tree elements and determines the current outline number in
+      # the tree.
+      # Only accepts default ordering, ordering by an other field than lft
+      # does not work.
+      # This method does not used the cached number field.
+      #
+      # Example:
+      #   Category.each_with_outline_number(Category.root.self_and_descendants) do |o, level|
+      #
+      def each_with_outline_number(objects, parent_number=nil)
+        objects = Array(objects) unless objects.is_a? Array
+
+        stack = []
+        last_num = parent_number
+        objects.each_with_index do |o, i|
+          if i == 0 && last_num == nil && !o.root?
+            last_num = o.parent.outline_number
+          end
+
+          if stack.last.nil? || o.parent_id != stack.last[:parent_id]
+            # we are on a new level, did we descend or ascend?
+            if stack.any? { |h| h[:parent_id] == o.parent_id }
+              # ascend
+              stack.pop while stack.last[:parent_id] != o.parent_id
+            else
+              # descend
+              stack << {:parent_id => o.parent_id, :parent_number => last_num, :siblings => []}
+            end
+          end
+
+          if o.root? && !roots_have_outline_numbers?
+            num = nil
+          else
+            num = o.send(:build_outline_number,
+              o.root? ? '' : stack.last[:parent_number],
+              o.send(:outline_number_sequence, stack.last[:siblings])
+            )
+          end
+          yield(o, num)
+
+          stack.last[:siblings] << o
+          last_num = num
+        end
+      end
+
+
+      def update_outline_numbers(objects, parent_number=nil)
+        each_with_outline_number(objects, parent_number) do |o, num|
+          o.update_attributes(outline_number_field_name => num)
+        end
+      end
+
+
+      # Do root nodes have outline numbers
+      def roots_have_outline_numbers?
+        false
+      end
+
+    end
+
+    module InstanceMethods
+
+      def outline_number
+        self[outline_number_field_name]
+      end
+
+
+      def update_outline_number
+        self.class.update_outline_numbers(self)
+      end
+
+
+      def update_self_and_descendants_outline_number
+        self.class.update_outline_numbers(self_and_descendants)
+      end
+
+
+      def update_descendants_outline_number
+        self.class.update_outline_numbers(self.descendants, self.outline_number)
+      end
+
+
+      protected
+
+      # Gets the outline sequence number for this node
+      #
+      # For example, if the parent's outline number is 1.2 and this is the
+      # 3rd sibling this will return 3.
+      #
+      def outline_number_sequence(prev_siblings)
+        prev_siblings.count + 1
+      end
+
+
+      # Constructs the full outline number
+      #
+      def build_outline_number(parent_number, sequence)
+        if parent_number && parent_number != ''
+          parent_number + outline_number_seperator + sequence.to_s
+        else
+          sequence.to_s
+        end
+      end
+
+      def outline_number_seperator
+        '.'
+      end
+
+    end
+  end
+end

data/lib/mongoid_nested_set/rebuild.rb

@@ -0,0 +1,40 @@
+module Mongoid::Acts::NestedSet
+
+  module Rebuild
+
+    # Rebuilds the left & rights if unset or invalid.  Also very useful for converting from acts_as_tree.
+    # Warning: Very expensive!
+    def rebuild!(options = {})
+      # Don't rebuild a valid tree.
+      return true if valid?
+
+      scope = lambda{ |node| {} }
+      if acts_as_nested_set_options[:scope]
+        scope = lambda { |node| node.nested_set_scope.options.merge(node.nested_set_scope.selector) }
+      end
+      indices = {}
+
+      set_left_and_rights = lambda do |node|
+        # set left
+        left = (indices[scope.call(node)] += 1)
+        # find
+        node.nested_set_scope.where(parent_field_name => node.id).asc(left_field_name).asc(right_field_name).each { |n| set_left_and_rights.call(n) }
+        # set right
+        right = (indices[scope.call(node)] += 1)
+
+        node.class.collection.find(:_id => node.id).update(
+          {"$set" => {left_field_name => left, right_field_name => right}},
+          {:safe => true}
+        )
+      end
+
+      # Find root node(s)
+      root_nodes = self.where(parent_field_name => nil).asc(left_field_name).asc(right_field_name).asc(:_id).each do |root_node|
+        # setup index for this scope
+        indices[scope.call(root_node)] ||= 0
+        set_left_and_rights.call(root_node)
+      end
+    end
+
+  end
+end

data/lib/mongoid_nested_set/relations.rb

@@ -0,0 +1,100 @@
+module Mongoid::Acts::NestedSet
+
+  module Relations
+
+    # Returns root
+    def root
+      self_and_ancestors.first
+    end
+
+
+    # Returns the array of all parents and self
+    def self_and_ancestors
+      nested_set_scope.where(
+        left_field_name => {"$lte" => left},
+        right_field_name => {"$gte" => right}
+      )
+    end
+
+
+    # Returns an array of all parents
+    def ancestors
+      without_self self_and_ancestors
+    end
+
+
+    # Returns the array of all children of the parent, including self
+    def self_and_siblings
+      nested_set_scope.where(parent_field_name => parent_id)
+    end
+
+
+    # Returns the array of all children of the parent, except self
+    def siblings
+      without_self self_and_siblings
+    end
+
+
+    # Returns a set of all of its nested children which do not have children
+    def leaves
+      descendants.where("this.#{right_field_name} - this.#{left_field_name} == 1")
+    end
+
+
+    # Returns the level of this object in the tree
+    # root level is 0
+    def level
+      parent_id.nil? ? 0 : ancestors.count
+    end
+
+
+    # Returns a set of itself and all of its nested children
+    def self_and_descendants
+      nested_set_scope.where(
+        left_field_name => {"$gte" => left},
+        right_field_name => {"$lte" => right}
+      )
+    end
+
+
+    # Returns a set of all of its children and nested children
+    def descendants
+      without_self self_and_descendants
+    end
+
+
+    def is_descendant_of?(other)
+      other.left < self.left && self.left < other.right && same_scope?(other)
+    end
+    alias :descendant_of? is_descendant_of?
+
+
+    def is_or_is_descendant_of?(other)
+      other.left <= self.left && self.left < other.right && same_scope?(other)
+    end
+
+
+    def is_ancestor_of?(other)
+      self.left < other.left && other.left < self.right && same_scope?(other)
+    end
+    alias :ancestor_of? is_ancestor_of?
+
+
+    def is_or_is_ancestor_of?(other)
+      self.left <= other.left && other.left < self.right && same_scope?(other)
+    end
+
+
+    # Find the first sibling to the left
+    def left_sibling
+      siblings.where(left_field_name => {"$lt" => left}).remove_order_by.desc(left_field_name).first
+    end
+
+
+    # Find the first sibling to the right
+    def right_sibling
+      siblings.where(left_field_name => {"$gt" => left}).asc(left_field_name).first
+    end
+
+  end
+end

data/lib/mongoid_nested_set/remove_order_by.rb

@@ -0,0 +1,15 @@
+module Mongoid
+  module Criterion
+    module Ordering
+      def remove_order_by
+        @options[:sort] = nil
+        self
+      end
+    end
+  end
+
+  class Criteria
+    include Criterion::Ordering
+  end
+end
+

data/lib/mongoid_nested_set/update.rb

@@ -0,0 +1,230 @@
+module Mongoid::Acts::NestedSet
+
+  module Update
+
+    # Shorthand method for finding the left sibling and moving to the left of it
+    def move_left
+      move_to_left_of left_sibling
+    end
+
+
+    # Shorthand method for finding the right sibling and moving to the right of it
+    def move_right
+      move_to_right_of right_sibling
+    end
+
+
+    # Move the node to the left of another node (you can pass id only)
+    def move_to_left_of(node)
+      move_to node, :left
+    end
+
+
+    # Move the node to the right of another node (you can pass id only)
+    def move_to_right_of(node)
+      move_to node, :right
+    end
+
+
+    # Move the node to the child of another node (you can pass id only)
+    def move_to_child_of(node)
+      move_to node, :child
+    end
+
+
+    # Move the node to root nodes
+    def move_to_root
+      move_to nil, :root
+    end
+
+
+    def move_possible?(target)
+      self != target && # Can't target self
+        same_scope?(target) && # can't be in different scopes
+        !((left <= target.left && right >= target.left) or (left <= target.right && right >= target.right))
+    end
+
+
+
+    protected
+
+    def store_new_parent
+      @move_to_new_parent_id = ((self.new_record? && parent_id) || send("#{parent_field_name}_changed?")) ? parent_id : false
+      true # force callback to return true
+    end
+
+
+    def move_to_new_parent
+      if @move_to_new_parent_id.nil?
+        move_to_root
+      elsif @move_to_new_parent_id
+        move_to_child_of(@move_to_new_parent_id)
+      end
+    end
+
+
+    # on creation, set automatically lft and rgt to the end of the tree
+    def set_default_left_and_right
+      maxright = nested_set_scope.remove_order_by.max(right_field_name) || 0
+      self[left_field_name] = maxright + 1
+      self[right_field_name] = maxright + 2
+      self[:depth] = 0
+    end
+
+
+    def move_to(target, position)
+      raise Mongoid::Errors::MongoidError, "You cannot move a new node" if self.new_record?
+
+      res = run_callbacks :move do
+
+        # No transaction support in MongoDB.
+        # ACID is not guaranteed
+        # TODO
+
+        if target.is_a? scope_class
+          target.reload_nested_set
+        elsif position != :root
+          # load object if node is not an object
+          target = nested_set_scope.where(:_id => target).first
+        end
+        self.reload_nested_set
+
+        unless position == :root || target
+          raise Mongoid::Errors::MongoidError, "Impossible move, target node cannot be found."
+        end
+
+        unless position == :root || move_possible?(target)
+          raise Mongoid::Errors::MongoidError, "Impossible move, target node cannot be inside moved tree."
+        end
+
+        bound = case position
+                when :child; target[right_field_name]
+                when :left;  target[left_field_name]
+                when :right; target[right_field_name] + 1
+                when :root;  1
+                else raise Mongoid::Errors::MongoidError, "Position should be :child, :left, :right or :root ('#{position}' received)."
+                end
+
+        old_parent = self[parent_field_name]
+        new_parent = case position
+                     when :child; target.id
+                     when :root;  nil
+                     else         target[parent_field_name]
+                     end
+        
+        left, right     = [self[left_field_name], self[right_field_name]]
+        width, distance = [right - left + 1, bound - left]
+        edge            = bound > right ? bound - 1 : bound
+
+        # there would be no change
+        return self if left == edge || right == edge
+
+        # moving backwards
+        if distance < 0
+          distance -= width
+          left += width
+        end
+
+        scope_class.mongo_session.with(:safe => true) do |session|
+          collection = session[scope_class.collection_name]
+          scope = nested_set_scope.remove_order_by
+
+          # allocate space for new move
+          collection.find(
+            scope.gte(left_field_name => bound).selector
+          ).update_all("$inc" => { left_field_name => width })
+
+          collection.find(
+            scope.gte(right_field_name => bound).selector
+          ).update_all("$inc" => { right_field_name => width })
+
+          # move the nodes
+          collection.find(
+            scope.and(left_field_name => {"$gte" => left}, right_field_name => {"$lt" => left + width}).selector
+          ).update_all("$inc" => { left_field_name => distance, right_field_name => distance })
+
+          # remove the hole
+          collection.find(
+            scope.gt(left_field_name => right).selector
+          ).update_all("$inc" => { left_field_name => -width })
+
+          collection.find(
+            scope.gt(right_field_name => right).selector
+          ).update_all("$inc" => { right_field_name => -width })
+        end
+
+        self.set(parent_field_name, new_parent)
+        self.reload_nested_set
+        self.update_self_and_descendants_depth
+
+        if outline_numbering?
+          if old_parent && old_parent != new_parent
+            scope_class.where(:_id => old_parent).first.update_descendants_outline_number
+          end
+          if new_parent
+            scope_class.where(:_id => new_parent).first.update_descendants_outline_number
+          else
+            update_self_and_descendants_outline_number
+          end
+          self.reload_nested_set
+        end
+
+        target.reload_nested_set if target
+      end
+      self
+    end
+
+
+    # Update cached level attribute
+    def update_depth
+      if depth?
+        self.update_attribute(:depth, level)
+      end
+      self
+    end
+
+
+    # Update cached level attribute for self and descendants
+    def update_self_and_descendants_depth
+      if depth?
+        scope_class.each_with_level(self_and_descendants) do |node, level|
+          node.with(:safe => true).set(:depth, level) unless node.depth == level
+        end
+        self.reload
+      end
+      self
+    end
+
+
+    # Prunes a branch off of the tree, shifting all of the elements on the right
+    # back to the left so the counts still work
+    def destroy_descendants
+      return if right.nil? || left.nil? || skip_before_destroy
+
+      if acts_as_nested_set_options[:dependent] == :destroy
+        descendants.each do |model|
+          model.skip_before_destroy = true
+          model.destroy
+        end
+      else
+        c = nested_set_scope.where(left_field_name.to_sym.gt => left, right_field_name.to_sym.lt => right)
+        scope_class.where(c.selector).delete_all
+      end
+
+      # update lefts and rights for remaining nodes
+      diff = right - left + 1
+
+      scope_class.with(:safe => true).where(
+        nested_set_scope.where(left_field_name.to_sym.gt => right).selector
+      ).inc(left_field_name, -diff)
+
+      scope_class.with(:safe => true).where(
+        nested_set_scope.where(right_field_name.to_sym.gt => right).selector
+      ).inc(right_field_name, -diff)
+
+      # Don't allow multiple calls to destroy to corrupt the set
+      self.skip_before_destroy = true
+    end
+
+  end
+end

data/lib/mongoid_nested_set/validation.rb

@@ -0,0 +1,59 @@
+module Mongoid::Acts::NestedSet
+
+  module Validation
+
+    # Warning: Very expensive!  Do not use unless you know what you are doing.
+    # This method is only useful for determining if the entire tree is valid
+    def valid?
+      left_and_rights_valid? && no_duplicates_for_fields? && all_roots_valid?
+    end
+
+
+    # Warning: Very expensive!  Do not use unless you know what you are doing.
+    def left_and_rights_valid?
+      all.detect { |node|
+        node.send(left_field_name).nil? ||
+          node.send(right_field_name).nil? ||
+          node.send(left_field_name) >= node.send(right_field_name) ||
+          !node.parent.nil? && (
+            node.send(left_field_name) <= node.parent.send(left_field_name) ||
+            node.send(right_field_name) >= node.parent.send(right_field_name)
+        )
+      }.nil?
+    end
+
+
+    # Warning: Very expensive!  Do not use unless you know what you are doing.
+    def no_duplicates_for_fields?
+      roots.group_by{|record| scope_field_names.collect{|field| record.send(field.to_sym)}}.all? do |scope, grouped_roots|
+        [left_field_name, right_field_name].all? do |field|
+          grouped_roots.first.nested_set_scope.only(field).group_by {|doc| doc.send(field)}.all? {|k, v| v.size == 1}
+        end
+      end
+    end
+
+
+    # Wrapper for each_root_valid? that can deal with scope
+    # Warning: Very expensive!  Do not use unless you know what you are doing.
+    def all_roots_valid?
+      if acts_as_nested_set_options[:scope]
+        roots.group_by{|record| scope_field_names.collect{|field| record.send(field.to_sym)}}.all? do |scope, grouped_roots|
+          each_root_valid?(grouped_roots)
+        end
+      else
+        each_root_valid?(roots)
+      end
+    end
+
+
+    def each_root_valid?(roots_to_validate)
+      right = 0
+      roots_to_validate.all? do |root|
+        (root.left > right && root.right > right).tap do
+          right = root.right
+        end
+      end
+    end
+
+  end
+end

data/lib/mongoid_nested_set/version.rb

@@ -0,0 +1,3 @@
+module MongoidNestedSet
+  VERSION = "0.3.0"
+end

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/spec/matchers/nestedset_pos.rb

@@ -0,0 +1,46 @@
+module Mongoid::Acts::NestedSet
+  module Matchers
+
+    def have_nestedset_pos(lft, rgt, options = {})
+      NestedSetPosition.new(lft, rgt, options)
+    end
+
+    class NestedSetPosition
+
+      def initialize(lft, rgt, options)
+        @lft = lft
+        @rgt = rgt
+        @options = options
+      end
+
+      def matches?(node)
+        @node = node
+        !!(
+          node.respond_to?('left') && node.respond_to?('right') &&
+          node.left == @lft &&
+          node.right == @rgt
+        )
+      end
+
+      def description
+        "have position {left: #{@lft}, right: #{@rgt}}"
+      end
+
+      def failure_message_for_should
+        sprintf("expected nested set position: {left: %2s, right: %2s}\n" +
+                "                         got: {left: %2s, right: %2s}",
+          @lft,
+          @rgt,
+          @node.respond_to?('left')  ? @node.left  : '?',
+          @node.respond_to?('right') ? @node.right : '?'
+        )
+      end
+
+      def failure_message_for_should_not
+        sprintf("expected nested set to not have position: {left: %2s, right: %2s}", @lft, @rgt)
+      end
+
+    end
+
+  end
+end

data/spec/models/circle_node.rb

@@ -0,0 +1,4 @@
+require "#{File.dirname(__FILE__)}/shape_node"
+
+class CircleNode < ShapeNode
+end

data/spec/models/node.rb

@@ -0,0 +1,10 @@
+require "#{File.dirname(__FILE__)}/test_document"
+
+class Node
+  include Mongoid::Document
+  include Mongoid::Acts::NestedSet::TestDocument
+  acts_as_nested_set :scope => :root_id
+
+  field :name
+  field :root_id, :type => Integer
+end

data/spec/models/node_without_nested_set.rb

@@ -0,0 +1,6 @@
+
+class NodeWithoutNestedSet
+  include Mongoid::Document
+
+  field :name
+end

data/spec/models/numbering_node.rb

@@ -0,0 +1,10 @@
+require "#{File.dirname(__FILE__)}/test_document"
+
+class NumberingNode
+  include Mongoid::Document
+  include Mongoid::Acts::NestedSet::TestDocument
+  acts_as_nested_set :scope => :root_id, :outline_number_field => 'number'
+
+  field :name
+  field :root_id, :type => Integer
+end