order_query 0.3.4 → 0.4.0

data/lib/order_query/space.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'order_query/column'
 require 'order_query/sql/order_by'
 module OrderQuery
@@ -8,14 +10,19 @@ module OrderQuery
     delegate :count, :empty?, to: :@base_scope
 
     # @param [ActiveRecord::Relation] base_scope
-    # @param [Array<Array<Symbol,String>>, OrderQuery::Spec] order_spec
+    # @param [Array<Array<Symbol,String>>] order_spec
+    # @see Column#initialize for the order_spec element format.
     def initialize(base_scope, order_spec)
-      @base_scope   = base_scope
-      @columns   = order_spec.map { |cond_spec| Column.new(cond_spec, base_scope) }
+      @base_scope = base_scope
+      @columns = order_spec.map do |cond_spec|
+        Column.new(base_scope, *cond_spec)
+      end
       # add primary key if columns are not unique
       unless @columns.last.unique?
-        raise ArgumentError.new('Unique column must be last') if @columns.detect(&:unique?)
-        @columns << Column.new([base_scope.primary_key], base_scope)
+        if @columns.detect(&:unique?)
+          fail ArgumentError, 'Unique column must be last'
+        end
+        @columns << Column.new(base_scope, base_scope.primary_key)
       end
       @order_by_sql = SQL::OrderBy.new(@columns)
     end
@@ -27,12 +34,13 @@ module OrderQuery
 
     # @return [ActiveRecord::Relation] scope ordered by columns
     def scope
-      @scope ||= @base_scope.order(@order_by_sql.build)
+      @scope ||= @base_scope.order(Arel.sql(@order_by_sql.build))
     end
 
     # @return [ActiveRecord::Relation] scope ordered by columns in reverse
     def scope_reverse
-      @scope_reverse ||= @base_scope.order(@order_by_sql.build_reverse)
+      @scope_reverse ||= @base_scope
+                         .order(Arel.sql(@order_by_sql.build_reverse))
     end
 
     # @return [ActiveRecord::Base]
@@ -46,7 +54,8 @@ module OrderQuery
     end
 
     def inspect
-      "#<OrderQuery::Space @columns=#{@columns.inspect} @base_scope=#{@base_scope.inspect}>"
+      "#<OrderQuery::Space @columns=#{@columns.inspect} "\
+      "@base_scope=#{@base_scope.inspect}>"
     end
   end
 end

data/lib/order_query/sql/column.rb

@@ -1,20 +1,24 @@
+# frozen_string_literal: true
+
 module OrderQuery
   module SQL
+    # A column in the given scope.
     class Column
-      attr_reader :column, :scope
+      attr_reader :scope, :column
 
-      def initialize(column, scope)
-        @column = column
+      def initialize(scope, column)
         @scope = scope
+        @column = column
       end
 
       def column_name
         @column_name ||= begin
-          sql = column.options[:sql]
+          sql = column.custom_sql
           if sql
             sql.respond_to?(:call) ? sql.call : sql
           else
-            connection.quote_table_name(scope.table_name) + '.' + connection.quote_column_name(column.name)
+            "#{connection.quote_table_name(scope.table_name)}."\
+            "#{connection.quote_column_name(column.name)}"
           end
         end
       end

data/lib/order_query/sql/order_by.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 module OrderQuery
   module SQL
+    # Constructs SQL for ORDER BY.
     class OrderBy
       # @param [Array<Column>]
       def initialize(columns)
@@ -31,23 +34,63 @@ module OrderQuery
         end
       end
 
-      def column_clause_ray(col, reverse = false)
-        "#{col.column_name} #{sort_direction_sql(col, reverse)}".freeze
+      def column_clause_ray(col, reverse = false,
+                            with_null_clause = needs_null_sort?(col, reverse))
+        clauses = []
+        # TODO: use NULLS FIRST/LAST where supported.
+        clauses << order_by_nulls_sql(col, reverse) if with_null_clause
+        clauses << "#{col.column_name} #{sort_direction_sql(col, reverse)}"
+        clauses.join(', ').freeze
       end
 
+      # rubocop:disable Metrics/AbcSize
+
       def column_clause_enum(col, reverse = false)
-        enum = col.order_enum
-        # Collapse boolean enum to `ORDER BY column ASC|DESC`
-        if enum == [false, true] || enum == [true, false]
-          return column_clause_ray col, reverse ^ enum.last
+        # Collapse booleans enum to `ORDER BY column ASC|DESC`
+        return optimize_enum_bools(col, reverse) if optimize_enum_bools?(col)
+        if optimize_enum_bools_nil?(col)
+          return optimize_enum_bools_nil(col, reverse)
         end
-        enum.map { |v|
-          "#{order_by_value_sql col, v} #{sort_direction_sql(col, reverse)}"
-        }.join(', ').freeze
+        clauses = []
+        with_nulls = false
+        if col.order_enum.include?(nil)
+          with_nulls = true
+        elsif needs_null_sort?(col, reverse)
+          clauses << order_by_nulls_sql(col, reverse)
+        end
+        clauses.concat(col.order_enum.map do |v|
+          "#{order_by_value_sql col, v, with_nulls} " \
+            "#{sort_direction_sql(col, reverse)}"
+        end)
+        clauses.join(', ').freeze
       end
+      # rubocop:enable Metrics/AbcSize
 
-      def order_by_value_sql(col, v)
-        "#{col.column_name}=#{col.quote v}"
+      def needs_null_sort?(col, reverse,
+                           nulls_direction = col.nulls_direction(reverse))
+        return false unless col.nullable?
+        nulls_direction != col.default_nulls_direction(reverse)
+      end
+
+      def order_by_nulls_sql(col, reverse)
+        if col.default_nulls_direction !=
+           (col.direction == :asc ? :first : :last)
+          reverse = !reverse
+        end
+        "#{col.column_name} IS NULL #{sort_direction_sql(col, reverse)}"
+      end
+
+      def order_by_value_sql(col, v, with_nulls = false)
+        if with_nulls
+          if v.nil?
+            "#{col.column_name} IS NULL"
+          else
+            "#{col.column_name} IS NOT NULL AND " \
+               "#{col.column_name}=#{col.quote v}"
+          end
+        else
+          "#{col.column_name}=#{col.quote v}"
+        end
       end
 
       # @return [String]
@@ -59,6 +102,35 @@ module OrderQuery
       def join_order_by_clauses(clauses)
         clauses.join(', ').freeze
       end
+
+      private
+
+      def optimize_enum_bools?(col)
+        col.order_enum == [false, true] || col.order_enum == [true, false]
+      end
+
+      def optimize_enum_bools(col, reverse)
+        column_clause_ray(col, col.order_enum[-1] ^ reverse)
+      end
+
+      ENUM_SET_TRUE_FALSE_NIL = Set[false, true, nil]
+
+      def optimize_enum_bools_nil?(col)
+        Set.new(col.order_enum) == ENUM_SET_TRUE_FALSE_NIL &&
+          !col.order_enum[1].nil?
+      end
+
+      def optimize_enum_bools_nil(col, reverse)
+        last_bool_true = if col.order_enum[-1].nil?
+                           col.order_enum[-2]
+                         else
+                           col.order_enum[-1]
+                         end
+        reverse_override = last_bool_true ^ reverse
+        with_nulls_sort =
+          needs_null_sort?(col, reverse_override, col.nulls_direction(reverse))
+        column_clause_ray(col, reverse_override, with_nulls_sort)
+      end
     end
   end
 end

data/lib/order_query/sql/where.rb

@@ -1,7 +1,8 @@
-# coding: utf-8
+# frozen_string_literal: true
+
 module OrderQuery
   module SQL
-    # Build where clause for searching around a record in an order space
+    # Builds where clause for searching around a record in an order space.
     class Where
       attr_reader :point
 
@@ -13,7 +14,9 @@ module OrderQuery
 
       # Join column pairs with OR, and nest within each other with AND
       # @param [:before or :after] side
-      # @return [query, parameters] WHERE columns matching records strictly before / after this one
+      # @return [query, parameters] WHERE columns matching records strictly
+      #   before / after this one.
+      #
       #   sales < 5 OR
       #   sales = 5 AND (
       #     invoice < 3 OR
@@ -21,12 +24,14 @@ module OrderQuery
       #       ... ))
       def build(side, strict = true)
         # generate pairs of terms such as sales < 5, sales = 5
-        terms = @columns.map.with_index { |col, i|
-          be_strict = (i != @columns.size - 1) ? true : strict
-          [where_side(col, side, be_strict), where_tie(col)].reject { |x| x == WHERE_IDENTITY }
-        }
+        terms = @columns.map.with_index do |col, i|
+          be_strict = i != @columns.size - 1 ? true : strict
+          [where_side(col, side, be_strict), where_tie(col)].reject do |x|
+            x == WHERE_IDENTITY
+          end
+        end
         # group pairwise with OR, and nest with AND
-        query = foldr_terms terms.map { |pair| join_terms 'OR'.freeze, *pair }, 'AND'.freeze
+        query = foldr_terms terms.map { |pair| join_terms 'OR', *pair }, 'AND'
         if ::OrderQuery.wrap_top_level_or
           # wrap in a redundant AND clause for performance
           query = wrap_top_level_or query, terms, side
@@ -48,7 +53,8 @@ module OrderQuery
       # joins terms with an operator, empty terms are skipped
       # @return [query, parameters]
       def join_terms(op, *terms)
-        [terms.map(&:first).reject(&:empty?).join(" #{op} "), terms.map(&:second).reduce([], :+)]
+        [terms.map(&:first).reject(&:empty?).join(" #{op} "),
+         terms.map(&:second).reduce([], :+)]
       end
 
       def wrap_term_with_parens(t)
@@ -66,8 +72,11 @@ module OrderQuery
       # Read more at https://github.com/glebm/order_query/issues/3
       def wrap_top_level_or(query, terms, side)
         top_term_i = terms.index(&:present?)
-        if top_term_i && terms[top_term_i].length == 2 && !(col = @columns[top_term_i]).order_enum
-          join_terms 'AND'.freeze, where_side(col, side, false), wrap_term_with_parens(query)
+        if top_term_i && terms[top_term_i].length == 2 &&
+           !(col = @columns[top_term_i]).order_enum
+          join_terms 'AND',
+                     where_side(col, side, false),
+                     wrap_term_with_parens(query)
         else
           query
         end
@@ -83,7 +92,8 @@ module OrderQuery
       end
 
       # @param [:before or :after] side
-      # @return [query, params] return query fragment for column values before / after the current one
+      # @return [query, params] return query fragment for column values
+      #   before / after the current one.
       def where_side(col, side, strict = true, value = point.value(col))
         if col.order_enum
           where_in col, col.enum_side(value, side, strict)
@@ -93,26 +103,49 @@ module OrderQuery
       end
 
       def where_in(col, values)
-        case values.length
-          when 0
-            WHERE_IDENTITY
-          when 1
-            where_eq col, values[0]
-          else
-            ["#{col.column_name} IN (?)".freeze, [values]]
-        end
+        join_terms 'OR',
+                   (values.include?(nil) ? where_eq(col, nil) : WHERE_IDENTITY),
+                   case (non_nil_values = values - [nil]).length
+                   when 0
+                     WHERE_IDENTITY
+                   when 1
+                     where_eq col, non_nil_values
+                   else
+                     ["#{col.column_name} IN (?)", [non_nil_values]]
+                   end
       end
 
       def where_eq(col, value = point.value(col))
-        [%Q(#{col.column_name} = ?).freeze, [value]]
+        if value.nil?
+          ["#{col.column_name} IS NULL", []]
+        else
+          ["#{col.column_name} = ?", [value]]
+        end
       end
 
-      RAY_OP = {asc: '>'.freeze, desc: '<'.freeze}.freeze
+      RAY_OP = { asc: '>', desc: '<' }.freeze
+      NULLS_ORD = { first: 'IS NOT NULL', last: 'IS NULL' }.freeze
+
+      # rubocop:disable Metrics/AbcSize
+
       def where_ray(col, from, mode, strict = true)
-        ["#{col.column_name} #{RAY_OP[col.direction(mode == :before)]}#{'=' unless strict} ?".freeze, [from]]
+        reverse = (mode == :before)
+        if from.nil?
+          ["#{col.column_name} #{NULLS_ORD[col.nulls_direction(reverse)]}", []]
+        else
+          ["#{col.column_name} " \
+           "#{RAY_OP[col.direction(reverse)]}#{'=' unless strict} ?",
+           [from]].tap do |ray|
+            if col.nullable? && col.nulls_direction(reverse) == :last
+              ray[0] += " OR #{col.column_name} IS NULL"
+              ray[0] = "(#{ray[0]})"
+            end
+          end
+        end
       end
+      # rubocop:enable Metrics/AbcSize
 
-      WHERE_IDENTITY = [''.freeze, [].freeze].freeze
+      WHERE_IDENTITY = ['', [].freeze].freeze
 
       private
 
@@ -121,8 +154,8 @@ module OrderQuery
       # Read more about folds:
       # * http://www.haskell.org/haskellwiki/Fold
       # * http://en.wikipedia.org/wiki/Fold_(higher-order_function)
-      def foldr_i(z, xs, &f)
-        xs.reverse_each.each_with_index.inject(z) { |b, (a, i)| f.call a, b, i }
+      def foldr_i(z, xs)
+        xs.reverse_each.each_with_index.inject(z) { |b, (a, i)| yield a, b, i }
       end
     end
   end

data/lib/order_query/version.rb

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

data/spec/gemfiles/rails_5_0.gemfile

@@ -5,4 +5,4 @@ gemspec path: '../../'
 gem 'activerecord', '~> 5.0.5'
 gem 'activesupport', '~> 5.0.5'
 
-eval_gemfile './shared.gemfile'
+eval_gemfile '../../shared.gemfile'

data/spec/gemfiles/rails_5_1.gemfile

@@ -5,4 +5,4 @@ gemspec path: '../../'
 gem 'activerecord', '~> 5.1.3'
 gem 'activesupport', '~> 5.1.3'
 
-eval_gemfile './shared.gemfile'
+eval_gemfile '../../shared.gemfile'

data/spec/gemfiles/rails_5_2.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'activerecord', '~> 5.2.0.rc1'
+gem 'activesupport', '~> 5.2.0.rc1'
+
+eval_gemfile '../../shared.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,31 @@ 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
+          priorities = [nil, 'low', 'medium', 'high']
+          let!(:issues) { priorities.map { |p| create_issue(priority: p) } }
+          priorities.permutation do |p|
+            it "works for #{p} (desc)" do
+              scope = Issue.seek([:priority, p]).scope
+              actual = scope.all.map(&:priority)
+              expected = p
+              expect(actual).to eq(expected), scope.to_sql
+            end
+            it "works for #{p} (asc)" do
+              scope = Issue.seek([:priority, p, :asc]).scope
+              actual = scope.all.map(&:priority)
+              expected = p.reverse
+              expect(actual).to eq(expected), scope.to_sql
+            end
+          end
         end
 
         before do
@@ -217,28 +281,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
             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,55 +317,168 @@ 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
           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)
+            it "works for #{p} (desc)" do
+              scope = Post.seek([:pinned, p]).scope
+              actual = scope.all.map(&:pinned)
+              expected = p
+              expect(actual).to eq(expected), scope.to_sql
+            end
+            it "works for #{p} (asc)" do
+              scope = Post.seek([:pinned, p, :asc]).scope
+              actual = scope.all.map(&:pinned)
+              expected = p.reverse
+              expect(actual).to eq(expected), scope.to_sql
             end
           end
         end
 
+        context 'nil published_at' do
+          # rubocop:disable Metrics/AbcSize
+
+          def expect_next(space, post, next_post)
+            point = space.at(post)
+            actual = point.next
+            failure_message =
+              "expected: #{post.title}.next == #{next_post.title}\n" \
+              "     got: #{actual ? actual.title : 'nil'}\n" \
+              "     all: #{space.scope.all.map(&:title)}\n" \
+              "     sql: #{space.at(older).before.limit(1).to_sql}"
+            expect(actual ? actual.title : nil).to eq(next_post.title),
+                                                   failure_message
+          end
+
+          def expect_prev(space, post, prev_post)
+            point = space.at(post)
+            actual = point.previous
+            failure_message =
+              "expected: #{post.title}.previous == #{prev_post.title}\n" \
+              "     got: #{actual ? actual.title : 'nil'}\n" \
+              "     all: #{space.scope.all.map(&:title)}\n" \
+              "     sql: #{space.at(older).before.limit(1).to_sql}"
+            expect(actual ? actual.title : nil).to eq(prev_post.title),
+                                                   failure_message
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          let! :null do
+            Post.create!(title: 'null', 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])
+            scope = space.scope
+            actual = scope.all.map(&:title)
+            expected = [null, older, newer].map(&:title)
+            expect(actual).to eq(expected), scope.to_sql
+            expect_next space, older, newer
+            expect_prev space, newer, older
+            expect_prev space, older, null
+            expect_next space, null, older
+          end
+
+          it 'orders nulls first (asc)' do
+            space = Post.seek([:published_at, :asc, nulls: :first])
+            scope = space.scope
+            actual = scope.all.map(&:title)
+            expected = [null, newer, older].map(&:title)
+            expect(actual).to eq(expected), scope.to_sql
+            expect_prev space, newer, null
+            expect_next space, null, newer
+          end
+
+          it 'orders nulls last (desc)' do
+            space = Post.seek([:published_at, :desc, nulls: :last])
+            scope = space.scope
+            actual = scope.all.map(&:title)
+            expected = [older, newer, null].map(&:title)
+            expect(actual).to eq(expected), scope.to_sql
+            expect_next space, newer, null
+            expect_prev space, null, newer
+          end
+
+          it 'orders nulls last (asc)' do
+            space = Post.seek([:published_at, :asc, nulls: :last])
+            scope = space.scope
+            actual = scope.all.map(&:title)
+            expected = [newer, older, null].map(&:title)
+            expect(actual).to eq(expected), scope.to_sql
+            expect_next space, older, null
+            expect_prev space, null, older
+          end
+        end
+
         context 'after/before no strict' do
           context 'by middle attribute in search order' do
-            let!(:base) { Post.create! pinned: true, published_at: Time.now }
-            let!(:older) { Post.create! pinned: true, published_at: Time.now + 1.hour }
-            let!(:younger) { Post.create! pinned: true, published_at: Time.now - 1.hour }
+            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 [younger]
+              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, younger]
+              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) { Post.create! pinned: true, published_at: Time.new(2016, 5, 1, 5, 4, 3), id: 6 }
-            let!(:previous) { Post.create! pinned: true, published_at: Time.new(2016, 5, 1, 5, 4, 3), id: 4 }
-            let!(:next_one) { Post.create! pinned: true, published_at: Time.new(2016, 5, 1, 5, 4, 3), id: 9 }
+            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)
@@ -318,10 +500,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
@@ -334,7 +518,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
@@ -342,7 +527,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
@@ -358,6 +544,7 @@ describe 'OrderQuery' do
           t.datetime :updated_at, null: false
         end
       end
+      User.reset_column_information
     end
 
     after :all do