ranked-model 0.4.8 → 0.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '004680e8b292451d304375f3ae01d0100702db74867d93b2a713e7c908241d78'
-  data.tar.gz: cc831e2837ba8ad07c21f6b890959e071005824a4f53bd51c135c8055fb1904f
+  metadata.gz: 61451e859060c7d8a3f889bd54327b103797d728312cedef66efa1b25d11767f
+  data.tar.gz: 2e1df0f514decf2e43667c2d0139e510202fc0ebc32aed758831ea20497aaf1a
 SHA512:
-  metadata.gz: d4494e9eede725ef30ecbd05006a4d91deb89f62aced56b96fa3be2f0f5732f41336d5a3d1c450e3f5d2c0f1821a15de096a1ee68732d8cb5d10a300008270ca
-  data.tar.gz: 04fa0d21ff8b2c6533ebc6705cc00c7258bd955c88a91636995d362136de9cf2a57c6e8ca49c43e112757e1209dc9a9fe3c2285b2bfde47639bcab90d2368fd4
+  metadata.gz: d046ed8e55533b8f453a67e0c705738e9353b22b20b01310381a56195803ee066cd647e1b8801484ca79518a8ea2394577841d4b9c4eb97d12f0b36246c1bfc7
+  data.tar.gz: ca05b38d74cbe11544cabb70890c64d26c9a94c4608d2b4d7da1253535efc03775ef3fed80fc9b93709f503f3f53a8cd725b7f2b8c43ad8565a72139f0ec53e5

data/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [brendon]

data/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

data/.github/workflows/ci.yml

@@ -0,0 +1,90 @@
+---
+name: CI
+on: [push, pull_request]
+
+jobs:
+  tests:
+    name: Ruby ${{ matrix.ruby }}, ${{ matrix.gemfile }}, DB ${{ matrix.db }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - 2.4
+          - 2.5
+          - 2.6
+          - 2.7
+          - '3.0'
+          - 3.1
+        gemfile:
+          - gemfiles/rails_5_2.gemfile
+          - gemfiles/rails_6_0.gemfile
+          - gemfiles/rails_6_1.gemfile
+          - gemfiles/rails_7_0.gemfile
+        db:
+          - sqlite
+          - mysql
+          - postgresql
+        exclude:
+          - ruby: 2.4
+            gemfile: gemfiles/rails_6_0.gemfile
+          - ruby: 2.4
+            gemfile: gemfiles/rails_6_1.gemfile
+          - ruby: 2.4
+            gemfile: gemfiles/rails_7_0.gemfile
+          - ruby: 2.5
+            gemfile: gemfiles/rails_7_0.gemfile
+          - ruby: 2.6
+            gemfile: gemfiles/rails_7_0.gemfile
+          - ruby: '3.0'
+            gemfile: gemfiles/rails_5_2.gemfile
+          - ruby: 3.1
+            gemfile: gemfiles/rails_5_2.gemfile
+          - ruby: 3.1
+            gemfile: gemfiles/rails_6_0.gemfile
+        os:
+          - ubuntu-latest
+    services:
+      mysql:
+        image: mysql:5.7
+        env:
+            MYSQL_ALLOW_EMPTY_PASSWORD: yes
+        ports:
+            - 3306:3306
+        options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
+
+      postgres:
+        # Docker Hub image
+        image: postgres
+        # Provide the password for postgres
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_HOST_AUTH_METHOD: trust
+        ports:
+          - 5432:5432
+        # Set health checks to wait until postgres has started
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    env:
+      BUNDLE_GEMFILE: ${{ matrix.gemfile }}
+      DB: ${{ matrix.db }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: "Create MySQL database"
+        if: ${{ env.DB == 'mysql' }}
+        run: |
+          mysql -h 127.0.0.1 -u root -e 'create database ranked_model_test;'
+      - name: "Create PostgreSQL database"
+        if: ${{ env.DB == 'postgresql' }}
+        run: |
+          psql -c 'create database ranked_model_test;' -h localhost -U postgres
+      - name: Run tests
+        run: bundle exec rake

data/.gitignore

@@ -2,6 +2,7 @@ pkg/*
 *.gem
 .bundle
 *.un~
+*.swp
 
 Gemfile.lock
 *.gemfile.lock

data/Appraisals

@@ -1,48 +1,3 @@
-appraise "rails-4-2" do
-  group :sqlite do
-    gem "activerecord-jdbcsqlite3-adapter", "~> 1.3.24", platform: :jruby
-  end
-  group :mysql do
-    gem "mysql2", "~> 0.4.0", platform: :ruby
-    gem "jdbc-mysql", "~> 5.1.47", platform: :jruby
-    gem "activerecord-jdbcmysql-adapter", "~> 1.3.24", platform: :jruby
-  end
-  group :postgresql do
-    gem "pg", "~> 0.18.4", platform: :ruby
-    gem "activerecord-jdbcpostgresql-adapter", "~> 1.3.24", platform: :jruby
-  end
-
-  gem "activerecord", "~> 4.2.0"
-end
-
-appraise "rails-5-0" do
-  group :sqlite do
-    gem "activerecord-jdbcsqlite3-adapter", "~> 50.0", platform: :jruby
-  end
-  group :mysql do
-    gem "activerecord-jdbcmysql-adapter", "~> 50.0", platform: :jruby
-  end
-  group :postgresql do
-    gem "activerecord-jdbcpostgresql-adapter", "~> 50.0", platform: :jruby
-  end
-
-  gem "activerecord", "~> 5.0.0"
-end
-
-appraise "rails-5-1" do
-  group :sqlite do
-    gem "activerecord-jdbcsqlite3-adapter", "~> 51.0", platform: :jruby
-  end
-  group :mysql do
-    gem "activerecord-jdbcmysql-adapter", "~> 51.0", platform: :jruby
-  end
-  group :postgresql do
-    gem "activerecord-jdbcpostgresql-adapter", "~> 51.0", platform: :jruby
-  end
-
-  gem "activerecord", "~> 5.1.0"
-end
-
 appraise "rails-5-2" do
   group :sqlite do
     gem "activerecord-jdbcsqlite3-adapter", "~> 52.0", platform: :jruby
@@ -84,3 +39,17 @@ appraise "rails-6-1" do
   end
   gem "activerecord", "~> 6.1.0"
 end
+
+appraise "rails-7-0" 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", "~> 7.0.0"
+end

data/Readme.mkd

@@ -136,6 +136,37 @@ Pond.first.ducks.rank(:swimming_order)
 Duck.walking.rank(:walking)
 ```
 
+Drawbacks
+---------
+
+While ranked-model is performant when storing data, it might cause N+1s depending on how you write your code. Consider this snippet:
+
+```ruby
+ducks = Duck.all
+ducks.map do |duck|
+  {
+    id: duck.id,
+    position: duck.row_order_rank # This causes N+1!
+  }
+end
+```
+
+Every call to `duck.row_order_rank` will make a call to the DB to check the rank of that 
+particular element. If you have a long list of elements this might cause issues to your DB.
+
+In order to avoid that, you can use the `rank(:your_rank)` scope and some Ruby code to get
+the element's position:
+
+```ruby
+ducks = Duck.rank(:row_order).all
+ducks.map.with_index do |duck, index|
+  {
+    id: duck.id,
+    position: index
+  }
+end
+```
+
 Single Table Inheritance (STI)
 ------------------------------
 

data/gemfiles/rails_5_2.gemfile

@@ -5,17 +5,17 @@ source "https://rubygems.org"
 gem "activerecord", "~> 5.2.0"
 
 group :sqlite do
-  gem "sqlite3", "~> 1.3.13", platform: :ruby
+  gem "sqlite3", platform: :ruby
   gem "activerecord-jdbcsqlite3-adapter", "~> 52.0", platform: :jruby
 end
 
 group :postgresql do
-  gem "pg", "~> 1.2.0", platform: :ruby
+  gem "pg", platform: :ruby
   gem "activerecord-jdbcpostgresql-adapter", "~> 52.0", platform: :jruby
 end
 
 group :mysql do
-  gem "mysql2", "~> 0.5.0", platform: :ruby
+  gem "mysql2", platform: :ruby
   gem "activerecord-jdbcmysql-adapter", "~> 52.0", platform: :jruby
 end
 

data/gemfiles/rails_6_0.gemfile

@@ -10,12 +10,12 @@ group :sqlite do
 end
 
 group :postgresql do
-  gem "pg", "~> 1.2.0", platform: :ruby
+  gem "pg", platform: :ruby
   gem "activerecord-jdbcpostgresql-adapter", "~> 60.0", platform: :jruby
 end
 
 group :mysql do
-  gem "mysql2", "~> 0.5.0", platform: :ruby
+  gem "mysql2", platform: :ruby
   gem "activerecord-jdbcmysql-adapter", "~> 60.0", platform: :jruby
 end
 

data/gemfiles/rails_6_1.gemfile

@@ -10,12 +10,12 @@ group :sqlite do
 end
 
 group :postgresql do
-  gem "pg", "~> 1.2.0", platform: :ruby
+  gem "pg", platform: :ruby
   gem "activerecord-jdbcpostgresql-adapter", "~> 61.0", platform: :jruby
 end
 
 group :mysql do
-  gem "mysql2", "~> 0.5.0", platform: :ruby
+  gem "mysql2", platform: :ruby
   gem "activerecord-jdbcmysql-adapter", "~> 61.0", platform: :jruby
 end
 

data/gemfiles/rails_7_0.gemfile

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

data/lib/ranked-model/ranker.rb

@@ -1,356 +1,357 @@
-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
+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
+        instance.send "#{ranker.name}_position=", relative_rank unless position.is_a?(Integer)
+      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
+              instance.send "#{ranker.column}=", 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.8"
+  VERSION = "0.4.9"
 end

data/ranked-model.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   s.description = %q{ranked-model is a modern row sorting library built for Rails 4.2+. It uses ARel aggressively and is better optimized than most other libraries.}
   s.license     = 'MIT'
 
-  s.add_dependency "activerecord", ">= 4.2"
+  s.add_dependency "activerecord", ">= 5.2"
   s.add_development_dependency "rspec", "~> 3"
   s.add_development_dependency "rspec-its"
   s.add_development_dependency "mocha"

data/spec/duck-model/inferred_ducks_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper"
+
+describe Duck do
+  before do
+    5.times do |i|
+      Duck.create(name: "Duck #{i + 1}")
+    end
+  end
+
+  describe "updating a duck order with last" do
+    it "should maintain the order after creating a new duck" do
+      duck = Duck.first
+      duck.update(row_position: :last)
+      expect(duck.row_rank).to eq(4)
+
+      Duck.create(name: "Wacky")
+
+      expect(duck.row_rank).to eq(4)
+
+      duck.update(pond: 'Shin')
+      expect(duck.row_rank).to eq(4)
+    end
+  end
+
+  describe "updating a duck order with first" do
+    it "should maintain the order after creating a new duck" do
+      duck = Duck.last
+      duck.update(row_position: :first)
+      expect(duck.row_rank).to eq(0)
+
+      Duck.create(name: "Wacky")
+
+      expect(duck.row_rank).to eq(0)
+
+      duck.update(pond: 'Shin')
+      expect(duck.row_rank).to eq(0)
+    end
+  end
+
+  describe "updating a duck order with up" do
+    it "should maintain the order after creating a new duck" do
+      duck_id = Duck.ranker(:row).with(Duck.new).current_at_position(2).instance.id
+      duck = Duck.find(duck_id)
+      duck.update(row_position: :up)
+      expect(duck.row_rank).to eq(1)
+
+      Duck.create(name: "Wacky")
+
+      expect(duck.row_rank).to eq(1)
+
+      duck.update(pond: 'Shin')
+      expect(duck.row_rank).to eq(1)
+    end
+  end
+
+  describe "updating a duck order with down" do
+    it "should maintain the order after creating a new duck" do
+      duck_id = Duck.ranker(:row).with(Duck.new).current_at_position(2).instance.id
+      duck = Duck.find(duck_id)
+      duck.update(row_position: :down)
+      expect(duck.row_rank).to eq(3)
+
+      Duck.create(name: "Wacky")
+
+      expect(duck.row_rank).to eq(3)
+
+      duck.update(pond: 'Shin')
+      expect(duck.row_rank).to eq(3)
+    end
+  end
+end

data/spec/support/database.yml

@@ -6,6 +6,7 @@ sqlite:
 
 mysql:
   adapter: mysql2
+  host: 127.0.0.1
   database: ranked_model_test
   pool: 5
   timeout: 5000
@@ -14,6 +15,7 @@ mysql:
 
 postgresql:
   adapter: postgresql
+  host: 127.0.0.1
   database: ranked_model_test
   pool: 5
   timeout: 5000

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ranked-model
 version: !ruby/object:Gem::Version
-  version: 0.4.8
+  version: 0.4.9
 platform: ruby
 authors:
 - Matthew Beale
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-07 00:00:00.000000000 Z
+date: 2023-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -130,6 +130,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/FUNDING.yml"
+- ".github/dependabot.yml"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -138,12 +141,10 @@ files:
 - LICENSE
 - Rakefile
 - Readme.mkd
-- gemfiles/rails_4_2.gemfile
-- gemfiles/rails_5_0.gemfile
-- gemfiles/rails_5_1.gemfile
 - gemfiles/rails_5_2.gemfile
 - gemfiles/rails_6_0.gemfile
 - gemfiles/rails_6_1.gemfile
+- gemfiles/rails_7_0.gemfile
 - lib/ranked-model.rb
 - lib/ranked-model/railtie.rb
 - lib/ranked-model/ranker.rb
@@ -152,6 +153,7 @@ files:
 - ranked-model.gemspec
 - spec/duck-model/column_default_ducks_spec.rb
 - spec/duck-model/duck_spec.rb
+- spec/duck-model/inferred_ducks_spec.rb
 - spec/duck-model/lots_of_ducks_spec.rb
 - spec/duck-model/wrong_ducks_spec.rb
 - spec/ego-model/ego_spec.rb
@@ -191,6 +193,7 @@ summary: An acts_as_sortable replacement built for Rails 4.2+
 test_files:
 - spec/duck-model/column_default_ducks_spec.rb
 - spec/duck-model/duck_spec.rb
+- spec/duck-model/inferred_ducks_spec.rb
 - spec/duck-model/lots_of_ducks_spec.rb
 - spec/duck-model/wrong_ducks_spec.rb
 - spec/ego-model/ego_spec.rb

data/gemfiles/rails_4_2.gemfile

@@ -1,23 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "activerecord", "~> 4.2.0"
-
-group :sqlite do
-  gem "sqlite3", "~> 1.3.13", platform: :ruby
-  gem "activerecord-jdbcsqlite3-adapter", "~> 1.3.24", platform: :jruby
-end
-
-group :postgresql do
-  gem "pg", "~> 0.18.4", platform: :ruby
-  gem "activerecord-jdbcpostgresql-adapter", "~> 1.3.24", platform: :jruby
-end
-
-group :mysql do
-  gem "mysql2", "~> 0.4.0", platform: :ruby
-  gem "jdbc-mysql", "~> 5.1.47", platform: :jruby
-  gem "activerecord-jdbcmysql-adapter", "~> 1.3.24", platform: :jruby
-end
-
-gemspec path: "../"

data/gemfiles/rails_5_0.gemfile

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

data/gemfiles/rails_5_1.gemfile

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