acts_as_restful_list 0.5.0 → 0.6

data/History.rdoc

@@ -1,3 +1,9 @@
+=== Version 0.6.0 / 2011-07-18
+
+* enhancements
+  * Automatically initialize the order of the list under conditions that would 
+    otherwise break things. Thanks evizitei!!
+
 === Version 0.5.0 / 2011-02-08
 
 * enhancements
@@ -21,4 +27,4 @@
 === Version 0.0.3 / 2010-02-14
 
 * enhancements
-  * can set the position column
+  * can set the position column

data/lib/acts_as_restful_list.rb

@@ -57,19 +57,24 @@ module ActsAsRestfulList
   
   module InstanceMethods
     def set_position
-      last_record = self.class.last( :conditions => scope_condition, :order => "#{position_column} ASC" )
-      self.send( "#{position_column}=", ( last_record.nil? ? 1 : last_record.send(position_column) + 1 ) )
+      initialize_order if !last_record.nil? and last_record_position.nil?
+    
+      self.send( "#{position_column}=", last_record.nil? ? 1 : last_record_position + 1)
     end
     
     def reset_order_after_update
-      if scope_condition != scope_condition_was
-        self.class.update_all("#{position_column} = (#{position_column} - 1) #{optimistic_locking_update}", [scope_condition_was, "#{position_column} > #{self.send( "#{position_column}_was" )}", "id != #{id}"].compact.join(' AND '))
-        self.class.update_all("#{position_column} = (#{position_column} + 1) #{optimistic_locking_update}", [scope_condition, "#{position_column} >= #{self.send( position_column )}", "id != #{id}"].compact.join(' AND '))
-      elsif self.send( "#{position_column}_changed?" )
-        if self.send( "#{position_column}_was" ) > self.send( position_column )
-          self.class.update_all("#{position_column} = (#{position_column} + 1) #{optimistic_locking_update}", [scope_condition, "#{position_column} >= #{self.send( position_column )}", "id != #{id}", "#{position_column} < #{self.send( "#{position_column}_was" )}"].compact.join(' AND '))
-        else
-          self.class.update_all("#{position_column} = (#{position_column} - 1) #{optimistic_locking_update}", [scope_condition, "#{position_column} <= #{self.send( position_column )}", "#{position_column} >= #{self.send( "#{position_column}_was" )}", "id != #{id}"].compact.join(' AND '))
+      if previous_position.nil?
+        initialize_order
+      else        
+        if scope_condition != scope_condition_was
+          self.class.update_all( decrement_position_sql, [scope_condition_was, "#{position_column} > #{previous_position}", "id != #{id}"].compact.join(' AND '))
+          self.class.update_all( increment_position_sql, [scope_condition, "#{position_column} >= #{current_position}", "id != #{id}"].compact.join(' AND '))
+        elsif self.send( "#{position_column}_changed?" )
+          if previous_position > current_position
+            self.class.update_all( increment_position_sql, [scope_condition, "#{position_column} >= #{current_position}", "id != #{id}", "#{position_column} < #{previous_position}"].compact.join(' AND '))
+          else
+            self.class.update_all( decrement_position_sql, [scope_condition, "#{position_column} <= #{current_position}", "#{position_column} >= #{previous_position}", "id != #{id}"].compact.join(' AND '))
+          end
         end
       end
     end
@@ -77,6 +82,42 @@ module ActsAsRestfulList
     def reset_order_after_destroy
       self.class.update_all("#{position_column} = (#{position_column} - 1) #{optimistic_locking_update}", [scope_condition, "#{position_column} > #{self.send( position_column )}"].compact.join(' AND '))
     end
+    
+    def initialize_order
+      initial_set = self.class.find(:all,:conditions=>scope_condition,:select=>"id",:order=>"created_at ASC")
+      
+      initial_set.each_with_index do |item,idx|
+        ActiveRecord::Base.connection.execute("update #{self.class.table_name} set position = #{idx + 1} where id = #{item.id};")
+      end
+    end
+    
+    def last_record
+      self.class.last( :conditions => scope_condition, :order => "#{position_column} ASC" )
+    end
+    
+    def last_record_position
+      last_record.send(position_column)
+    end
+    
+    def current_position
+      self.send( position_column )
+    end
+    
+    def current_position=(value)
+      self.send( "#{position_column}=", value )
+    end
+    
+    def previous_position
+      self.send( "#{position_column}_was" )
+    end
+    
+    def increment_position_sql
+      "#{position_column} = (#{position_column} + 1) #{optimistic_locking_update}"
+    end
+    
+    def decrement_position_sql
+      "#{position_column} = (#{position_column} - 1) #{optimistic_locking_update}"
+    end
   end
 end
 

metadata

@@ -1,39 +1,51 @@
 --- !ruby/object:Gem::Specification 
 name: acts_as_restful_list
 version: !ruby/object:Gem::Version 
-  hash: 11
-  prerelease: false
-  segments: 
-  - 0
-  - 5
-  - 0
-  version: 0.5.0
+  prerelease: 
+  version: "0.6"
 platform: ruby
 authors: 
-- "'Trey Bean'"
+- Trey Bean
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-02-08 00:00:00 -07:00
+date: 2011-07-18 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 1
-        - 2
-        - 9
-        version: 1.2.9
+        version: "0"
   type: :development
+  prerelease: false
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
 description: Just like acts_as_list, but allows updating through standard restful methods.
 email: trey@12spokes.com
 executables: []
@@ -44,19 +56,13 @@ extra_rdoc_files:
 - LICENSE
 - README.rdoc
 files: 
-- .document
+- lib/acts_as_restful_list.rb
 - .gitignore
 - History.rdoc
 - LICENSE
 - README.rdoc
-- Rakefile
 - Todo.rdoc
 - VERSION
-- acts_as_restful_list.gemspec
-- lib/acts_as_restful_list.rb
-- spec/acts_as_restful_list_spec.rb
-- spec/spec.opts
-- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/12spokes/acts_as_restful_list
 licenses: []
@@ -71,7 +77,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: -2292716820751671520
       segments: 
       - 0
       version: "0"
@@ -80,17 +86,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Restful acts_as_list
-test_files: 
-- spec/acts_as_restful_list_spec.rb
-- spec/spec_helper.rb
+test_files: []
+

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/Rakefile

@@ -1,45 +0,0 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "acts_as_restful_list"
-    gem.summary = %Q{Restful acts_as_list}
-    gem.description = %Q{Just like acts_as_list, but allows updating through standard restful methods.}
-    gem.email = "trey@12spokes.com"
-    gem.homepage = "http://github.com/12spokes/acts_as_restful_list"
-    gem.authors = ["'Trey Bean'"]
-    gem.add_development_dependency "rspec", ">= 1.2.9"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
-
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-task :spec => :check_dependencies
-
-task :default => :spec
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "acts_as_restful_list #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/acts_as_restful_list.gemspec

@@ -1,57 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{acts_as_restful_list}
-  s.version = "0.5.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["'Trey Bean'"]
-  s.date = %q{2011-02-08}
-  s.description = %q{Just like acts_as_list, but allows updating through standard restful methods.}
-  s.email = %q{trey@12spokes.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-     ".gitignore",
-     "History.rdoc",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "Todo.rdoc",
-     "VERSION",
-     "acts_as_restful_list.gemspec",
-     "lib/acts_as_restful_list.rb",
-     "spec/acts_as_restful_list_spec.rb",
-     "spec/spec.opts",
-     "spec/spec_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/12spokes/acts_as_restful_list}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Restful acts_as_list}
-  s.test_files = [
-    "spec/acts_as_restful_list_spec.rb",
-     "spec/spec_helper.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
-    else
-      s.add_dependency(%q<rspec>, [">= 1.2.9"])
-    end
-  else
-    s.add_dependency(%q<rspec>, [">= 1.2.9"])
-  end
-end
-

data/spec/acts_as_restful_list_spec.rb

@@ -1,524 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "ActsAsRestfulList" do
-  after(:each) do
-    ActiveRecord::Base.connection.execute("DELETE FROM mixins")
-    ActiveRecord::Base.connection.execute("DELETE FROM sqlite_sequence where name='mixins'")
-  end
-  
-  describe 'standard declaration with no options' do
-    before(:all) do
-      ActiveRecord::Schema.define(:version => 1) do
-        create_table :mixins do |t|
-          t.column :position, :integer
-          t.column :parent_id, :integer
-          t.column :created_at, :datetime
-          t.column :updated_at, :datetime
-        end
-      end
-      
-      class Mixin < ActiveRecord::Base
-        acts_as_restful_list
-      end
-    end
-    
-    after(:all) do
-      Object.send(:remove_const, :Mixin)
-
-      ActiveRecord::Base.connection.tables.each do |table|
-        ActiveRecord::Base.connection.drop_table(table)
-      end
-    end
-    
-    it "should return position as it's position column" do
-      Mixin.new.position_column.should == 'position'
-    end
-    
-    it 'should set the position before creating the record' do
-      mixin = Mixin.new
-      mixin.should_receive(:set_position).and_return(true)
-      mixin.save!
-    end
-    
-    it 'should save the first record with position 1' do
-      Mixin.create!.position.should == 1
-    end
-    
-    it 'should put each new record at the end of the list' do
-      (1..4).each do |n|
-        Mixin.create!.position.should == n
-      end
-    end
-    
-    describe 'reordering on update' do
-      before(:each) do
-        (1..4).each{ Mixin.create! }
-      end
-      
-      it 'should reset order after updating a record' do
-        mixin = Mixin.create
-        mixin.should_receive(:reset_order_after_update).and_return(true)
-        mixin.save!
-      end
-      
-      it 'should automatically reorder the list if a record is updated with a lower position' do
-        fourth_mixin = Mixin.first( :conditions => { :position => 4 } )
-        fourth_mixin.position = 2
-        fourth_mixin.save!
-        fourth_mixin.reload.position.should == 2
-        Mixin.all(:order => 'position ASC').collect(&:position).should == [1,2,3,4]
-      end
-      
-      it 'should reorder the list correctly if a record in the middle is updated with a lower position' do
-        third_mixin = Mixin.first( :conditions => { :position => 3 } )
-        third_mixin.position = 2
-        third_mixin.save!
-        third_mixin.reload.position.should == 2
-        Mixin.all(:order => 'position ASC').collect(&:position).should == [1,2,3,4]
-      end
-      
-      it 'should automatically reorder the list if a record is updated with a higher position' do
-        second_mixin = Mixin.first( :conditions => { :position => 2 } )
-        second_mixin.position = 4
-        second_mixin.save!
-        second_mixin.reload.position.should == 4
-        Mixin.all(:order => 'position ASC').collect(&:position).should == [1,2,3,4]
-      end
-    end
-    
-    describe 'reordering on deletion' do
-      it 'should reset the order after deleting a record' do
-        mixin = Mixin.create
-        mixin.should_receive(:reset_order_after_destroy).and_return(true)
-        mixin.destroy
-      end
-      
-      it 'should automatically reorder the list if the record is deleted' do
-        (1..4).each{ Mixin.create! }
-        second_mixin = Mixin.first( :conditions => { :position => 2 } )
-        second_mixin.destroy
-        Mixin.all(:order => 'position ASC').collect(&:position).should == [1,2,3]
-      end
-    end
-    
-    it 'should return nil for scope_condition since it was not set' do
-      Mixin.new.scope_condition.should be_nil
-    end
-  end
-  
-  describe 'optimistic locking' do
-    before(:all) do
-      ActiveRecord::Schema.define(:version => 1) do
-        create_table :mixins do |t|
-          t.column :position, :integer
-          t.column :parent_id, :integer
-          t.column :lock_version, :integer, :default => 0
-          t.column :created_at, :datetime
-          t.column :updated_at, :datetime
-        end
-      end
-      
-      class Mixin < ActiveRecord::Base
-        acts_as_restful_list
-      end
-    end
-    
-    after(:all) do
-      Object.send(:remove_const, :Mixin)
-
-      ActiveRecord::Base.connection.tables.each do |table|
-        ActiveRecord::Base.connection.drop_table(table)
-      end
-    end
-    
-    before(:each) do
-      (1..4).each{ Mixin.create! }
-    end
-    
-    describe 'reordering on destroy' do
-      it 'should raise an error for stale objects' do
-        second_mixin = Mixin.first( :conditions => { :position => 2 } )
-        third_mixin  = Mixin.first( :conditions => { :position => 3 } )
-        second_mixin.destroy
-        lambda {
-          third_mixin.destroy
-        }.should raise_error(ActiveRecord::StaleObjectError)
-      end
-      
-      it 'should NOT raise an error if update did not affect existing position' do
-        second_mixin = Mixin.first( :conditions => { :position => 2 } )
-        third_mixin  = Mixin.first( :conditions => { :position => 3 } )
-        third_mixin.destroy
-        lambda {
-          second_mixin.destroy
-        }.should_not raise_error(ActiveRecord::StaleObjectError)
-        Mixin.all(:order => 'position ASC').collect(&:position).should == [1,2]
-      end
-    end
-    
-    describe 'reordering on update' do
-      it 'should raise an error for stale objects' do
-        first_mixin  = Mixin.first( :conditions => { :position => 1 } )
-        fourth_mixin = Mixin.first( :conditions => { :position => 4 } )
-        fourth_mixin.update_attributes(:position => 1)
-        lambda {
-          first_mixin.update_attributes(:position => 2)
-        }.should raise_error(ActiveRecord::StaleObjectError)
-      end
-      
-      it 'should NOT raise an error if update did not affect existing position' do
-        first_mixin  = Mixin.first( :conditions => { :position => 1 } )
-        fourth_mixin = Mixin.first( :conditions => { :position => 4 } )
-        fourth_mixin.update_attributes(:position => 2)
-        lambda {
-          first_mixin.update_attributes(:position => 3)
-        }.should_not raise_error(ActiveRecord::StaleObjectError)
-        Mixin.all(:order => 'position ASC').collect(&:position).should == [1,2,3,4]
-      end
-    end
-    
-  end
-  
-  describe 'declaring acts_as_restful_list and setting the column' do
-    before(:all) do
-      ActiveRecord::Schema.define(:version => 1) do
-        create_table :mixins do |t|
-          t.column :pos, :integer
-          t.column :parent_id, :integer
-          t.column :created_at, :datetime
-          t.column :updated_at, :datetime
-        end
-      end
-      
-      class Mixin < ActiveRecord::Base
-        acts_as_restful_list :column => :pos
-      end
-    end
-    
-    after(:all) do
-      Object.send(:remove_const, :Mixin)
-
-      ActiveRecord::Base.connection.tables.each do |table|
-        ActiveRecord::Base.connection.drop_table(table)
-      end
-    end
-    
-    it "should return pos as it's position column" do
-      Mixin.new.position_column.should == 'pos'
-    end
-    
-    it 'should set the position before creating the record' do
-      mixin = Mixin.new
-      mixin.should_receive(:set_position).and_return(true)
-      mixin.save!
-    end
-    
-    it 'should save the first record with position 1' do
-      Mixin.create!.pos.should == 1
-    end
-    
-    it 'should put each new record at the end of the list' do
-      (1..4).each do |n|
-        Mixin.create!.pos.should == n
-      end
-    end
-    
-    describe 'reordering on update' do
-      before(:each) do
-        (1..4).each{ Mixin.create! }
-      end
-      
-      it 'should reset order after updating a record' do
-        mixin = Mixin.create
-        mixin.should_receive(:reset_order_after_update).and_return(true)
-        mixin.save!
-      end
-      
-      it 'should automatically reorder the list if a record is updated with a lower position' do
-        fourth_mixin = Mixin.first( :conditions => { :pos => 4 } )
-        fourth_mixin.pos = 2
-        fourth_mixin.save!
-        fourth_mixin.reload.pos.should == 2
-        Mixin.all(:order => 'pos ASC').collect(&:pos).should == [1,2,3,4]
-      end
-      
-      it 'should automatically reorder the list if a record is updated with a higher position' do
-        second_mixin = Mixin.first( :conditions => { :pos => 2 } )
-        second_mixin.pos = 4
-        second_mixin.save!
-        second_mixin.reload.pos.should == 4
-        Mixin.all(:order => 'pos ASC').collect(&:pos).should == [1,2,3,4]
-      end
-    end
-    
-    describe 'reordering on deletion' do
-      it 'should reset the order after deleting a record' do
-        mixin = Mixin.create
-        mixin.should_receive(:reset_order_after_destroy).and_return(true)
-        mixin.destroy
-      end
-      
-      it 'should automatically reorder the list if the record is deleted' do
-        (1..4).each{ Mixin.create! }
-        second_mixin = Mixin.first( :conditions => { :pos => 2 } )
-        second_mixin.destroy
-        Mixin.all(:order => 'pos ASC').collect(&:pos).should == [1,2,3]
-      end
-    end
-  end
-  
-  describe 'declaring acts_as_restful_list and setting the scope' do
-    before(:all) do
-      ActiveRecord::Schema.define(:version => 1) do
-        create_table :mixins do |t|
-          t.column :position, :integer
-          t.column :parent_id, :integer
-          t.column :created_at, :datetime
-          t.column :updated_at, :datetime
-        end
-      end
-      
-      class Mixin < ActiveRecord::Base
-        acts_as_restful_list :scope => :parent_id
-      end
-    end
-    
-    after(:all) do
-      Object.send(:remove_const, :Mixin)
-
-      ActiveRecord::Base.connection.tables.each do |table|
-        ActiveRecord::Base.connection.drop_table(table)
-      end
-    end
-    
-    it 'should define scope_condition as an instance method' do
-      Mixin.new.should respond_to(:scope_condition)
-    end
-    
-    it 'should return a scope condition that limits based on the parent_id' do
-      Mixin.new(:parent_id => 3).scope_condition.should == "parent_id = 3"
-    end
-    
-    it 'should return a scope limiting based parent_id being NULL if parent_id is nil' do
-      Mixin.new.scope_condition.should == "parent_id IS NULL"
-    end
-    
-    it 'should set the position based on the scope list when adding a new item' do
-      Mixin.create!.position.should == 1
-      Mixin.create!(:parent_id => 1).position.should == 1
-      Mixin.create!(:parent_id => 1).position.should == 2
-      Mixin.create!(:parent_id => 2).position.should == 1
-    end
-    
-    describe 'reordering on update' do
-      before(:each) do
-        (1..4).each{ Mixin.create!(:parent_id => 1) }
-        (1..6).each{ Mixin.create!(:parent_id => 2) }
-      end
-      
-      it 'should automatically reorder the list if a record is updated with a lower position' do
-        fourth_mixin = Mixin.first( :conditions => { :position => 4, :parent_id => 1 } )
-        fourth_mixin.position = 2
-        fourth_mixin.save!
-        fourth_mixin.reload.position.should == 2
-        Mixin.all(:conditions => { :parent_id => 1 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-        Mixin.all(:conditions => { :parent_id => 2 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4,5,6]
-      end
-      
-      it 'should automatically reorder the list if a record is updated with a higher position' do
-        second_mixin = Mixin.first( :conditions => { :position => 2, :parent_id => 1  } )
-        second_mixin.position = 4
-        second_mixin.save!
-        second_mixin.reload.position.should == 4
-        Mixin.all(:conditions => { :parent_id => 1 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-        Mixin.all(:conditions => { :parent_id => 2 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4,5,6]
-      end
-      
-      it 'should report the old and new scope correctly' do
-        second_mixin = Mixin.first( :conditions => { :position => 2, :parent_id => 1  } )
-        second_mixin.parent_id = 2
-        second_mixin.position = 4
-        second_mixin.scope_condition_was.should == 'parent_id = 1'
-        second_mixin.scope_condition.should == 'parent_id = 2'
-      end
-      
-      it 'should automatically reorder both lists if a record is moved between them' do
-        second_mixin = Mixin.first( :conditions => { :position => 2, :parent_id => 1  } )
-        second_mixin.parent_id = 2
-        second_mixin.position = 4
-        second_mixin.save!
-        second_mixin.reload.parent_id.should == 2
-        second_mixin.reload.position.should == 4
-        Mixin.all(:conditions => { :parent_id => 1 }, :order => 'position ASC').collect(&:position).should == [1,2,3]
-        Mixin.all(:conditions => { :parent_id => 2 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4,5,6,7]
-      end
-    end
-    
-    it 'should automatically reorder the list scoped by parent if the record is deleted' do
-      (1..4).each{ Mixin.create!(:parent_id => 1) }
-      (1..6).each{ Mixin.create!(:parent_id => 2) }
-      second_mixin = Mixin.first( :conditions => { :position => 2, :parent_id => 1 } )
-      second_mixin.destroy
-      Mixin.all(:conditions => { :parent_id => 1 }, :order => 'position ASC').collect(&:position).should == [1,2,3]
-      Mixin.all(:conditions => { :parent_id => 2 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4,5,6]
-    end
-  end
-  
-  describe 'declaring acts_as_restful_list and setting the scope without the _id' do
-    before(:all) do
-      ActiveRecord::Schema.define(:version => 1) do
-        create_table :mixins do |t|
-          t.column :position, :integer
-          t.column :parent_id, :integer
-          t.column :created_at, :datetime
-          t.column :updated_at, :datetime
-        end
-      end
-      
-      class Mixin < ActiveRecord::Base
-        acts_as_restful_list :scope => :parent
-      end
-    end
-    
-    after(:all) do
-      Object.send(:remove_const, :Mixin)
-
-      ActiveRecord::Base.connection.tables.each do |table|
-        ActiveRecord::Base.connection.drop_table(table)
-      end
-    end
-    
-    it 'should define scope_condition as an instance method' do
-      Mixin.new.should respond_to(:scope_condition)
-    end
-    
-    it 'should return a scope condition that limits based on the parent_id' do
-      Mixin.new(:parent_id => 3).scope_condition.should == "parent_id = 3"
-    end
-  end
-  
-  
-  describe 'declaring acts_as_restful_list and setting the scope on a column that is not an _id column' do
-    before(:all) do
-      ActiveRecord::Schema.define(:version => 1) do
-        create_table :mixins do |t|
-          t.column :position, :integer
-          t.column :parent_name, :string
-          t.column :created_at, :datetime
-          t.column :updated_at, :datetime
-        end
-      end
-      
-      class Mixin < ActiveRecord::Base
-        acts_as_restful_list :scope => :parent_name
-      end
-    end
-    
-    after(:all) do
-      Object.send(:remove_const, :Mixin)
-      
-      ActiveRecord::Base.connection.tables.each do |table|
-        ActiveRecord::Base.connection.drop_table(table)
-      end
-    end
-    
-    it 'should define scope_condition as an instance method' do
-      Mixin.new.should respond_to(:scope_condition)
-    end
-    
-    it 'should return a scope condition that limits based on the parent_id' do
-      Mixin.new(:parent_name => 'Brandy').scope_condition.should == "parent_name = 'Brandy'"
-    end
-  end
-  
-  
-  describe 'declaring acts_as_restful_list and setting the scope to multiple columns' do
-    before(:all) do
-      ActiveRecord::Schema.define(:version => 1) do
-        create_table :mixins do |t|
-          t.column :position, :integer
-          t.column :user_id, :integer
-          t.column :parent_id, :integer
-          t.column :created_at, :datetime
-          t.column :updated_at, :datetime
-        end
-      end
-      
-      class Mixin < ActiveRecord::Base
-        acts_as_restful_list :scope => [:parent, :user]
-      end
-    end
-    
-    after(:all) do
-      Object.send(:remove_const, :Mixin)
-      
-      ActiveRecord::Base.connection.tables.each do |table|
-        ActiveRecord::Base.connection.drop_table(table)
-      end
-    end
-    
-    it 'should define scope_condition as an instance method' do
-      Mixin.new.should respond_to(:scope_condition)
-    end
-    
-    it 'should return a scope condition that limits based on the parent_id' do
-      Mixin.new(:user_id => 4, :parent_id => 3).scope_condition.should == "parent_id = 3 AND user_id = 4"
-    end
-    
-    describe 'reordering on update' do
-      before(:each) do
-        (1..4).each{ Mixin.create!(:parent_id => 1, :user_id => 5) }
-        (1..4).each{ Mixin.create!(:parent_id => 2, :user_id => 5) }
-        (1..4).each{ Mixin.create!(:parent_id => 1, :user_id => 7) }
-        (1..4).each{ Mixin.create!(:parent_id => 2, :user_id => 7) }
-      end
-      
-      it 'should automatically reorder the list if a record is updated with a lower position' do
-        user5_parent1_fourth_mixin = Mixin.first( :conditions => { :position => 4, :parent_id => 1, :user_id => 5 } )
-        user5_parent1_fourth_mixin.position = 2
-        user5_parent1_fourth_mixin.save!
-        user5_parent1_fourth_mixin.reload.position.should == 2
-        Mixin.all(:conditions => { :parent_id => 1, :user_id => 5 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-        Mixin.all(:conditions => { :parent_id => 1, :user_id => 5 }, :order => 'position ASC').collect(&:id).should == [1,4,2,3]
-        Mixin.all(:conditions => { :parent_id => 2, :user_id => 5 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-        Mixin.all(:conditions => { :parent_id => 2, :user_id => 5 }, :order => 'position ASC').collect(&:id).should == [5,6,7,8]
-        Mixin.all(:conditions => { :parent_id => 1, :user_id => 7 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-        Mixin.all(:conditions => { :parent_id => 1, :user_id => 7 }, :order => 'position ASC').collect(&:id).should == [9,10,11,12]
-        Mixin.all(:conditions => { :parent_id => 2, :user_id => 7 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-        Mixin.all(:conditions => { :parent_id => 2, :user_id => 7 }, :order => 'position ASC').collect(&:id).should == [13,14,15,16]
-      end
-      
-      it 'should automatically reorder the list if a record is updated with a higher position' do
-        second_mixin = Mixin.first( :conditions => { :position => 2, :parent_id => 1, :user_id => 5  } )
-        second_mixin.position = 4
-        second_mixin.save!
-        second_mixin.reload.position.should == 4
-        Mixin.all(:conditions => { :parent_id => 1, :user_id => 5 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-        Mixin.all(:conditions => { :parent_id => 1, :user_id => 5 }, :order => 'position ASC').collect(&:id).should == [1,3,4,2]
-        Mixin.all(:conditions => { :parent_id => 2, :user_id => 5 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-        Mixin.all(:conditions => { :parent_id => 2, :user_id => 5 }, :order => 'position ASC').collect(&:id).should == [5,6,7,8]
-        Mixin.all(:conditions => { :parent_id => 1, :user_id => 7 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-        Mixin.all(:conditions => { :parent_id => 1, :user_id => 7 }, :order => 'position ASC').collect(&:id).should == [9,10,11,12]
-        Mixin.all(:conditions => { :parent_id => 2, :user_id => 7 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-        Mixin.all(:conditions => { :parent_id => 2, :user_id => 7 }, :order => 'position ASC').collect(&:id).should == [13,14,15,16]
-      end
-    end
-    
-    it 'should automatically reorder if the record is deleted' do
-      (1..4).each{ Mixin.create!(:parent_id => 1, :user_id => 5) }
-      (1..4).each{ Mixin.create!(:parent_id => 2, :user_id => 5) }
-      (1..4).each{ Mixin.create!(:parent_id => 1, :user_id => 7) }
-      (1..4).each{ Mixin.create!(:parent_id => 2, :user_id => 7) }
-      second_mixin = Mixin.first( :conditions => { :position => 2, :parent_id => 1, :user_id => 5 } )
-      second_mixin.destroy
-      Mixin.all(:conditions => { :parent_id => 1, :user_id => 5 }, :order => 'position ASC').collect(&:position).should == [1,2,3]
-      Mixin.all(:conditions => { :parent_id => 1, :user_id => 5 }, :order => 'position ASC').collect(&:id).should == [1,3,4]
-      Mixin.all(:conditions => { :parent_id => 2, :user_id => 5 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-      Mixin.all(:conditions => { :parent_id => 2, :user_id => 5 }, :order => 'position ASC').collect(&:id).should == [5,6,7,8]
-      Mixin.all(:conditions => { :parent_id => 1, :user_id => 7 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-      Mixin.all(:conditions => { :parent_id => 1, :user_id => 7 }, :order => 'position ASC').collect(&:id).should == [9,10,11,12]
-      Mixin.all(:conditions => { :parent_id => 2, :user_id => 7 }, :order => 'position ASC').collect(&:position).should == [1,2,3,4]
-      Mixin.all(:conditions => { :parent_id => 2, :user_id => 7 }, :order => 'position ASC').collect(&:id).should == [13,14,15,16]
-    end
-  end
-end

data/spec/spec.opts

@@ -1 +0,0 @@
---color

data/spec/spec_helper.rb

@@ -1,14 +0,0 @@
-require 'rubygems'
-gem 'activerecord', '>= 3'
-require 'active_record'
-
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'acts_as_restful_list'
-require 'rspec'
-require 'rspec/autorun'
-
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
-
-RSpec.configure do |config|
-end