sortifiable 0.1.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+*0.1.0 (February 6th, 2011)
+
+* First release

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Andrew White
+
+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,27 @@
+== Sortifiable
+
+This gem provides an acts_as_list compatible capability for sorting
+and reordering a number of objects in a list. The class that has this
+specified needs to have a +position+ column defined as an integer on
+the mapped database table.
+
+This gem requires ActiveRecord 3.0 as it has been refactored to use
+the scope methods and query interface introduced with Ruby on Rails 3.0
+
+
+=== Example
+
+  class TodoList < ActiveRecord::Base
+    has_many :todo_items, :order => "position"
+  end
+
+  class TodoItem < ActiveRecord::Base
+    belongs_to :todo_list
+    acts_as_list :scope => :todo_list
+  end
+
+  todo_list.first.move_to_bottom
+  todo_list.last.move_higher
+
+
+Copyright (c) 2011 Andrew White, released under the MIT license

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+desc 'Default: run sortifiable unit tests.'
+task :default => :test
+
+desc 'Test the sortifiable gem.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the sortifiable gem.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Sortifiable'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/sortifiable/version.rb

@@ -0,0 +1,3 @@
+module Sortifiable
+  VERSION = "0.1.0"
+end

data/lib/sortifiable.rb

@@ -0,0 +1,267 @@
+require 'active_support/concern'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_record'
+require 'sortifiable/version'
+
+# This +acts_as+ extension provides the capabilities for sorting and
+# reordering a number of objects in a list. The class that has this
+# specified needs to have a +position+ column defined as an integer on
+# the mapped database table.
+#
+# Todo list example:
+#
+#   class TodoList < ActiveRecord::Base
+#     has_many :todo_items, :order => "position"
+#   end
+#
+#   class TodoItem < ActiveRecord::Base
+#     belongs_to :todo_list
+#     acts_as_list :scope => :todo_list
+#   end
+#
+#   todo_list.first.move_to_bottom
+#   todo_list.last.move_higher
+module Sortifiable
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :acts_as_list_options, :instance_writer => false
+    self.acts_as_list_options = {}
+
+    before_create :add_to_list_bottom
+    before_destroy :decrement_position_on_lower_items, :if => :in_list?
+  end
+
+  module ClassMethods
+    # Configuration options are:
+    #
+    # * +column+ - specifies the column name to use for keeping the
+    #   position integer (default: +position+)
+    # * +scope+ - restricts what is to be considered a list. Given a symbol,
+    #   it'll attach <tt>_id</tt> (if it hasn't already been added) and use
+    #   that as the foreign key restriction. It's also possible to give it
+    #   an entire string that is interpolated if you need a tighter scope
+    #   than just a foreign key. Example:
+    #
+    #     acts_as_list :scope => 'user_id = #{user_id} AND completed = 0'
+    #
+    #   It can also be given an array of symbols or a belongs_to association.
+    def acts_as_list(options = {})
+      options.reverse_merge!(:scope => [], :column => :position)
+
+      if options[:scope].is_a?(Symbol) && reflections.key?(options[:scope])
+        reflection = reflections[options.delete(:scope)]
+
+        if reflection.belongs_to?
+          if reflection.options[:polymorphic]
+            options[:scope] = [
+              reflection.association_foreign_key.to_sym,
+              reflection.options[:foreign_type].to_sym
+            ]
+          else
+            reflection.association_foreign_key.to_sym
+          end
+        else
+          raise ArgumentError, "Only belongs_to associations can be used as a scope"
+        end
+      elsif options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/
+        options[:scope] = "#{options[:scope]}_id".to_sym
+      end
+
+      self.acts_as_list_options = options
+    end
+  end
+
+  # All the methods available to a record that has had <tt>acts_as_list</tt>
+  # specified. Each method works by assuming the object to be the item in the
+  # list, so <tt>chapter.move_lower</tt> would move that chapter lower in the
+  # list of all chapters. Likewise, <tt>chapter.first?</tt> would return +true+
+  # if that chapter is the first in the list of all chapters.
+
+  # Add the item to the end of the list
+  def add_to_list
+    remove_from_list if in_list?
+    update_attribute(position_column, last_position + 1)
+  end
+
+  # Returns the current position
+  def current_position
+    send(position_column).to_i
+  end
+
+  # Decrease the position of this item without adjusting the rest of the list.
+  def decrement_position
+    in_list? && update_attribute(position_column, current_position - 1)
+  end
+
+  # Return +true+ if this object is the first in the list.
+  def first?
+    in_list? && current_position == 1
+  end
+  alias_method :top?, :first?
+
+  # Returns the first item in the list
+  def first_item
+    list_scope.first
+  end
+  alias_method :top_item, :first_item
+
+  # Return the next higher item in the list.
+  def higher_item
+    item_at_offset(-1)
+  end
+  alias_method :previous_item, :higher_item
+
+  # Return items lower than this item or an empty array if it is the last item
+  def higher_items
+    list_scope.where(["#{quoted_position_column} < ?", current_position]).all
+  end
+
+  # Test if this record is in a list
+  def in_list?
+    !new_record? && !send(position_column).nil?
+  end
+
+  # Increase the position of this item without adjusting the rest of the list.
+  def increment_position
+    in_list? && update_attribute(position_column, current_position + 1)
+  end
+
+  # Insert the item at the given position (defaults to the top position of 1).
+  def insert_at(position = 1)
+    if position > 0
+      remove_from_list
+      if position > last_position
+        add_to_list
+      else
+        increment_position_on_lower_items(position - 1)
+        update_attribute(position_column, position)
+      end
+    else
+      false
+    end
+  end
+
+  # Return the item at the offset specified from the current position
+  def item_at_offset(offset)
+    in_list? ? offset_scope(offset).first : nil
+  end
+
+  # Return +true+ if this object is the last in the list.
+  def last?
+    in_list? && current_position == last_position
+  end
+  alias_method :bottom?, :last?
+
+  # Returns the bottom item
+  def last_item
+    list_scope.last
+  end
+  alias_method :bottom_item, :last_item
+
+  # Returns the bottom position in the list.
+  def last_position
+    item = last_item
+    item ? item.current_position : 0
+  end
+  alias_method :bottom_position, :last_position
+
+  # Return the next lower item in the list.
+  def lower_item
+    item_at_offset(1)
+  end
+  alias_method :next_item, :lower_item
+
+  # Return items lower than this item or an empty array if it is the last item
+  def lower_items
+    list_scope.where(["#{quoted_position_column} > ?", current_position]).all
+  end
+
+  # Swap positions with the next higher item, if one exists.
+  def move_higher
+    in_list? && (first? || insert_at(current_position - 1))
+  end
+  alias_method :move_up, :move_higher
+
+  # Swap positions with the next lower item, if one exists.
+  def move_lower
+    in_list? && (last? || insert_at(current_position + 1))
+  end
+  alias_method :move_down, :move_lower
+
+  # Move to the bottom of the list. If the item is already in the list,
+  # the items below it have their position adjusted accordingly.
+  def move_to_bottom
+    in_list? && (last? || add_to_list)
+  end
+
+  # Move to the top of the list. If the item is already in the list,
+  # the items above it have their position adjusted accordingly.
+  def move_to_top
+    in_list? && (first? || insert_at(1))
+  end
+
+  # Removes the item from the list.
+  def remove_from_list
+    if in_list?
+      decrement_position_on_lower_items
+      update_attribute(position_column, nil)
+    else
+      false
+    end
+  end
+
+  private
+    def add_to_list_bottom #:nodoc:
+      send("#{position_column}=".to_sym, last_position + 1)
+    end
+
+    def base_scope #:nodoc:
+      self.class.unscoped.where(scope_condition)
+    end
+
+    def decrement_position_on_lower_items #:nodoc:
+      lower_scope(current_position).update_all(position_update('- 1'))
+    end
+
+    def increment_position_on_lower_items(position) #:nodoc:
+      lower_scope(position).update_all(position_update('+ 1'))
+    end
+
+    def list_scope #:nodoc:
+      base_scope.order(position_column).where("#{quoted_position_column} IS NOT NULL")
+    end
+
+    def lower_scope(position) #:nodoc:
+      base_scope.where(["#{quoted_position_column} > ?", position])
+    end
+
+    def offset_scope(offset) #:nodoc:
+      base_scope.where(position_column => current_position + offset)
+    end
+
+    def position_column #:nodoc:
+      acts_as_list_options[:column]
+    end
+
+    def position_update(direction) #:nodoc:
+      "#{quoted_position_column} = (#{quoted_position_column} #{direction})"
+    end
+
+    def quoted_position_column #:nodoc:
+      connection.quote_column_name(position_column)
+    end
+
+    def scope_condition #:nodoc:
+      if acts_as_list_options[:scope].is_a?(String)
+        instance_eval("\"#{acts_as_list_options[:scope]}\"")
+      else
+        Array.wrap(acts_as_list_options[:scope]).inject({}){ |m,k| m[k] = send(k); m }
+      end
+    end
+
+end
+
+ActiveRecord::Base.send(:include, Sortifiable)

data/sortifiable.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sortifiable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sortifiable"
+  s.version     = Sortifiable::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Andrew White"]
+  s.email       = ["andyw@pixeltrix.co.uk"]
+  s.homepage    = %q{http://github.com/pixeltrix/sortifiable/}
+  s.summary     = %q{Sort your models}
+  s.description = <<-EOF
+This gem provides an acts_as_list compatible capability for sorting
+and reordering a number of objects in a list. The class that has this
+specified needs to have a +position+ column defined as an integer on
+the mapped database table.
+
+This gem requires ActiveRecord 3.0 as it has been refactored to use
+the scope methods and query interface introduced with Ruby on Rails 3.0
+EOF
+
+  s.files = [
+    ".gemtest",
+    "CHANGELOG",
+    "LICENSE",
+    "README",
+    "Rakefile",
+    "lib/sortifiable.rb",
+    "lib/sortifiable/version.rb",
+    "sortifiable.gemspec",
+    "test/sortifiable_test.rb"
+  ]
+
+  s.test_files    = ["test/sortifiable_test.rb"]
+  s.require_paths = ["lib"]
+
+  s.add_dependency "activesupport", "~> 3.0.3"
+  s.add_dependency "activerecord", "~> 3.0.3"
+  s.add_development_dependency "bundler", "~> 1.0.10"
+  s.add_development_dependency "sqlite3", "~> 1.3.3"
+end

data/test/sortifiable_test.rb

@@ -0,0 +1,566 @@
+require 'test/unit'
+require 'rubygems'
+require 'active_record'
+require 'active_support/core_ext/kernel/reporting'
+require 'sortifiable'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+def setup_db
+  silence_stream(STDOUT) do
+    ActiveRecord::Schema.define(:version => 1) do
+      create_table :mixins do |t|
+        t.column :pos, :integer
+        t.column :parent_id, :integer
+        t.column :parent_type, :string
+        t.column :created_at, :datetime
+        t.column :updated_at, :datetime
+      end
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+setup_db
+
+class Mixin < ActiveRecord::Base
+end
+
+class ListMixin < Mixin
+  acts_as_list :column => "pos", :scope => :parent
+  set_table_name "mixins"
+  default_scope order(:pos)
+end
+
+class ListMixinSub1 < ListMixin
+end
+
+class ListMixinSub2 < ListMixin
+end
+
+class ListWithStringScopeMixin < ActiveRecord::Base
+  acts_as_list :column => "pos", :scope => 'parent_id = #{parent_id}'
+  set_table_name "mixins"
+  default_scope order(:pos)
+end
+
+class ArrayScopeListMixin < Mixin
+  acts_as_list :column => "pos", :scope => [:parent_id, :parent_type]
+  set_table_name "mixins"
+  default_scope order(:pos)
+end
+
+teardown_db
+
+class ListTest < Test::Unit::TestCase
+
+  def setup
+    setup_db
+    (1..4).each { |counter| ListMixin.create! :pos => counter, :parent_id => 5 }
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_reordering
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    ListMixin.find(2).move_lower
+    assert_equal [1, 3, 2, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    ListMixin.find(2).move_higher
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    ListMixin.find(1).move_to_bottom
+    assert_equal [2, 3, 4, 1], ListMixin.where('parent_id = 5').map(&:id)
+
+    ListMixin.find(1).move_to_top
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    ListMixin.find(2).move_to_bottom
+    assert_equal [1, 3, 4, 2], ListMixin.where('parent_id = 5').map(&:id)
+
+    ListMixin.find(4).move_to_top
+    assert_equal [4, 1, 3, 2], ListMixin.where('parent_id = 5').map(&:id)
+  end
+
+  def test_move_to_bottom_with_next_to_last_item
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+    ListMixin.find(3).move_to_bottom
+    assert_equal [1, 2, 4, 3], ListMixin.where('parent_id = 5').map(&:id)
+  end
+
+  def test_next_prev
+    assert_equal ListMixin.find(2), ListMixin.find(1).lower_item
+    assert_nil ListMixin.find(1).higher_item
+    assert_equal ListMixin.find(3), ListMixin.find(4).higher_item
+    assert_nil ListMixin.find(4).lower_item
+  end
+
+  def test_injection
+    item = ListMixin.new(:parent_id => 1)
+    assert_equal({ :parent_id => 1 }, item.send(:scope_condition))
+    assert_equal("pos", item.send(:position_column))
+  end
+
+  def test_insert
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 2, new.pos
+    assert !new.first?
+    assert new.last?
+
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 3, new.pos
+    assert !new.first?
+    assert new.last?
+
+    new = ListMixin.create(:parent_id => 0)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+  end
+
+  def test_insert_at
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 1, new.pos
+
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 2, new.pos
+
+    new = ListMixin.create(:parent_id => 20)
+    assert_equal 3, new.pos
+
+    new4 = ListMixin.create(:parent_id => 20)
+    assert_equal 4, new4.pos
+
+    new4.insert_at(3)
+    assert_equal 3, new4.pos
+
+    new.reload
+    assert_equal 4, new.pos
+
+    new.insert_at(2)
+    assert_equal 2, new.pos
+
+    new4.reload
+    assert_equal 4, new4.pos
+
+    new5 = ListMixin.create(:parent_id => 20)
+    assert_equal 5, new5.pos
+
+    new5.insert_at(1)
+    assert_equal 1, new5.pos
+
+    new4.reload
+    assert_equal 5, new4.pos
+  end
+
+  def test_delete_middle
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    ListMixin.find(2).destroy
+
+    assert_equal [1, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    assert_equal 1, ListMixin.find(1).pos
+    assert_equal 2, ListMixin.find(3).pos
+    assert_equal 3, ListMixin.find(4).pos
+
+    ListMixin.find(1).destroy
+
+    assert_equal [3, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    assert_equal 1, ListMixin.find(3).pos
+    assert_equal 2, ListMixin.find(4).pos
+  end
+
+  def test_with_string_based_scope
+    new = ListWithStringScopeMixin.create(:parent_id => 500)
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+  end
+
+  def test_nil_scope
+    new1, new2, new3 = ListMixin.create, ListMixin.create, ListMixin.create
+    new2.move_higher
+    assert_equal [new2, new1, new3], ListMixin.where('parent_id IS NULL')
+  end
+
+  def test_remove_from_list_should_then_fail_in_list?
+    assert_equal true, ListMixin.find(1).in_list?
+    ListMixin.find(1).remove_from_list
+    assert_equal false, ListMixin.find(1).in_list?
+  end
+
+  def test_remove_from_list_should_set_position_to_nil
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    ListMixin.find(2).remove_from_list
+
+    assert_equal [2, 1, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    assert_equal 1,   ListMixin.find(1).pos
+    assert_equal nil, ListMixin.find(2).pos
+    assert_equal 2,   ListMixin.find(3).pos
+    assert_equal 3,   ListMixin.find(4).pos
+  end
+
+  def test_remove_before_destroy_does_not_shift_lower_items_twice
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    ListMixin.find(2).remove_from_list
+    ListMixin.find(2).destroy
+
+    assert_equal [1, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    assert_equal 1, ListMixin.find(1).pos
+    assert_equal 2, ListMixin.find(3).pos
+    assert_equal 3, ListMixin.find(4).pos
+  end
+
+  def test_before_destroy_callbacks_do_not_update_position_to_nil_before_deleting_the_record
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    # We need to trigger all the before_destroy callbacks without actually
+    # destroying the record so we can see the affect the callbacks have on
+    # the record.
+    list = ListMixin.find(2)
+    if list.respond_to?(:run_callbacks)
+      list.run_callbacks(:destroy)
+    else
+      list.send(:callback, :before_destroy)
+    end
+
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5').map(&:id)
+
+    assert_equal 1, ListMixin.find(1).pos
+    assert_equal 2, ListMixin.find(2).pos
+    assert_equal 2, ListMixin.find(3).pos
+    assert_equal 3, ListMixin.find(4).pos
+  end
+
+  def test_higher_items
+    assert_equal [1, 2], ListMixin.find(3).higher_items.map(&:id)
+    assert_equal [], ListMixin.find(1).higher_items.map(&:id)
+  end
+
+  def test_lower_items
+    assert_equal [3, 4], ListMixin.find(2).lower_items.map(&:id)
+    assert_equal [], ListMixin.find(4).lower_items.map(&:id)
+  end
+
+end
+
+class ListSubTest < Test::Unit::TestCase
+
+  def setup
+    setup_db
+    (1..4).each { |i| ((i % 2 == 1) ? ListMixinSub1 : ListMixinSub2).create! :pos => i, :parent_id => 5000 }
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_reordering
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+
+    ListMixin.find(2).move_lower
+    assert_equal [1, 3, 2, 4], ListMixin.where('parent_id = 5000').map(&:id)
+
+    ListMixin.find(2).move_higher
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+
+    ListMixin.find(1).move_to_bottom
+    assert_equal [2, 3, 4, 1], ListMixin.where('parent_id = 5000').map(&:id)
+
+    ListMixin.find(1).move_to_top
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+
+    ListMixin.find(2).move_to_bottom
+    assert_equal [1, 3, 4, 2], ListMixin.where('parent_id = 5000').map(&:id)
+
+    ListMixin.find(4).move_to_top
+    assert_equal [4, 1, 3, 2], ListMixin.where('parent_id = 5000').map(&:id)
+  end
+
+  def test_move_to_bottom_with_next_to_last_item
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+    ListMixin.find(3).move_to_bottom
+    assert_equal [1, 2, 4, 3], ListMixin.where('parent_id = 5000').map(&:id)
+  end
+
+  def test_next_prev
+    assert_equal ListMixin.find(2), ListMixin.find(1).lower_item
+    assert_nil ListMixin.find(1).higher_item
+    assert_equal ListMixin.find(3), ListMixin.find(4).higher_item
+    assert_nil ListMixin.find(4).lower_item
+  end
+
+  def test_injection
+    item = ListMixin.new("parent_id"=>1)
+    assert_equal({ :parent_id => 1 }, item.send(:scope_condition))
+    assert_equal("pos", item.send(:position_column))
+  end
+
+  def test_insert_at
+    new = ListMixin.create("parent_id" => 20)
+    assert_equal 1, new.pos
+
+    new = ListMixinSub1.create("parent_id" => 20)
+    assert_equal 2, new.pos
+
+    new = ListMixinSub2.create("parent_id" => 20)
+    assert_equal 3, new.pos
+
+    new4 = ListMixin.create("parent_id" => 20)
+    assert_equal 4, new4.pos
+
+    new4.insert_at(3)
+    assert_equal 3, new4.pos
+
+    new.reload
+    assert_equal 4, new.pos
+
+    new.insert_at(2)
+    assert_equal 2, new.pos
+
+    new4.reload
+    assert_equal 4, new4.pos
+
+    new5 = ListMixinSub1.create("parent_id" => 20)
+    assert_equal 5, new5.pos
+
+    new5.insert_at(1)
+    assert_equal 1, new5.pos
+
+    new4.reload
+    assert_equal 5, new4.pos
+  end
+
+  def test_delete_middle
+    assert_equal [1, 2, 3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+
+    ListMixin.find(2).destroy
+
+    assert_equal [1, 3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+
+    assert_equal 1, ListMixin.find(1).pos
+    assert_equal 2, ListMixin.find(3).pos
+    assert_equal 3, ListMixin.find(4).pos
+
+    ListMixin.find(1).destroy
+
+    assert_equal [3, 4], ListMixin.where('parent_id = 5000').map(&:id)
+
+    assert_equal 1, ListMixin.find(3).pos
+    assert_equal 2, ListMixin.find(4).pos
+  end
+
+  def test_higher_items
+    ListMixin.find(2).remove_from_list
+    assert_equal [1], ListMixin.find(3).higher_items.map(&:id)
+    assert_equal [], ListMixin.find(1).higher_items.map(&:id)
+  end
+
+  def test_lower_items
+    ListMixin.find(3).remove_from_list
+    assert_equal [4], ListMixin.find(2).lower_items.map(&:id)
+    assert_equal [], ListMixin.find(4).lower_items.map(&:id)
+  end
+
+end
+
+class ArrayScopeListTest < Test::Unit::TestCase
+
+  def setup
+    setup_db
+    (1..4).each do |counter|
+      ArrayScopeListMixin.create!(
+        :pos => counter,
+        :parent_id => 5,
+        :parent_type => 'ParentClass'
+      )
+    end
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def conditions(options = {})
+    { :parent_id => 5, :parent_type => 'ParentClass' }.merge(options)
+  end
+
+  def test_reordering
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    ArrayScopeListMixin.find(2).move_lower
+    assert_equal [1, 3, 2, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    ArrayScopeListMixin.find(2).move_higher
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    ArrayScopeListMixin.find(1).move_to_bottom
+    assert_equal [2, 3, 4, 1], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    ArrayScopeListMixin.find(1).move_to_top
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    ArrayScopeListMixin.find(2).move_to_bottom
+    assert_equal [1, 3, 4, 2], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    ArrayScopeListMixin.find(4).move_to_top
+    assert_equal [4, 1, 3, 2], ArrayScopeListMixin.where(conditions).map(&:id)
+  end
+
+  def test_move_to_bottom_with_next_to_last_item
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+    ArrayScopeListMixin.find(3).move_to_bottom
+    assert_equal [1, 2, 4, 3], ArrayScopeListMixin.where(conditions).map(&:id)
+  end
+
+  def test_next_prev
+    assert_equal ArrayScopeListMixin.find(2), ArrayScopeListMixin.find(1).lower_item
+    assert_nil ArrayScopeListMixin.find(1).higher_item
+    assert_equal ArrayScopeListMixin.find(3), ArrayScopeListMixin.find(4).higher_item
+    assert_nil ArrayScopeListMixin.find(4).lower_item
+  end
+
+  def test_injection
+    item = ArrayScopeListMixin.new(conditions)
+    assert_equal(conditions, item.send(:scope_condition))
+    assert_equal("pos", item.send(:position_column))
+  end
+
+  def test_insert
+    new = ArrayScopeListMixin.create(conditions(:parent_id => 20))
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+
+    new = ArrayScopeListMixin.create(conditions(:parent_id => 20))
+    assert_equal 2, new.pos
+    assert !new.first?
+    assert new.last?
+
+    new = ArrayScopeListMixin.create(conditions(:parent_id => 20))
+    assert_equal 3, new.pos
+    assert !new.first?
+    assert new.last?
+
+    new = ArrayScopeListMixin.create(conditions(:parent_id => 0))
+    assert_equal 1, new.pos
+    assert new.first?
+    assert new.last?
+  end
+
+  def test_insert_at
+    new = ArrayScopeListMixin.create(conditions(:parent_id => 20))
+    assert_equal 1, new.pos
+
+    new = ArrayScopeListMixin.create(conditions(:parent_id => 20))
+    assert_equal 2, new.pos
+
+    new = ArrayScopeListMixin.create(conditions(:parent_id => 20))
+    assert_equal 3, new.pos
+
+    new4 = ArrayScopeListMixin.create(conditions(:parent_id => 20))
+    assert_equal 4, new4.pos
+
+    new4.insert_at(3)
+    assert_equal 3, new4.pos
+
+    new.reload
+    assert_equal 4, new.pos
+
+    new.insert_at(2)
+    assert_equal 2, new.pos
+
+    new4.reload
+    assert_equal 4, new4.pos
+
+    new5 = ArrayScopeListMixin.create(conditions(:parent_id => 20))
+    assert_equal 5, new5.pos
+
+    new5.insert_at(1)
+    assert_equal 1, new5.pos
+
+    new4.reload
+    assert_equal 5, new4.pos
+  end
+
+  def test_delete_middle
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    ArrayScopeListMixin.find(2).destroy
+
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    assert_equal 1, ArrayScopeListMixin.find(1).pos
+    assert_equal 2, ArrayScopeListMixin.find(3).pos
+    assert_equal 3, ArrayScopeListMixin.find(4).pos
+
+    ArrayScopeListMixin.find(1).destroy
+
+    assert_equal [3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    assert_equal 1, ArrayScopeListMixin.find(3).pos
+    assert_equal 2, ArrayScopeListMixin.find(4).pos
+  end
+
+  def test_remove_from_list_should_then_fail_in_list?
+    assert_equal true, ArrayScopeListMixin.find(1).in_list?
+    ArrayScopeListMixin.find(1).remove_from_list
+    assert_equal false, ArrayScopeListMixin.find(1).in_list?
+  end
+
+  def test_remove_from_list_should_set_position_to_nil
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    ArrayScopeListMixin.find(2).remove_from_list
+
+    assert_equal [2, 1, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    assert_equal 1,   ArrayScopeListMixin.find(1).pos
+    assert_equal nil, ArrayScopeListMixin.find(2).pos
+    assert_equal 2,   ArrayScopeListMixin.find(3).pos
+    assert_equal 3,   ArrayScopeListMixin.find(4).pos
+  end
+
+  def test_remove_before_destroy_does_not_shift_lower_items_twice
+    assert_equal [1, 2, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    ArrayScopeListMixin.find(2).remove_from_list
+    ArrayScopeListMixin.find(2).destroy
+
+    assert_equal [1, 3, 4], ArrayScopeListMixin.where(conditions).map(&:id)
+
+    assert_equal 1, ArrayScopeListMixin.find(1).pos
+    assert_equal 2, ArrayScopeListMixin.find(3).pos
+    assert_equal 3, ArrayScopeListMixin.find(4).pos
+  end
+
+  def test_higher_items
+    assert_equal [1, 2], ArrayScopeListMixin.find(3).higher_items.map(&:id)
+    assert_equal [], ArrayScopeListMixin.find(1).higher_items.map(&:id)
+  end
+
+  def test_lower_items
+    assert_equal [3, 4], ArrayScopeListMixin.find(2).lower_items.map(&:id)
+    assert_equal [], ArrayScopeListMixin.find(4).lower_items.map(&:id)
+  end
+
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification 
+name: sortifiable
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Andrew White
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-07 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 3
+        - 0
+        - 3
+        version: 3.0.3
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 3
+        - 0
+        - 3
+        version: 3.0.3
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 0
+        - 10
+        version: 1.0.10
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 1
+        - 3
+        - 3
+        version: 1.3.3
+  type: :development
+  version_requirements: *id004
+description: |
+  This gem provides an acts_as_list compatible capability for sorting
+  and reordering a number of objects in a list. The class that has this
+  specified needs to have a +position+ column defined as an integer on
+  the mapped database table.
+  
+  This gem requires ActiveRecord 3.0 as it has been refactored to use
+  the scope methods and query interface introduced with Ruby on Rails 3.0
+
+email: 
+- andyw@pixeltrix.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gemtest
+- CHANGELOG
+- LICENSE
+- README
+- Rakefile
+- lib/sortifiable.rb
+- lib/sortifiable/version.rb
+- sortifiable.gemspec
+- test/sortifiable_test.rb
+has_rdoc: true
+homepage: http://github.com/pixeltrix/sortifiable/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Sort your models
+test_files: 
+- test/sortifiable_test.rb