ranked-model-rails2 0.4.0

data/lib/ranked-model/railtie.rb

@@ -0,0 +1,14 @@
+require 'ranked-model'
+require 'rails'
+
+module RankedModel
+
+  class Railtie < Rails::Railtie
+    
+    initializer "ranked-model.initialize" do |app|
+
+    end
+
+  end
+
+end

data/lib/ranked-model/ranker.rb

@@ -0,0 +1,327 @@
+module RankedModel
+
+  class InvalidScope < StandardError; end
+  class InvalidField < StandardError; end
+
+  class Ranker
+    attr_accessor :name, :column, :scope, :with_same, :class_name, :unless
+
+    def initialize name, options={}
+      self.name = name.to_sym
+      self.column = options[:column] || name
+      self.class_name = options[:class_name]
+
+      [ :scope, :with_same, :unless ].each do |key|
+        self.send "#{key}=", options[key]
+      end
+    end
+
+    def with instance
+      Mapper.new self, instance
+    end
+
+    class Mapper
+      attr_accessor :ranker, :instance
+
+      def initialize ranker, instance
+        self.ranker   = ranker
+        self.instance = instance
+
+        validate_ranker_for_instance!
+      end
+
+      def validate_ranker_for_instance!
+        if ranker.scope && !instance_class.respond_to?(ranker.scope)
+          raise RankedModel::InvalidScope, %Q{No scope called "#{ranker.scope}" found in model}
+        end
+
+        if ranker.with_same
+          if (case ranker.with_same
+                when Symbol
+                  !instance.respond_to?(ranker.with_same)
+                when Array
+                  array_element = ranker.with_same.detect {|attr| !instance.respond_to?(attr) }
+                else
+                  false
+              end)
+            raise RankedModel::InvalidField, %Q{No field called "#{array_element || ranker.with_same}" found in model}
+          end
+        end
+      end
+
+      def handle_ranking
+        case ranker.unless
+        when Proc
+          return if ranker.unless.call(instance)
+        when Symbol
+          return if instance.send(ranker.unless)
+        end
+
+        update_index_from_position
+        assure_unique_position
+      end
+
+      def update_rank! value
+        # Bypass callbacks
+        #
+        instance_class.
+          where(instance_class.primary_key => instance.id).
+          update_all([%Q{#{ranker.column} = ?}, value])
+      end
+
+      def position
+        instance.send "#{ranker.name}_position"
+      end
+
+      def rank
+        instance.send "#{ranker.column}"
+      end
+
+      def current_at_position _pos
+        if (ordered_instance = finder.offset(_pos).first)
+          RankedModel::Ranker::Mapper.new ranker, ordered_instance
+        end
+      end
+
+      def has_rank?
+        !rank.nil?
+      end
+
+    private
+
+      def instance_class
+        ranker.class_name.nil? ? instance.class : ranker.class_name.constantize
+      end
+
+      def position_at value
+        instance.send "#{ranker.name}_position=", value
+        update_index_from_position
+      end
+
+      def rank_at value
+        instance.send "#{ranker.column}=", value
+      end
+
+      def rank_changed?
+        instance.send "#{ranker.column}_changed?"
+      end
+
+      def new_record?
+        instance.new_record?
+      end
+
+      def update_index_from_position
+        case position
+          when :first, 'first'
+            if current_first && current_first.rank
+              rank_at( ( ( RankedModel::MIN_RANK_VALUE - current_first.rank ).to_f / 2 ).ceil + current_first.rank)
+            else
+              position_at :middle
+            end
+          when :last, 'last'
+            if current_last && current_last.rank
+              rank_at( ( ( RankedModel::MAX_RANK_VALUE - current_last.rank ).to_f / 2 ).ceil + current_last.rank )
+            else
+              position_at :middle
+            end
+          when :middle, 'middle'
+            rank_at( ( ( RankedModel::MAX_RANK_VALUE - RankedModel::MIN_RANK_VALUE ).to_f / 2 ).ceil + RankedModel::MIN_RANK_VALUE )
+          when :down, 'down'
+            neighbors = find_next_two(rank)
+            if neighbors[:lower]
+              min = neighbors[:lower].rank
+              max = neighbors[:upper] ? neighbors[:upper].rank : RankedModel::MAX_RANK_VALUE
+              rank_at( ( ( max - min ).to_f / 2 ).ceil + min )
+            end
+          when :up, 'up'
+            neighbors = find_previous_two(rank)
+            if neighbors[:upper]
+              max = neighbors[:upper].rank
+              min = neighbors[:lower] ? neighbors[:lower].rank : RankedModel::MIN_RANK_VALUE
+              rank_at( ( ( max - min ).to_f / 2 ).ceil + min )
+            end
+          when String
+            position_at position.to_i
+          when 0
+            position_at :first
+          when Integer
+            neighbors = neighbors_at_position(position)
+            min = ((neighbors[:lower] && neighbors[:lower].has_rank?) ? neighbors[:lower].rank : RankedModel::MIN_RANK_VALUE)
+            max = ((neighbors[:upper] && neighbors[:upper].has_rank?) ? neighbors[:upper].rank : RankedModel::MAX_RANK_VALUE)
+            rank_at( ( ( max - min ).to_f / 2 ).ceil + min )
+          when NilClass
+            if !rank
+              position_at :last
+            end
+        end
+      end
+
+      def assure_unique_position
+        if ( new_record? || rank_changed? )
+          unless rank
+            rank_at( RankedModel::MAX_RANK_VALUE )
+          end
+
+          if (rank > RankedModel::MAX_RANK_VALUE) || current_at_rank(rank)
+            rearrange_ranks
+          end
+        end
+      end
+
+      def rearrange_ranks
+        _scope = finder
+        unless instance.id.nil?
+          # Never update ourself, shift others around us.
+          _scope = _scope.where(%Q{#{instance_class.q(instance_class.primary_key)} != ?}, instance.id)
+        end
+        if current_first.rank && current_first.rank > RankedModel::MIN_RANK_VALUE && rank == RankedModel::MAX_RANK_VALUE
+          _scope.
+            where(%Q{#{instance_class.q(ranker.column)} <= ?}, rank).
+            update_all( %Q{#{ranker.column} = #{ranker.column} - 1} )
+        elsif current_last.rank && current_last.rank < (RankedModel::MAX_RANK_VALUE - 1) && rank < current_last.rank
+          _scope.
+            where(%Q{#{instance_class.q(ranker.column)} >= ?}, rank).
+            update_all( %Q{#{ranker.column} = #{ranker.column} + 1} )
+        elsif current_first.rank && current_first.rank > RankedModel::MIN_RANK_VALUE && rank > current_first.rank
+          _scope.
+            where(%Q{#{instance_class.q(ranker.column)} < ?}, rank).
+            update_all( %Q{#{ranker.column} = #{ranker.column} - 1} )
+          rank_at( rank - 1 )
+        else
+          rebalance_ranks
+        end
+      end
+
+      def rebalance_ranks
+        total = current_order.size + 2
+        has_set_self = false
+        total.times do |index|
+          next if index == 0 || index == total
+          rank_value = ((((RankedModel::MAX_RANK_VALUE - RankedModel::MIN_RANK_VALUE).to_f / total) * index ).ceil + RankedModel::MIN_RANK_VALUE)
+          index = index - 1
+          if has_set_self
+            index = index - 1
+          else
+            if !current_order[index] ||
+               ( !current_order[index].rank.nil? &&
+                 current_order[index].rank >= rank )
+              rank_at rank_value
+              has_set_self = true
+              next
+            end
+          end
+          current_order[index].update_rank! rank_value
+        end
+      end
+
+      def finder(order = :asc)
+        @finder ||= begin
+          _finder = instance_class
+          columns = [instance_class.primary_key, ranker.column].map(&:to_sym)
+          if ranker.scope
+            _finder = _finder.send ranker.scope
+          end
+          case ranker.with_same
+            when Symbol
+              columns << ranker.with_same
+              _finder = _finder.where \
+                ranker.with_same => instance["#{ranker.with_same}"]
+            when Array
+              columns += ranker.with_same.map(&:to_sym)
+              ranker.with_same.each do |c|
+                _finder = _finder.where(c.to_sym => instance["#{c}"])
+              end
+          end
+          if !new_record?
+            _finder = _finder.where \
+              %Q{#{instance_class.q(instance_class.primary_key)} != ?}, instance.id
+          end
+          _finder.order("#{instance_class.q(ranker.column)} #{order.to_s.upcase}").select(columns)
+        end
+      end
+
+      def current_order
+        @current_order ||= begin
+          finder.collect { |ordered_instance|
+            RankedModel::Ranker::Mapper.new ranker, ordered_instance
+          }
+        end
+      end
+
+      def current_first
+        @current_first ||= begin
+          if (ordered_instance = finder.first)
+            RankedModel::Ranker::Mapper.new ranker, ordered_instance
+          end
+        end
+      end
+
+      def current_last
+        @current_last ||= begin
+          if (ordered_instance = finder.
+                                   reverse.
+                                   first)
+            RankedModel::Ranker::Mapper.new ranker, ordered_instance
+          end
+        end
+      end
+
+      def current_at_rank _rank
+        if (ordered_instance = finder.
+                                 except( :order ).
+                                 where( ranker.column => _rank ).
+                                 first)
+          RankedModel::Ranker::Mapper.new ranker, ordered_instance
+        end
+      end
+
+      def neighbors_at_position _pos
+        if _pos > 0
+          if (ordered_instances = finder.offset(_pos-1).limit(2).to_a)
+            if ordered_instances[1]
+              { :lower => RankedModel::Ranker::Mapper.new( ranker, ordered_instances[0] ),
+                :upper => RankedModel::Ranker::Mapper.new( ranker, ordered_instances[1] ) }
+            elsif ordered_instances[0]
+              { :lower => RankedModel::Ranker::Mapper.new( ranker, ordered_instances[0] ) }
+            else
+              { :lower => current_last }
+            end
+          end
+        else
+          if (ordered_instance = finder.first)
+            { :upper => RankedModel::Ranker::Mapper.new( ranker, ordered_instance ) }
+          else
+            {}
+          end
+        end
+      end
+
+      def find_next_two _rank
+        ordered_instances = finder.where(%Q{#{instance_class.q(ranker.column)} > ?}, _rank).limit(2)
+        if ordered_instances[1]
+          { :lower => RankedModel::Ranker::Mapper.new( ranker, ordered_instances[0] ),
+            :upper => RankedModel::Ranker::Mapper.new( ranker, ordered_instances[1] ) }
+        elsif ordered_instances[0]
+          { :lower => RankedModel::Ranker::Mapper.new( ranker, ordered_instances[0] ) }
+        else
+          {}
+        end
+      end
+
+      def find_previous_two _rank
+        ordered_instances = finder(:desc).where(%Q{#{instance_class.q(ranker.column)} < ?}, _rank).limit(2)
+        if ordered_instances[1]
+          { :upper => RankedModel::Ranker::Mapper.new( ranker, ordered_instances[0] ),
+            :lower => RankedModel::Ranker::Mapper.new( ranker, ordered_instances[1] ) }
+        elsif ordered_instances[0]
+          { :upper => RankedModel::Ranker::Mapper.new( ranker, ordered_instances[0] ) }
+        else
+          {}
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ranked-model/version.rb

@@ -0,0 +1,3 @@
+module RankedModel
+  VERSION = "0.4.0"
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'ranked-model/railtie'

data/ranked-model-rails2.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ranked-model/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ranked-model-rails2"
+  s.version     = RankedModel::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["ThoughtWorks Studios"]
+  s.email       = ["mingle-dev@thoughtworks.com"]
+  s.homepage    = "https://github.com/ThoughtWorksStudios/ranked-model-rails2"
+  s.summary     = %q{An acts_as_sortable replacement built for Rails 2}
+  s.description = %q{ranked-model-rails2 is a modern row sorting library built for Rails 2, backported from ranked-model. It uses fake_arel and is better optimized than most other libraries.}
+  s.license     = 'MIT'
+
+  s.add_dependency "activerecord", "~> 2.3.18"
+  s.add_dependency "fake_arel", "~> 1.5.1"
+  s.add_development_dependency "rspec", "~> 2.13.0"
+  s.add_development_dependency "sqlite3", "~> 1.3.7"
+  s.add_development_dependency "genspec", "~> 0.2.8"
+  s.add_development_dependency "mocha", "~> 0.14.0"
+  s.add_development_dependency "database_cleaner", "~> 1.2.0"
+  s.add_development_dependency "rake", "~> 10.1.0"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/duck-model/duck_spec.rb

@@ -0,0 +1,770 @@
+require 'spec_helper'
+
+describe Duck do
+
+  before {
+    @duck = Duck.new
+  }
+
+  subject { @duck }
+
+  it { subject.respond_to?(:row_position).should be_true }
+  it { subject.respond_to?(:row_position=).should be_true }
+  it { subject.respond_to?(:size_position).should be_true }
+  it { subject.respond_to?(:size_position=).should be_true }
+  it { subject.respond_to?(:age_position).should be_true }
+  it { subject.respond_to?(:age_position=).should be_true }
+  it { subject.respond_to?(:landing_order_position).should be_true }
+  it { subject.respond_to?(:landing_order_position=).should be_true }
+
+end
+
+describe Duck do
+
+  before {
+    @ducks = {
+      :quacky => Duck.create(
+        :name => 'Quacky',
+        :pond => 'Shin' ),
+      :feathers => Duck.create(
+        :name => 'Feathers',
+        :pond => 'Shin' ),
+      :wingy => Duck.create(
+        :name => 'Wingy',
+        :pond => 'Shin' ),
+      :webby => Duck.create(
+        :name => 'Webby',
+        :pond => 'Boyden' ),
+      :waddly => Duck.create(
+        :name => 'Waddly',
+        :pond => 'Meddybemps' ),
+      :beaky => Duck.create(
+        :name => 'Beaky',
+        :pond => 'Great Moose' )
+    }
+    @ducks.each { |name, duck|
+      duck.reload
+      duck.update_attribute :row_position, 0
+      duck.update_attribute :size_position, 0
+      duck.update_attribute :age_position, 0
+      duck.save!
+    }
+    @ducks.each {|name, duck| duck.reload }
+  }
+
+  describe "sorting by size on in_shin_pond" do
+
+    before {
+      @ducks[:quacky].update_attribute :size_position, 0
+      @ducks[:wingy].update_attribute :size_position, 2
+    }
+
+    subject { Duck.in_shin_pond.rank(:size).to_a }
+
+    its(:size) { should == 3 }
+
+    its(:first) { should == @ducks[:quacky] }
+
+    its(:last) { should == @ducks[:wingy] }
+
+  end
+
+  describe "sorting by age on Shin pond" do
+
+    before {
+      @ducks[:feathers].update_attribute :age_position, 0
+      @ducks[:wingy].update_attribute :age_position, 0
+    }
+
+    subject { Duck.where(:pond => 'Shin').rank(:age).to_a }
+
+    its(:size) { should == 3 }
+
+    its(:first) { should == @ducks[:wingy] }
+
+    its(:last) { should == @ducks[:quacky] }
+
+  end
+
+  describe "sorting by row" do
+
+    before {
+      @ducks[:beaky].update_attribute :row_position, 0
+      @ducks[:webby].update_attribute :row_position, 2
+      @ducks[:waddly].update_attribute :row_position, 2
+      @ducks[:wingy].update_attribute :row_position, 6
+    }
+
+    subject { Duck.rank(:row).to_a }
+
+    its(:size) { should == 6 }
+
+    its(:first) { should == @ducks[:beaky] }
+
+    its(:last) { should == @ducks[:wingy] }
+
+  end
+
+  describe "mixed sorting by" do
+
+    before {
+      @ducks[:quacky].update_attribute :size_position, 0
+      @ducks[:beaky].update_attribute :row_position, 0
+      @ducks[:webby].update_attribute :row_position, 2
+      @ducks[:wingy].update_attribute :size_position, 1
+      @ducks[:waddly].update_attribute :row_position, 2
+      @ducks[:wingy].update_attribute :row_position, 6
+      @ducks[:webby].update_attribute :row_position, 6
+    }
+
+    describe "row" do
+
+      subject { Duck.rank(:row).to_a }
+
+      its(:size) { should == 6 }
+
+      its(:first) { should == @ducks[:beaky] }
+
+      its(:last) { should == @ducks[:webby] }
+
+    end
+
+    describe "row" do
+
+      subject { Duck.in_shin_pond.rank(:size).to_a }
+
+      its(:size) { should == 3 }
+
+      its(:first) { should == @ducks[:quacky] }
+
+      its(:last) { should == @ducks[:feathers] }
+
+    end
+
+  end
+
+  describe "changing an unrelated attribute" do
+
+    it "doesn't change ranking" do
+      # puts Duck.rank(:age).collect {|duck| "#{duck.name} #{duck.age}" }
+      duck = Duck.rank(:age)[2]
+      lambda {
+        duck.update_attribute :name, 'New Name'
+      }.should_not change(duck.reload, :age)
+      # puts Duck.rank(:age).collect {|duck| "#{duck.name} #{duck.age}" }
+    end
+
+  end
+
+  describe "changing a related attribute" do
+
+    it "marks record as changed" do
+      duck = Duck.rank(:age)[2]
+      duck.age_position = 1
+      duck.changed?.should be_true
+    end
+
+  end
+
+  describe "setting only truly values" do
+
+    subject { Duck.rank(:age).first }
+
+    it "doesnt set empty string" do
+      subject.age_position = ''
+      subject.age_position.should be_nil
+    end
+
+  end
+
+  describe "setting and fetching by positioning" do
+
+    describe "in the middle" do
+
+      before {
+        @ordered = Duck.rank(:row).where("id != ?", @ducks[:wingy].id).collect {|duck| duck.id }
+        @ducks[:wingy].update_attribute :row_position, 2
+      }
+
+      context {
+
+        subject { Duck.ranker(:row).with(Duck.new).current_at_position(2).instance }
+
+        its(:id) { should == @ducks[:wingy].id }
+
+      }
+
+      context {
+
+        subject { Duck.rank(:row).collect {|duck| duck.id } }
+
+        it { subject[0..1].should == @ordered[0..1] }
+
+        it { subject[3..subject.length].should == @ordered[2..@ordered.length] }
+
+      }
+
+    end
+
+    describe "at the start" do
+
+      before {
+        @ordered = Duck.rank(:row).where("id != ?", @ducks[:wingy].id).collect {|duck| duck.id }
+        @ducks[:wingy].update_attribute :row_position, 0
+      }
+
+      context {
+
+        subject { Duck.ranker(:row).with(Duck.new).current_at_position(0).instance }
+
+        its(:id) { should == @ducks[:wingy].id }
+
+      }
+
+      context {
+
+        subject { Duck.ranker(:row).with(Duck.new).instance_eval { current_first }.instance }
+
+        its(:id) { should == @ducks[:wingy].id }
+
+      }
+
+      context {
+
+        subject { Duck.rank(:row).collect {|duck| duck.id } }
+
+        it { subject[1..subject.length].should == @ordered }
+
+      }
+
+    end
+
+    describe "at the end" do
+
+      before {
+        @ordered = Duck.rank(:row).where("id != ?", @ducks[:wingy].id).collect {|duck| duck.id }
+        @ducks[:wingy].update_attribute :row_position, (@ducks.size - 1)
+      }
+
+      context {
+
+        subject { Duck.ranker(:row).with(Duck.new).current_at_position(@ducks.size - 1).instance }
+
+        its(:id) { should == @ducks[:wingy].id }
+
+      }
+
+      context {
+
+        subject { Duck.rank(:row).last }
+
+        its(:id) { should == @ducks[:wingy].id }
+
+      }
+
+      context {
+
+        subject { Duck.ranker(:row).with(Duck.new).instance_eval { current_last }.instance }
+
+        its(:id) { should == @ducks[:wingy].id }
+
+      }
+
+      context {
+
+        subject { Duck.rank(:row).collect {|duck| duck.id } }
+
+        it { subject[0..-2].should == @ordered }
+
+      }
+
+    end
+
+    describe "at the end with symbol" do
+
+      before {
+        @ordered = Duck.rank(:row).where("id != ?", @ducks[:wingy].id).collect {|duck| duck.id }
+        @ducks[:wingy].update_attribute :row_position, :last
+      }
+
+      context {
+
+        subject { Duck.ranker(:row).with(Duck.new).current_at_position(@ducks.size - 1).instance }
+
+        its(:id) { should == @ducks[:wingy].id }
+
+      }
+
+      context {
+
+        subject { Duck.rank(:row).last }
+
+        its(:id) { should == @ducks[:wingy].id }
+
+      }
+
+      context {
+
+        subject { Duck.ranker(:row).with(Duck.new).instance_eval { current_last }.instance }
+
+        its(:id) { should == @ducks[:wingy].id }
+
+      }
+
+      context {
+
+        subject { Duck.rank(:row).collect {|duck| duck.id } }
+
+        it { subject[0..-2].should == @ordered }
+
+      }
+
+    end
+
+    describe "at the end with string" do
+
+      before {
+        @ordered = Duck.rank(:row).where("id != ?", @ducks[:wingy].id).collect {|duck| duck.id }
+        @ducks[:wingy].update_attribute :row_position, 'last'
+      }
+
+      context {
+
+        subject { Duck.ranker(:row).with(Duck.new).current_at_position(@ducks.size - 1).instance }
+
+        its(:id) { should == @ducks[:wingy].id }
+
+      }
+
+      context {
+
+        subject { Duck.rank(:row).last }
+
+        its(:id) { should == @ducks[:wingy].id }
+
+      }
+
+      context {
+
+        subject { Duck.ranker(:row).with(Duck.new).instance_eval { current_last }.instance }
+
+        its(:id) { should == @ducks[:wingy].id }
+
+      }
+
+      context {
+
+        subject { Duck.rank(:row).collect {|duck| duck.id } }
+
+        it { subject[0..-2].should == @ordered }
+
+      }
+
+    end
+
+    describe "down with symbol" do
+
+      context "when in the middle" do
+
+        before {
+          @ordered = Duck.rank(:row).where("id != ?", @ducks[:wingy].id).collect { |duck| duck.id }
+          @ducks[:wingy].update_attribute :row_position, :down
+        }
+
+        context {
+
+          subject { Duck.ranker(:row).with(Duck.new).current_at_position(4).instance }
+
+          its(:id) { should == @ducks[:wingy].id }
+
+        }
+
+        context {
+
+          subject { Duck.rank(:row).collect { |duck| duck.id } }
+
+          it { subject[0..3].should == @ordered[0..3] }
+
+          it { subject[5..subject.length].should == @ordered[4..@ordered.length] }
+
+        }
+
+      end
+
+      context "when last" do
+
+        before {
+          @ordered = Duck.rank(:row).where("id != ?", @ducks[:quacky].id).collect { |duck| duck.id }
+          @ducks[:quacky].update_attribute :row_position, :down
+        }
+
+        context {
+
+          subject { Duck.ranker(:row).with(Duck.new).current_at_position(@ducks.size - 1).instance }
+
+          its(:id) { should == @ducks[:quacky].id }
+
+        }
+
+        context {
+
+          subject { Duck.rank(:row).collect { |duck| duck.id } }
+
+          it { subject[0..-2].should eq(@ordered) }
+
+        }
+
+      end
+
+      context "when second last" do
+
+        before {
+          @ordered = Duck.rank(:row).where("id != ?", @ducks[:feathers].id).collect { |duck| duck.id }
+          @ducks[:feathers].update_attribute :row_position, :down
+        }
+
+        context {
+
+          subject { Duck.ranker(:row).with(Duck.new).current_at_position(@ducks.size - 1).instance }
+
+          its(:id) { should == @ducks[:feathers].id }
+
+        }
+
+        context {
+
+          subject { Duck.rank(:row).collect { |duck| duck.id } }
+
+          it { subject[0..-2].should eq(@ordered) }
+
+        }
+
+      end
+
+    end
+
+    describe "down with string" do
+
+      context "when in the middle" do
+
+        before {
+          @ordered = Duck.rank(:row).where("id != ?", @ducks[:wingy].id).collect { |duck| duck.id }
+          @ducks[:wingy].update_attribute :row_position, 'down'
+        }
+
+        context {
+
+          subject { Duck.ranker(:row).with(Duck.new).current_at_position(4).instance }
+
+          its(:id) { should == @ducks[:wingy].id }
+
+        }
+
+        context {
+
+          subject { Duck.rank(:row).collect { |duck| duck.id } }
+
+          it { subject[0..3].should == @ordered[0..3] }
+
+          it { subject[5..subject.length].should == @ordered[4..@ordered.length] }
+
+        }
+
+      end
+
+      context "when last" do
+
+        before {
+          @ordered = Duck.rank(:row).where("id != ?", @ducks[:quacky].id).collect { |duck| duck.id }
+          @ducks[:quacky].update_attribute :row_position, 'down'
+        }
+
+        context {
+
+          subject { Duck.ranker(:row).with(Duck.new).current_at_position(@ducks.size - 1).instance }
+
+          its(:id) { should == @ducks[:quacky].id }
+
+        }
+
+        context {
+
+          subject { Duck.rank(:row).collect { |duck| duck.id } }
+
+          it { subject[0..-2].should eq(@ordered) }
+
+        }
+
+      end
+
+      context "when second last" do
+
+        before {
+          @ordered = Duck.rank(:row).where("id != ?", @ducks[:feathers].id).collect { |duck| duck.id }
+          @ducks[:feathers].update_attribute :row_position, 'down'
+        }
+
+        context {
+
+          subject { Duck.ranker(:row).with(Duck.new).current_at_position(@ducks.size - 1).instance }
+
+          its(:id) { should == @ducks[:feathers].id }
+
+        }
+
+        context {
+
+          subject { Duck.rank(:row).collect { |duck| duck.id } }
+
+          it { subject[0..-2].should eq(@ordered) }
+
+        }
+
+      end
+
+    end
+
+    describe "up with symbol" do
+
+      context "when in the middle" do
+
+        before {
+          @ordered = Duck.rank(:row).where("id != ?", @ducks[:wingy].id).collect { |duck| duck.id }
+          @ducks[:wingy].update_attribute :row_position, :up
+        }
+
+        context {
+
+          subject { Duck.ranker(:row).with(Duck.new).current_at_position(2).instance }
+
+          its(:id) { should == @ducks[:wingy].id }
+
+        }
+
+        context {
+
+          subject { Duck.rank(:row).collect { |duck| duck.id } }
+
+          it { subject[0..1].should == @ordered[0..1] }
+
+          it { subject[3..subject.length].should == @ordered[2..@ordered.length] }
+
+        }
+
+      end
+
+      context "when first" do
+
+        before {
+          @ordered = Duck.rank(:row).where("id != ?", @ducks[:beaky].id).collect { |duck| duck.id }
+          @ducks[:beaky].update_attribute :row_position, :up
+        }
+
+        context {
+
+          subject { Duck.ranker(:row).with(Duck.new).current_at_position(0).instance }
+
+          its(:id) { should == @ducks[:beaky].id }
+
+        }
+
+        context {
+
+          subject { Duck.rank(:row).collect { |duck| duck.id } }
+
+          it { subject[1..subject.length].should eq(@ordered) }
+
+        }
+
+      end
+
+      context "when second" do
+
+        before {
+          @ordered = Duck.rank(:row).where("id != ?", @ducks[:waddly].id).collect { |duck| duck.id }
+          @ducks[:waddly].update_attribute :row_position, :up
+        }
+
+        context {
+
+          subject { Duck.ranker(:row).with(Duck.new).current_at_position(0).instance }
+
+          its(:id) { should == @ducks[:waddly].id }
+
+        }
+
+        context {
+
+          subject { Duck.rank(:row).collect { |duck| duck.id } }
+
+          it { subject[1..subject.length].should eq(@ordered) }
+
+        }
+
+      end
+
+    end
+
+    describe "up with string" do
+
+      context "when in the middle" do
+
+        before {
+          @ordered = Duck.rank(:row).where("id != ?", @ducks[:wingy].id).collect { |duck| duck.id }
+          @ducks[:wingy].update_attribute :row_position, 'up'
+        }
+
+        context {
+
+          subject { Duck.ranker(:row).with(Duck.new).current_at_position(2).instance }
+
+          its(:id) { should == @ducks[:wingy].id }
+
+        }
+
+        context {
+
+          subject { Duck.rank(:row).collect { |duck| duck.id } }
+
+          it { subject[0..1].should == @ordered[0..1] }
+
+          it { subject[3..subject.length].should == @ordered[2..@ordered.length] }
+
+        }
+
+      end
+
+      context "when first" do
+
+        before {
+          @ordered = Duck.rank(:row).where("id != ?", @ducks[:beaky].id).collect { |duck| duck.id }
+          @ducks[:beaky].update_attribute :row_position, 'up'
+        }
+
+        context {
+
+          subject { Duck.ranker(:row).with(Duck.new).current_at_position(0).instance }
+
+          its(:id) { should == @ducks[:beaky].id }
+
+        }
+
+        context {
+
+          subject { Duck.rank(:row).collect { |duck| duck.id } }
+
+          it { subject[1..subject.length].should eq(@ordered) }
+
+        }
+
+      end
+
+      context "when second" do
+
+        before {
+          @ordered = Duck.rank(:row).where("id != ?", @ducks[:waddly].id).collect { |duck| duck.id }
+          @ducks[:waddly].update_attribute :row_position, 'up'
+        }
+
+        context {
+
+          subject { Duck.ranker(:row).with(Duck.new).current_at_position(0).instance }
+
+          its(:id) { should == @ducks[:waddly].id }
+
+        }
+
+        context {
+
+          subject { Duck.rank(:row).collect { |duck| duck.id } }
+
+          it { subject[1..subject.length].should eq(@ordered) }
+
+        }
+
+      end
+
+    end
+
+  end
+
+end
+
+describe Duck do
+
+  before {
+    @ducks = {
+      :quacky => Duck.create(
+        :name => 'Quacky',
+        :lake_id => 0,
+        :flock_id => 0 ),
+      :feathers => Duck.create(
+        :name => 'Feathers',
+        :lake_id => 0,
+        :flock_id => 0 ),
+      :wingy => Duck.create(
+        :name => 'Wingy',
+        :lake_id => 0,
+        :flock_id => 0 ),
+      :webby => Duck.create(
+        :name => 'Webby',
+        :lake_id => 1,
+        :flock_id => 1 ),
+      :waddly => Duck.create(
+        :name => 'Waddly',
+        :lake_id => 1,
+        :flock_id => 0 ),
+      :beaky => Duck.create(
+        :name => 'Beaky',
+        :lake_id => 0,
+        :flock_id => 1 ),
+    }
+    @ducks.each { |name, duck|
+      duck.reload
+      duck.update_attribute :landing_order_position, 0
+      duck.save!
+    }
+    @ducks.each {|name, duck| duck.reload }
+  }
+
+  describe "sorting by landing_order" do
+
+    before {
+      @ducks[:quacky].update_attribute :landing_order_position, 0
+      @ducks[:wingy].update_attribute :landing_order_position, 1
+    }
+
+    subject { Duck.in_lake_and_flock(0,0).rank(:landing_order).to_a }
+
+    its(:size) { should == 3 }
+
+    its(:first) { should == @ducks[:quacky] }
+
+    its(:last) { should == @ducks[:feathers] }
+
+  end
+
+  describe "sorting by landing_order doesn't touch other items" do
+
+    before {
+      @untouchable_ranks = lambda {
+        [:webby, :waddly, :beaky].inject([]) do |ranks, untouchable_duck|
+          ranks << @ducks[untouchable_duck].landing_order
+        end
+      }
+
+      @previous_ranks = @untouchable_ranks.call
+
+      @ducks[:quacky].update_attribute :landing_order_position, 0
+      @ducks[:wingy].update_attribute :landing_order_position, 1
+      @ducks[:feathers].update_attribute :landing_order_position, 0
+      @ducks[:wingy].update_attribute :landing_order_position, 1
+    }
+
+    subject { @untouchable_ranks.call }
+
+    it { should == @previous_ranks }
+
+  end
+
+end