dm-is-nested_set 0.9.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Sindre Aarsaether (somebee.com)
+
+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,95 @@
+dm-is-nested_set
+================
+
+DataMapper plugin allowing the creation of nested sets from data models.
+Provides all the same functionality as dm-is-tree, plus tons more! Read on.
+
+== What is a nested set?
+
+Nested set is a clever model for storing hierarchical data in a flat table.
+Instead of (only) storing the id of the parent on each node, a nested set puts
+all nodes in a clever structure (see Example below). That is what makes it
+possible to get the all of the descendants (not only immediate children),
+ancestors, or siblings, in one single query to the database.
+
+The only downside to nested sets (compared to trees] is that the queries it
+takes to know these things, and to move nodes around in the tree are rather
+complex. That is what this plugin takes care of (+ lots of other neat stuff)!
+
+Nested sets are a good choice for most kinds of ordered trees with more than
+two levels of nesting. Very good for menus, categories, and threaded posts.
+
+== Installation
+
+Download and install the latest dm-more-gem. Remember to require it!
+
+== Getting started
+
+Coming
+
+== Traversing the tree
+
+Coming
+
+== Moving nodes
+
+Coming
+
+
+== Example of a nested set
+
+We have a nested menu of categories. The categories are as follows:
+
+-Electronics
+ - Televisions
+   - Tube
+   - LCD
+   - Plasma
+ - Portable Electronics
+   - MP3 Players
+   - CD Players
+
+In a nested set, each of these categories would have 'left' and 'right' fields,
+informing about where in the set they are positioned. This can be illustrated:
+ _____________________________________________________________________________
+|   _________________________________    __________________________________   |
+|  |   ______    _____    ________   |  |   _______________    _________   |  |
+|  |  |      |  |     |  |        |  |  |  |               |  |         |  |  |
+1  2  3      4  5     6  7        8  9  10 11             12  13  CD-  14 15 16
+|  |  | Tube |  | LCD |  | Plasma |  |  |  |  MP3 Players  |  | Players |  |  |
+|  |  |______|  |_____|  |________|  |  |  |_______________|  |_________|  |  |
+|  |                                 |  |                                  |  |
+|  |          Televisions            |  |       Portable Electronics       |  |
+|  |_________________________________|  |__________________________________|  |
+|                                                                             |
+|                                 Electronics                                 |
+|_____________________________________________________________________________|
+
+All sets has a left / right value, that just says 'here do I start', and 'here
+do I end'. The category 'Televisions' starts at 2, and ends at 9. We then know
+that _all_ descendants of 'Televisions' reside between 2 and 9. Whats more, we
+can see all categories that does not have any subcategory, by checking if their
+left and right value has a gap between them. Clever huh?
+
+Now, if we want to insert the category 'Flash' into 'MP3 Players', the new set
+and left/right values would now be:
+ _____________________________________________________________________________
+|                                        __________________________________   |
+|   _________________________________   |   _______________                |  |
+|  |   ______    _____    ________   |  |  |   _________   |   _________   |  |
+|  |  |      |  |     |  |        |  |  |  |  |         |  |  |         |  |  |
+1  2  3      4  5     6  7        8  9  10 11 12 Flash 13 14  15  CD-  16 17 18
+|  |  | Tube |  | LCD |  | Plasma |  |  |  |  |_________|  |  | Players |  |  |
+|  |  |______|  |_____|  |________|  |  |  |               |  |_________|  |  |
+|  |                                 |  |  |  MP3 Players  |               |  |
+|  |          Televisions            |  |  |_______________|  Portable El. |  |
+|  |_________________________________|  |__________________________________|  |
+|                                                                             |
+|                                 Electronics                                 |
+|_____________________________________________________________________________|
+
+== More about nested sets
+
+* http://www.developersdex.com/gurus/articles/112.asp
+* http://dev.mysql.com/tech-resources/articles/hierarchical-data.html
+* http://www.codeproject.com/KB/database/nestedsets.aspx (nice illustrations)

data/Rakefile

@@ -0,0 +1,65 @@
+require 'rubygems'
+require 'spec'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+require 'pathname'
+
+CLEAN.include '{log,pkg}/'
+
+spec = Gem::Specification.new do |s|
+  s.name             = 'dm-is-nested_set'
+  s.version          = '0.9.2'
+  s.platform         = Gem::Platform::RUBY
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w[ README LICENSE TODO ]
+  s.summary          = 'DataMapper plugin allowing the creation of nested sets from data models'
+  s.description      = s.summary
+  s.author           = 'Sindre Aarsaether'
+  s.email            = 'sindre@identu.no'
+  s.homepage         = 'http://github.com/sam/dm-more/tree/master/dm-is-nested_set'
+  s.require_path     = 'lib'
+  s.files            = FileList[ '{lib,spec}/**/*.rb', 'spec/spec.opts', 'Rakefile', *s.extra_rdoc_files ]
+  s.add_dependency('dm-core', "=#{s.version}")
+end
+
+task :default => [ :spec ]
+
+WIN32 = (RUBY_PLATFORM =~ /win32|mingw|cygwin/) rescue nil
+SUDO  = WIN32 ? '' : ('sudo' unless ENV['SUDOLESS'])
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Install #{spec.name} #{spec.version} (default ruby)"
+task :install => [ :package ] do
+  sh "#{SUDO} gem install --local pkg/#{spec.name}-#{spec.version} --no-update-sources", :verbose => false
+end
+
+desc "Uninstall #{spec.name} #{spec.version} (default ruby)"
+task :uninstall => [ :clobber ] do
+  sh "#{SUDO} gem uninstall #{spec.name} -v#{spec.version} -I -x", :verbose => false
+end
+
+namespace :jruby do
+  desc "Install #{spec.name} #{spec.version} with JRuby"
+  task :install => [ :package ] do
+    sh %{#{SUDO} jruby -S gem install --local pkg/#{spec.name}-#{spec.version} --no-update-sources}, :verbose => false
+  end
+end
+
+desc 'Run specifications'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
+  t.spec_files = Pathname.glob(Pathname.new(__FILE__).dirname + 'spec/**/*_spec.rb')
+
+  begin
+    t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+    t.rcov_opts << '--exclude' << 'spec'
+    t.rcov_opts << '--text-summary'
+    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+  rescue Exception
+    # rcov not installed
+  end
+end

data/TODO

@@ -0,0 +1,9 @@
+TODO
+====
+* Add support for more than one root, and scope/namespacing
+* Write docs throughout the plugin
+* Add support for transactions and tablelocking when reorganizing items
+* Add function for (re)building nested set from ordinary tree
+* Caching the finder-methods
+* Allow options to pass through finders
+* Handle children of destroyed objects

data/lib/dm-is-nested_set.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'pathname'
+
+gem 'dm-core', '=0.9.2'
+require 'dm-core'
+
+gem 'dm-adjust', '=0.9.2'
+require 'dm-adjust'
+
+require Pathname(__FILE__).dirname.expand_path / 'dm-is-nested_set' / 'is' / 'nested_set.rb'

data/lib/dm-is-nested_set/is/nested_set.rb

@@ -0,0 +1,388 @@
+module DataMapper
+  module Is
+    module NestedSet
+
+      ##
+      # docs in the works
+      #
+      def is_nested_set(options={})
+        options = { :child_key => [:parent_id], :scope => [] }.merge(options)
+
+        extend  DataMapper::Is::NestedSet::ClassMethods
+        include DataMapper::Is::NestedSet::InstanceMethods
+
+        @nested_set_scope = options[:scope]
+        @nested_set_parent = options[:child_key]
+
+        property :lft, Integer, :writer => :private
+        property :rgt, Integer, :writer => :private
+
+        # a temporary fix. I need to filter. now I just use parent.children in self_and_siblings, which could
+        # be cut down to 1 instead of 2 queries. this would be the other way, but seems hackish:
+        # options[:child_key].each{|pname| property(pname, Integer) unless properties.detect{|p| p.name == pname}}
+
+        belongs_to :parent,   :class_name => self.name, :child_key => options[:child_key], :order => [:lft.asc]
+        has n,     :children, :class_name => self.name, :child_key => options[:child_key], :order => [:lft.asc]
+
+        #before :create do
+        #  # scenarios:
+        #  # - user creates a new object and does not specify a parent
+        #  # - user creates a new object with a direct reference to a parent
+        #  # - user spawnes a new object, and then moves it to a position
+        #  if !self.parent
+        #    self.class.root ? self.move_without_saving(:into => self.class.root) : self.move_without_saving(:to => 1)
+        #    # if this is actually root, it will not move a bit (as lft is already 1)
+        #  elsif self.parent && !self.lft
+        #    # user has set a parent before saving (and without moving it anywhere). just move into that, and continue
+        #    # might be som problems here if the referenced parent is not saved.
+        #    self.move_without_saving(:into => self.parent)
+        #  end
+        #end
+
+        before :save do
+          if self.new_record?
+            if !self.parent
+              # TODO must change for nested sets
+              self.root ? self.move_without_saving(:into => self.root) : self.move_without_saving(:to => 1)
+            elsif self.parent && !self.lft
+              self.move_without_saving(:into => self.parent)
+            end
+          else
+
+            if self.nested_set_scope != self.original_nested_set_scope
+              # TODO detach from old list first. many edge-cases here, need good testing
+              self.lft,self.rgt = nil,nil
+              #puts "#{self.root.inspect} - #{[self.nested_set_scope,self.original_nested_set_scope].inspect}"
+              self.root ? self.move_without_saving(:into => self.root) : self.move_without_saving(:to => 1)
+            elsif (self.parent && !self.lft) || (self.parent != self.ancestor)
+              # if the parent is set, we try to move this into that parent, otherwise move into root.
+              self.parent ? self.move_without_saving(:into => self.parent) : self.move_without_saving(:into => self.class.root)
+            end
+
+          end
+        end
+
+        #before :update do
+        #  # scenarios:
+        #  # - user moves the object to a position
+        #  # - user has changed the parent
+        #  # - user has removed any reference to a parent
+        #  # - user sets the parent_id to something, and then use #move before saving
+        #  if (self.parent && !self.lft) || (self.parent != self.ancestor)
+        #    # if the parent is set, we try to move this into that parent, otherwise move into root.
+        #    self.parent ? self.move_without_saving(:into => self.parent) : self.move_without_saving(:into => self.class.root)
+        #  end
+        #end
+
+      end
+
+      module ClassMethods
+        attr_reader :nested_set_scope, :nested_set_parent
+
+        def adjust_gap!(scoped_set,at,adjustment)
+          scoped_set.all(:rgt.gt => at).adjust!({:rgt => adjustment},true)
+          scoped_set.all(:lft.gt => at).adjust!({:lft => adjustment},true)
+        end
+
+        ##
+        # get the root of the tree. if sets are scoped, this will return false
+        #
+        def root
+          # TODO scoping
+          # what should this return if there is a scope? always false, or node if there is only one?
+          roots.length > 1 ? false : roots.first
+        end
+
+        ##
+        # not implemented
+        #
+        def roots
+          # TODO scoping
+          # TODO supply filtering-option?
+          all(nested_set_parent.zip([]).to_hash)
+        end
+
+        ##
+        #
+        #
+        def leaves
+          # TODO scoping, how should it act?
+          # TODO supply filtering-option?
+          all(:conditions => ["rgt=lft+1"], :order => [:lft.asc])
+        end
+
+        ##
+        # rebuilds the parent/child relationships (parent_id) from nested set (left/right values)
+        #
+        def rebuild_tree_from_set
+          all.each do |node|
+            node.parent = node.ancestor
+            node.save
+          end
+        end
+
+        ##
+        # rebuilds the nested set using parent/child relationships and a chosen order
+        #
+        def rebuild_set_from_tree(order=nil)
+          # TODO pending
+        end
+      end
+
+      module InstanceMethods
+
+        ##
+        #
+        # @private
+        def nested_set_scope
+          self.class.nested_set_scope.map{|p| [p,attribute_get(p)]}.to_hash
+        end
+
+        ##
+        #
+        # @private
+        def original_nested_set_scope
+          # TODO commit
+          self.class.nested_set_scope.map{|p| [p, original_values.key?(p) ? original_values[p] : attribute_get(p)]}.to_hash
+        end
+
+        ##
+        # the whole nested set this node belongs to. served flat like a pancake!
+        #
+        def nested_set
+          # TODO add option for serving it as a nested array
+          self.class.all(nested_set_scope.merge(:order => [:lft.asc]))
+        end
+
+        ##
+        # move self / node to a position in the set. position can _only_ be changed through this
+        #
+        # @example [Usage]
+        #   * node.move :higher           # moves node higher unless it is at the top of parent
+        #   * node.move :lower            # moves node lower unless it is at the bottom of parent
+        #   * node.move :below => other   # moves this node below other resource in the set
+        #   * node.move :into => other    # same as setting a parent-relationship
+        #
+        # @param vector <Symbol, Hash> A symbol, or a key-value pair that describes the requested movement
+        #
+        # @option :higher<Symbol> move node higher
+        # @option :highest<Symbol> move node to the top of the list (within its parent)
+        # @option :lower<Symbol> move node lower
+        # @option :lowest<Symbol> move node to the bottom of the list (within its parent)
+        # @option :indent<Symbol> move node into sibling above
+        # @option :outdent<Symbol> move node out below its current parent
+        # @option :into<Resource> move node into another node
+        # @option :above<Resource> move node above other node
+        # @option :below<Resource> move node below other node
+        # @option :to<Integer> move node to a specific location in the nested set
+        #
+        # @return <FalseClass> returns false if it cannot move to the position, or if it is already there
+        # @raise <RecursiveNestingError> if node is asked to position itself into one of its descendants
+        # @raise <UnableToPositionError> if node is unable to calculate a new position for the element
+        # @see move_without_saving
+        def move(vector)
+          move_without_saving(vector)
+          save
+        end
+
+        ##
+        # @see move
+        def move_without_saving(vector)
+          if vector.is_a? Hash then action,object = vector.keys[0],vector.values[0] else action = vector end
+
+          changed_scope = nested_set_scope != original_nested_set_scope
+
+          position = case action
+            when :higher  then left_sibling  ? left_sibling.lft    : nil # : "already at the top"
+            when :highest then ancestor      ? ancestor.lft+1      : nil # : "is root, or has no parent"
+            when :lower   then right_sibling ? right_sibling.rgt+1 : nil # : "already at the bottom"
+            when :lowest  then ancestor      ? ancestor.rgt        : nil # : "is root, or has no parent"
+            when :indent  then left_sibling  ? left_sibling.rgt    : nil # : "cannot find a sibling to indent into"
+            when :outdent then ancestor      ? ancestor.rgt+1      : nil # : "is root, or has no parent"
+            when :into    then object        ? object.rgt          : nil # : "supply an object"
+            when :above   then object        ? object.lft          : nil # : "supply an object"
+            when :below   then object        ? object.rgt+1        : nil # : "supply an object"
+            when :to      then object        ? object.to_i         : nil # : "supply a number"
+          end
+
+          ##
+          # raising an error whenever it couldnt move seems a bit harsh. want to return self for nesting.
+          # if anyone has a good idea about how it should react when it cant set a valid position,
+          # don't hesitate to find me in #datamapper, or send me an email at sindre -a- identu -dot- no
+          #
+          # raise UnableToPositionError unless position.is_a?(Integer) && position > 0
+          return false if !position || position < 1
+          # return false if you are trying to move this into another scope
+          return false if [:into, :above,:below].include?(action) && nested_set_scope != object.nested_set_scope
+          # if node is already in the requested position
+          if self.lft == position || self.rgt == position - 1
+            self.parent = self.ancestor # must set this again, because it might have been changed by the user before move.
+            return false
+          end
+
+          transaction do |transaction|
+
+            ##
+            # if this node is already positioned we need to move it, and close the gap it leaves behind etc
+            # otherwise we only need to open a gap in the set, and smash that buggar in
+            #
+            if self.lft && self.rgt
+              # raise exception if node is trying to move into one of its descendants (infinate loop, spacetime will warp)
+              raise RecursiveNestingError if position > self.lft && position < self.rgt
+              # find out how wide this node is, as we need to make a gap large enough for it to fit in
+              gap = self.rgt - self.lft + 1
+              # make a gap at position, that is as wide as this node
+              self.class.adjust_gap!(nested_set,position-1,gap)
+              # offset this node (and all its descendants) to the right position
+              old_position = self.lft
+              offset = position - old_position
+              nested_set.all(:rgt => self.lft..self.rgt).adjust!({:lft => offset, :rgt => offset},true)
+              # close the gap this movement left behind.
+              self.class.adjust_gap!(nested_set,old_position,-gap)
+            else
+              # make a gap where the new node can be inserted
+              self.class.adjust_gap!(nested_set,position-1,2)
+              # set the position fields
+              self.lft, self.rgt = position, position + 1
+            end
+
+            self.parent = self.ancestor
+
+          end
+        end
+
+        ##
+        # get the level of this node, where 0 is root. temporary solution
+        #
+        # @return <Integer>
+        def level
+          # TODO make a level-property that is cached and intelligently adjusted when saving objects
+          ancestors.length
+        end
+
+        ##
+        # get all ancestors of this node, up to (and including) self
+        #
+        # @return <Collection>
+        def self_and_ancestors
+          nested_set.all(:lft.lte => lft, :rgt.gte => rgt)
+        end
+
+        ##
+        # get all ancestors of this node
+        #
+        # @return <Collection> collection of all parents, with root as first item
+        # @see #self_and_ancestors
+        def ancestors
+          nested_set.all(:lft.lt => lft, :rgt.gt => rgt)
+          #self_and_ancestors.reject{|r| r.key == self.key } # because identitymap is not used in console
+        end
+
+        ##
+        # get the parent of this node. Same as #parent, but finds it from lft/rgt instead of parent-key
+        #
+        # @return <Resource, NilClass> returns the parent-object, or nil if this is root/detached
+        def ancestor
+          ancestors.reverse.first
+        end
+
+        ##
+        # get the root this node belongs to. this will atm always be the same as Resource.root, but has a
+        # meaning when scoped sets is implemented
+        #
+        # @return <Resource, NilClass>
+        def root
+          nested_set.first
+        end
+
+        ##
+        # check if this node is a root
+        #
+        def root?
+          !parent && !new_record?
+        end
+
+        ##
+        # get all descendants of this node, including self
+        #
+        # @return <Collection> flat collection, sorted according to nested_set positions
+        def self_and_descendants
+          # TODO supply filtering-option?
+          nested_set.all(:lft => lft..rgt)
+        end
+
+        ##
+        # get all descendants of this node
+        #
+        # @return <Collection> flat collection, sorted according to nested_set positions
+        # @see #self_and_descendants
+        def descendants
+          # TODO add argument for returning as a nested array.
+          # TODO supply filtering-option?
+          nested_set.all(:lft => (lft+1)..(rgt-1))
+        end
+
+        ##
+        # get all descendants of this node that does not have any children
+        #
+        # @return <Collection>
+        def leaves
+          # TODO supply filtering-option?
+          nested_set.all(:lft => (lft+1)..rgt, :conditions=>["rgt=lft+1"])
+        end
+
+        ##
+        # check if this node is a leaf (does not have subnodes).
+        # use this instead ofdescendants.empty?
+        #
+        # @par
+        def leaf?
+          rgt-lft == 1
+        end
+
+        ##
+        # get all siblings of this node, and include self
+        #
+        # @return <Collection>
+        def self_and_siblings
+          parent ? parent.children : [self]
+        end
+
+        ##
+        # get all siblings of this node
+        #
+        # @return <Collection>
+        # @see #self_and_siblings
+        def siblings
+          # TODO find a way to return this as a collection?
+          # TODO supply filtering-option?
+          self_and_siblings.reject{|r| r.key == self.key } # because identitymap is not used in console
+        end
+
+        ##
+        # get sibling to the left of/above this node in the nested tree
+        #
+        # @return <Resource, NilClass> the resource to the left, or nil if self is leftmost
+        # @see #self_and_siblings
+        def left_sibling
+          self_and_siblings.find{|v| v.rgt == lft-1}
+        end
+
+        ##
+        # get sibling to the right of/above this node in the nested tree
+        #
+        # @return <Resource, NilClass> the resource to the right, or nil if self is rightmost
+        # @see #self_and_siblings
+        def right_sibling
+          self_and_siblings.find{|v| v.lft == rgt+1}
+        end
+
+      end
+
+      class UnableToPositionError < StandardError; end
+      class RecursiveNestingError < StandardError; end
+
+      Model.send(:include, self)
+    end # NestedSet
+  end # Is
+end # DataMapper

data/spec/integration/nested_set_spec.rb

@@ -0,0 +1,313 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
+
+  class User
+    include DataMapper::Resource
+
+    property :id, Serial
+    property :name, String
+
+    has n, :categories
+  end
+
+  class Category
+    include DataMapper::Resource
+
+    property :id, Integer, :serial => true
+    property :name, String
+
+    belongs_to :user
+
+    is :nested_set, :scope => [:user_id]
+
+
+
+    # convenience method only for speccing.
+    def pos; [lft,rgt] end
+  end
+
+  def setup
+    repository(:default) do
+
+      User.auto_migrate!
+      @paul = User.create!(:name => "paul")
+      @john = User.create!(:name => "john")
+
+      Category.auto_migrate!
+      electronics  = Category.create!(:id => 1, :name => "Electronics")
+      televisions  = Category.create!(:id => 2, :parent_id => 1,  :name => "Televisions")
+      tube         = Category.create!(:id => 3, :parent_id => 2,  :name => "Tube")
+      lcd          = Category.create!(:id => 4, :parent_id => 2,  :name => "LCD")
+      plasma       = Category.create!(:id => 5, :parent_id => 2,  :name => "Plasma")
+      portable_el  = Category.create!(:id => 6, :parent_id => 1,  :name => "Portable Electronics")
+      mp3_players  = Category.create!(:id => 7, :parent_id => 6,  :name => "MP3 Players")
+      flash        = Category.create!(:id => 8, :parent_id => 7,  :name => "Flash")
+      cd_players   = Category.create!(:id => 9, :parent_id => 6,  :name => "CD Players")
+      radios       = Category.create!(:id => 10,:parent_id => 6,  :name => "2 Way Radios")
+    end
+  end
+
+  setup
+
+  # id | lft| rgt| title
+  #========================================
+  # 1  | 1  | 20 | - Electronics
+  # 2  | 2  | 9  |   - Televisions
+  # 3  | 3  | 4  |     - Tube
+  # 4  | 5  | 6  |     - LCD
+  # 5  | 7  | 8  |     - Plasma
+  # 6  | 10 | 19 |   - Portable Electronics
+  # 7  | 11 | 14 |     - MP3 Players
+  # 8  | 12 | 13 |       - Flash
+  # 9  | 15 | 16 |     - CD Players
+  # 10 | 17 | 18 |     - 2 Way Radios
+
+  # |  |  |      |  |     |  |        |  |  |  |  |           |  |  |            |  |              |  |  |
+  # 1  2  3      4  5     6  7        8  9  10 11 12  Flash  13 14  15          16  17            18 19 20
+  # |  |  | Tube |  | LCD |  | Plasma |  |  |  |  |___________|  |  | CD Players |  | 2 Way Radios |  |  |
+  # |  |  |______|  |_____|  |________|  |  |  |                 |  |____________|  |______________|  |  |
+  # |  |                                 |  |  |   MP3 Players   |                                    |  |
+  # |  |          Televisions            |  |  |_________________|       Portable Electronics         |  |
+  # |  |_________________________________|  |_________________________________________________________|  |
+  # |                                                                                                    |
+  # |                                       Electronics                                                  |
+  # |____________________________________________________________________________________________________|
+
+
+
+  describe 'DataMapper::Is::NestedSet' do
+    before :all do
+
+    end
+
+    describe 'Class#rebuild_tree_from_set' do
+      it 'should reset all parent_ids correctly' do
+        repository(:default) do
+          plasma = Category.get(5)
+          plasma.parent_id.should == 2
+          plasma.ancestor.id.should == 2
+          plasma.pos.should == [7,8]
+          plasma.parent_id = nil
+          Category.rebuild_tree_from_set
+          plasma.parent_id.should == 2
+        end
+      end
+    end
+
+    describe 'Class#root and #root' do
+      it 'should return the toplevel node' do
+        Category.root.name.should == "Electronics"
+      end
+    end
+
+    describe 'Class#leaves and #leaves' do
+      it 'should return all nodes without descendants' do
+        repository(:default) do
+          Category.leaves.length.should == 6
+
+          r = Category.root
+          r.leaves.length.should == 6
+          r.children[1].leaves.length.should == 3
+        end
+      end
+    end
+
+    describe '#ancestor, #ancestors and #self_and_ancestors' do
+      it 'should return ancestors in an array' do
+        repository(:default) do |repos|
+          c8 = Category.get(8)
+          c8.ancestor.should == Category.get(7)
+          c8.ancestor.should == c8.parent
+
+          c8.ancestors.map{|a|a.name}.should == ["Electronics","Portable Electronics","MP3 Players"]
+          c8.self_and_ancestors.map{|a|a.name}.should == ["Electronics","Portable Electronics","MP3 Players","Flash"]
+        end
+      end
+    end
+
+    describe '#children' do
+      it 'should return children of node' do
+        repository(:default) do |repos|
+          r = Category.root
+          r.children.length.should == 2
+
+          t = r.children.first
+          t.children.length.should == 3
+          t.children.first.name.should == "Tube"
+          t.children[2].name.should == "Plasma"
+        end
+      end
+    end
+
+    describe '#descendants and #self_and_descendants' do
+      it 'should return all subnodes of node' do
+        repository(:default) do
+          r = Category.root
+          r.self_and_descendants.length.should == 10
+          r.descendants.length.should == 9
+
+          t = r.children[1]
+          t.descendants.length.should == 4
+          t.descendants.map{|a|a.name}.should == ["MP3 Players","Flash","CD Players","2 Way Radios"]
+        end
+      end
+    end
+
+    describe '#siblings and #self_and_siblings' do
+      it 'should return all siblings of node' do
+        repository(:default) do
+          r = Category.root
+          r.self_and_siblings.length.should == 1
+          r.descendants.length.should == 9
+
+          televisions = r.children[0]
+          televisions.siblings.length.should == 1
+          televisions.siblings.map{|a|a.name}.should == ["Portable Electronics"]
+        end
+      end
+    end
+
+    describe '#move' do
+
+      # Outset:
+      # id | lft| rgt| title
+      #========================================
+      # 1  | 1  | 20 | - Electronics
+      # 2  | 2  | 9  |   - Televisions
+      # 3  | 3  | 4  |     - Tube
+      # 4  | 5  | 6  |     - LCD
+      # 5  | 7  | 8  |     - Plasma
+      # 6  | 10 | 19 |   - Portable Electronics
+      # 7  | 11 | 14 |     - MP3 Players
+      # 8  | 12 | 13 |       - Flash
+      # 9  | 15 | 16 |     - CD Players
+      # 10 | 17 | 18 |     - 2 Way Radios
+
+
+      it 'should move items correctly with :higher / :highest / :lower / :lowest' do
+        repository(:default) do |repos|
+
+          Category.get(4).pos.should == [5,6]
+
+          Category.get(4).move(:above => Category.get(3))
+          Category.get(4).pos.should == [3,4]
+
+          Category.get(4).move(:higher).should == false
+          Category.get(4).pos.should == [3,4]
+          Category.get(3).pos.should == [5,6]
+          Category.get(4).right_sibling.should == Category.get(3)
+
+          Category.get(4).move(:lower)
+          Category.get(4).pos.should == [5,6]
+          Category.get(4).left_sibling.should == Category.get(3)
+          Category.get(4).right_sibling.should == Category.get(5)
+
+          Category.get(4).move(:highest)
+          Category.get(4).pos.should == [3,4]
+          Category.get(4).move(:higher).should == false
+
+          Category.get(4).move(:lowest)
+          Category.get(4).pos.should == [7,8]
+          Category.get(4).left_sibling.should == Category.get(5)
+
+          Category.get(4).move(:higher) # should reset the tree to how it was
+
+        end
+      end
+
+      it 'should move items correctly with :indent / :outdent' do
+        repository(:default) do |repos|
+
+          mp3_players = Category.get(7)
+
+          portable_electronics = Category.get(6)
+          televisions = Category.get(2)
+
+          mp3_players.pos.should == [11,14]
+          #mp3_players.descendants.length.should == 1
+
+          # The category is at the top of its parent, should not be able to indent.
+          mp3_players.move(:indent).should == false
+
+          mp3_players.move(:outdent)
+
+          mp3_players.pos.should == [16,19]
+          mp3_players.left_sibling.should == portable_electronics
+
+          mp3_players.move(:higher) # Move up above Portable Electronics
+
+          mp3_players.pos.should == [10,13]
+          mp3_players.left_sibling.should == televisions
+        end
+      end
+    end
+
+    describe 'moving objects with #move_* #and place_node_at' do
+      it 'should set left/right when choosing a parent' do
+        repository(:default) do |repos|
+          Category.auto_migrate!
+
+          c1 = Category.create!(:name => "New Electronics")
+
+          c2 = Category.create!(:name => "OLED TVs")
+
+          c1.pos.should == [1,4]
+          c1.root.should == c1
+          c2.pos.should == [2,3]
+
+          c3 = Category.create(:name => "Portable Electronics")
+          c3.parent=c1
+          c3.save
+
+          c1.pos.should == [1,6]
+          c2.pos.should == [2,3]
+          c3.pos.should == [4,5]
+
+          c3.parent=c2
+          c3.save
+
+          c1.pos.should == [1,6]
+          c2.pos.should == [2,5]
+          c3.pos.should == [3,4]
+
+          c3.parent=c1
+          c3.move(:into => c2)
+
+          c1.pos.should == [1,6]
+          c2.pos.should == [2,5]
+          c3.pos.should == [3,4]
+
+          c4 = Category.create(:name => "Tube", :parent => c2)
+          c5 = Category.create(:name => "Flatpanel", :parent => c2)
+
+          c1.pos.should == [1,10]
+          c2.pos.should == [2,9]
+          c3.pos.should == [3,4]
+          c4.pos.should == [5,6]
+          c5.pos.should == [7,8]
+
+          c5.move(:above => c3)
+          c3.pos.should == [5,6]
+          c4.pos.should == [7,8]
+          c5.pos.should == [3,4]
+
+        end
+      end
+    end
+
+    describe 'scoping' do
+      it 'should detach from list when changing scope' do
+        setup
+        plasma = Category.get(5)
+        plasma.pos.should == [7,8]
+        plasma.user_id = 1
+        plasma.save
+
+        plasma.pos.should == [1,2]
+      end
+    end
+
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--format specdoc
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+gem 'rspec', '>=1.1.3'
+require 'spec'
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'lib/dm-is-nested_set'
+
+def load_driver(name, default_uri)
+  return false if ENV['ADAPTER'] != name.to_s
+
+  lib = "do_#{name}"
+
+  begin
+    gem lib, '=0.9.2'
+    require lib
+    DataMapper.setup(name, ENV["#{name.to_s.upcase}_SPEC_URI"] || default_uri)
+    DataMapper::Repository.adapters[:default] =  DataMapper::Repository.adapters[name]
+    true
+  rescue Gem::LoadError => e
+    warn "Could not load #{lib}: #{e}"
+    false
+  end
+end
+
+ENV['ADAPTER'] ||= 'sqlite3'
+
+HAS_SQLITE3  = load_driver(:sqlite3,  'sqlite3::memory:')
+HAS_MYSQL    = load_driver(:mysql,    'mysql://localhost/dm_core_test')
+HAS_POSTGRES = load_driver(:postgres, 'postgres://postgres@localhost/dm_core_test')

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: dm-is-nested_set
+version: !ruby/object:Gem::Version 
+  version: 0.9.2
+platform: ruby
+authors: 
+- Sindre Aarsaether
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-25 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.9.2
+    version: 
+description: DataMapper plugin allowing the creation of nested sets from data models
+email: sindre@identu.no
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- lib/dm-is-nested_set/is/nested_set.rb
+- lib/dm-is-nested_set.rb
+- spec/integration/nested_set_spec.rb
+- spec/spec_helper.rb
+- spec/spec.opts
+- Rakefile
+- README
+- LICENSE
+- TODO
+has_rdoc: true
+homepage: http://github.com/sam/dm-more/tree/master/dm-is-nested_set
+post_install_message: 
+rdoc_options: []
+
+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.0.1
+signing_key: 
+specification_version: 2
+summary: DataMapper plugin allowing the creation of nested sets from data models
+test_files: []
+