mongoid_nested_set 0.1.0

data/lib/mongoid_nested_set/fields.rb

@@ -0,0 +1,60 @@
+module Mongoid::Acts::NestedSet
+
+  # Mixed int both classes and instances to provide easy access to the field names
+  module Fields
+
+    def left_field_name
+      acts_as_nested_set_options[:left_field]
+    end
+
+
+    def right_field_name
+      acts_as_nested_set_options[:right_field]
+    end
+
+
+    def parent_field_name
+      acts_as_nested_set_options[:parent_field]
+    end
+
+
+    def outline_number_field_name
+      acts_as_nested_set_options[:outline_number_field]
+    end
+
+
+    def scope_field_names
+      Array(acts_as_nested_set_options[:scope])
+    end
+
+
+    def scope_class
+      acts_as_nested_set_options[:klass]
+    end
+
+
+    def quoted_left_field_name
+      # TODO
+      left_field_name
+    end
+
+
+    def quoted_right_field_name
+      # TODO
+      right_field_name
+    end
+
+
+    def quoted_parent_field_name
+      # TODO
+      parent_field_name
+    end
+
+
+    def quoted_scope_field_names
+      # TODO
+      scope_field_names
+    end
+
+  end
+end

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,41 @@
+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.scoped }
+      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.update(
+          {:_id => node.id},
+          {"$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,11 @@
+module Mongoid
+  module Criterion
+    module Optional
+      def remove_order_by
+        @options[:sort] = nil
+        self
+      end
+    end
+  end
+end
+

data/lib/mongoid_nested_set/update.rb

@@ -0,0 +1,233 @@
+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.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
+
+        if bound > self[right_field_name]
+          bound = bound - 1
+          other_bound = self[right_field_name] + 1
+        else
+          other_bound = self[left_field_name] - 1
+        end
+
+        # there would be no change
+        return self if bound == self[right_field_name] || bound == self[left_field_name]
+
+        # we have defined the boundaries of two non-overlapping intervals,
+        # so sorting puts both the intervals and their boundaries in order
+        a, b, c, d = [self[left_field_name], self[right_field_name], bound, other_bound].sort
+
+        old_parent = self[parent_field_name]
+        new_parent = case position
+                     when :child; target.id
+                     when :root;  nil
+                     else         target[parent_field_name]
+                     end
+
+        # TODO: Worst case O(n) queries, improve?
+        # MongoDB 1.9 may allow javascript in updates: http://jira.mongodb.org/browse/SERVER-458
+        nested_set_scope.only(left_field_name, right_field_name, parent_field_name).remove_order_by.each do |node|
+          updates = {}
+          if (a..b).include? node.left
+            updates[left_field_name] = node.left + d - b
+          elsif (c..d).include? node.left
+            updates[left_field_name] = node.left + a - c
+          end
+
+          if (a..b).include? node.right
+            updates[right_field_name] = node.right + d - b
+          elsif (c..d).include? node.right
+            updates[right_field_name] = node.right + a - c
+          end
+
+          updates[parent_field_name] = new_parent if self.id == node.id
+
+          node.class.collection.update(
+            {:_id => node.id },
+            {"$set" => updates},
+            {:safe => true}
+          ) unless updates.empty?
+        end
+
+        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_attributes(: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.class.collection.update(
+            {:_id => node.id},
+            {"$set" => {:depth => level}},
+            {:safe => true}
+          ) 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.fuse(:where => {left_field_name => {"$gt" => left}, right_field_name => {"$lt" => right}})
+        scope_class.delete_all(:conditions => c.selector)
+      end
+
+      # update lefts and rights for remaining nodes
+      diff = right - left + 1
+      scope_class.collection.update(
+        nested_set_scope.fuse(:where => {left_field_name => {"$gt" => right}}).selector,
+        {"$inc" => { left_field_name => -diff }},
+        {:safe => true, :multi => true}
+      )
+      scope_class.collection.update(
+        nested_set_scope.fuse(:where => {right_field_name => {"$gt" => right}}).selector,
+        {"$inc" => { right_field_name => -diff }},
+        {:safe => true, :multi => true}
+      )
+
+      # Don't allow multiple calls to destroy to corrupt the set
+      self.skip_before_destroy = true
+    end
+
+  end
+end