simple_nested_set 0.0.1 → 0.0.2

data/lib/simple_nested_set/act_macro.rb

@@ -10,29 +10,16 @@ module SimpleNestedSet
       # define_callbacks :move, :terminator => "result == false"
       # before_move :init_as_node
 
-      before_validation :init_as_node
-      before_destroy :prune_branch
+      before_validation lambda { |r| r.nested_set.init_as_node }
+      before_destroy    lambda { |r| r.nested_set.prune_branch }
+
       belongs_to :parent, :class_name => self.name
       has_many :children, :foreign_key => :parent_id, :class_name => self.base_class.name
 
       default_scope :order => :lft
 
-      klass = options[:class] || self
-      scopes = Array(options[:scope]).map { |s| s.to_s !~ /_id$/ ? :"#{s}_id" : s }
-
-      nested_set_proc = lambda do |*args|
-        args.empty? ? {} : { :conditions => nested_set.conditions(*args) }
-      end
-
-      scope :nested_set, nested_set_proc do
-        define_method(:scope_columns) { scopes }
-        define_method(:klass) { klass }
-        define_method(:conditions) { |record| scopes.inject({}) { |c, name| c.merge(name => record[name]) } }
-      end
-
-      scope :with_levels, lambda {
-        { :select => "COUNT(id) AS level" } # TODO ... ?
-      }
+      class_inheritable_accessor :nested_set_class
+      self.nested_set_class = NestedSet.build_class(self, options[:scope])
     end
 
     def acts_as_nested_set?

data/lib/simple_nested_set/class_methods.rb

@@ -2,43 +2,59 @@ require 'active_support/core_ext/hash/slice'
 
 module SimpleNestedSet
   module ClassMethods
-    NESTED_SET_ATTRIBUTES = [:parent_id, :left_id, :right_id]
-
     def create(attributes)
-      with_move_by_attributes(attributes) { super }
+      nested_set_class.with_move_by_attributes(attributes) { super }
     end
 
     def create!(attributes)
-      with_move_by_attributes(attributes) { super }
+      nested_set_class.with_move_by_attributes(attributes) { super }
+    end
+
+    # Returns the first root node (with the given scope if any)
+    def root(scope = nil)
+      roots(scope).first
     end
 
-    # Returns the single root
-    def root(*args)
-      nested_set(*args).first(:conditions => { :parent_id => nil })
+    # Returns root nodes (with the given scope if any)
+    def roots(scope = nil)
+      nested_set_class.scope(scope).without_parent
     end
 
     # Returns roots when multiple roots (or virtual root, which is the same)
-    def roots(*args)
-      nested_set(*args).scoped(:conditions => { :parent_id => nil } )
+    def leaves(scope = nil)
+      nested_set_class.scope(scope).with_leaves
+    end
+
+    def without_node(id)
+      where(arel_table[:id].not_eq(id))
+    end
+
+    def without_parent
+      with_parent(nil)
     end
 
-    def leaves(*args)
-      nested_set(*args).scoped(:conditions => 'lft = rgt - 1' )
+    def with_parent(parent_id)
+      where(:parent_id => parent_id)
     end
 
-    protected
+    def with_ancestors(lft, rgt)
+      where(arel_table[:lft].lt(lft).and(arel_table[:rgt].gt(rgt)))
+    end
+
+    def with_descendants(lft, rgt)
+      where(arel_table[:lft].gt(lft).and(arel_table[:rgt].lt(rgt)))
+    end
 
-      def with_move_by_attributes(attributes)
-        transaction do
-          nested_set_attributes = extract_nested_set_attributes!(attributes)
-          yield.tap { |record| record.send(:move_by_attributes, nested_set_attributes) }
-        end
-      end
+    def with_left_sibling(lft)
+      where(:rgt => lft - 1)
+    end
 
-      def extract_nested_set_attributes!(attributes)
-        result = attributes.slice(*NESTED_SET_ATTRIBUTES)
-        attributes.except!(*NESTED_SET_ATTRIBUTES)
-        result
-      end
+    def with_right_sibling(rgt)
+      where(:lft => rgt + 1)
+    end
+
+    def with_leaves
+      where("#{arel_table[:lft].to_sql} = #{arel_table[:rgt].to_sql} - 1")
+    end
   end
 end

data/lib/simple_nested_set/instance_methods.rb

@@ -2,19 +2,24 @@ require 'active_support/core_ext/hash/keys'
 
 module SimpleNestedSet
   module InstanceMethods
+    def nested_set
+      @nested_set ||= nested_set_class.new(self)
+    end
+
+    # TODO refactor
     def update_attributes(attributes)
-      move_by_attributes(attributes)
-      super
+      nested_set.with_move_by_attributes(attributes) { super }
     end
 
     def update_attributes!(attributes)
-      move_by_attributes(attributes)
-      super
+      nested_set.with_move_by_attributes(attributes) { super }
     end
 
-    # Returns true if the node has the same scope as the given node
-    def same_scope?(other)
-      nested_set.scope_columns.all? { |name| self.send(name) == other.send(name) }
+    # recursively populates the parent and children associations of self and
+    # all descendants using one query
+    def load_tree
+      nested_set.populate_associations(descendants)
+      self
     end
 
     # Returns the level of this object in the tree, root level is 0
@@ -27,13 +32,14 @@ module SimpleNestedSet
       parent_id.blank?
     end
 
-    # Returns true is this is a child node
+    # Returns true if this is a child node
     def child?
       !root?
     end
 
+    # Returns true if this is a leaf node
     def leaf?
-      rgt - lft == 1
+      rgt.to_i - lft.to_i == 1
     end
 
     # compare by left column
@@ -48,20 +54,22 @@ module SimpleNestedSet
 
     # Returns the parent
     def parent
-      nested_set.klass.find(parent_id) unless root?
+      self.class.find(parent_id) unless root?
     end
 
+    # Returns true if this is an ancestor of the given node
     def ancestor_of?(other)
       lft < other.lft && rgt > other.rgt
     end
 
+    # Returns true if this is equal to or an ancestor of the given node
     def self_or_ancestor_of?(other)
       self == other || ancestor_of?(other)
     end
 
     # Returns an array of all parents
     def ancestors
-      nested_set.scoped(:conditions => "lft < #{lft} AND rgt > #{rgt}")
+      nested_set.with_ancestors(lft, rgt)
     end
 
     # Returns the array of all parents and self
@@ -69,17 +77,19 @@ module SimpleNestedSet
       ancestors + [self]
     end
 
+    # Returns true if this is a descendent of the given node
     def descendent_of?(other)
       lft > other.lft && rgt < other.rgt
     end
 
+    # Returns true if this is equal to or a descendent of the given node
     def self_or_descendent_of?(other)
       self == other || descendent_of?(other)
     end
 
     # Returns a set of all of its children and nested children.
     def descendants
-      rgt - lft == 1 ? []  : nested_set.scoped(:conditions => ['lft > ? AND rgt < ?', lft, rgt])
+      rgt - lft == 1 ? []  : nested_set.with_descendants(lft, rgt)
     end
 
     # Returns a set of itself and all of its nested children.
@@ -87,16 +97,11 @@ module SimpleNestedSet
       [self] + descendants
     end
 
-    # Returns the number of descendents
-    def descendents_count
+    # Returns the number of descendants
+    def descendants_count
       rgt > lft ? (rgt - lft - 1) / 2 : 0
     end
 
-    # # Returns a set of only this entry's immediate children
-    # def children
-    #   rgt - lft == 1 ? []  : nested_set.scoped(:conditions => { :parent_id => id })
-    # end
-
     # Returns a set of only this entry's immediate children including self
     def self_and_children
       [self] + children
@@ -104,251 +109,65 @@ module SimpleNestedSet
 
     # Returns true if the node has any children
     def children?
-      descendents_count > 0
+      descendants_count > 0
     end
     alias has_children? children?
 
     # Returns the array of all children of the parent, except self
     def siblings
-      without_self(self_and_siblings)
+      self_and_siblings.without_node(id)
     end
 
     # Returns the array of all children of the parent, included self
     def self_and_siblings
-      nested_set.scoped(:conditions => { :parent_id => parent_id })
+      nested_set.with_parent(parent_id)
     end
 
     # Returns the lefthand sibling
     def previous_sibling
-      nested_set.first :conditions => { :rgt => lft - 1 }
+      nested_set.with_left_sibling(lft).first
     end
     alias left_sibling previous_sibling
 
     # Returns the righthand sibling
     def next_sibling
-      nested_set.first :conditions => { :lft => rgt + 1 }
+      nested_set.with_right_sibling(rgt).first
     end
     alias right_sibling next_sibling
 
-    # Returns all descendents that are leaves
+    # Returns all descendants that are leaves
     def leaves
-      rgt - lft == 1 ? []  : nested_set.scoped(:conditions => ["lft > ? AND rgt < ? AND lft = rgt - 1", lft, rgt])
+      rgt - lft == 1 ? []  : nested_set.with_descendants(lft, rgt).with_leaves
     end
 
-    # Move the node to the child of another node
+    # Moves the node to the child of another node
     def move_to_child_of(node)
-      node ? move_to(node, :child) : move_to_root
+      node ? nested_set.move_to(node, :child) : move_to_root
     end
 
+    # Makes this node a root node
     def move_to_root
-      move_to(nil, :root)
+      nested_set.move_to(nil, :root)
     end
 
-    # moves the node to the left of its left sibling if any
+    # Moves the node to the left of its left sibling if any
     def move_left
       move_to_left_of(left_sibling) if left_sibling
     end
 
-    # moves the node to the right of its right sibling if any
+    # Moves the node to the right of its right sibling if any
     def move_right
       move_to_right_of(right_sibling) if right_sibling
     end
 
     # Move the node to the left of another node
     def move_to_left_of(node)
-      move_to(node, :left)
+      nested_set.move_to(node, :left)
     end
 
     # Move the node to the left of another node
     def move_to_right_of(node)
-      move_to(node, :right)
-    end
-
-    protected
-
-      def nested_set
-        @nested_set ||= self.class.nested_set(self)
-      end
-
-      def without_self(scope)
-        scope.scoped :conditions => ["#{self.class.table_name}.id <> ?", id]
-      end
-
-      # before validation set lft and rgt to the end of the tree
-      def init_as_node
-        if lft.nil? || rgt.nil?
-          max_right = nested_set.maximum(:rgt) || 0
-          self.lft = max_right + 1
-          self.rgt = max_right + 2
-        end
-      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 prune_branch
-        unless rgt.nil? || lft.nil?
-          diff = rgt - lft + 1
-          self.class.transaction {
-            nested_set.delete_all "lft > #{lft} AND rgt < #{rgt}"
-            nested_set.update_all "lft = (lft - #{diff})",   "lft >= #{rgt}"
-            nested_set.update_all "rgt = (rgt - #{diff} )",  "rgt >= #{rgt}"
-          }
-        end
-      end
-
-      # reload left, right, and parent
-      def reload_nested_set
-        reload :select => 'lft, rgt, parent_id'
-      end
-
-      def move_by_attributes(attributes)
-        return unless attributes.detect { |key, value| [:parent_id, :left_id, :right_id].include?(key.to_sym) }
-
-        attributes.symbolize_keys!
-        attributes.each { |key, value| attributes[key] = nil if value == 'null' }
-
-        parent_id = attributes[:parent_id] ? attributes[:parent_id] : self.parent_id
-        parent = parent_id.blank? ? nil : nested_set.klass.find(parent_id)
-
-        # if left_id is given but blank, set right_id to leftmost sibling
-        if attributes.has_key?(:left_id) && attributes[:left_id].blank?
-          attributes.delete(:left_id)
-          siblings = parent ? parent.children : self.class.roots(self)
-          attributes[:right_id] = siblings.first.id if siblings.first
-        end
-
-        # if right_id is given but blank, set left_id to rightmost sibling
-        if attributes.has_key?(:right_id) && attributes[:right_id].blank?
-          attributes.delete(:right_id)
-          siblings = parent ? parent.children : self.class.roots(self)
-          attributes[:left_id] = siblings.last.id if siblings.last
-        end
-
-        parent_id, left_id, right_id = [:parent_id, :left_id, :right_id].map do |key|
-          value = attributes.delete(key)
-          value.blank? ? nil : value.to_i
-        end
-
-        protect_inconsistent_move!(parent_id, left_id, right_id)
-
-        if left_id && left_id != id
-          move_to_right_of(left_id)
-        elsif right_id && right_id != id
-          move_to_left_of(right_id)
-        elsif parent_id != self.parent_id
-          move_to_child_of(parent_id)
-        end
-      end
-
-      def move_to(target, position)
-        # return if _run_before_move_callbacks == false
-
-        transaction do
-          target.reload_nested_set if target.is_a?(nested_set.klass)
-          self.reload_nested_set
-
-          target = nested_set.klass.find(target) if target && !target.is_a?(ActiveRecord::Base)
-          protect_impossible_move!(position, target) if target
-
-          bound = case position
-            when :child
-              target.rgt
-            when :left
-              target.lft
-            when :right
-              target.rgt + 1
-            when :root
-              roots = self.class.roots
-              roots.empty? ? 1 : roots.last.rgt + 1
-          end
-
-          if bound > rgt
-            bound -= 1
-            other_bound = rgt + 1
-          else
-            other_bound = lft - 1
-          end
-
-          # there would be no change
-          return if bound == rgt || bound == lft
-
-          # 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 = [lft, rgt, bound, other_bound].sort
-
-          parent_id = case position
-            when :child;  target.id
-            when :root;   nil
-            else          target.parent_id
-          end
-
-          sql = <<-sql
-            lft = CASE
-              WHEN lft BETWEEN :a AND :b THEN lft + :d - :b
-              WHEN lft BETWEEN :c AND :d THEN lft + :a - :c
-              ELSE lft END,
-
-            rgt = CASE
-              WHEN rgt BETWEEN :a AND :b THEN rgt + :d - :b
-              WHEN rgt BETWEEN :c AND :d THEN rgt + :a - :c
-              ELSE rgt END,
-
-            parent_id = CASE
-              WHEN id = :id THEN :parent_id
-              ELSE parent_id END
-          sql
-          args  = { :a => a, :b => b, :c => c, :d => d, :id => id, :parent_id => parent_id }
-          nested_set.klass.update_all [sql, args], nested_set.conditions(self)
-
-          target.reload_nested_set if target
-          reload_nested_set
-
-          # _run_after_move_callbacks
-        end
-      end
-
-      def protect_impossible_move!(position, target)
-        positions = [:child, :left, :right, :root]
-        impossible_move!("Position must be one of #{positions.inspect} but is #{position.inspect}.") unless positions.include?(position)
-        impossible_move!("A new node can not be moved") if new_record?
-        impossible_move!("A node can't be moved to itself") if self == target
-        impossible_move!("A node can't be moved to a descendant of itself.") if (lft..rgt).include?(target.lft) && (lft..rgt).include?(target.rgt)
-        impossible_move!("A node can't be moved to a different scope") unless same_scope?(target)
-      end
-
-      def protect_inconsistent_move!(parent_id, left_id, right_id)
-        left = self.class.find(left_id) if left_id
-        right = self.class.find(right_id) if right_id
-
-        if left && right && (!left.right_sibling || left.right_sibling.id != right_id)
-          inconsistent_move! <<-msg
-            Both :left_id (#{left_id.inspect}) and :right_id (#{right_id.inspect}) were given but
-            :right_id (#{right_id}) does not refer to the right_sibling (#{left.right_sibling.inspect})
-            of the node referenced by :left_id (#{left.inspect})
-          msg
-        end
-
-        if left && parent_id && left.parent_id != parent_id
-          inconsistent_move! <<-msg
-            Both :left_id (#{left_id.inspect}) and :parent_id (#{parent_id.inspect}) were given but
-            left.parent_id (#{left.parent_id}) does not equal parent_id
-          msg
-        end
-
-        if right && parent_id && right.parent_id != parent_id
-          inconsistent_move! <<-msg
-            Both :right_id (#{right_id.inspect}) and :parent_id (#{parent_id.inspect}) were given but
-            right.parent_id (#{right.parent_id}) does not equal parent_id
-          msg
-        end
-      end
-
-      def inconsistent_move!(message)
-        raise InconsistentMove, "Impossible move: #{message.split("\n").map! { |line| line.strip }.join}"
-      end
-
-      def impossible_move!(message)
-        raise ImpossibleMove, "Impossible move: #{message.split("\n").map! { |line| line.strip }.join}"
-      end
+      nested_set.move_to(node, :right)
+    end
   end
 end

data/lib/simple_nested_set/move/by_attributes.rb

@@ -0,0 +1,64 @@
+module SimpleNestedSet
+  module Move
+    class ByAttributes
+      class << self
+        def attribute_reader(*names)
+          names.each do |name|
+            define_method(name) { attributes[name].blank? ? nil : attributes[name].to_i }
+          end
+        end
+      end
+
+      include Protection
+
+      attr_reader :node, :attributes
+      attribute_reader :parent_id, :left_id, :right_id
+
+      delegate :nested_set, :to => :node
+
+      def initialize(node, attributes)
+        @node, @attributes = node, attributes
+        normalize_attributes!
+        protect_inconsistent_move!(parent_id, left_id, right_id)
+      end
+
+      def perform
+        if left_id && left_id != node.id
+          node.move_to_right_of(left_id)
+        elsif right_id && right_id != node.id
+          node.move_to_left_of(right_id)
+        elsif parent_id != node.parent_id
+          node.move_to_child_of(parent_id)
+        end
+      end
+
+      protected
+
+        def normalize_attributes!
+          attributes.symbolize_keys!
+          attributes.each { |key, value| attributes[key] = nil if value == 'null' }
+
+          # if left_id is given but blank, set right_id to leftmost sibling
+          if attributes.has_key?(:left_id) && attributes[:left_id].blank? && siblings.any?
+            attributes[:right_id] = siblings.first.id
+          end
+
+          # if right_id is given but blank, set left_id to rightmost sibling
+          if attributes.has_key?(:right_id) && attributes[:right_id].blank? && siblings.any?
+            attributes[:left_id] = siblings.last.id
+          end
+        end
+
+        def siblings
+          @siblings ||= parent ? parent.children : node.nested_set.roots(node)
+        end
+
+        def parent
+          @parent ||= begin
+            parent_id = self.parent_id || node.parent_id
+            parent_id.blank? ? nil : nested_set.find(parent_id)
+          end
+        end
+    end
+  end
+end

data/lib/simple_nested_set/move/protection.rb

@@ -0,0 +1,53 @@
+module SimpleNestedSet
+  module Move
+    class Inconsistent < ActiveRecord::ActiveRecordError ; end
+    class Impossible   < ActiveRecord::ActiveRecordError ; end
+
+    module Protection
+      def protect_impossible_move!
+        positions = [:child, :left, :right, :root]
+        impossible_move!("A new node can not be moved") if node.new_record?
+        impossible_move!("Position must be one of #{positions.inspect} but is #{position.inspect}.") unless positions.include?(position)
+        impossible_move!("A new node can not be moved") if node.new_record?
+        impossible_move!("A node can't be moved to itself") if node == target
+        impossible_move!("A node can't be moved to a descendant of itself.") if target && (node.lft..node.rgt).include?(target.lft) && (node.lft..node.rgt).include?(target.rgt)
+        impossible_move!("A node can't be moved to a different scope") if target && !nested_set.same_scope?(target)
+      end
+
+      def protect_inconsistent_move!(parent_id, left_id, right_id)
+        left  = nested_set.find(left_id) if left_id
+        right = nested_set.find(right_id) if right_id
+
+        if left && right && (!left.right_sibling || left.right_sibling.id != right_id)
+          inconsistent_move! <<-msg
+            Both :left_id (#{left_id.inspect}) and :right_id (#{right_id.inspect}) were given but
+            :right_id (#{right_id}) does not refer to the right_sibling (#{left.right_sibling.inspect})
+            of the node referenced by :left_id (#{left.inspect})
+          msg
+        end
+
+        if left && parent_id && left.parent_id != parent_id
+          inconsistent_move! <<-msg
+            Both :left_id (#{left_id.inspect}) and :parent_id (#{parent_id.inspect}) were given but
+            left.parent_id (#{left.parent_id}) does not equal parent_id
+          msg
+        end
+
+        if right && parent_id && right.parent_id != parent_id
+          inconsistent_move! <<-msg
+            Both :right_id (#{right_id.inspect}) and :parent_id (#{parent_id.inspect}) were given but
+            right.parent_id (#{right.parent_id}) does not equal parent_id
+          msg
+        end
+      end
+
+      def inconsistent_move!(message)
+        raise Inconsistent, "Impossible move: #{message.split("\n").map! { |line| line.strip }.join}"
+      end
+
+      def impossible_move!(message)
+        raise Impossible, "Impossible move: #{message.split("\n").map! { |line| line.strip }.join}"
+      end
+    end
+  end
+end

data/lib/simple_nested_set/move/to_target.rb

@@ -0,0 +1,97 @@
+module SimpleNestedSet
+  module Move
+    class ToTarget
+      include Protection
+
+      attr_reader :node, :target, :position
+
+      delegate :id, :nested_set, :to => :node
+
+      def initialize(node, target, position)
+        @node, @target, @position = node, target, position
+        @target = nested_set.find(target) if target && !target.is_a?(ActiveRecord::Base)
+
+        protect_impossible_move!
+      end
+
+      def perform
+        unless bound == node.rgt || bound == node.lft # there would be no change
+          reload
+          nested_set.transaction { nested_set.update_all(query) }
+          reload
+        end
+      end
+
+      def reload
+        target.nested_set.reload if target
+        node.nested_set.reload
+      end
+
+      def parent_id
+        @parent_id ||= case position
+          when :child;  target.id
+          when :root;   nil
+          else          target.parent_id
+        end
+      end
+
+      def boundaries
+        # we have defined the boundaries of two non-overlapping intervals,
+        # so sorting puts both the intervals and their boundaries in order
+        @boundaries ||= [node.lft, node.rgt, bound, other_bound].sort
+      end
+
+      def bound
+        @bound ||= begin
+          bound = case position
+            when :child ; target.rgt
+            when :left  ; target.lft
+            when :right ; target.rgt + 1
+            when :root  ; roots.empty? ? 1 : roots.last.rgt + 1
+          end
+          bound > node.rgt ? bound - 1 : bound
+        end
+      end
+
+      # TODO name other_bound in a more reasonable way
+      def other_bound
+        @other_bound ||= bound > node.rgt ? node.rgt + 1 : node.lft - 1
+      end
+
+      def roots
+        @roots ||= node.nested_set.roots
+      end
+
+      def query
+        sql = <<-sql
+          lft = CASE
+            WHEN lft BETWEEN :a AND :b THEN lft + :d - :b
+            WHEN lft BETWEEN :c AND :d THEN lft + :a - :c
+            ELSE lft END,
+
+          rgt = CASE
+            WHEN rgt BETWEEN :a AND :b THEN rgt + :d - :b
+            WHEN rgt BETWEEN :c AND :d THEN rgt + :a - :c
+            ELSE rgt END,
+
+          parent_id = CASE
+            WHEN id = :id THEN :parent_id
+            ELSE parent_id END,
+
+          level = (
+            SELECT count(id)
+            FROM #{table_name} as t
+            WHERE t.lft < #{table_name}.lft AND rgt > #{table_name}.rgt
+          )
+        sql
+        # TODO name a, b, c, d in a more reasonable way
+        a, b, c, d = boundaries
+        [sql, { :a => a, :b => b, :c => c, :d => d, :id => id, :parent_id => parent_id }]
+      end
+
+      def table_name
+        node.class.quoted_table_name
+      end
+    end
+  end
+end

data/lib/simple_nested_set/nested_set.rb

@@ -0,0 +1,101 @@
+module SimpleNestedSet
+  class NestedSet < ActiveRecord::Relation
+    NESTED_SET_ATTRIBUTES = [:parent_id, :left_id, :right_id]
+
+    class_inheritable_accessor :node_class, :scope_names
+
+    class << self
+      def build_class(model, scopes)
+        model.const_get(:NestedSet) rescue model.const_set(:NestedSet, Class.new(NestedSet)).tap do |node_class|
+          node_class.node_class = model
+          node_class.scope_names = Array(scopes).map { |s| s.to_s =~ /_id$/ ? s.to_sym : :"#{s}_id" }
+        end
+      end
+
+      def scope(scope)
+        scope.blank? ? node_class.scoped : node_class.where(scope_condition(scope))
+      end
+
+      def scope_condition(scope)
+        scope_names.inject({}) do |c, name|
+          c.merge(name => scope.respond_to?(name) ? scope.send(name) : scope[name])
+        end
+      end
+
+      def with_move_by_attributes(attributes, node = nil)
+        node_class.transaction do
+          nested_set_attributes = extract_nested_set_attributes!(attributes)
+          result = yield
+          (node || result).nested_set.move_by_attributes(nested_set_attributes) unless nested_set_attributes.empty?
+          result
+        end
+      end
+
+      def extract_nested_set_attributes!(attributes)
+        result = attributes.slice(*NESTED_SET_ATTRIBUTES)
+        attributes.except!(*NESTED_SET_ATTRIBUTES)
+        result
+      end
+    end
+
+    attr_reader :node
+
+    def initialize(*args)
+      super(node_class, node_class.arel_table)
+      @node = args.first if args.size == 1
+      @where_values = self.class.scope(node).instance_variable_get(:@where_values) if node
+    end
+
+    def with_move_by_attributes(attributes, &block)
+      self.class.with_move_by_attributes(attributes, node, &block)
+    end
+
+    # Returns true if the node has the same scope as the given node
+    def same_scope?(other)
+      scope_names.all? { |scope| node.send(scope) == other.send(scope) }
+    end
+
+    # reload left, right, and parent
+    def reload
+      node.reload(:select => 'lft, rgt, parent_id')
+    end
+
+    def populate_associations(nodes)
+      node.children.target = nodes.select do |child|
+        next unless child.parent_id == node.id
+        nodes.delete(child)
+        child.nested_set.populate_associations(nodes)
+        child.parent = node
+      end
+    end
+
+    # before validation set lft and rgt to the end of the tree
+    def init_as_node
+      unless node.rgt && node.lft
+        max_right = maximum(:rgt) || 0
+        node.lft, node.rgt = max_right + 1, max_right + 2
+      end
+    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 prune_branch
+      if node.rgt && node.lft
+        transaction do
+          diff = node.rgt - node.lft + 1
+          delete_all(['lft > ? AND rgt < ?', node.lft, node.rgt])
+          update_all(['lft = (lft - ?)', diff], ['lft >= ?', node.rgt])
+          update_all(['rgt = (rgt - ?)', diff], ['rgt >= ?', node.rgt])
+        end
+      end
+    end
+
+    def move_by_attributes(attributes)
+      Move::ByAttributes.new(node, attributes).perform
+    end
+
+    def move_to(target, position)
+      Move::ToTarget.new(node, target, position).perform
+    end
+  end
+end

data/lib/simple_nested_set/version.rb

@@ -1,3 +1,3 @@
 module SimpleNestedSet
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/simple_nested_set.rb

@@ -1,10 +1,14 @@
 module SimpleNestedSet
-  class InconsistentMove < ActiveRecord::ActiveRecordError ; end
-  class ImpossibleMove   < ActiveRecord::ActiveRecordError ; end
-
   autoload :ActMacro,        'simple_nested_set/act_macro'
   autoload :ClassMethods,    'simple_nested_set/class_methods'
   autoload :InstanceMethods, 'simple_nested_set/instance_methods'
+  autoload :NestedSet,       'simple_nested_set/nested_set'
+
+  module Move
+    autoload :ByAttributes,  'simple_nested_set/move/by_attributes'
+    autoload :ToTarget,      'simple_nested_set/move/to_target'
+    autoload :Protection,    'simple_nested_set/move/protection'
+  end
 end
 
 ActiveRecord::Base.send :extend, SimpleNestedSet::ActMacro

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: simple_nested_set
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-02 00:00:00 +02:00
+date: 2010-08-04 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -104,6 +104,10 @@ files:
 - lib/simple_nested_set/act_macro.rb
 - lib/simple_nested_set/class_methods.rb
 - lib/simple_nested_set/instance_methods.rb
+- lib/simple_nested_set/move/by_attributes.rb
+- lib/simple_nested_set/move/protection.rb
+- lib/simple_nested_set/move/to_target.rb
+- lib/simple_nested_set/nested_set.rb
 - lib/simple_nested_set/version.rb
 has_rdoc: true
 homepage: http://github.com/svenfuchs/simple_nested_set