order_query 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e1364db02e6ba3b3d20bf11d77103dc33a1d287
-  data.tar.gz: 70f8f66433ef24caebe56b83a165073ac7377f88
+  metadata.gz: 65a8e133a25873debf2d301e567ebd385e173aed
+  data.tar.gz: ba20134c27cc4b03deb1f76c382c9a6a0abd9b0a
 SHA512:
-  metadata.gz: 2ea5b0e8beb0268407ce15504ce0d57200c41fe4f059782c220c7c2b84c40205dd12123eb61f67e9b01d1c287b836123424ae6925d585142bea19b0077d2cf78
-  data.tar.gz: 3a9dc43bab64321c33f27d2869f895cb36efab27fea662919e61a49d7454863fef8c83ee16a50350b6beb789b51f86936b80636ecac4dfdf1b948a44ce4b0057
+  metadata.gz: f642f0b9d674d7cdd2b1bc7cae39831cc059baf574787640ddeb1d5170059982e4ff9a93629b4c2a57b897991af15d83940a29ce80b14d09b971b88ac51a4719
+  data.tar.gz: de5fccc4d3e103bd32f2237d5a89d2a70d9df5799e4f205100adf8026200af588214704a6bc92a0ff979017405fac95914c6b758fb6df23ecd61a3a69ad85714

data/CHANGES.md

@@ -1,6 +1,11 @@
+## 0.1.2
+
+* Wrap top-level `OR` with a redundant `AND` for [performance reasons](https://github.com/glebm/order_query/issues/3).
+* Remove redundant parens from the query
+
 ## 0.1.1
 
-* `#next(true)` and `#previous(true)` return nil if there is only one record in total.
+* `#next(true)` and `#previous(true)` return `nil` if there is only one record in total.
 
 ## 0.1.0
 

data/Gemfile

@@ -4,6 +4,7 @@ gemspec
 
 group :test, :development do
   gem 'coveralls', require: false
+  gem 'byebug', platform: :mri_21, require: false
 end
 
 platform :mri, :rbx do

data/README.md

@@ -16,7 +16,7 @@ This is slow. Here is where `order_query` comes in!
 Add to Gemfile:
 
 ```ruby
-gem 'order_query', '~> 0.1.1'
+gem 'order_query', '~> 0.1.2'
 ```
 
 ## Usage
@@ -43,7 +43,7 @@ Post.order_list #=> ActiveRecord::Relation<...>
 Post.reverse_order_list #=> ActiveRecord::Relation<...>
 ```
 
-### Relative order
+### Records relative to a given one
 
 `order_query` also adds an instance method for querying relative to the record:
 
@@ -62,7 +62,7 @@ p.after      #=> ActiveRecord::Relation<...>
 
 ### Advanced options
 
-There is a number of advanced options to help you:
+Pass arrays and custom sql as order conditions:
 
 ```ruby
 class Issue < ActiveRecord::Base
@@ -85,10 +85,9 @@ class Issue < ActiveRecord::Base
 end
 ```
 
-### Dynamic criteria
+### Dynamic order conditions
 
-Including `OrderQuery` adds `.order_by_query` and `#relative_order_by_query`.
-These methods can be called directly directly with the order criteria:
+To query with dynamic order conditions use `Model.order_by_query` and `Model#relative_order_by_query`:
 
 ```ruby
 Issue.order_by_query([[:id, :desc]])         #=> ActiveRecord::Relation<...>
@@ -97,12 +96,11 @@ Issue.find(31).relative_order_by_query([[:id, :desc]]).next #=> Issue<...>
 Issue.find(31).relative_order_by_query(Issue.visible, [[:id, :desc]]).next #=> Issue<...>
 ```
 
-This is especially helpful if the order criteria is dynamic, so `order_query` cannot be used to define them beforehand.
 For example, consider ordering by a list of ids returned from an elasticsearh query:
 
 ```ruby
 ids = Issue.keyword_search('ruby') #=> [7, 3, 5]
-Issue.where(id: ids).order_by_query([[:id, ids]]).to_a #=> [Issue<id=7>, Issue<id=3>, Issue<id=5>]
+Issue.where(id: ids).order_by_query([[:id, ids]]).first(2).to_a #=> [Issue<id=7>, Issue<id=3>]
 ```
 
 ## How it works
@@ -131,8 +129,9 @@ SELECT "posts".* FROM "posts"  WHERE
       "posts"."published_at" < '2014-03-21 15:01:35.064096' OR
       "posts"."published_at" = '2014-03-21 15:01:35.064096' AND "posts"."id" < 9))
 ORDER BY
-  "posts"."pinned"='t' DESC,
-  "posts"."pinned"='f' DESC, "posts"."published_at" DESC, "posts"."id" DESC
+  "posts"."pinned"='t' DESC, "posts"."pinned"='f' DESC,
+  "posts"."published_at" DESC,
+  "posts"."id" DESC
 LIMIT 1
 ```
 
@@ -158,6 +157,11 @@ ORDER BY
 LIMIT 1
 ```
 
+The top-level `x0 OR ..` clause is actually wrapped with `x0' AND (x0 OR ...)`, where *x0'* is a non-strict condition,
+for [performance reasons](https://github.com/glebm/order_query/issues/3).
+
+See how this affects query planning in Markus Winand's slides on [Pagination done the Right Way](http://use-the-index-luke.com/blog/2013-07/pagination-done-the-postgresql-way).
+
 This project uses MIT license.
 
 

data/lib/order_query/order_condition.rb

@@ -2,12 +2,12 @@ module OrderQuery
   class OrderCondition
     attr_reader :name, :order, :order_order, :options, :scope
 
-    def initialize(scope, line)
-      line              = line.dup
-      @options          = line.extract_options!
-      @name             = line[0]
-      @order            = line[1] || :asc
-      @order_order      = line[2] || :desc
+    def initialize(scope, spec)
+      spec              = spec.dup
+      @options          = spec.extract_options!
+      @name             = spec[0]
+      @order            = spec[1] || :asc
+      @order_order      = spec[2] || :desc
       @scope            = scope
       @unique           = @options.key?(:unique) ? !!@options[:unique] : (name.to_s == scope.primary_key)
     end
@@ -16,6 +16,29 @@ module OrderQuery
       @unique
     end
 
+    def ray?
+      !order.is_a?(Array)
+    end
+
+    # @param [Object] value
+    # @param [:before, :after] mode
+    # @return [Array] valid order values before / after passed (depending on the mode)
+    def values_around(value, mode, strict = true)
+      ord = order
+      pos = ord.index(value)
+      if pos
+        dir = order_order
+        if mode == :after && dir == :desc || mode == :before && dir == :asc
+          ord.from pos + (strict ? 1 : 0)
+        else
+          ord.first pos + (strict ? 0 : 1)
+        end
+      else
+        # default to all if current is not in sort order values
+        ord
+      end
+    end
+
     def col_name_sql
       sql = options[:sql]
       if sql

data/lib/order_query/order_space.rb

@@ -1,44 +1,74 @@
 require 'order_query/order_condition'
 module OrderQuery
+  # Combine order specification with a scope
   class OrderSpace
-    include Enumerable
-    attr_reader :order
+    attr_reader :conditions
 
-    delegate :each, :length, :size, to: :@order
-
-    def initialize(scope, order)
+    # @param [ActiveRecord::Relation] scope
+    # @param [Array<Array<Symbol,String>>] order_spec
+    def initialize(scope, order_spec)
       @scope = scope
-      @order = order.map { |line| OrderCondition.new(scope, line) }
+      @conditions = order_spec.map { |spec| OrderCondition.new(scope, spec) }
     end
 
+    # @return [ActiveRecord::Relation]
     def scope
       @scope.order(order_by_sql)
     end
 
+    # @return [ActiveRecord::Relation]
     def reverse_scope
       @scope.order(order_by_reverse_sql)
     end
 
-    def to_order_by_sql
-      @order.map { |spec|
-        ord = spec.order
-        if ord == :asc || ord == :desc
-          "#{spec.col_name_sql} #{ord.to_s.upcase}"
-        elsif ord.respond_to?(:map)
-          ord.map { |v| "#{spec.col_name_sql}=#{@scope.connection.quote v} #{spec.order_order.to_s.upcase}" } * ', '
-        else
-          raise "Unknown order #{spec.order.inspect} (#{spec.inspect})"
+    SORT_DIRECTIONS = [:asc, :desc].freeze
+
+    # @return [String]
+    def sort_direction_sql(direction)
+      if SORT_DIRECTIONS.include?(direction)
+        direction.to_s.upcase.freeze
+      else
+        raise ArgumentError.new("sort direction must be in #{SORT_DIRECTIONS.map(&:inspect).join(', ')}, is #{direction.inspect}")
+      end
+    end
+
+    # @return [Array<String>]
+    def order_by_sql_clauses
+      conditions.map { |cond|
+        case order_spec = cond.order
+          when Symbol
+            "#{cond.col_name_sql} #{sort_direction_sql order_spec}".freeze
+          when Enumerable
+            order_spec.map { |v|
+              "#{cond.col_name_sql}=#{@scope.connection.quote v} #{cond.order_order.to_s.upcase}"
+            }.join(', ').freeze
+          else
+            raise ArgumentError.new("Invalid order #{order_spec.inspect} (#{cond.inspect})")
         end
       }
     end
 
-    def order_by_reverse_sql
+    # @return [Array<String>]
+    def order_by_reverse_sql_clauses
       swap = {'DESC' => 'ASC', 'ASC' => 'DESC'}
-      to_order_by_sql.map { |s| s.gsub(/DESC|ASC/) { |m| swap[m] }  } * ', '
+      order_by_sql_clauses.map { |s|
+        s.gsub(/DESC|ASC/) { |m| swap[m] }
+      }
     end
 
+    # @return [String]
+    def order_by_reverse_sql
+      join_order_by_clauses order_by_reverse_sql_clauses
+    end
+
+    # @return [String]
     def order_by_sql
-       to_order_by_sql * ', '
+      join_order_by_clauses order_by_sql_clauses
+    end
+
+    # @param [Array<String>] clauses
+    def join_order_by_clauses(clauses)
+      clauses.join(', ').freeze
     end
   end
 end

data/lib/order_query/relative_order.rb

@@ -1,50 +1,67 @@
 require 'order_query/order_space'
+require 'order_query/where_builder'
+
 module OrderQuery
 
+  # Search around a record in a scope
   class RelativeOrder
-    attr_reader :record, :scope, :order, :values, :options
+    attr_reader :record, :order
+    delegate :scope, :reverse_scope, to: :order
 
-    def initialize(record, scope, order)
+    # @param [ActiveRecord::Base] record
+    # @param [OrderQuery::OrderSpace] order_space
+    def initialize(record, order_space)
       @record = record
-      @scope  = scope
-      @order  = order.is_a?(OrderSpace) ? order : OrderSpace.new(scope, order)
+      @order  = order_space
+      @query_builder = WhereBuilder.new record, order_space
     end
 
+    # @return [ActiveRecord::Base]
     def first
-      order.scope.first
+      scope.first
     end
 
+    # @return [ActiveRecord::Base]
     def last
-      order.scope.last
+      reverse_scope.first
     end
 
+    # @return [Integer]
     def count
       @total ||= scope.count
     end
 
+    # @return [Integer]
     def position
       count - after.count
     end
 
+    # @params [true, false] loop if true, consider last and first as adjacent (unless they are equal)
+    # @return [ActiveRecord::Base]
     def next(loop = true)
-      record_unless_current after.first || (first if loop)
+      unless_record_eq after.first || (first if loop)
     end
 
+    # @return [ActiveRecord::Base]
     def previous(loop = true)
-      record_unless_current before.first || (last if loop)
+      unless_record_eq before.first || (last if loop)
     end
 
+    # @return [ActiveRecord::Relation]
     def after
       records :after
     end
 
+    # @return [ActiveRecord::Relation]
     def before
       records :before
     end
 
-    def records(mode)
-      scope             = (mode == :after ? order.scope : order.reverse_scope)
-      query, query_args = build_query(mode)
+    # @param [:before, :after] direction
+    # @return [ActiveRecord::Relation]
+    def records(direction)
+      scope             = (direction == :after ? order.scope : order.reverse_scope)
+      query, query_args = @query_builder.build_query(direction)
       if query.present?
         scope.where(query, *query_args)
       else
@@ -54,95 +71,10 @@ module OrderQuery
 
     protected
 
-    def record_unless_current(record)
-      record unless record == @record
-    end
-
-    # @param [:before or :after] mode
-    # @return [query, parameters] conditions that exclude all elements not before / after the current one
-    def build_query(mode)
-      group_operators order.map { |term| [where_mode(term, mode), where_eq(term)] }
-    end
-
-    # Join conditions with operators and parenthesis
-    # @param [Array] term_pairs of query terms [[x0, y0], [x1, y1], ...],
-    #                xi, yi are pairs of [query, parameters]
-    # @return [query, parameters]
-    #   x0 OR
-    #   y0 AND (x1 OR
-    #           y1 AND (x2 OR
-    #                   y2 AND x3))
-    #
-    # Since x matches order criteria with values that come before / after the current record,
-    # and y matches order criteria with values equal to the current record's value (for resolving ties),
-    # the resulting condition matches just the elements that come before / after the record
-    def group_operators(term_pairs)
-      # create "x OR y" string
-      term = join_terms 'OR', *term_pairs[0]
-      rest = term_pairs.from(1)
-      if rest.present?
-        # nest the remaining pairs recursively, appending them with " AND "
-        rest_grouped    = group_operators rest
-        rest_grouped[0] = "(#{rest_grouped[0]})" unless rest.length == 1
-        join_terms 'AND', term, rest_grouped
-      else
-        term
-      end
-    end
-
-    # joins terms with an operator
-    # @return [query, parameters]
-    def join_terms(op, *terms)
-      [terms.map { |t| t.first.presence }.compact.join(" #{op} "),
-       terms.map(&:second).reduce(:+) || []]
-    end
-
-    EMPTY_FILTER = ['', []]
-
-    # @return [query, params] Unless order attribute is unique, such as id, return ['WHERE value = ?', current value].
-    def where_eq(attr)
-      if attr.unique?
-        EMPTY_FILTER
-      else
-        [%Q(#{attr.col_name_sql} = ?), [attr_value(attr)]]
-      end
-    end
-
-    # @param [:before or :after] mode
-    # @return [query, params] return query conditions for attribute values before / after the current one
-    def where_mode(attr, mode)
-      ord   = attr.order
-      value = attr_value attr
-      if ord.is_a?(Array)
-        # ord is an array of sort values, ordered first to last
-        pos         = ord.index(value)
-        sort_values = if pos
-                        dir = attr.order_order
-                        if mode == :after && dir == :desc || mode == :before && dir == :asc
-                          ord.from(pos + 1)
-                        else
-                          ord.first(pos)
-                        end
-                      else
-                        # default to all if current is not in sort order values
-                        ord
-                      end
-        # if current not in result set, do not apply filter
-        return EMPTY_FILTER unless sort_values.present?
-        if sort_values.length == 1
-          ["#{attr.col_name_sql} = ?", [sort_values]]
-        else
-          ["#{attr.col_name_sql} IN (?)", [sort_values]]
-        end
-      else
-        # ord is :asc or :desc
-        op = {before: {asc: '<', desc: '>'}, after: {asc: '>', desc: '<'}}[mode][ord || :asc]
-        ["#{attr.col_name_sql} #{op} ?", [value]]
-      end
-    end
-
-    def attr_value(attr)
-      record.send attr.name
+    # @param [ActiveRecord::Base] rec
+    # @return [ActiveRecord::Base, nil] rec unless rec == @record
+    def unless_record_eq(rec)
+      rec unless rec == @record
     end
   end
 end

data/lib/order_query/version.rb

@@ -1,3 +1,3 @@
 module OrderQuery
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/lib/order_query/where_builder.rb

@@ -0,0 +1,116 @@
+module OrderQuery
+  # Build where clause for searching around a record in an order space
+  class WhereBuilder
+    # @return [ActiveRecord::Base]
+    attr_reader :record
+    # @return [OrderQuery::OrderSpace]
+    attr_reader :order
+
+    # @param [ActiveRecord::Base] record
+    # @param [OrderQuery::OrderSpace] order_space
+    def initialize(record, order_space)
+      @order  = order_space
+      @record = record
+    end
+
+    # @param [:before or :after] mode
+    # @return [query, parameters] conditions that exclude all elements not before / after the current one
+    def build_query(mode)
+      conditions = order.conditions
+      terms = conditions.map { |cond| [where_mode(cond, mode, true), where_eq(cond)] }
+      query = group_operators terms
+      # Wrap top level OR clause for performance, see https://github.com/glebm/order_query/issues/3
+      if self.class.wrap_top_level_or && !terms[0].include?(EMPTY_FILTER)
+        join_terms 'AND'.freeze,
+                   where_mode(conditions.first, mode, false),
+                   ["(#{query[0]})", query[1]]
+      else
+        query
+      end
+    end
+
+    # Join conditions with operators and parenthesis
+    # @param [Array] term_pairs of query terms [[x0, y0], [x1, y1], ...],
+    #                xi, yi are pairs of [query, parameters]
+    # @return [query, parameters]
+    #   x0 OR
+    #   y0 AND (x1 OR
+    #           y1 AND (x2 OR
+    #                   y2 AND x3))
+    #
+    # Since x matches order criteria with values that come before / after the current record,
+    # and y matches order criteria with values equal to the current record's value (for resolving ties),
+    # the resulting condition matches just the elements that come before / after the record
+    def group_operators(term_pairs)
+      # create "x OR y" string
+      disjunctive = join_terms 'OR'.freeze, *term_pairs[0]
+      rest = term_pairs.from(1)
+      if rest.present?
+        # nest the remaining pairs recursively, appending them with " AND "
+        rest_grouped    = group_operators rest
+        rest_grouped[0] = "(#{rest_grouped[0]})" unless rest.length == 1
+        join_terms 'AND'.freeze, disjunctive, rest_grouped
+      else
+        disjunctive
+      end
+    end
+
+    # joins terms with an operator
+    # @return [query, parameters]
+    def join_terms(op, *terms)
+      [terms.map { |t| t.first.presence }.compact.join(" #{op} "),
+       terms.map(&:second).reduce(:+) || []]
+    end
+
+    EMPTY_FILTER = [''.freeze, []]
+
+    # @return [query, params] Unless order attribute is unique, such as id, return ['WHERE value = ?', current value].
+    def where_eq(cond)
+      if cond.unique?
+        EMPTY_FILTER
+      else
+        [%Q(#{cond.col_name_sql} = ?).freeze, [attr_value(cond)]]
+      end
+    end
+
+    def where_ray(cond, from, mode, strict = true)
+      ops = %w(< >)
+      ops = ops.reverse if mode == :after
+      op  = {asc: ops[0], desc: ops[1]}[cond.order || :asc]
+      ["#{cond.col_name_sql} #{op}#{'=' unless strict} ?".freeze, [from]]
+    end
+
+    def where_in(cond, values)
+      case values.length
+        when 0
+          EMPTY_FILTER
+        when 1
+          ["#{cond.col_name_sql} = ?".freeze, [values]]
+        else
+          ["#{cond.col_name_sql} IN (?)".freeze, [values]]
+      end
+    end
+
+    # @param [:before or :after] mode
+    # @return [query, params] return query conditions for attribute values before / after the current one
+    def where_mode(cond, mode, strict = true)
+      value = attr_value cond
+      if cond.ray?
+        where_ray cond, value, mode, strict
+      else
+        # ord is an array of sort values, ordered first to last
+        # if current not in result set, do not apply filter
+        where_in cond, cond.values_around(value, mode, strict)
+      end
+    end
+
+    def attr_value(cond)
+      record.send cond.name
+    end
+
+    class << self
+      attr_accessor :wrap_top_level_or
+    end
+    self.wrap_top_level_or = true
+  end
+end

data/lib/order_query.rb

@@ -6,19 +6,20 @@ module OrderQuery
   extend ActiveSupport::Concern
 
   included do
-    # @return [OrderSpace] order definition
-    # @example
-    #   Issue.order_query [[:id, :desc]] #=> <ActiveRecord::Relation#...>
-    scope :order_by_query, ->(order) { OrderSpace.new(self, order).scope }
-    scope :reverse_order_by_query, ->(order) { OrderSpace.new(self, order).reverse_scope }
+    scope :order_by_query, ->(order_spec) { OrderSpace.new(self, order_spec).scope }
+    scope :reverse_order_by_query, ->(order_spec) { OrderSpace.new(self, order_spec).reverse_scope }
   end
 
-  def relative_order_by_query(scope = self.class.all, order)
-    RelativeOrder.new(self, scope, order)
+  # @param [ActiveRecord::Relation] scope
+  # @param [Array<Array<Symbol,String>>] order_spec
+  def relative_order_by_query(scope = self.class.all, order_spec)
+    RelativeOrder.new(self, OrderSpace.new(scope, order_spec))
   end
 
   module ClassMethods
     protected
+    # @param [Symbol] name
+    # @param [Array<Array<Symbol,String>>] order_spec
     # @example
     #   class Issue
     #     order_query :order_display, [[:created_at, :desc], [:id, :desc]]
@@ -26,12 +27,11 @@ module OrderQuery
     #
     #   Issue.order_display #=> <ActiveRecord::Relation#...>
     #   Issue.active.find(31).display_order(Issue.active).next  #=> <Issue#...>
-    def order_query(name, order)
-      scope name, -> { order_by_query(order) }
-      scope :"reverse_#{name}", -> { reverse_order_by_query(order) }
-      define_method(name) do |scope = nil|
-        scope ||= self.class.all
-        relative_order_by_query(scope, order)
+    def order_query(name, order_spec)
+      scope name, -> { order_by_query(order_spec) }
+      scope :"reverse_#{name}", -> { reverse_order_by_query(order_spec) }
+      define_method name do |scope = nil|
+        relative_order_by_query scope || self.class.all, order_spec
       end
     end
   end

data/spec/order_query_spec.rb

@@ -36,127 +36,153 @@ def create_issue(attr = {})
   Issue.create!({priority: 'high', votes: 3, suspicious_votes: 0, updated_at: Time.now}.merge(attr))
 end
 
-describe 'OrderQuery.order_query' do
-
-  context 'Issue test model' do
-    t        = Time.now
-    datasets = [
-        [
-            ['high', 5, 0, t],
-            ['high', 5, 1, t],
-            ['high', 5, 1, t - 1.day],
-            ['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, 1, t - 1.day],
-            ['low', 30, 0, t + 1.day]
-        ],
-    ]
-
-    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])
+def with_wrap_top_level(value)
+  builder = OrderQuery::WhereBuilder
+  around do |ex|
+    was = builder.wrap_top_level_or
+    begin
+      builder.wrap_top_level_or = value
+      ex.run
+    ensure
+      builder.wrap_top_level_or = was
+    end
+  end
+end
+
+describe 'OrderQuery' do
+
+  [false, true].each do |wrap_top_level_or|
+    context "(wrap_top_level_or: #{wrap_top_level_or})" do
+      with_wrap_top_level wrap_top_level_or
+
+      context 'Issue test model' do
+        t        = Time.now
+        datasets = [
+            [
+                ['high', 5, 0, t],
+                ['high', 5, 1, t],
+                ['high', 5, 1, t - 1.day],
+                ['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, 1, t - 1.day],
+                ['low', 30, 0, t + 1.day]
+            ],
+        ]
+
+        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])
+            end
+            issues.reverse_each(&:save!)
+            expect(Issue.display_order.to_a).to eq(issues)
+            issues.each_slice(2) do |prev, cur|
+              cur ||= issues.first
+              expect(prev.display_order.next).to eq(cur)
+              expect(cur.display_order.previous).to eq(prev)
+              expect(cur.display_order.scope.count).to eq(Issue.count)
+              expect(cur.display_order.before.count + 1 + cur.display_order.after.count).to eq(cur.display_order.count)
+
+              expect(cur.display_order.before.to_a.reverse + [cur] + cur.display_order.after.to_a).to eq(Issue.display_order.to_a)
+            end
+          end
         end
-        issues.reverse_each(&:save!)
-        expect(Issue.display_order.to_a).to eq(issues)
-        issues.each_slice(2) do |prev, cur|
-          cur ||= issues.first
-          expect(prev.display_order.next).to eq(cur)
-          expect(cur.display_order.previous).to eq(prev)
-          expect(cur.display_order.scope.count).to eq(Issue.count)
-          expect(cur.display_order.before.count + 1 + cur.display_order.after.count).to eq(cur.display_order.count)
-
-          expect(cur.display_order.before.to_a.reverse + [cur] + cur.display_order.after.to_a).to eq(Issue.display_order.to_a)
+
+        it '#next returns nil when there is only 1 record' do
+          p = create_issue.display_order
+          expect(p.next).to be_nil
+          expect(p.next(true)).to be_nil
         end
-      end
-    end
 
-    it '#next returns nil when there is only 1 record' do
-      p = create_issue.display_order
-      expect(p.next).to be_nil
-      expect(p.next(true)).to be_nil
-    end
+        it 'is ordered correctly for order query [[:id, :asc]]' do
+          a = create_issue
+          b = create_issue
+          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(Issue.id_order_asc.count).to eq(2)
+        end
 
-    it 'is ordered correctly for order query [[:id, :asc]]' do
-      a = create_issue
-      b = create_issue
-      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(Issue.id_order_asc.count).to eq(2)
-    end
+        it '.order_by_query works on a list of ids' do
+          ids = (1..3).map { create_issue.id }
+          expect(Issue.order_by_query([[:id, ids]]).size).to eq ids.length
+        end
 
-    it '.order_by_query works on a list of ids' do
-      ids = (1..3).map { create_issue.id }
-      expect(Issue.order_by_query([[:id, ids]])).to have(ids.length).issues
-    end
+        it '.order_by_query preserves previous' do
+          create_issue(active: true)
+          expect(Issue.where(active: false).order_by_query([[:id, :desc]])).to be_empty
+          expect(Issue.where(active: true).order_by_query([[:id, :desc]]).size).to eq 1
+        end
 
-    it '.order_by_query preserves previous' do
-      create_issue(active: true)
-      expect(Issue.where(active: false).order_by_query([[:id, :desc]])).to have(0).records
-      expect(Issue.where(active: true).order_by_query([[:id, :desc]])).to have(1).record
-    end
+        it '#relative_order_by_query falls back to scope when order condition is missing self' do
+          a = create_issue(priority: 'medium')
+          b = create_issue(priority: 'high')
+          expect(a.relative_order_by_query(Issue.display_order, [[:priority, ['wontfix', 'askbob']], [:id, :desc]]).next).to eq(b)
+        end
 
-    it '#relative_order_by_query falls back to scope when order condition is missing self' do
-      a = create_issue(priority: 'medium')
-      b = create_issue(priority: 'high')
-      expect(a.relative_order_by_query(Issue.display_order, [[:priority, ['wontfix', 'askbob']], [:id, :desc]]).next).to eq(b)
-    end
+        before do
+          Issue.delete_all
+        end
 
-    before do
-      Issue.delete_all
-    end
+        before :all do
+          ActiveRecord::Schema.define do
+            self.verbose = false
+
+            create_table :issues do |t|
+              t.column :priority, :string
+              t.column :votes, :integer
+              t.column :suspicious_votes, :integer
+              t.column :announced_at, :datetime
+              t.column :updated_at, :datetime
+              t.column :active, :boolen, null: false, default: true
+            end
+          end
+
+          Issue.reset_column_information
+        end
 
-    before :all do
-      ActiveRecord::Schema.define do
-        self.verbose = false
-
-        create_table :issues do |t|
-          t.column :priority, :string
-          t.column :votes, :integer
-          t.column :suspicious_votes, :integer
-          t.column :announced_at, :datetime
-          t.column :updated_at, :datetime
-          t.column :active, :boolen, null: false, default: true
+        after :all do
+          ActiveRecord::Migration.drop_table :issues
         end
       end
 
-      Issue.reset_column_information
-    end
-  end
-
-  context 'Post test model' do
-    it '#next works' do
-      p1 = create_post(pinned: true)
-      o1 = p1.order_list
-      expect(o1.next).to be_nil
-      expect(o1.next(true)).to be_nil
-      p2 = create_post(pinned: false)
-      o2 = p2.order_list
-      expect(o1.next(false)).to eq(p2)
-      expect(o2.next(false)).to be_nil
-      expect(o2.next(true)).to eq(p1)
-    end
+      context 'Post test model' do
+        it '#next works' do
+          p1 = create_post(pinned: true)
+          o1 = p1.order_list
+          expect(o1.next).to be_nil
+          expect(o1.next(true)).to be_nil
+          p2 = create_post(pinned: false)
+          o2 = p2.order_list
+          expect(o1.next(false)).to eq(p2)
+          expect(o2.next(false)).to be_nil
+          expect(o2.next(true)).to eq(p1)
+        end
 
-    before do
-      Post.delete_all
-    end
-    before :all do
-      ActiveRecord::Schema.define do
-        self.verbose = false
-        create_table :posts do |t|
-          t.boolean :pinned
-          t.datetime :published_at
+        before do
+          Post.delete_all
+        end
+        before :all do
+          ActiveRecord::Schema.define do
+            self.verbose = false
+            create_table :posts do |t|
+              t.boolean :pinned
+              t.datetime :published_at
+            end
+          end
+        end
+        after :all do
+          ActiveRecord::Migration.drop_table :posts
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: order_query
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Gleb Mazovetskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-25 00:00:00.000000000 Z
+date: 2014-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -82,6 +82,7 @@ files:
 - lib/order_query/order_space.rb
 - lib/order_query/relative_order.rb
 - lib/order_query/version.rb
+- lib/order_query/where_builder.rb
 - spec/order_query_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/glebm/order_query
@@ -105,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: Find next / previous Active Record(s) in one query