ranked-model 0.0.1 → 0.0.2

data/.gitignore

@@ -1,3 +1,5 @@
 pkg/*
 *.gem
 .bundle
+
+Gemfile.lock

data/Readme.mkd

@@ -1,4 +1,4 @@
-**ranked-model** is a modern row sorting library built for Rails 3.  It uses ARel aggressivly and is better optimized than most other libraries.
+**ranked-model** is a modern row sorting library built for Rails 3.  It uses ARel aggressively and is better optimized than most other libraries.
 
 Installation
 ------------

data/lib/ranked-model.rb

@@ -5,7 +5,8 @@ module RankedModel
 
   # Signed MEDIUMINT in MySQL
   #
-  MAX_RANK_VALUE = 65534
+  MAX_RANK_VALUE = 8388607
+  MIN_RANK_VALUE = -8388607
 
   def self.included base
 

data/lib/ranked-model/ranker.rb

@@ -1,5 +1,8 @@
 module RankedModel
 
+  class InvalidScope < StandardError; end
+  class InvalidField < StandardError; end
+
   class Ranker
     attr_accessor :name, :column, :scope, :with_same
 
@@ -22,12 +25,24 @@ module RankedModel
       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 && !instance.respond_to?(ranker.with_same)
+          raise RankedModel::InvalidField, %Q{No field called "#{ranker.with_same}" found in model}
+        end
+      end
+
       def handle_ranking
         update_index_from_position
         assure_unique_position
-      end      
+      end
 
       def update_rank! value
         # Bypass callbacks
@@ -43,6 +58,12 @@ module RankedModel
         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
+
     private
 
       def position_at value
@@ -65,25 +86,30 @@ module RankedModel
       def update_index_from_position
         case position
           when :first
-            if !current_order.empty? && current_order.first.rank
-              rank_at( current_order.first.rank / 2 )
+            if current_first && current_first.rank
+              rank_at( ( ( RankedModel::MIN_RANK_VALUE - current_first.rank ).to_f / 2 ).ceil + current_first.rank)
             else
-              rank_at 0
+              position_at :middle
             end
           when :last
-            if !current_order.empty? && current_order.last.rank
-              rank_at( ( RankedModel::MAX_RANK_VALUE + current_order.last.rank ) / 2 )
+            if current_last && current_last.rank
+              rank_at( ( ( RankedModel::MAX_RANK_VALUE - current_last.rank ).to_f / 2 ).ceil + current_last.rank )
             else
-              rank_at RankedModel::MAX_RANK_VALUE
+              position_at :middle
             end
+          when :middle
+            rank_at( ( ( RankedModel::MAX_RANK_VALUE - RankedModel::MIN_RANK_VALUE ).to_f / 2 ).ceil + RankedModel::MIN_RANK_VALUE )
           when String
             position_at position.to_i
           when 0
             position_at :first
           when Integer
-            if current_order[position]
-              rank_at( ( current_order[position-1].rank + current_order[position].rank ) / 2 )
-            else
+            neighbors = neighbors_at_position(position)
+            min = (neighbors[:lower] ? neighbors[:lower].rank : RankedModel::MIN_RANK_VALUE)
+            max = (neighbors[:upper] ? 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
@@ -92,24 +118,38 @@ module RankedModel
       def assure_unique_position
         if ( new_record? || rank_changed? )
           unless rank
-            rank_at RankedModel::MAX_RANK_VALUE
+            rank_at( RankedModel::MAX_RANK_VALUE )
           end
 
-          if (rank > RankedModel::MAX_RANK_VALUE) || (current_order.find do |rankable|
-            rankable.rank.nil? ||
-            rankable.rank == rank
-          end)
-            rebalance_ranks
+          if (rank > RankedModel::MAX_RANK_VALUE) || current_at_rank(rank)
+            rearrange_ranks
           end
         end
       end
-      
+
+      def rearrange_ranks
+        if current_last.rank < (RankedModel::MAX_RANK_VALUE - 1) && rank < current_last.rank
+          instance.class.
+            where( instance.class.arel_table[:id].not_eq(instance.id) ).
+            where( instance.class.arel_table[ranker.column].gteq(rank) ).
+            update_all( "#{ranker.column} = #{ranker.column} + 1" )
+        elsif current_first.rank > RankedModel::MIN_RANK_VALUE && rank > current_first.rank 
+          instance.class.
+            where( instance.class.arel_table[:id].not_eq(instance.id) ).
+            where( instance.class.arel_table[ranker.column].lt(rank) ).
+            update_all( "#{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 / total * index
+          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
@@ -126,26 +166,81 @@ module RankedModel
         end
       end
 
-      def current_order
-        @current_order ||= begin
-          finder = instance.class
+      def finder
+        @finder ||= begin
+          _finder = instance.class
           if ranker.scope
-            finder = finder.send ranker.scope
+            _finder = _finder.send ranker.scope
           end
           if ranker.with_same
-            finder = finder.where \
+            _finder = _finder.where \
               instance.class.arel_table[ranker.with_same].eq(instance.attributes["#{ranker.with_same}"])
           end
           if !new_record?
-            finder = finder.where \
+            _finder = _finder.where \
               instance.class.arel_table[:id].not_eq(instance.id)
           end
-          finder.order(ranker.column).select([:id, ranker.column]).collect { |ordered_instance|
+          _finder.order(instance.class.arel_table[ranker.column].asc).select([:id, ranker.column])
+        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.
+                                   except( :order ).
+                                   order( instance.class.arel_table[ranker.column].desc ).
+                                   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).all)
+            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
+
     end
 
   end

data/lib/ranked-model/version.rb

@@ -1,3 +1,3 @@
 module RankedModel
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/ranked-model.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.email       = ["matt.beale@madhatted.com"]
   s.homepage    = "https://github.com/harvesthq/ranked-model"
   s.summary     = %q{An acts_as_sortable replacement built for Rails 3}
-  s.description = %q{ranked-model is a modern row sorting library built for Rails 3. It uses ARel aggressivly and is better optimized than most other libraries.}
+  s.description = %q{ranked-model is a modern row sorting library built for Rails 3. It uses ARel aggressively and is better optimized than most other libraries.}
 
   s.add_dependency "activerecord", ">= 3.0.3"
   s.add_development_dependency "rspec"

data/spec/duck-model/duck_spec.rb

@@ -25,9 +25,9 @@ describe Duck do
     }
     @ducks.each { |name, duck|
       duck.reload
-      duck.row_position = 0
-      duck.size_position =  0
-      duck.age_position = 0
+      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 }
@@ -124,4 +124,150 @@ describe Duck do
 
   end
 
+  describe "setting and fetching by positioning" do
+
+    describe "in the middle" do
+
+      before {
+        @ordered = Duck.rank(:row).where(Duck.arel_table[:id].not_eq @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(Duck.arel_table[:id].not_eq @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(Duck.arel_table[:id].not_eq @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(Duck.arel_table[:id].not_eq @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
+
+  end
+
 end

data/spec/duck-model/lots_of_ducks_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Duck do
+
+  before {
+    200.times do |i|
+      Duck.create \
+        :name => "Duck #{i}"
+    end
+  }
+
+  describe "setting and fetching by position" do
+
+    describe '137' do
+
+      before {
+        @last = Duck.last
+        @last.update_attribute :row_position, 137
+      }
+
+      subject { Duck.ranker(:row).with(Duck.new).current_at_position(137).instance }
+
+      its(:id) { should == @last.id }
+
+    end
+
+    describe '2' do
+
+      before {
+        @last = Duck.last
+        @last.update_attribute :row_position, 2
+      }
+
+      subject { Duck.ranker(:row).with(Duck.new).current_at_position(2).instance }
+
+      its(:id) { should == @last.id }
+
+    end
+
+  end
+
+  describe "a rearrangement" do
+
+    describe "with max value" do
+
+      before {
+        @first = Duck.first
+        @second = Duck.offset(1).first
+        @ordered = Duck.rank(:row).where(Duck.arel_table[:id].not_in([@first.id, @second.id])).collect {|d| d.id }
+        @first.update_attribute :row, RankedModel::MAX_RANK_VALUE
+        @second.update_attribute :row, RankedModel::MAX_RANK_VALUE
+      }
+
+      context {
+
+        subject { Duck.rank(:row).collect {|d| d.id } }
+
+        it { should == (@ordered[0..-2] + [@first.id, @second.id, @ordered[-1]]) }
+
+      }
+
+    end
+
+    describe "with min value" do
+
+      before {
+        @first = Duck.first
+        @second = Duck.offset(1).first
+        @ordered = Duck.rank(:row).where(Duck.arel_table[:id].not_in([@first.id, @second.id])).collect {|d| d.id }
+        @first.update_attribute :row, RankedModel::MIN_RANK_VALUE
+        @second.update_attribute :row, RankedModel::MIN_RANK_VALUE
+      }
+
+      context {
+
+        subject { Duck.rank(:row).collect {|d| d.id } }
+
+        it { should == ([@second.id, @first.id] + @ordered) }
+
+      }
+
+    end
+
+    describe "with no more gaps" do
+
+      before {
+        @first = Duck.first
+        @second = Duck.where(:row => RankedModel::MAX_RANK_VALUE).first || Duck.offset(1).first
+        @third = Duck.offset(2).first
+        @fourth = Duck.offset(4).first
+        @lower = Duck.rank(:row).
+          where(Duck.arel_table[:id].not_in([@first.id, @second.id, @third.id, @fourth.id])).
+          where(Duck.arel_table[:row].lt(RankedModel::MAX_RANK_VALUE / 2)).
+          collect {|d| d.id }
+        @upper = Duck.rank(:row).
+          where(Duck.arel_table[:id].not_in([@first.id, @second.id, @third.id, @fourth.id])).
+          where(Duck.arel_table[:row].gteq(RankedModel::MAX_RANK_VALUE / 2)).
+          collect {|d| d.id }
+        @first.update_attribute :row, RankedModel::MIN_RANK_VALUE
+        @second.update_attribute :row, RankedModel::MAX_RANK_VALUE
+        @third.update_attribute :row, (RankedModel::MAX_RANK_VALUE / 2)
+        @fourth.update_attribute :row, @third.row
+      }
+
+      context {
+
+        subject { Duck.rank(:row).collect {|d| d.id } }
+
+        it { should == ([@first.id] + @lower + [@fourth.id, @third.id] + @upper + [@second.id]) }
+
+      }
+
+    end
+
+  end
+
+end

data/spec/duck-model/wrong_ducks_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe WrongScopeDuck do
+
+  it "should raise an error because of an unknown scope" do
+
+    expect {
+      WrongScopeDuck.create(:name => 'Quocky', :pond => 'Shin')
+    }.to raise_error(RankedModel::InvalidScope, 'No scope called "non_existant_scope" found in model')
+
+  end
+
+end
+
+describe WrongFieldDuck do
+
+  it "should raise an error because of an unknown field" do
+
+    expect {
+      WrongFieldDuck.create(:name => 'Quicky', :pond => 'Shin')
+    }.to raise_error(RankedModel::InvalidField, 'No field called "non_existant_field" found in model')
+
+  end
+
+end

data/spec/support/active_record.rb

@@ -18,6 +18,18 @@ ActiveRecord::Schema.define :version => 0 do
     t.integer :age
     t.string :pond
   end
+
+  create_table :wrong_scope_ducks, :force => true do |t|
+    t.string :name
+    t.integer :size
+    t.string :pond
+  end
+
+  create_table :wrong_field_ducks, :force => true do |t|
+    t.string :name
+    t.integer :age
+    t.string :pond
+  end
 end
 
 class Duck < ActiveRecord::Base
@@ -30,3 +42,19 @@ class Duck < ActiveRecord::Base
   scope :in_shin_pond, where(:pond => 'Shin')
 
 end
+
+# Negative examples
+
+class WrongScopeDuck < ActiveRecord::Base
+
+  include RankedModel
+  ranks :size, :scope => :non_existant_scope
+
+end
+
+class WrongFieldDuck < ActiveRecord::Base
+
+  include RankedModel
+  ranks :age, :with_same => :non_existant_field
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ranked-model
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Matthew Beale
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-08 00:00:00 -05:00
+date: 2011-04-14 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -104,7 +104,7 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id006
-description: ranked-model is a modern row sorting library built for Rails 3. It uses ARel aggressivly and is better optimized than most other libraries.
+description: ranked-model is a modern row sorting library built for Rails 3. It uses ARel aggressively and is better optimized than most other libraries.
 email: 
 - matt.beale@madhatted.com
 executables: []
@@ -117,7 +117,6 @@ files:
 - .gitignore
 - .rspec
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - Rakefile
 - Readme.mkd
@@ -128,6 +127,8 @@ files:
 - rails/init.rb
 - ranked-model.gemspec
 - spec/duck-model/duck_spec.rb
+- spec/duck-model/lots_of_ducks_spec.rb
+- spec/duck-model/wrong_ducks_spec.rb
 - spec/ranked-model/ranker_spec.rb
 - spec/ranked-model/version_spec.rb
 - spec/spec_helper.rb
@@ -170,6 +171,8 @@ specification_version: 3
 summary: An acts_as_sortable replacement built for Rails 3
 test_files: 
 - spec/duck-model/duck_spec.rb
+- spec/duck-model/lots_of_ducks_spec.rb
+- spec/duck-model/wrong_ducks_spec.rb
 - spec/ranked-model/ranker_spec.rb
 - spec/ranked-model/version_spec.rb
 - spec/spec_helper.rb

data/Gemfile.lock

@@ -1,81 +0,0 @@
-PATH
-  remote: .
-  specs:
-    ranked-model (0.0.1)
-      activerecord (>= 3.0.3)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    abstract (1.0.0)
-    actionpack (3.0.3)
-      activemodel (= 3.0.3)
-      activesupport (= 3.0.3)
-      builder (~> 2.1.2)
-      erubis (~> 2.6.6)
-      i18n (~> 0.4)
-      rack (~> 1.2.1)
-      rack-mount (~> 0.6.13)
-      rack-test (~> 0.5.6)
-      tzinfo (~> 0.3.23)
-    activemodel (3.0.3)
-      activesupport (= 3.0.3)
-      builder (~> 2.1.2)
-      i18n (~> 0.4)
-    activerecord (3.0.3)
-      activemodel (= 3.0.3)
-      activesupport (= 3.0.3)
-      arel (~> 2.0.2)
-      tzinfo (~> 0.3.23)
-    activesupport (3.0.3)
-    arel (2.0.7)
-    builder (2.1.2)
-    diff-lcs (1.1.2)
-    erubis (2.6.6)
-      abstract (>= 1.0.0)
-    genspec (0.1.1)
-      rspec
-      sc-core-ext (>= 1.2.0)
-    i18n (0.5.0)
-    mocha (0.9.10)
-      rake
-    rack (1.2.1)
-    rack-mount (0.6.13)
-      rack (>= 1.0.0)
-    rack-test (0.5.7)
-      rack (>= 1.0)
-    railties (3.0.3)
-      actionpack (= 3.0.3)
-      activesupport (= 3.0.3)
-      rake (>= 0.8.7)
-      thor (~> 0.14.4)
-    rake (0.8.7)
-    rspec (2.4.0)
-      rspec-core (~> 2.4.0)
-      rspec-expectations (~> 2.4.0)
-      rspec-mocks (~> 2.4.0)
-    rspec-core (2.4.0)
-    rspec-expectations (2.4.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.4.0)
-    rspec-rails (2.4.1)
-      actionpack (~> 3.0)
-      activesupport (~> 3.0)
-      railties (~> 3.0)
-      rspec (~> 2.4.0)
-    sc-core-ext (1.2.1)
-      activesupport (>= 2.3.5)
-    sqlite3 (1.3.3)
-    thor (0.14.6)
-    tzinfo (0.3.24)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  genspec
-  mocha
-  ranked-model!
-  rspec
-  rspec-rails
-  sqlite3