order_query 0.3.3 → 0.5.1

data/lib/order_query/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module OrderQuery
-  VERSION = '0.3.3'
+  VERSION = '0.5.1'
 end

data/spec/gemfiles/rails_5_0.gemfile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'activerecord', '~> 5.0.6'
+gem 'activesupport', '~> 5.0.6'
+
+platforms :mri, :rbx do
+  # https://github.com/rails/rails/blob/v5.0.6/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb#L4
+  gem 'mysql2', '< 0.5'
+
+  # https://github.com/rails/rails/blob/v5.0.6/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L2
+  gem 'pg', '~> 0.18'
+
+  # https://github.com/rails/rails/blob/v5.0.6/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb#L7
+  gem 'sqlite3', '~> 1.3.6'
+end
+
+eval_gemfile '../../shared.gemfile'

data/spec/gemfiles/rails_5_1.gemfile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'activerecord', '~> 5.1.3'
+gem 'activesupport', '~> 5.1.3'
+
+platforms :mri, :rbx do
+  # https://github.com/rails/rails/blob/v5.1.5/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb#L4
+  gem 'mysql2', '< 0.5'
+
+  # https://github.com/rails/rails/blob/v5.1.5/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L2
+  gem 'pg', '>= 0.18', '< 2.0'
+
+  # https://github.com/rails/rails/blob/v5.1.5/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb#L10
+  gem 'sqlite3', '~> 1.3.6'
+end
+
+eval_gemfile '../../shared.gemfile'

data/spec/gemfiles/rails_5_2.gemfile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'activerecord', '~> 5.2.3'
+gem 'activesupport', '~> 5.2.3'
+
+platforms :mri, :rbx do
+  # https://github.com/rails/rails/blob/v5.2.3/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb#L6
+  gem 'mysql2', '>= 0.4.4', '< 0.6.0'
+
+  # https://github.com/rails/rails/blob/v5.2.3/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L4
+  gem 'pg', '>= 0.18', '< 2.0'
+
+  # https://github.com/rails/rails/blob/v5.2.3/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb#L12
+  gem 'sqlite3', '~> 1.3', '>= 1.3.6'
+end
+
+eval_gemfile '../../shared.gemfile'

data/spec/gemfiles/rails_6_0.gemfile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'activerecord', '~> 6.0.3'
+gem 'activesupport', '~> 6.0.3'
+
+platforms :mri, :rbx do
+  # https://github.com/rails/rails/blob/v6.0.0/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb#L13
+  gem 'sqlite3', '~> 1.4'
+
+  # https://github.com/rails/rails/blob/v6.0.0/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L4
+  gem 'pg', '>= 0.18', '< 2.0'
+
+  # https://github.com/rails/rails/blob/v6.0.0/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb#L6
+  gem 'mysql2', '>= 0.4.4'
+end
+
+eval_gemfile '../../shared.gemfile'

data/spec/gemfiles/rails_6_1.gemfile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'activerecord', '~> 6.1.1'
+gem 'activesupport', '~> 6.1.1'
+
+platforms :mri, :rbx do
+  # https://github.com/rails/rails/blob/v6.0.0/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb#L13
+  gem 'sqlite3', '~> 1.4'
+
+  # https://github.com/rails/rails/blob/v6.0.0/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L4
+  gem 'pg', '>= 0.18', '< 2.0'
+
+  # https://github.com/rails/rails/blob/v6.0.0/activerecord/lib/active_record/connection_adapters/mysql2_adapter.rb#L6
+  gem 'mysql2', '>= 0.4.4'
+end
+
+eval_gemfile '../../shared.gemfile'

data/spec/gemfiles/rubocop.gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+eval_gemfile '../../rubocop.gemfile'

data/spec/order_query_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 # Bare model
@@ -10,23 +12,23 @@ class Post < ActiveRecord::Base
   include OrderQuery
   order_query :order_list,
               [:pinned, [true, false]],
-              [:published_at, :desc],
-              [:id, :desc]
+              %i[published_at desc],
+              %i[id desc]
 end
 
 def create_post(attr = {})
-  Post.create!({pinned: false, published_at: Time.now}.merge(attr))
+  Post.create!({ pinned: false, published_at: Time.now }.merge(attr))
 end
 
 # Advanced model
 class Issue < ActiveRecord::Base
   DISPLAY_ORDER = [
-      [:pinned, [true, false]],
-      [:priority, %w(high medium low)],
-      [:valid_votes_count, :desc, sql: '(votes - suspicious_votes)'],
-      [:updated_at, :desc],
-      [:id, :desc]
-  ]
+    [:pinned, [true, false]],
+    [:priority, %w[high medium low]],
+    [:valid_votes_count, :desc, sql: '(votes - suspicious_votes)'],
+    %i[updated_at desc],
+    %i[id desc]
+  ].freeze
 
   def valid_votes_count
     votes - suspicious_votes
@@ -34,11 +36,14 @@ class Issue < ActiveRecord::Base
 
   include OrderQuery
   order_query :display_order, DISPLAY_ORDER
-  order_query :id_order_asc, [[:id, :asc]]
+  order_query :id_order_asc, [%i[id asc]]
 end
 
 def create_issue(attr = {})
-  Issue.create!({priority: 'high', votes: 3, suspicious_votes: 0, updated_at: Time.now}.merge(attr))
+  Issue.create!(
+    { priority: 'high', votes: 3, suspicious_votes: 0, updated_at: Time.now }
+      .merge(attr)
+  )
 end
 
 def wrap_top_level_or(value)
@@ -54,53 +59,84 @@ def wrap_top_level_or(value)
   end
 end
 
-describe 'OrderQuery' do
+RSpec.describe 'OrderQuery' do
+  context 'Column' do
+    it 'fails with ArgumentError if invalid vals_and_or_dir is passed' do
+      expect do
+        OrderQuery::Column.new(Post.all, :pinned, :desc, :extra)
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'Point' do
+    context '#value' do
+      it 'fails if nil on non-nullable column' do
+        post = OpenStruct.new
+        post.pinned = nil
+        space = Post.seek([:pinned])
+        expect do
+          OrderQuery::Point.new(post, space)
+                           .value(space.columns.find { |c| c.name == :pinned })
+        end.to raise_error(OrderQuery::Errors::NonNullableColumnIsNullError)
+      end
+    end
+  end
 
   [false, true].each do |wrap_top_level_or|
     context "(wtlo: #{wrap_top_level_or})" do
       wrap_top_level_or wrap_top_level_or
 
       context 'Issue test model' do
-        t        = Time.now
-        datasets = [
+        datasets = lambda {
+          t = Time.now
+          [
             [
-                ['high', 5, 0, t, true],
-                ['high', 5, 1, t, true],
-                ['high', 5, 0, t],
-                ['high', 5, 0, t - 1.day],
-                ['high', 5, 1, t],
-                ['medium', 10, 0, t],
-                ['medium', 10, 5, t - 12.hours],
-                ['low', 30, 0, t + 1.day]
+              ['high', 5, 0, t, true],
+              ['high', 5, 1, t, true],
+              ['high', 5, 0, t],
+              ['high', 5, 0, t - 1.day],
+              ['high', 5, 1, t],
+              ['medium', 10, 0, t],
+              ['medium', 10, 5, t - 12.hours],
+              ['low', 30, 0, t + 1.day]
             ],
             [
-                ['high', 5, 0, t],
-                ['high', 5, 1, t],
-                ['high', 5, 1, t - 1.day],
-                ['low', 30, 0, t + 1.day]
+              ['high', 5, 0, t],
+              ['high', 5, 1, t],
+              ['high', 5, 1, t - 1.day],
+              ['low', 30, 0, t + 1.day]
             ],
             [
-                ['high', 5, 1, t - 1.day],
-                ['low', 30, 0, t + 1.day]
-            ],
-        ]
+              ['high', 5, 1, t - 1.day],
+              ['low', 30, 0, t + 1.day]
+            ]
+          ]
+        }.call
 
         datasets.each_with_index do |ds, i|
           it "is ordered correctly (test data #{i})" do
             issues = ds.map do |attr|
-              Issue.new(priority: attr[0], votes: attr[1], suspicious_votes: attr[2], updated_at: attr[3], pinned: attr[4] || false)
+              Issue.new(priority: attr[0], votes: attr[1],
+                        suspicious_votes: attr[2], updated_at: attr[3],
+                        pinned: attr[4] || false)
             end
             issues.shuffle.reverse_each(&:save!)
             expect(Issue.display_order.to_a).to eq(issues)
             expect(Issue.display_order_reverse.to_a).to eq(issues.reverse)
-            issues.zip(issues.rotate).each_with_index do |(cur, nxt), i|
-              expect(cur.display_order.position).to eq(i + 1)
+            issues.zip(issues.rotate).each_with_index do |(cur, nxt), j|
+              expect(cur.display_order.position).to eq(j + 1)
               expect(cur.display_order.next).to eq(nxt)
               expect(Issue.display_order_at(cur).next).to eq nxt
               expect(cur.display_order.space.count).to eq(Issue.count)
-              expect(cur.display_order.before.count + 1 + cur.display_order.after.count).to eq(nxt.display_order.count)
+              expect(
+                cur.display_order.before.count + 1 +
+                  cur.display_order.after.count
+              ).to eq(nxt.display_order.count)
               expect(nxt.display_order.previous).to eq(cur)
-              expect(nxt.display_order.before.to_a.reverse + [nxt] + nxt.display_order.after.to_a).to eq(Issue.display_order.to_a)
+              expect(
+                nxt.display_order.before.to_a.reverse + [nxt] +
+                  nxt.display_order.after.to_a
+              ).to eq(Issue.display_order.to_a)
             end
           end
         end
@@ -117,16 +153,20 @@ describe 'OrderQuery' do
           expect(a.id_order_asc.next).to eq b
           expect(b.id_order_asc.previous).to eq a
           expect([a] + a.id_order_asc.after.to_a).to eq(Issue.id_order_asc.to_a)
-          expect(b.id_order_asc.before.reverse.to_a + [b]).to eq(Issue.id_order_asc.to_a)
+          expect(b.id_order_asc.before.reverse.to_a + [b]).to(
+            eq Issue.id_order_asc.to_a
+          )
           expect(Issue.id_order_asc.count).to eq(2)
         end
 
         it '.seek works on a list of ids' do
-          ids = 3.times.map { create_issue.id }
+          ids = Array.new(3) { create_issue.id }
           expect(Issue.seek([[:id, ids]]).count).to eq ids.length
           expect(Issue.seek([:id, ids]).count).to eq ids.length
           expect(Issue.seek([:id, ids]).scope.pluck(:id)).to eq ids
-          expect(Issue.seek([:id, ids]).scope_reverse.pluck(:id)).to eq ids.reverse
+          expect(Issue.seek([:id, ids]).scope_reverse.pluck(:id)).to(
+            eq(ids.reverse)
+          )
         end
 
         context 'partitioned on a boolean flag' do
@@ -136,7 +176,7 @@ describe 'OrderQuery' do
             create_issue(active: true)
           end
 
-          let!(:order) { [[:id, :desc]] }
+          let!(:order) { [%i[id desc]] }
           let!(:active) { Issue.where(active: true).seek(order) }
           let!(:inactive) { Issue.where(active: false).seek(order) }
 
@@ -172,7 +212,38 @@ describe 'OrderQuery' do
         it '#seek falls back to scope when order column is missing self' do
           a = create_issue(priority: 'medium')
           b = create_issue(priority: 'high')
-          expect(a.seek(Issue.display_order, [[:priority, ['wontfix', 'askbob']], [:id, :desc]]).next).to eq(b)
+          expect(
+            a.seek(
+              Issue.display_order,
+              [[:priority, %w[wontfix askbob]], %i[id desc]]
+            ).next
+          ).to eq(b)
+        end
+
+        context 'nil in string enum' do
+          display = ->(issue) { "##{issue.id}-#{issue.priority || 'NULL'}" }
+          priorities = [nil, 'low', 'medium', 'high']
+          let!(:issues) do
+            priorities.flat_map do |p|
+              [create_issue(priority: p), create_issue(priority: p)]
+            end
+          end
+          priorities.permutation do |perm|
+            it "works for #{perm} (desc)" do
+              expect_order(
+                Issue.seek([:priority, perm]),
+                issues.sort_by { |x| [perm.index(x.priority), x.id] },
+                &display
+              )
+            end
+            it "works for #{perm} (asc)" do
+              expect_order(
+                Issue.seek([:priority, perm, :asc]),
+                issues.sort_by { |x| [perm.index(x.priority), -x.id] }.reverse,
+                &display
+              )
+            end
+          end
         end
 
         before do
@@ -217,28 +288,33 @@ describe 'OrderQuery' do
 
         context '#inspect' do
           it 'Column' do
-            expect(OrderQuery::Column.new([:id, :desc], Post).inspect).to eq '(id unique desc)'
-            expect(OrderQuery::Column.new([:virtual, :desc, sql: 'SIN(id)'], Post).inspect).to eq '(virtual SIN(id) desc)'
+            expect(OrderQuery::Column.new(Post, :id, :desc).inspect)
+              .to eq '(id unique desc)'
+            expect(
+              OrderQuery::Column.new(Post, :virtual, :desc, sql: 'SIN(id)')
+                  .inspect
+            ).to eq '(virtual SIN(id) desc)'
           end
 
-          let(:space) {
+          let(:space) do
             OrderQuery::Space.new(Post, [[:pinned, [true, false]]])
-          }
+          end
 
           it 'Point' do
-            post  = create_post
+            post = create_post
             point = OrderQuery::Point.new(post, space)
-            expect(point.inspect).to(
-                eq %Q(#<OrderQuery::Point @record=#<Post id: #{post.id}, pinned: false, published_at: #{post.attribute_for_inspect(:published_at)}> @space=#<OrderQuery::Space @columns=[(pinned [true, false] desc), (id unique asc)] @base_scope=Post(id: integer, pinned: boolean, published_at: datetime)>>)
-            )
+            # rubocop:disable Metrics/LineLength
+            expect(point.inspect).to eq %(#<OrderQuery::Point @record=#<Post id: #{post.id}, title: nil, pinned: false, published_at: #{post.attribute_for_inspect(:published_at)}> @space=#<OrderQuery::Space @columns=[(pinned [true, false] desc), (id unique asc)] @base_scope=Post(id: integer, title: string, pinned: boolean, published_at: datetime)>>)
+            # rubocop:enable Metrics/LineLength
           end
 
           it 'Space' do
-            expect(space.inspect).to eq '#<OrderQuery::Space @columns=[(pinned [true, false] desc), (id unique asc)] @base_scope=Post(id: integer, pinned: boolean, published_at: datetime)>'
+            # rubocop:disable Metrics/LineLength
+            expect(space.inspect).to eq '#<OrderQuery::Space @columns=[(pinned [true, false] desc), (id unique asc)] @base_scope=Post(id: integer, title: string, pinned: boolean, published_at: datetime)>'
+            # rubocop:enable Metrics/LineLength
           end
         end
 
-
         context 'boolean enum order' do
           before do
             create_post pinned: true
@@ -248,29 +324,141 @@ describe 'OrderQuery' do
             Post.delete_all
           end
           it 'ORDER BY is collapsed' do
-            expect(Post.seek([:pinned, [true, false]]).scope.to_sql).to include('ORDER BY "posts"."pinned" DESC')
+            expect(Post.seek([:pinned, [true, false]]).scope.to_sql).to(
+              match(/ORDER BY .posts.\..pinned. DESC/)
+            )
           end
           it 'enum asc' do
-            expect(Post.seek([:pinned, [false, true], :asc]).scope.pluck(:pinned)).to eq([true, false])
-            expect(Post.seek([:pinned, [true, false], :asc]).scope.pluck(:pinned)).to eq([false, true])
+            expect(
+              Post.seek([:pinned, [false, true], :asc]).scope.pluck(:pinned)
+            ).to eq([true, false])
+            expect(
+              Post.seek([:pinned, [true, false], :asc]).scope.pluck(:pinned)
+            ).to eq([false, true])
           end
           it 'enum desc' do
-            expect(Post.seek([:pinned, [false, true], :desc]).scope.pluck(:pinned)).to eq([false, true])
-            expect(Post.seek([:pinned, [true, false], :desc]).scope.pluck(:pinned)).to eq([true, false])
+            expect(
+              Post.seek([:pinned, [false, true], :desc]).scope.pluck(:pinned)
+            ).to eq([false, true])
+            expect(
+              Post.seek([:pinned, [true, false], :desc]).scope.pluck(:pinned)
+            ).to eq([true, false])
           end
         end
 
-        xcontext 'nil in enum' do
+        context 'nil in boolean enum' do
+          display = ->(post) { "##{post.id}-#{post.pinned || 'NULL'}" }
           states = [nil, false, true]
-          let!(:posts) { states.map { |state| create_post(pinned: state) } }
-          states.permutation do |p|
-            # There is no cross-DB SQL that can be generated to position nil results
-            # http://use-the-index-luke.com/sql/sorting-grouping/order-by-asc-desc-nulls-last
-            next unless p.first.nil? || p.last.nil?
-            # Positioning NULLs first or last can be achieved, but remains on the ToDo / contributions welcome list
-            it "nil in enum works for #{p}" do
-              expect(Post.seek([:pinned, p]).scope.all.map(&:pinned)).to eq(p)
-              expect(Post.seek([:pinned, p, :asc]).scope.all.map(&:pinned)).to eq(p.reverse)
+          let!(:posts) do
+            states.flat_map do |state|
+              [create_post(pinned: state), create_post(pinned: state)]
+            end
+          end
+          states.permutation do |perm|
+            it "works for #{perm} (desc)" do
+              expect_order(
+                Post.seek([:pinned, perm]),
+                posts.sort_by { |x| [perm.index(x.pinned), x.id] },
+                &display
+              )
+            end
+            it "works for #{perm} (asc)" do
+              expect_order(
+                Post.seek([:pinned, perm, :asc]),
+                posts.sort_by { |x| [-perm.index(x.pinned), x.id] },
+                &display
+              )
+            end
+          end
+        end
+
+        context 'nil published_at' do
+          display = ->(post) { post.title }
+
+          let! :null_1 do
+            Post.create!(title: 'null_1', published_at: nil).reload
+          end
+          let! :null_2 do
+            Post.create!(title: 'null_2', published_at: nil).reload
+          end
+          let! :older do
+            Post.create!(title: 'older', published_at: Time.now + 1.hour)
+          end
+          let! :newer do
+            Post.create!(title: 'newer', published_at: Time.now - 1.hour)
+          end
+
+          it 'orders nulls first (desc)' do
+            space = Post.seek([:published_at, :desc, nulls: :first])
+            expect_order space, [null_1, null_2, older, newer], &display
+          end
+
+          it 'orders nulls first (asc)' do
+            space = Post.seek([:published_at, :asc, nulls: :first])
+            expect_order space, [null_1, null_2, newer, older], &display
+          end
+
+          it 'orders nulls last (desc)' do
+            space = Post.seek([:published_at, :desc, nulls: :last])
+            expect_order space, [older, newer, null_1, null_2], &display
+          end
+
+          it 'orders nulls last (asc)' do
+            space = Post.seek([:published_at, :asc, nulls: :last])
+            expect_order space, [newer, older, null_1, null_2], &display
+          end
+        end
+
+        context 'after/before no strict' do
+          context 'by middle attribute in search order' do
+            let! :base do
+              Post.create! pinned: true, published_at: Time.now
+            end
+            let! :older do
+              Post.create! pinned: true, published_at: Time.now + 1.hour
+            end
+            let! :newer do
+              Post.create! pinned: true, published_at: Time.now - 1.hour
+            end
+
+            it 'includes first element' do
+              point = Post.order_list_at(base)
+
+              expect(point.after.count).to eq 1
+              expect(point.after.to_a).to eq [newer]
+
+              expect(point.after(false).count).to eq 2
+              expect(point.after(false).to_a).to eq [base, newer]
+              expect(point.before(false).to_a).to eq [base, older]
+            end
+          end
+
+          context 'by last attribute in search order' do
+            let!(:base) do
+              Post.create! pinned: true,
+                           published_at: Time.new(2016, 5, 1, 5, 4, 3),
+                           id: 6
+            end
+            let!(:previous) do
+              Post.create! pinned: true,
+                           published_at: Time.new(2016, 5, 1, 5, 4, 3),
+                           id: 4
+            end
+            let!(:next_one) do
+              Post.create! pinned: true,
+                           published_at: Time.new(2016, 5, 1, 5, 4, 3),
+                           id: 9
+            end
+
+            it 'includes first element' do
+              point = Post.order_list_at(base)
+
+              expect(point.after.count).to eq 1
+              expect(point.after.to_a).to eq [previous]
+
+              expect(point.after(false).count).to eq 2
+              expect(point.after(false).to_a).to eq [base, previous]
+              expect(point.before(false).to_a).to eq [base, next_one]
             end
           end
         end
@@ -282,10 +470,12 @@ describe 'OrderQuery' do
           ActiveRecord::Schema.define do
             self.verbose = false
             create_table :posts do |t|
+              t.string :title
               t.boolean :pinned
               t.datetime :published_at
             end
           end
+          Post.reset_column_information
         end
         after :all do
           ActiveRecord::Migration.drop_table :posts
@@ -298,7 +488,8 @@ describe 'OrderQuery' do
     context 'wrap top-level OR on' do
       wrap_top_level_or true
       it 'wraps top-level OR' do
-        after_scope = User.create!(updated_at: Date.parse('2014-09-06')).seek([[:updated_at, :desc], [:id, :desc]]).after
+        after_scope = User.create!(updated_at: Date.parse('2014-09-06'))
+                          .seek([%i[updated_at desc], %i[id desc]]).after
         expect(after_scope.to_sql).to include('<=')
       end
     end
@@ -306,7 +497,8 @@ describe 'OrderQuery' do
     context 'wrap top-level OR off' do
       wrap_top_level_or false
       it 'does not wrap top-level OR' do
-        after_scope = User.create!(updated_at: Date.parse('2014-09-06')).seek([[:updated_at, :desc], [:id, :desc]]).after
+        after_scope = User.create!(updated_at: Date.parse('2014-09-06'))
+                          .seek([%i[updated_at desc], %i[id desc]]).after
         expect(after_scope.to_sql).to_not include('<=')
       end
     end
@@ -322,6 +514,7 @@ describe 'OrderQuery' do
           t.datetime :updated_at, null: false
         end
       end
+      User.reset_column_information
     end
 
     after :all do