ranked-model 0.4.7 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8dac9a4acefc5a44cfe74e77931854bb8edd031cc986f3bc0bd8232f543dc0f9
-  data.tar.gz: 9bd6120114a23ef47ae08581b860cd0cb4fa18779fb237b9b9570d94a889cc75
+  metadata.gz: '004680e8b292451d304375f3ae01d0100702db74867d93b2a713e7c908241d78'
+  data.tar.gz: cc831e2837ba8ad07c21f6b890959e071005824a4f53bd51c135c8055fb1904f
 SHA512:
-  metadata.gz: dc8d0ad9348de7596934a2eab69da78228c3351bd4d16303eae592b3893ecfedc28ff4620997977e8a88dc9d26dc27999c99e6e2abddc7ab6fe1f24aeb108527
-  data.tar.gz: 03a77db0fc8e9f59b4ffaccf24c966a54125141ab07a931046387e30cf62b7bf0577d9d983d268322dc69a7004c68c001168083d428cffff118832085afe3d21
+  metadata.gz: d4494e9eede725ef30ecbd05006a4d91deb89f62aced56b96fa3be2f0f5732f41336d5a3d1c450e3f5d2c0f1821a15de096a1ee68732d8cb5d10a300008270ca
+  data.tar.gz: 04fa0d21ff8b2c6533ebc6705cc00c7258bd955c88a91636995d362136de9cf2a57c6e8ca49c43e112757e1209dc9a9fe3c2285b2bfde47639bcab90d2368fd4

data/.travis.yml

@@ -26,6 +26,7 @@ gemfile:
   - gemfiles/rails_5_1.gemfile
   - gemfiles/rails_5_2.gemfile
   - gemfiles/rails_6_0.gemfile
+  - gemfiles/rails_6_1.gemfile
 matrix:
   exclude:
     # Rails <6 does not support Ruby 3, see:
@@ -49,3 +50,7 @@ matrix:
       gemfile: gemfiles/rails_6_0.gemfile
     - rvm: jruby-9.1.17.0
       gemfile: gemfiles/rails_6_0.gemfile
+    - rvm: 2.4
+      gemfile: gemfiles/rails_6_1.gemfile
+    - rvm: jruby-9.1.17.0
+      gemfile: gemfiles/rails_6_1.gemfile

data/Appraisals

@@ -70,3 +70,17 @@ appraise "rails-6-0" do
   end
   gem "activerecord", "~> 6.0.0"
 end
+
+appraise "rails-6-1" do
+  group :sqlite do
+    gem "sqlite3", "~> 1.4", platform: :ruby
+    gem "activerecord-jdbcsqlite3-adapter", "~> 61.0", platform: :jruby
+  end
+  group :mysql do
+    gem "activerecord-jdbcmysql-adapter", "~> 61.0", platform: :jruby
+  end
+  group :postgresql do
+    gem "activerecord-jdbcpostgresql-adapter", "~> 61.0", platform: :jruby
+  end
+  gem "activerecord", "~> 6.1.0"
+end

data/Gemfile

@@ -4,13 +4,13 @@ source "https://rubygems.org"
 gemspec
 
 group :sqlite do
-  gem "sqlite3", "~> 1.3.13", platform: :ruby
+  gem "sqlite3", platform: :ruby
 end
 
 group :postgresql do
-  gem "pg", "~> 1.2.0", platform: :ruby
+  gem "pg", platform: :ruby
 end
 
 group :mysql do
-  gem "mysql2", "~> 0.5.0", platform: :ruby
+  gem "mysql2", platform: :ruby
 end

data/Readme.mkd

@@ -5,7 +5,7 @@
 Installation
 ------------
 
-ranked-model passes specs with Rails 4.2, 5.0, 5.1, 5.2 and 6.0 for MySQL, Postgres, and SQLite on Ruby 2.4 through 3.0 (with exceptions, please check the CI setup for supported combinations), and jruby-9.1.17.0 where Rails supports the platform.
+ranked-model passes specs with Rails 4.2, 5.0, 5.1, 5.2, 6.0 and 6.1 for MySQL, Postgres, and SQLite on Ruby 2.4 through 3.0 (with exceptions, please check the CI setup for supported combinations), and jruby-9.1.17.0 where Rails supports the platform.
 
 To install ranked-model, just add it to your `Gemfile`:
 
@@ -212,7 +212,7 @@ class AddRowOrderToDucks < ActiveRecord::Migration[6.0]
     Duck.update_all('row_order = EXTRACT(EPOCH FROM created_at)')
 
     # Alternatively, implement any other sorting default
-    # Duck.order(created_at: :desc).desc.each do |duck|
+    # Duck.order(created_at: :desc).each do |duck|
     #   duck.update!(row_order: duck.created_at.to_i + duck.age / 2)
     # end
   end

data/gemfiles/rails_6_1.gemfile

@@ -0,0 +1,22 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 6.1.0"
+
+group :sqlite do
+  gem "sqlite3", "~> 1.4", platform: :ruby
+  gem "activerecord-jdbcsqlite3-adapter", "~> 61.0", platform: :jruby
+end
+
+group :postgresql do
+  gem "pg", "~> 1.2.0", platform: :ruby
+  gem "activerecord-jdbcpostgresql-adapter", "~> 61.0", platform: :jruby
+end
+
+group :mysql do
+  gem "mysql2", "~> 0.5.0", platform: :ruby
+  gem "activerecord-jdbcmysql-adapter", "~> 61.0", platform: :jruby
+end
+
+gemspec path: "../"

data/lib/ranked-model/ranker.rb

@@ -1,358 +1,356 @@
-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(ranker.column => value)
-      end
-
-      def reset_ranks!
-        finder.update_all(ranker.column => nil)
-      end
-
-      def position
-        instance.send "#{ranker.name}_position"
-      end
-
-      def relative_rank
-        escaped_column = instance_class.connection.quote_column_name ranker.column
-
-        finder.where("#{escaped_column} < #{rank}").count(:all)
-      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 reset_cache
-        @finder, @current_order, @current_first, @current_last = nil
-      end
-
-      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_average current_first.rank, RankedModel::MIN_RANK_VALUE
-            else
-              position_at :middle
-            end
-          when :last, 'last'
-            if current_last && current_last.rank
-              rank_at_average current_last.rank, RankedModel::MAX_RANK_VALUE
-            else
-              position_at :middle
-            end
-          when :middle, 'middle'
-            rank_at_average RankedModel::MIN_RANK_VALUE, RankedModel::MAX_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_average min, max
-            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_average min, max
-            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_average min, max
-          when NilClass
-            if !rank
-              position_at :last
-            end
-        end
-      end
-
-      def rank_at_average(min, max)
-        if (max - min).between?(-1, 1) # No room at the inn...
-          rebalance_ranks
-          position_at position
-        else
-          rank_at( ( ( max - min ).to_f / 2 ).ceil + min )
-        end
-      end
-
-      def assure_unique_position
-        if ( new_record? || rank_changed? )
-          if (rank > RankedModel::MAX_RANK_VALUE) || rank_taken?
-            rearrange_ranks
-          end
-        end
-      end
-
-      def rearrange_ranks
-        _scope = finder
-        escaped_column = instance_class.connection.quote_column_name ranker.column
-        # If there is room at the bottom of the list and we're added to the very top of the list...
-        if current_first.rank && current_first.rank > RankedModel::MIN_RANK_VALUE && rank == RankedModel::MAX_RANK_VALUE
-          # ...then move everyone else down 1 to make room for us at the end
-          _scope.
-            where( instance_class.arel_table[ranker.column].lteq(rank) ).
-            update_all( "#{escaped_column} = #{escaped_column} - 1" )
-        # If there is room at the top of the list and we're added below the last value in the list...
-        elsif current_last.rank && current_last.rank < (RankedModel::MAX_RANK_VALUE - 1) && rank < current_last.rank
-          # ...then move everyone else at or above our desired rank up 1 to make room for us
-          _scope.
-            where( instance_class.arel_table[ranker.column].gteq(rank) ).
-            update_all( "#{escaped_column} = #{escaped_column} + 1" )
-        # If there is room at the bottom of the list and we're added above the lowest value in the list...
-        elsif current_first.rank && current_first.rank > RankedModel::MIN_RANK_VALUE && rank > current_first.rank
-          # ...then move everyone else below us down 1 and change our rank down 1 to avoid the collission
-          _scope.
-            where( instance_class.arel_table[ranker.column].lt(rank) ).
-            update_all( "#{escaped_column} = #{escaped_column} - 1" )
-          rank_at( rank - 1 )
-        else
-          rebalance_ranks
-        end
-      end
-
-      def rebalance_ranks
-        ActiveRecord::Base.transaction do
-          if rank && instance.persisted?
-            origin = current_order.index { |item| item.instance.id == instance.id }
-            if origin
-              destination = current_order.index { |item| rank <= item.rank }
-              destination -= 1 if origin < destination
-
-              current_order.insert destination, current_order.delete_at(origin)
-            end
-          end
-
-          gaps = current_order.size + 1
-          range = (RankedModel::MAX_RANK_VALUE - RankedModel::MIN_RANK_VALUE).to_f
-          gap_size = (range / gaps).ceil
-
-          reset_ranks!
-
-          current_order.each.with_index(1) do |item, position|
-            new_rank = (gap_size * position) + RankedModel::MIN_RANK_VALUE
-
-            if item.instance.id == instance.id
-              rank_at new_rank
-            else
-              item.update_rank! new_rank
-            end
-          end
-
-          reset_cache
-        end
-      end
-
-      def finder(order = :asc)
-        @finder ||= {}
-        @finder[order] ||= begin
-          _finder = instance_class
-          columns = [instance_class.primary_key.to_sym, ranker.column]
-
-          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.attributes[ranker.with_same.to_s]
-          when Array
-            ranker.with_same.each do |column|
-              columns << column
-              _finder = _finder.where column => instance.attributes[column.to_s]
-            end
-          end
-
-          unless new_record?
-            _finder = _finder.where.not instance_class.primary_key.to_sym => instance.id
-          end
-
-          _finder.reorder(ranker.column.to_sym => order).select(columns)
-        end
-      end
-
-      def current_order
-        @current_order ||= begin
-          finder.unscope(where: instance_class.primary_key.to_sym).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 rank_taken?
-        finder.except(:order).where(ranker.column => rank).exists?
-      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(instance_class.arel_table[ranker.column].gt _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(instance_class.arel_table[ranker.column].lt _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
+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(ranker.column => value)
+      end
+
+      def reset_ranks!
+        finder.update_all(ranker.column => nil)
+      end
+
+      def position
+        instance.send "#{ranker.name}_position"
+      end
+
+      def relative_rank
+        escaped_column = instance_class.connection.quote_column_name ranker.column
+
+        finder.where("#{escaped_column} < #{rank}").count(:all)
+      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 reset_cache
+        @finder, @current_order, @current_first, @current_last = nil
+      end
+
+      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_average current_first.rank, RankedModel::MIN_RANK_VALUE
+            else
+              position_at :middle
+            end
+          when :last, 'last'
+            if current_last && current_last.rank
+              rank_at_average current_last.rank, RankedModel::MAX_RANK_VALUE
+            else
+              position_at :middle
+            end
+          when :middle, 'middle'
+            rank_at_average RankedModel::MIN_RANK_VALUE, RankedModel::MAX_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_average min, max
+            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_average min, max
+            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_average min, max
+          when NilClass
+            if !rank
+              position_at :last
+            end
+        end
+      end
+
+      def rank_at_average(min, max)
+        if (max - min).between?(-1, 1) # No room at the inn...
+          rebalance_ranks
+          position_at position
+        else
+          rank_at( ( ( max - min ).to_f / 2 ).ceil + min )
+        end
+      end
+
+      def assure_unique_position
+        if ( new_record? || rank_changed? )
+          if (rank > RankedModel::MAX_RANK_VALUE) || rank_taken?
+            rearrange_ranks
+          end
+        end
+      end
+
+      def rearrange_ranks
+        _scope = finder
+        escaped_column = instance_class.connection.quote_column_name ranker.column
+        # If there is room at the bottom of the list and we're added to the very top of the list...
+        if current_first.rank && current_first.rank > RankedModel::MIN_RANK_VALUE && rank == RankedModel::MAX_RANK_VALUE
+          # ...then move everyone else down 1 to make room for us at the end
+          _scope.
+            where( instance_class.arel_table[ranker.column].lteq(rank) ).
+            update_all( "#{escaped_column} = #{escaped_column} - 1" )
+        # If there is room at the top of the list and we're added below the last value in the list...
+        elsif current_last.rank && current_last.rank < (RankedModel::MAX_RANK_VALUE - 1) && rank < current_last.rank
+          # ...then move everyone else at or above our desired rank up 1 to make room for us
+          _scope.
+            where( instance_class.arel_table[ranker.column].gteq(rank) ).
+            update_all( "#{escaped_column} = #{escaped_column} + 1" )
+        # If there is room at the bottom of the list and we're added above the lowest value in the list...
+        elsif current_first.rank && current_first.rank > RankedModel::MIN_RANK_VALUE && rank > current_first.rank
+          # ...then move everyone else below us down 1 and change our rank down 1 to avoid the collission
+          _scope.
+            where( instance_class.arel_table[ranker.column].lt(rank) ).
+            update_all( "#{escaped_column} = #{escaped_column} - 1" )
+          rank_at( rank - 1 )
+        else
+          rebalance_ranks
+        end
+      end
+
+      def rebalance_ranks
+        ActiveRecord::Base.transaction do
+          if rank && instance.persisted?
+            origin = current_order.index { |item| item.instance.id == instance.id }
+            if origin
+              destination = current_order.index { |item| rank <= item.rank }
+              destination -= 1 if origin < destination
+
+              current_order.insert destination, current_order.delete_at(origin)
+            end
+          end
+
+          gaps = current_order.size + 1
+          range = (RankedModel::MAX_RANK_VALUE - RankedModel::MIN_RANK_VALUE).to_f
+          gap_size = (range / gaps).ceil
+
+          reset_ranks!
+
+          current_order.each.with_index(1) do |item, position|
+            new_rank = (gap_size * position) + RankedModel::MIN_RANK_VALUE
+
+            if item.instance.id == instance.id
+              rank_at new_rank
+            else
+              item.update_rank! new_rank
+            end
+          end
+
+          reset_cache
+        end
+      end
+
+      def finder(order = :asc)
+        @finder ||= {}
+        @finder[order] ||= begin
+          _finder = instance_class
+          columns = [instance_class.primary_key.to_sym, ranker.column]
+
+          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.attributes[ranker.with_same.to_s]
+          when Array
+            ranker.with_same.each do |column|
+              columns << column
+              _finder = _finder.where column => instance.attributes[column.to_s]
+            end
+          end
+
+          unless new_record?
+            _finder = _finder.where.not instance_class.primary_key.to_sym => instance.id
+          end
+
+          _finder.reorder(ranker.column.to_sym => order).select(columns)
+        end
+      end
+
+      def current_order
+        @current_order ||= begin
+          finder.unscope(where: instance_class.primary_key.to_sym).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.last)
+            RankedModel::Ranker::Mapper.new ranker, ordered_instance
+          end
+        end
+      end
+
+      def rank_taken?
+        finder.except(:order).where(ranker.column => rank).exists?
+      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(instance_class.arel_table[ranker.column].gt _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(instance_class.arel_table[ranker.column].lt _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

@@ -1,3 +1,3 @@
 module RankedModel
-  VERSION = "0.4.7"
+  VERSION = "0.4.8"
 end

data/ranked-model.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rspec-its"
   s.add_development_dependency "mocha"
   s.add_development_dependency "database_cleaner", "~> 1.7.0"
-  s.add_development_dependency "rake", "~> 10.1.0"
+  s.add_development_dependency "rake", ">= 12.3.3"
   s.add_development_dependency "appraisal"
   s.add_development_dependency "pry"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ranked-model
 version: !ruby/object:Gem::Version
-  version: 0.4.7
+  version: 0.4.8
 platform: ruby
 authors:
 - Matthew Beale
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-16 00:00:00.000000000 Z
+date: 2022-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -84,16 +84,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 10.1.0
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 10.1.0
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -143,6 +143,7 @@ files:
 - gemfiles/rails_5_1.gemfile
 - gemfiles/rails_5_2.gemfile
 - gemfiles/rails_6_0.gemfile
+- gemfiles/rails_6_1.gemfile
 - lib/ranked-model.rb
 - lib/ranked-model/railtie.rb
 - lib/ranked-model/ranker.rb
@@ -168,7 +169,7 @@ homepage: https://github.com/mixonic/ranked-model
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -183,8 +184,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.32
+signing_key:
 specification_version: 4
 summary: An acts_as_sortable replacement built for Rails 4.2+
 test_files: