pkondzior-sequel_nested_set 0.9.9

data/COPYING

@@ -0,0 +1,21 @@
+Copyright (c) 2009 Paweł Kondzior
+Copyright (c) 2007-2008 collectiveidea
+
+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

@@ -0,0 +1,3 @@
+Port of awesome nested set to Sequel::Model
+
+more readme tobedone.

data/TODO

@@ -0,0 +1,3 @@
+- Do more specs for scoped nested_set
+- Add move hooks (before_,after_)
+- Add documentation

data/lib/sequel_nested_set.rb

@@ -0,0 +1,563 @@
+unless Object.respond_to?(:returning)
+  class Object
+    def returning(value)
+      yield(value)
+      value
+    end
+  end
+end
+
+module Sequel
+  module Plugins
+    # 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 some complex
+    # sql queries. But everything is done here by this module!
+    #
+    # Nested sets are appropriate each time you want either an orderd tree (menus,
+    # commercial categories) or an efficient way of querying big trees (threaded posts).
+    #
+    # == API
+    #
+    #   # adds a new item at the "end" of the tree, i.e. with child.left = max(tree.right)+1
+    #   child = MyClass.new(:name => "child1")
+    #   child.save
+    #   # now move the item to its right place
+    #   child.move_to_child_of my_item
+    #
+    # You can pass an id or an object to:
+    # * <tt>#move_to_child_of</tt>
+    # * <tt>#move_to_right_of</tt>
+    # * <tt>#move_to_left_of</tt>
+    #
+    module NestedSet
+      # Configuration options are:
+      #
+      # * +:parent_column+ - specifies the column name to use for keeping the position integer (default: :parent_id)
+      # * +:left_column+ - column name for left boundry data, default :lft
+      # * +:right_column+ - column name for right boundry data, default :rgt
+      # * +: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.
+      #   Example: <tt>is :nested_set, { :scope => [:notable_id, :notable_type] }</tt>
+      # * +: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.
+      #
+      # See Sequle::Plugins::NestedSet::ClassMethods for a list of class methods and
+      # Sequle::Plugins::NestedSet::InstanceMethods for a list of instance methods added
+      # to acts_as_nested_set models
+      def self.apply(model, options = {})
+        options = {
+          :parent_column => :parent_id,
+          :left_column => :lft,
+          :right_column => :rgt,
+          :dependent => :delete_all, # or :destroy
+        }.merge(options)
+
+        if options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/
+          options[:scope] = "#{options[:scope]}_id".to_sym
+        end
+        
+        model.class.class_eval do
+          attr_accessor :nested_set_options
+        end
+        model.nested_set_options = options
+
+        model.before_create { set_default_left_and_right }
+        model.before_destroy { prune_from_tree }
+
+        model.set_restricted_columns(*([:left, :right, :parent_id, options[:parent_column], options[:left_column], options[:right_column]].uniq))
+      end
+
+      module DatasetMethods
+        # All nested set queries should use this nested dataset method, which returns Dataset that provides
+        # proper :scope which you can configure on is :nested, { :scope => ... }
+        # declaration in your Sequel::Model
+        def nested
+          order(self.model_classes[nil].qualified_left_column)
+        end
+
+        # Returns dataset for all root nodes
+        def roots
+          nested.filter(self.model_classes[nil].qualified_parent_column => nil)
+        end
+
+        # Returns dataset for all of nodes which do not have children
+        def leaves
+          nested.filter(self.model_classes[nil].qualified_right_column - self.model_classes[nil].qualified_left_column => 1)
+        end
+      end
+
+      module ClassMethods
+
+        # Returns the first root
+        def root
+          roots.first
+        end
+        
+        def qualified_parent_column(table_name = self.implicit_table_name)
+          "#{table_name}__#{self.nested_set_options[:parent_column]}".to_sym
+        end
+
+        def qualified_parent_column_literal
+          self.dataset.literal(self.nested_set_options[:parent_column])
+        end
+
+        def qualified_left_column(table_name = self.implicit_table_name)
+          "#{table_name}__#{self.nested_set_options[:left_column]}".to_sym
+        end
+
+        def qualified_left_column_literal
+          self.dataset.literal(self.nested_set_options[:left_column])
+        end
+
+        def qualified_right_column(table_name = self.implicit_table_name)
+          "#{table_name}__#{self.nested_set_options[:right_column]}".to_sym
+        end
+
+        def qualified_right_column_literal
+          self.dataset.literal(self.nested_set_options[:right_column])
+        end
+
+        def valid?
+          self.left_and_rights_valid? && self.no_duplicates_for_columns? && self.all_roots_valid?
+        end
+
+        def left_and_rights_valid?
+          self.left_outer_join(Client.implicit_table_name.as(:parent), self.qualified_parent_column => "parent__#{self.primary_key}".to_sym).
+            filter({ self.qualified_left_column => nil } |
+              { self.qualified_right_column => nil } |
+              (self.qualified_left_column >= self.qualified_right_column) |
+            (~{ self.qualified_parent_column => nil } & ((self.qualified_left_column <= self.qualified_left_column(:parent)) |
+              (self.qualified_right_column >= self.qualified_right_column(:parent))))).count == 0
+        end
+
+        def left_and_rights_valid_dataset?
+          self.left_outer_join(Client.implicit_table_name.as(:parent), self.qualified_parent_column => "parent__#{self.primary_key}".to_sym).
+            filter({ self.qualified_left_column => nil } |
+              { self.qualified_right_column => nil } |
+              (self.qualified_left_column >= self.qualified_right_column) |
+            (~{ self.qualified_parent_column => nil } & ((self.qualified_left_column <= self.qualified_left_column(:parent)) |
+              (self.qualified_right_column >= self.qualified_right_column(:parent)))))
+        end
+
+        def no_duplicates_for_columns?
+          # TODO: scope
+          #          scope_columns = Array(self.nested_set_options[:scope]).map do |c|
+          #            connection.quote_column_name(c)
+          #          end.push(nil).join(", ")
+          [self.qualified_left_column, self.qualified_right_column].all? do |column|
+            self.dataset.select(column, :count[column]).group(column).having(:count[column] > 1).first.nil?
+          end
+        end
+
+        # Wrapper for each_root_valid? that can deal with scope.
+        def all_roots_valid?
+          # TODO: scope
+#          if self.nested_set_options[:scope]
+#            roots.group(:group => scope_column_names).group_by{|record| scope_column_names.collect{|col| record.send(col.to_sym)}}.all? do |scope, grouped_roots|
+#              each_root_valid?(grouped_roots)
+#            end
+#          else
+            each_root_valid?(roots.all)
+#          end
+        end
+
+        def each_root_valid?(roots_to_validate)
+          left = right = 0
+          roots_to_validate.all? do |root|
+            returning(root.left > left && root.right > right) do
+              left = root.left
+              right = root.right
+            end
+          end
+        end
+        
+        # Rebuilds the left & rights if unset or invalid.  Also very useful for converting from acts_as_tree.
+        def rebuild!
+
+          scope = lambda{}
+          # TODO: add scope stuff
+          
+          # Don't rebuild a valid tree.
+          return true if valid?
+          indices = {}
+          
+          move_to_child_of_lambda = lambda do |parent_node|
+            # Set left
+            parent_node[nested_set_options[:left_column]] = indices[scope.call(parent_node)] += 1
+            # Gather child noodes of parend_node and iterate by children
+            parent_node.children.order(:id).all.each do |child_node|
+              move_to_child_of_lambda.call(child_node)
+            end
+            # Set right
+            parent_node[nested_set_options[:right_column]] = indices[scope.call(parent_node)] += 1
+            parent_node.save
+          end
+
+          # Gatcher root nodes and iterate by them
+          self.roots.all.each do |root_node|
+            # setup index for this scope
+            indices[scope.call(root_node)] ||= 0
+            move_to_child_of_lambda.call(root_node)
+          end
+        end
+
+        def to_text(&block)
+          text = []
+          self.roots.each do |root|
+            text << root.to_text(&block)
+          end
+          text.join("\n")
+        end
+
+        # Returns the entire set as a nested array. If flat is true then a flat
+        # array is returned instead. Specify mover to exclude any impossible
+        # moves. Pass a block to perform an operation on each item. The block
+        # arguments are |item, level|.
+        def to_nested_a(flat = false, mover = nil, &block)
+          descendants = self.nested.all
+          array = []
+
+          while not descendants.empty?
+            items = descendants.shift.to_nested_a(flat, mover, descendants, 0, &block)
+            array.send flat ? 'concat' : '<<', items
+          end
+
+          return array
+        end
+      end
+
+      module InstanceMethods
+
+        # Returns hash of Model nested set options
+        def nested_set_options
+          self.class.nested_set_options
+        end
+
+        # Setter of the left column
+        def left=(value)
+          self[self.nested_set_options[:left_column]] = value
+        end
+
+        # Setter of the right column
+        def right=(value)
+          self[self.nested_set_options[:right_column]] = value
+        end
+
+        # Getter of the left column
+        def left
+          self[self.nested_set_options[:left_column]] || 0
+        end
+
+        # Getter of the right column
+        def right
+          self[self.nested_set_options[:right_column]] || 0
+        end
+
+        # Setter of the parent column
+        def parent_id=(value)
+          self[self.nested_set_options[:parent_column]] = value
+        end
+
+        # Getter of parent column
+        def parent_id
+          self[self.nested_set_options[:parent_column]]
+        end
+
+        # Set left=, right= and parent_id= to be procted methods
+        # this methods should be used only internally by nested set plugin
+        protected :left=, :right=, :parent_id=
+
+        # Returns the level of this object in the tree
+        # root level is 0
+        def level
+          root? ? 0 : ancestors.count
+        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?
+          right - left == 1
+        end
+
+        # Returns true is this is a child node
+        def child?
+          !root?
+        end
+
+        # order by left column
+        def <=>(x)
+          left <=> x.left
+        end
+
+        # Returns root
+        def root
+          self_and_ancestors.first
+        end
+
+        # Returns the immediate parent
+        def parent
+          dataset.nested.filter(self.primary_key => self.parent_id).first if self.parent_id
+        end
+
+        # Returns the dataset for all parent nodes and self
+        def self_and_ancestors
+          dataset.filter((self.class.qualified_left_column <= left) & (self.class.qualified_right_column  >= right))
+        end
+
+        # Returns the dataset for all children of the parent, including self
+        def self_and_siblings
+          dataset.nested.filter(self.class.qualified_parent_column  => self.parent_id)
+        end
+
+        # Returns dataset for itself and all of its nested children
+        def self_and_descendants
+          dataset.nested.filter((self.class.qualified_left_column >= left) & (self.class.qualified_right_column <= right))
+        end
+
+        # Filter for dataset that will exclude self object
+        def without_self(dataset)
+          dataset.nested.filter(~{self.primary_key => self.id})
+        end
+
+        # Returns dataset for its immediate children
+        def children
+          dataset.nested.filter(self.class.qualified_parent_column => self.id)
+        end
+
+        # Returns dataset for all parents
+        def ancestors
+          without_self(self_and_ancestors)
+        end
+
+        # Returns dataset for all children of the parent, except self
+        def siblings
+          without_self(self_and_siblings)
+        end
+
+        # Returns dataset for all of its children and nested children
+        def descendants
+          without_self(self_and_descendants)
+        end
+
+        # Returns dataset for all of its nested children which do not have children
+        def leaves
+          descendants.filter(self.class.qualified_right_column - self.class.qualified_left_column => 1)
+        end
+
+        def is_descendant_of?(other)
+          other.left < self.left && self.left < other.right && same_scope?(other)
+        end
+
+        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
+
+        def is_or_is_ancestor_of?(other)
+          self.left <= other.left && other.left < self.right && same_scope?(other)
+        end
+
+        # Check if other model is in the same scope
+        def same_scope?(other)
+          Array(nil).all? do |attr|
+            self.send(attr) == other.send(attr)
+          end
+        end
+
+        # Find the first sibling to the left
+        def left_sibling
+          siblings.filter(self.class.qualified_left_column < left).order(self.class.qualified_left_column.desc).first
+        end
+
+        # Find the first sibling to the right
+        def right_sibling
+          siblings.filter(self.class.qualified_left_column > left).first
+        end
+
+
+        # Shorthand method for finding the left sibling and moving to the left of it.
+        def move_left
+          self.move_to_left_of(self.left_sibling)
+        end
+
+        # Shorthand method for finding the right sibling and moving to the right of it.
+        def move_right
+          self.move_to_right_of(self.right_sibling)
+        end
+
+        # Move the node to the left of another node (you can pass id only)
+        def move_to_left_of(node)
+          self.move_to(node, :left)
+        end
+
+        # Move the node to the left of another node (you can pass id only)
+        def move_to_right_of(node)
+          self.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)
+          self.move_to(node, :child)
+        end
+
+        # Move the node to root nodes
+        def move_to_root
+          self.move_to(nil, :root)
+        end
+
+        # Check if node move is possible for specific target
+        def move_possible?(target)
+          self != target && # Can't target self
+          same_scope?(target) && # can't be in different scopes
+          # !(left..right).include?(target.left..target.right) # this needs tested more
+          # detect impossible move
+          !((left <= target.left && right >= target.left) or (left <= target.right && right >= target.right))
+        end
+
+        # You can pass block that will have
+        def to_text
+          self_and_descendants.map do |node|
+            if block_given?
+              inspect = yield(node)
+            else
+              inspect = node.class.inspect
+            end
+            "#{'*'*(node.level+1)} #{inspect} (#{node.parent_id.inspect}, #{node.left}, #{node.right})"
+          end.join("\n")
+        end
+
+        # Returns self and its descendants as a nested array. If flat is true
+        # then a flat array is returned instead. Specify mover to exclude any
+        # impossible moves. Pass a block to perform an operation on each item.
+        # The block arguments are |item, level|. The remaining arguments for
+        # this method are for recursion and should not normally be given.
+        def to_nested_a(flat = false, mover = nil, descendants = nil, level = self.level, &block)
+          descendants ||= self.descendants.all
+          array = [ block_given? ? yield(self, level) : self ]
+
+          while not descendants.empty?
+            break unless descendants.first.parent_id == self.id
+            item = descendants.shift
+            items = item.to_nested_a(flat, mover, descendants, level + 1, &block)
+            array.send flat ? 'concat' : '<<', items if mover.nil? or mover.new? or mover.move_possible?(item)
+          end
+
+          return array
+        end
+
+        protected
+        # on creation, set automatically lft and rgt to the end of the tree
+        def set_default_left_and_right
+          maxright = dataset.nested.max(self.class.qualified_right_column).to_i || 0
+          # adds the new node to the right of all existing nodes
+          self.left = maxright + 1
+          self.right = maxright + 2
+        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_from_tree
+          return if self.right.nil? || self.left.nil?
+          diff = self.right - self.left + 1
+
+          #TODO: implemente :dependent option
+          #          delete_method = acts_as_nested_set_options[:dependent] == :destroy ?
+          #            :destroy_all : :delete_all
+
+          #TODO: implement prune method
+          #          self.class.base_class.transaction do
+          #            nested_set_scope.send(delete_method,
+          #              ["#{quoted_left_column_name} > ? AND #{quoted_right_column_name} < ?",
+          #                left, right]
+          #            )
+          #            nested_set_scope.update_all(
+          #              ["#{quoted_left_column_name} = (#{quoted_left_column_name} - ?)", diff],
+          #              ["#{quoted_left_column_name} >= ?", right]
+          #            )
+          #            nested_set_scope.update_all(
+          #              ["#{quoted_right_column_name} = (#{quoted_right_column_name} - ?)", diff],
+          #              ["#{quoted_right_column_name} >= ?", right]
+          #            )
+          #          end
+        end
+
+        # reload left, right, and parent
+        def reload_nested_set
+          reload(:select => "#{quoted_left_column_name}, " +
+              "#{quoted_right_column_name}, #{quoted_parent_column_name}")
+        end
+
+        def move_to(target, position)
+          raise Error, "You cannot move a new node" if self.new?
+#          #TODO: add callback
+          db.transaction do
+            unless position == :root || self.move_possible?(target)
+              raise Error, "Impossible move, target node cannot be inside moved tree."
+            end
+
+            bound = case position
+              when :child;  target.right
+              when :left;   target.left
+              when :right;  target.right + 1
+              when :root;   1
+              else raise Error, "Position should be :child, :left, :right or :root ('#{position}' received)."
+            end
+
+            if bound > self.right
+              bound = bound - 1
+              other_bound = self.right + 1
+            else
+              other_bound = self.left - 1
+            end
+            
+            # there would be no change
+            return if bound == self.right || bound == self.left
+
+            # 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, self.right, bound, other_bound].sort
+
+            new_parent = case position
+              when :child;  target.id
+              when :root;   'NULL'
+              else          target.parent_id
+            end
+
+            # TODO : scope stuff for update
+            self.dataset.update(
+               "#{self.class.qualified_left_column_literal} = (CASE " +
+                "WHEN #{self.class.qualified_left_column_literal} BETWEEN #{a} AND #{b} " +
+                  "THEN #{self.class.qualified_left_column_literal} + #{d} - #{b} " +
+                "WHEN #{self.class.qualified_left_column_literal} BETWEEN #{c} AND #{d} " +
+                  "THEN #{self.class.qualified_left_column_literal} + #{a} - #{c} " +
+                "ELSE #{self.class.qualified_left_column_literal} END), " +
+              "#{self.class.qualified_right_column_literal} = (CASE " +
+                "WHEN #{self.class.qualified_right_column_literal} BETWEEN #{a} AND #{b} " +
+                  "THEN #{self.class.qualified_right_column_literal} + #{d} - #{b} " +
+                "WHEN #{self.class.qualified_right_column_literal} BETWEEN #{c} AND #{d} " +
+                  "THEN #{self.class.qualified_right_column_literal} + #{a} - #{c} " +
+                "ELSE #{self.class.qualified_right_column_literal} END), " +
+              "#{self.class.qualified_parent_column_literal} = (CASE " +
+                "WHEN #{self.primary_key} = #{self.id} THEN #{new_parent} " +
+                "ELSE #{self.class.qualified_parent_column_literal} END)"
+            )
+            target.refresh if target
+            self.refresh
+            #TODO: add after_move
+          end
+        end
+      end
+    end
+  end
+end

data/spec/nested_set_spec.rb

@@ -0,0 +1,617 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Sequel Nested Set" do
+
+  describe "without scope" do
+    
+    before(:each) do
+      prepare_nested_set_data
+      @root = Client.filter(:name  => 'Top Level').first
+      @node1 = Client.filter(:name  => 'Child 1').first
+      @node2 = Client.filter(:name  => 'Child 2').first
+      @node2_1 = Client.filter(:name => 'Child 2.1').first
+      @node3 = Client.filter(:name => 'Child 3').first
+      @root2 = Client.filter(:name  => 'Top Level 2').first
+    end
+
+    describe "ClassMethods" do
+
+      it "should have nested_set_options" do
+        Client.should respond_to(:nested_set_options)
+      end
+
+      it "should have default options :left_column, :right_column, :parent_column, :dependent and :scope" do
+        Client.nested_set_options[:left_column].should == :lft
+        Client.nested_set_options[:right_column].should == :rgt
+        Client.nested_set_options[:parent_column].should == :parent_id
+        Client.nested_set_options[:dependent].should == :delete_all
+        Client.nested_set_options[:scope].should be_nil
+      end
+
+      it "should have qualified column methods" do
+        Client.qualified_parent_column.should == :clients__parent_id
+        Client.qualified_left_column.should == :clients__lft
+        Client.qualified_right_column.should == :clients__rgt
+      end
+
+      it "should have roots that contains all root nodes" do
+        roots = Client.roots.all
+        roots.should == Client.filter(:parent_id => nil).all
+        roots.should == [@root, @root2]
+      end
+  
+      it "should have root that will be root? => true" do
+        Client.roots.first.root?.should be_true
+      end
+
+      it "should have all leaves" do
+        leaves = Client.leaves.all
+        leaves.should == Client.nested.filter(:rgt - :lft => 1).all
+        leaves.should == [@node1, @node2_1, @node3, @root2]
+      end
+
+      it "should have root" do
+        Client.root.should == @root
+      end
+
+      it "should have to_text method that returns whole tree from all root nodes as text" do
+        Client.to_text.should == "* Client (nil, 1, 10)\n** Client (1, 2, 3)\n** Client (1, 4, 7)\n*** Client (3, 5, 6)\n** Client (1, 8, 9)\n* Client (nil, 11, 12)"
+      end
+
+      it "should have to_text method that returns whole tree from all root nodes as text and should be able to pass block" do
+        Client.to_text { |node| node.name }.should == "* Top Level (nil, 1, 10)\n** Child 1 (1, 2, 3)\n** Child 2 (1, 4, 7)\n*** Child 2.1 (3, 5, 6)\n** Child 3 (1, 8, 9)\n* Top Level 2 (nil, 11, 12)"
+      end
+
+      it "should have to_nested_a method that returns nested array of all nodes from roots to leaves" do
+        Client.to_nested_a.should == [[@root, [@node1], [@node2, [@node2_1]], [@node3]], [@root2]]
+      end
+
+      it "should have to_nested_a method that can pass block with node and level" do
+        Client.to_nested_a { |node, level| level }.should == [[0, [1], [1, [2]], [1]], [0]]
+      end
+    end
+
+    describe "InstanceMethods" do
+
+      it "should have nested_set_options" do
+        @root.class.should respond_to(:nested_set_options)
+      end
+
+      it "should have parent, left, right getter based on nested set config" do
+        node = Client.new.update_all(:parent_id => nil, :lft => 1, :rgt => 2)
+        node.left.should == node[node.class.nested_set_options[:left_column]]
+        node.right.should == node[node.class.nested_set_options[:right_column]]
+        node.parent_id.should == node[node.class.nested_set_options[:parent_column]]
+      end
+
+      it "should have parent, left, right setter based on nested set config" do
+        node = Client.new
+        node.send(:left=, 1)
+        node.send(:right=, 2)
+        node.send(:parent_id=, 69)
+        node.left.should == node[node.class.nested_set_options[:left_column]]
+        node.right.should == node[node.class.nested_set_options[:right_column]]
+        node.parent_id.should == node[node.class.nested_set_options[:parent_column]]
+      end
+
+      it "should parent, left and right setters be protected methods" do
+        Client.new.protected_methods.include?("left=").should be_true
+        Client.new.protected_methods.include?("right=").should be_true
+        Client.new.protected_methods.include?("parent_id=").should be_true
+      end
+
+      it "shoud have faild on new when passing keys configured as right_column, left_column, parent_column" do
+        lambda { Client.new(Client.nested_set_options[:left_column] => 1) }.should raise_error(Sequel::Error)
+        lambda { Client.new(Client.nested_set_options[:right_column] => 2) }.should raise_error(Sequel::Error)
+        lambda { Client.new(Client.nested_set_options[:parent_column] => nil) }.should raise_error(Sequel::Error)
+      end
+
+      it "Client.new with {:left => 1, :right => 2, :parent_id => nil} should raise NoMethodError exception" do
+        lambda { Client.new({:left => 1, :right => 2, :parent_id => nil}) }.should raise_error(Sequel::Error)
+      end
+
+      it "should have nested_set_options equal to Model.nested_set_options" do
+        @root.nested_set_options.should == Client.nested_set_options
+      end
+
+      it "should have nodes that have common root" do
+        @node1.root.should == @root
+      end
+
+      it "should have nodes that have their parent" do
+        @node2_1.parent.should == @node2
+      end
+
+      it "should have leaf that will be true leaf?" do
+        @root.leaf?.should_not be_true
+        @node2_1.leaf?.should be_true
+      end
+
+      it "should have child that will be true child?" do
+        @root.child?.should_not be_true
+        @node2_1.child?.should be_true
+      end
+
+      it "should have <=> method" do
+        @root.should respond_to(:<=>)
+      end
+
+      it "Should order by left column" do
+        (@node1 <=> @node2).should == -1
+      end
+
+      it "should have level of node" do
+        @root.level.should == 0
+        @node1.level.should == 1
+        @node2.level.should == 1
+        @node2_1.level.should == 2
+      end
+
+      it "should have parent relation" do
+        @node2_1.parent.should == @node2
+      end
+
+      it "should have self_and_sibling that have self node and all its siblings" do
+        @root.self_and_siblings.all.should == [@root, @root2]
+        @node1.self_and_siblings.all.should == [@node1, @node2, @node3]
+      end
+
+      it "should have siblings of node withot itself" do
+        @root.siblings.all.should == [@root2]
+        @node1.siblings.all.should == [@node2, @node3]
+      end
+
+      it "should have self_and_ancestors that have self node and all its ancestors" do
+        @root.self_and_ancestors.all.should == [@root]
+        @node1.self_and_ancestors.all.should == [@root, @node1]
+      end
+
+      it "should have ancestors of node withot itself" do
+        @root.ancestors.all.should == []
+        @node1.ancestors.all.should == [@root]
+      end
+
+      it "should have self_and_descendants that have self node and all its descendents" do
+        @root.self_and_descendants.all.should == [@root, @node1, @node2, @node2_1, @node3]
+        @node2.self_and_descendants.all.should == [@node2, @node2_1]
+        @node2_1.self_and_descendants.all.should == [@node2_1]
+      end
+
+      it "should have descendents that are children and nested children wihout itself" do
+        @root.descendants.all.should == [@node1, @node2, @node2_1, @node3]
+        @node2.descendants.all.should == [@node2_1]
+        @node2_1.descendants.all.should == []
+      end
+
+      it "should have children that returns set of only node immediate children" do
+        @root.children.all.should == [@node1, @node2, @node3]
+        @node2.children.all.should == [@node2_1]
+        @node2_1.children.all.should == []
+      end
+
+      it "should have leaves that are set of all of node nested children which do not have children" do
+        @root.leaves.all.should == [@node1, @node2_1, @node3]
+        @node2.leaves.all.should == [@node2_1]
+        @node2_1.leaves.all.should == []
+      end
+
+      it "should be able to get left sibling" do
+        @node2.left_sibling.should == @node1
+        @node3.left_sibling.should == @node2
+        @node1.left_sibling.should be_nil
+      end
+
+      it "should be able to get proper right sibling" do
+        @node1.right_sibling.should == @node2
+        @node2.right_sibling.should == @node3
+        @node3.right_sibling.should be_nil
+      end
+
+      it "should have node_x.is_or_is_descendant_of?(node_y) that will return proper boolean value" do
+        @node1.is_or_is_descendant_of?(@root).should be_true
+        @node2_1.is_or_is_descendant_of?(@root).should be_true
+        @node2_1.is_or_is_descendant_of?(@node2).should be_true
+        @node2.is_or_is_descendant_of?(@node2_1).should be_false
+        @node2.is_or_is_descendant_of?(@node1).should be_false
+        @node1.is_or_is_descendant_of?(@node1).should be_true
+      end
+
+      it "should have node_x.is_ancestor_of?(node_y) that will return proper boolean value" do
+        @node1.is_descendant_of?(@root).should be_true
+        @node2_1.is_descendant_of?(@root).should be_true
+        @node2_1.is_descendant_of?(@node2).should be_true
+        @node2.is_descendant_of?(@node2_1).should be_false
+        @node2.is_descendant_of?(@node1).should be_false
+        @node1.is_descendant_of?(@node1).should be_false
+      end
+
+      it "should have node_x.is_ancestor_of?(node_y) that will return proper boolean value" do
+        @root.is_ancestor_of?(@node1).should be_true
+        @root.is_ancestor_of?(@node2_1).should be_true
+        @node2.is_ancestor_of?(@node2_1).should be_true
+        @node2_1.is_ancestor_of?(@node2).should be_false
+        @node1.is_ancestor_of?(@node2).should be_false
+        @node1.is_ancestor_of?(@node1).should be_false
+      end
+
+      it "should have node_x.is_or_is_ancestor_of?(node_y) that will return proper boolean value" do
+        @root.is_or_is_ancestor_of?(@node1).should be_true
+        @root.is_or_is_ancestor_of?(@node2_1).should be_true
+        @node2.is_or_is_ancestor_of?(@node2_1).should be_true
+        @node2_1.is_or_is_ancestor_of?(@node2).should be_false
+        @node1.is_or_is_ancestor_of?(@node2).should be_false
+        @node1.is_or_is_ancestor_of?(@node1).should be_true
+      end
+
+      it "should have node2 with left sibling as node1 and node3 with left sibling node2" do
+        @node2.left_sibling.should == @node1
+        @node3.left_sibling.should == @node2
+      end
+
+      it "should have root without left sibling" do
+        @root.left_sibling.should be_nil
+      end
+
+      it "should have node2_1 without left sibling" do
+        @node2_1.left_sibling.should be_nil
+      end
+
+      it "should have node1 without left sibling" do
+        @node1.left_sibling.should be_nil
+      end
+
+      it "should have node2 with right sibling as node3 and node1 with right sibling node2" do
+        @node2.right_sibling.should == @node3
+        @node1.right_sibling.should == @node2
+      end
+
+      it "should have root with right sibling as root2 and root2 with without right sibling" do
+        @root.right_sibling.should == @root2
+        @root2.right_sibling.should be_nil
+      end
+
+      it "should have node2_1 without right sibling" do
+        @node2_1.right_sibling.should be_nil
+      end
+
+      it "should have node3 without right sibling" do
+        @node3.right_sibling.should be_nil
+      end
+
+      it "should have to_text method that returns whole tree of instance node as text" do
+        @root.to_text.should == "* Client (nil, 1, 10)\n** Client (1, 2, 3)\n** Client (1, 4, 7)\n*** Client (3, 5, 6)\n** Client (1, 8, 9)"
+      end
+
+      it "should have to_text method that returns whole tree of instance node as text and should be able to pass block" do
+        @root.to_text { |node| node.name }.should == "* Top Level (nil, 1, 10)\n** Child 1 (1, 2, 3)\n** Child 2 (1, 4, 7)\n*** Child 2.1 (3, 5, 6)\n** Child 3 (1, 8, 9)"
+      end
+
+      it "should node2 be able to move to the left" do
+        @node2.move_left
+        @node2.left_sibling.should be_nil
+        @node2.right_sibling.should == @node1.refresh
+        Client.valid?.should be_true
+      end
+
+      it "should node2 be able to move to the right" do
+        @node2.move_right
+        @node2.right_sibling.should be_nil
+        @node2.left_sibling.should == @node3.refresh
+        Client.valid?.should be_true
+      end
+
+      it "should node3 be able to move to the left of node1" do
+        @node3.move_to_left_of(@node1)
+        @node3.left_sibling.should be_nil
+        @node3.right_sibling.should == @node1.refresh
+        Client.valid?.should be_true
+      end
+
+      it "should node1 be able to move to the right of node1" do
+        @node1.move_to_right_of(@node3)
+        @node1.right_sibling.should be_nil
+        @node1.left_sibling.should == @node3.refresh
+        Client.valid?.should be_true
+      end
+  
+      it "should node2 be able to became root" do
+        @node2.move_to_root
+        @node2.parent.should be_nil
+        @node2.level.should == 0
+        @node2_1.level.should == 1
+        @node2.left == 1
+        @node2.right == 4
+        Client.valid?.should be_true
+      end
+  
+      it "should node1 be able to move to child of node3" do
+        @node1.move_to_child_of(@node3)
+        @node1.parent_id.should == @node3.id
+        Client.valid?.should be_true
+      end
+
+      it "should be able to move new node to the end of root children" do
+        child = Client.create(:name => 'New Child')
+        child.move_to_child_of(@root)
+        @root.children.last.should == child
+        Client.valid?.should be_true
+      end
+  
+      it "should be able to move node2 as child of node1" do
+        @node2.left.should == 4
+        @node2.right.should == 7
+        @node1.left.should == 2
+        @node1.right.should == 3
+        @node2.move_to_child_of(@node1)
+        @node2.parent_id.should == @node1.id
+        Client.valid?.should be_true
+        @node2.left.should == 3
+        @node2.right.should == 6
+        @node1.left.should == 2
+        @node1.right.should == 7
+      end
+
+      it "should be able to move root node to child of new node" do
+        @root2.left.should == 11
+        @root2.right.should == 12
+
+        root3 = Client.create(:name => 'New Root')
+        root3.left.should == 13
+        root3.right.should == 14
+
+        @root2.move_to_child_of(root3)
+
+        Client.valid?.should be_true
+        @root2.parent_id.should == root3.id
+
+        @root2.left.should == 12
+        @root2.right.should == 13
+
+        root3.left.should == 11
+        root3.right.should == 14
+      end
+  
+      it "should be able to move root node to child of new node" do
+        @root.left.should == 1
+        @root.right.should == 10
+        @node2_1.left.should == 5
+        @node2_1.right.should == 6
+    
+        root3 = Client.create(:name => 'New Root')
+        @root.move_to_child_of(root3)
+        Client.valid?.should be_true
+        @root.parent_id.should == root3.id
+
+        @root.left.should == 4
+        @root.right.should == 13
+
+        @node2_1.refresh
+        @node2_1.left.should == 8
+        @node2_1.right.should == 9
+      end
+
+      it "should be able to rebuild whole tree" do
+        node1 = Client.create(:name => 'Node-1')
+        node2 = Client.create(:name => 'Node-2')
+        node3 = Client.create(:name => 'Node-3')
+
+        node2.move_to_child_of node1
+        node3.move_to_child_of node1
+
+        output = Client.roots.last.to_text
+        Client.update('lft = null, rgt = null')
+        Client.rebuild!
+
+        Client.roots.last.to_text.should == output
+      end
+  
+      it "should be invalid which lft = null" do
+        Client.valid?.should be_true
+        Client.update("lft = NULL")
+        Client.valid?.should be_false
+      end
+
+      it "should be invalid which rgt = null" do
+        Client.valid?.should be_true
+        Client.update("rgt = NULL")
+        Client.valid?.should be_false
+      end
+  
+      it "should be valid with mising intermediate node" do
+        Client.valid?.should be_true
+        @node2.destroy
+        Client.valid?.should be_true
+      end
+  
+      it "should be invalid with overlapping right nodes" do
+        Client.valid?.should be_true
+        @root2[:lft] = 0
+        @root2.save
+        Client.valid?.should be_false
+      end
+
+      it "should be able to rebild" do
+        Client.valid?.should be_true
+        before_text = Client.root.to_text
+        Client.update('lft = NULL, rgt = NULL')
+        Client.rebuild!
+        Client.valid?.should be_true
+        before_text.should == Client.root.to_text
+      end
+
+      it "shold be able to move for sibbling" do
+        @node2.move_possible?(@node1).should be_true
+      end
+
+      it "shold not be able to move for itself" do
+        @root.move_possible?(@root).should be_false
+      end
+
+      it "should not be able to move for parent" do
+        @root.descendants.each do |descendant_node|
+          @root.move_possible?(descendant_node).should be_false
+          descendant_node.move_possible?(@root).should be_true
+        end
+      end
+
+      it "should be correct is_or_is_ancestor_of?" do
+        [@node1, @node2, @node2_1, @node3].each do |node|
+          @root.is_or_is_ancestor_of?(node).should be_true
+        end
+        @root.is_or_is_ancestor_of?(@root2).should be_false
+      end
+  
+      it "should be invalid left_and_rights_valid? for nil lefts" do
+        Client.left_and_rights_valid?.should be_true
+        @node2[:lft] = nil
+        @node2.save
+        Client.left_and_rights_valid?.should be_false
+      end
+
+      it "should be invalid left_and_rights_valid? for nil rights" do
+        Client.left_and_rights_valid?.should be_true
+        @node2[:rgt] = nil
+        @node2.save
+        Client.left_and_rights_valid?.should be_false
+      end
+
+      it "should return true for left_and_rights_valid? when node lft is equal for root lft" do
+        Client.left_and_rights_valid?.should be_true
+        @node2[:lft] = @root[:lft]
+        @node2.save
+        Client.left_and_rights_valid?.should be_false
+      end
+
+      it "should return true for left_and_rights_valid? when node rgt is equal for root rgt" do
+        Client.left_and_rights_valid?.should be_true
+        @node2[:rgt] = @root[:rgt]
+        @node2.save
+        Client.left_and_rights_valid?.should be_false
+      end
+
+      it "should be valid after moving dirty nodes" do
+        n1 = Client.create
+        n2 = Client.create
+        n3 = Client.create
+        n4 = Client.create
+
+        n2.move_to_child_of(n1)
+        Client.valid?.should be_true
+
+        n3.move_to_child_of(n1)
+        Client.valid?.should be_true
+
+        n4.move_to_child_of(n2)
+        Client.valid?.should be_true
+      end
+
+      it "should have to_nested_a method that returns nested array of all nodes from roots to leaves" do
+        @root.to_nested_a.should == [@root, [@node1], [@node2, [@node2_1]], [@node3]]
+      end
+
+      it "should have to_nested_a method that can pass block with node and level" do
+        @root.to_nested_a { |node, level| level }.should == [0, [1], [1, [2]], [1]]
+      end
+    end
+  end
+
+  describe "wiht scope" do
+    describe "ClassMethods" do
+      it "should be no duplicates for columns accross different scopes" do
+
+      end
+
+      it "should have all roots valid accross different scopes" do
+
+      end
+
+      it "should have multi scope" do
+
+      end
+
+      it "should be able to rebuild! accross different scopes" do
+        
+      end
+
+      it "should have same_scope? true for nodes in the same scope" do
+
+      end
+
+      it "should have equal nodes in the same scope" do
+
+      end
+
+      it "should @root and @node be in same scope" do
+#        @root.same_scope?(@node).should be_true
+      end
+
+      it "should @root and @root_in_other_scope be in different scope" do
+
+      end
+
+      #  def test_multi_scoped_no_duplicates_for_columns?
+      #    assert_nothing_raised do
+      #      Note.no_duplicates_for_columns?
+      #    end
+      #  end
+      #
+      #  def test_multi_scoped_all_roots_valid?
+      #    assert_nothing_raised do
+      #      Note.all_roots_valid?
+      #    end
+      #  end
+      #
+      #  def test_multi_scoped
+      #    note1 = Note.create!(:body => "A", :notable_id => 2, :notable_type => 'Category')
+      #    note2 = Note.create!(:body => "B", :notable_id => 2, :notable_type => 'Category')
+      #    note3 = Note.create!(:body => "C", :notable_id => 2, :notable_type => 'Default')
+      #
+      #    assert_equal [note1, note2], note1.self_and_siblings
+      #    assert_equal [note3], note3.self_and_siblings
+      #  end
+      #
+      #  def test_multi_scoped_rebuild
+      #    root = Note.create!(:body => "A", :notable_id => 3, :notable_type => 'Category')
+      #    child1 = Note.create!(:body => "B", :notable_id => 3, :notable_type => 'Category')
+      #    child2 = Note.create!(:body => "C", :notable_id => 3, :notable_type => 'Category')
+      #
+      #    child1.move_to_child_of root
+      #    child2.move_to_child_of root
+      #
+      #    Note.update_all('lft = null, rgt = null')
+      #    Note.rebuild!
+      #
+      #    assert_equal Note.roots.find_by_body('A'), root
+      #    assert_equal [child1, child2], Note.roots.find_by_body('A').children
+      #  end
+      #
+      #  def test_same_scope_with_multi_scopes
+      #    assert_nothing_raised do
+      #      notes(:scope1).same_scope?(notes(:child_1))
+      #    end
+      #    assert notes(:scope1).same_scope?(notes(:child_1))
+      #    assert notes(:child_1).same_scope?(notes(:scope1))
+      #    assert !notes(:scope1).same_scope?(notes(:scope2))
+      #  end
+      #
+      #  def test_quoting_of_multi_scope_column_names
+      #    assert_equal ["\"notable_id\"", "\"notable_type\""], Note.quoted_scope_column_names
+      #  end
+      #
+      #  def test_equal_in_same_scope
+      #    assert_equal notes(:scope1), notes(:scope1)
+      #    assert_not_equal notes(:scope1), notes(:child_1)
+      #  end
+      #
+      #  def test_equal_in_different_scopes
+      #    assert_not_equal notes(:scope1), notes(:scope2)
+      #  end
+    end
+
+    describe "InstanceMethods" do
+
+    end
+  end
+
+end
+

data/spec/rcov.opts

@@ -0,0 +1 @@
+-x gems,spec

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--colour
+--loadby
+mtime
+--backtrace
+--format
+specdoc

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'spec'
+require 'sequel'
+require 'logger'
+require 'ruby-debug'
+
+require File.dirname(__FILE__) + '/../lib/sequel_nested_set'
+
+DB = Sequel.sqlite # memory database
+DB.logger = Logger.new('log/db.log')
+
+class Client < Sequel::Model
+  is :nested_set
+  set_schema do
+    primary_key :id
+    column :name, :text
+    column :parent_id, :integer
+    column :lft, :integer
+    column :rgt, :integer
+  end
+end
+
+Client.create_table
+
+def prepare_nested_set_data
+  Client.drop_table if Client.table_exists?
+  Client.create_table!
+  DB[:clients] << {"name"=>"Top Level 2", "lft"=>11, "id"=>6, "rgt"=>12}
+  DB[:clients] << {"name"=>"Child 2.1", "lft"=>5, "id"=>4, "parent_id"=>3, "rgt"=>6}
+  DB[:clients] << {"name"=>"Child 1", "lft"=>2, "id"=>2, "parent_id"=>1, "rgt"=>3}
+  DB[:clients] << {"name"=>"Top Level", "lft"=>1, "id"=>1, "rgt"=>10}
+  DB[:clients] << {"name"=>"Child 2", "lft"=>4, "id"=>3, "parent_id"=>1, "rgt"=>7}
+  DB[:clients] << {"name"=>"Child 3", "lft"=>8, "id"=>5, "parent_id"=>1, "rgt"=>9}
+end
+
+prepare_nested_set_data
+
+
+

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: pkondzior-sequel_nested_set
+version: !ruby/object:Gem::Version 
+  version: 0.9.9
+platform: ruby
+authors: 
+- "Pawe\xC5\x82 Kondzior"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-11 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.8.0
+    version: 
+description: Nested set implementation, ported from the Awesome Nested Set Active Record plugin.
+email: kondzior.p@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- TODO
+- COPYING
+- README
+files: 
+- lib/sequel_nested_set.rb
+- TODO
+- COPYING
+- README
+has_rdoc: true
+homepage: http://sequelns.rubyforge.org/
+post_install_message: 
+rdoc_options: 
+- --quiet
+- --title
+- Sequel Nested Set
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README
+- --inline-source
+- --charset
+- utf8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Nested set implementation for Sequel Models
+test_files: 
+- spec/nested_set_spec.rb
+- spec/rcov.opts
+- spec/spec.opts
+- spec/spec_helper.rb