order_query 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b77ab79b198ad089f382ace5d234c433f239bff0
-  data.tar.gz: 1c2507543963747b645dd4426328fea48b6909e1
+  metadata.gz: 14a1cc9219fd6bb2221967eef338dcabee8854f1
+  data.tar.gz: e4a8c908c803e2c8afad23a0b278473043087cc7
 SHA512:
-  metadata.gz: 258a2dd941e882fb115a1a15f1f2be6cabe359840d9fe06fbbb6fbbe41dd37284b4cc27909507624367412a65383d6480462cb37d19181acff1602a8c67894b0
-  data.tar.gz: d72f77b66611f6ca0f784ac080e1ef6cd99369fe4cf8c279c8a7bdaa3a130a13821df4efceb035ff201772d7f3cde0563b1dac4752b95d6feaee69bb0fd9e624
+  metadata.gz: e93eb1ec39fab70c1895d34aeef9bbfab92c8da4b7c2962c7a822f4e0df5501331c4a5c733a471fdcfb61b287d4e9cebfd8ea668b258d957755e942011384ee1
+  data.tar.gz: 4ec32294d12907c1245607f2f2f79a9f205e9f7c7d7396f4b7a1bd1877fb597262cf29e7aa53d81aad512efc36a9737dbf68601f9828f69b7b16adaa77dc77eb

data/CHANGES.md

@@ -1,3 +1,7 @@
+## 0.2.0
+
+* Dynamic query methods renamed to `order_by`
+
 ## 0.1.3
 
 * New condition option `complete` for list conditions for optimized query generation

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.3'
+gem 'order_query', '~> 0.2.0'
 ```
 
 ## Usage
@@ -94,20 +94,20 @@ end
 
 ### Dynamic order conditions
 
-To query with dynamic order conditions use `Model.order_by_query` and `Model#relative_order_by_query`:
+To query with dynamic order conditions use `Model.order_by` and `Model#order_by`:
 
 ```ruby
-Issue.order_by_query([[:id, :desc]])         #=> ActiveRecord::Relation<...>
-Issue.reverse_order_by_query([[:id, :desc]]) #=> ActiveRecord::Relation<...>
-Issue.find(31).relative_order_by_query([[:id, :desc]]).next #=> Issue<...>
-Issue.find(31).relative_order_by_query(Issue.visible, [[:id, :desc]]).next #=> Issue<...>
+Issue.order_by([[:id, :desc]])         #=> ActiveRecord::Relation<...>
+Issue.visible.reverse_order_by([[:id, :desc]]) #=> ActiveRecord::Relation<...>
+Issue.find(31).order_by([[:id, :desc]]).next #=> Issue<...>
+Issue.find(31).order_by(Issue.visible, [[:id, :desc]]).next #=> Issue<...>
 ```
 
-For example, consider ordering by a list of ids returned from an elasticsearh query:
+For example, consider ordering by a list of ids returned from an elasticsearch query:
 
 ```ruby
 ids = Issue.keyword_search('ruby') #=> [7, 3, 5]
-Issue.where(id: ids).order_by_query([[:id, ids]]).first(2).to_a #=> [Issue<id=7>, Issue<id=3>]
+Issue.where(id: ids).order_by([[:id, ids]]).first(2).to_a #=> [Issue<id=7>, Issue<id=3>]
 ```
 
 ## How it works

data/lib/order_query.rb

@@ -1,22 +1,28 @@
 require 'active_support'
 require 'active_record'
-require 'order_query/relative_order'
+require 'order_query/space'
+require 'order_query/point'
 
 module OrderQuery
   extend ActiveSupport::Concern
 
-  included do
-    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
-
   # @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))
+  def order_by(scope = nil, order_spec)
+    scope ||= self.class.all
+    Point.new(self, Space.new(scope, order_spec))
   end
 
   module ClassMethods
+    def order_by(order_spec)
+      Space.new(self, order_spec).scope
+    end
+
+    def reverse_order_by(order_spec)
+      Space.new(self, order_spec).reverse_scope
+    end
+
+    #= DSL
     protected
     # @param [Symbol] name
     # @param [Array<Array<Symbol,String>>] order_spec
@@ -28,11 +34,17 @@ module OrderQuery
     #   Issue.order_display #=> <ActiveRecord::Relation#...>
     #   Issue.active.find(31).display_order(Issue.active).next  #=> <Issue#...>
     def order_query(name, order_spec)
-      scope name, -> { order_by_query(order_spec) }
-      scope :"reverse_#{name}", -> { reverse_order_by_query(order_spec) }
+      scope name, -> { order_by(order_spec) }
+      scope :"reverse_#{name}", -> { reverse_order_by(order_spec) }
       define_method name do |scope = nil|
-        relative_order_by_query scope || self.class.all, order_spec
+        order_by scope, order_spec
       end
     end
   end
+
+  class << self
+    attr_accessor :wrap_top_level_or
+  end
+  # Wrap top-level or with an AND and a redundant condition for performance
+  self.wrap_top_level_or = true
 end

data/lib/order_query/condition.rb

@@ -0,0 +1,65 @@
+require 'order_query/sql/condition'
+module OrderQuery
+  class Condition
+    attr_reader :name, :order, :order_enum, :options, :sql
+
+    # @option spec [String] :unique    Mark the attribute as unique to avoid redundant conditions
+    # @option spec [String] :complete  Mark the condition's domain as complete to avoid redundant conditions (only for array conditions)
+    def initialize(spec, scope)
+      spec    = spec.dup
+      options = spec.extract_options!
+      @name   = spec[0]
+      case spec[1]
+        when Array
+          @order_enum = spec[1]
+          @order      = spec[2] || :desc
+        else
+          @order = spec[1] || :asc
+      end
+      @options  = options
+      @unique   = if options.key?(:unique)
+                    !!options[:unique]
+                  else
+                    name.to_s == scope.primary_key
+                  end
+      @complete = if options.key?(:complete)
+                    !!options[:complete]
+                  else
+                    !@order_enum
+                  end
+
+      @sql = SQL::Condition.new(self, scope)
+    end
+
+    def unique?
+      @unique
+    end
+
+    def complete?
+      @complete
+    end
+
+    # @param [Object] value
+    # @param [:before, :after] mode
+    # @return [Array] valid order values before / after passed (depending on the mode)
+    def filter_values(value, mode, strict = true)
+      ord = order_enum
+      pos = ord.index(value)
+      if pos
+        dir = 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 inspect
+      "Condition(#{@name.inspect}#{" #{@order_enum.inspect}" if @order_enum} #{@order.to_s.upcase} #{'unique ' if @unique}#{@complete ? 'complete' : 'partial' if @order_enum})"
+    end
+  end
+end

data/lib/order_query/{relative_order.rb → point.rb}

@@ -1,19 +1,18 @@
-require 'order_query/order_space'
-require 'order_query/where_builder'
+require 'order_query/space'
+require 'order_query/sql/where'
 
 module OrderQuery
-
-  # Search around a record in a scope
-  class RelativeOrder
-    attr_reader :record, :order
-    delegate :scope, :reverse_scope, to: :order
+  # Search around a record in an order space
+  class Point
+    attr_reader :record, :space
+    delegate :scope, :reverse_scope, to: :space
 
     # @param [ActiveRecord::Base] record
-    # @param [OrderQuery::OrderSpace] order_space
-    def initialize(record, order_space)
-      @record = record
-      @order  = order_space
-      @query_builder = WhereBuilder.new record, order_space
+    # @param [OrderQuery::Space] space
+    def initialize(record, space)
+      @record    = record
+      @space     = space
+      @where_sql = SQL::Where.new(self)
     end
 
     # @return [ActiveRecord::Base]
@@ -60,8 +59,8 @@ module OrderQuery
     # @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)
+      query, query_args = @where_sql.build(direction)
+      scope = (direction == :after ? space.scope : space.reverse_scope)
       if query.present?
         scope.where(query, *query_args)
       else

data/lib/order_query/space.rb

@@ -0,0 +1,30 @@
+require 'order_query/condition'
+require 'order_query/sql/order_by'
+module OrderQuery
+  # Order specification and a scope
+  class Space
+    # @return [Array<Condition>]
+    attr_reader :conditions
+    # @return [ActiveRecord::Relation]
+    attr_reader :base_scope
+
+    # @param [ActiveRecord::Relation] scope
+    # @param [Array<Array<Symbol,String>>] order_spec
+    def initialize(base_scope, order_spec)
+      @base_scope   = base_scope
+      order_spec    = [order_spec] unless order_spec.empty? || order_spec.first.is_a?(Array)
+      @conditions   = order_spec.map { |spec| Condition.new(spec, base_scope) }
+      @order_by_sql = SQL::OrderBy.new(self)
+    end
+
+    # @return [ActiveRecord::Relation] scope ordered by conditions
+    def scope
+      @base_scope.order(@order_by_sql.build)
+    end
+
+    # @return [ActiveRecord::Relation] scope ordered by conditions in reverse
+    def reverse_scope
+      @base_scope.order(@order_by_sql.build_reverse)
+    end
+  end
+end

data/lib/order_query/sql/condition.rb

@@ -0,0 +1,34 @@
+module OrderQuery
+  module SQL
+    class Condition
+      attr_reader :condition, :scope
+
+      def initialize(condition, scope)
+        @condition = condition
+        @scope = scope
+      end
+
+      def column_name
+        @column_name ||= begin
+          sql = condition.options[:sql]
+          if sql
+            sql = sql.call if sql.respond_to?(:call)
+            sql
+          else
+            connection.quote_table_name(scope.table_name) + '.' + connection.quote_column_name(condition.name)
+          end
+        end
+      end
+
+      def quote(value)
+        connection.quote value
+      end
+
+      protected
+
+      def connection
+        scope.connection
+      end
+    end
+  end
+end

data/lib/order_query/sql/order_by.rb

@@ -0,0 +1,60 @@
+module OrderQuery
+  module SQL
+    class OrderBy
+      attr_reader :space
+
+      # @param [Array<Condition>]
+      def initialize(space)
+        @space = space
+      end
+
+      # @return [String]
+      def build
+        join_order_by_clauses order_by_sql_clauses
+      end
+
+      # @return [String]
+      def build_reverse
+        join_order_by_clauses order_by_reverse_sql_clauses
+      end
+
+      protected
+
+      # @return [Array<String>]
+      def order_by_sql_clauses
+        space.conditions.map { |cond|
+          if cond.order_enum
+            cond.order_enum.map { |v|
+              "#{cond.sql.column_name}=#{cond.sql.quote v} #{cond.order.to_s.upcase}"
+            }.join(', ').freeze
+          else
+            "#{cond.sql.column_name} #{sort_direction_sql cond.order}".freeze
+          end
+        }
+      end
+
+      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
+
+      # @param [Array<String>] clauses
+      def join_order_by_clauses(clauses)
+        clauses.join(', ').freeze
+      end
+
+      # @return [Array<String>]
+      def order_by_reverse_sql_clauses
+        swap = {'DESC' => 'ASC', 'ASC' => 'DESC'}
+        order_by_sql_clauses.map { |s|
+          s.gsub(/DESC|ASC/) { |m| swap[m] }
+        }
+      end
+    end
+  end
+end

data/lib/order_query/sql/where.rb

@@ -0,0 +1,120 @@
+# coding: utf-8
+module OrderQuery
+  module SQL
+    # Build where clause for searching around a record in an order space
+    class Where
+      attr_reader :point
+
+      # @param [OrderQuery::Point] point
+      def initialize(point)
+        @point = point
+      end
+
+      # @param [:before or :after] mode
+      # @return [query, parameters] conditions that exclude all elements not before / after the current one
+      def build(mode)
+        conditions = point.space.conditions
+        # pairs of [x0, y0]
+        pairs = conditions.map { |cond|
+          [where_relative(cond, mode, true), (where_eq(cond) unless cond.unique?)].reject { |x|
+            x.nil? || x == WHERE_IDENTITY || x == WHERE_NONE
+          }.compact
+        }
+        query = group_operators pairs
+        return query unless ::OrderQuery.wrap_top_level_or
+        # Wrap top level OR clause for performance, see https://github.com/glebm/order_query/issues/3
+        top_pair_idx = pairs.index(&:present?)
+        if top_pair_idx &&
+            (top_pair = pairs[top_pair_idx]).length == 2 &&
+            (top_level_cond = conditions[top_pair_idx]) &&
+            (redundant_cond = where_relative(top_level_cond, mode, false)) != top_pair.first
+          join_terms 'AND'.freeze, redundant_cond, wrap_parens(query)
+        else
+          query
+        end
+      end
+
+      # Join condition pairs internally with OR, and nested within each other with AND
+      # @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
+          join_terms 'AND'.freeze, disjunctive, (rest.length == 1 ? rest_grouped : wrap_parens(rest_grouped))
+        else
+          disjunctive
+        end
+      end
+
+      def wrap_parens(t)
+        ["(#{t[0]})", t[1]]
+      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
+
+      # @param [:before or :after] mode
+      # @return [query, params] return query conditions for attribute values before / after the current one
+      def where_relative(cond, mode, strict = true)
+        value = attr_value cond
+        if cond.order_enum
+          values = cond.filter_values(value, mode, strict)
+          if cond.complete? && values.length == cond.order_enum.length
+            WHERE_IDENTITY
+          else
+            where_in cond, values
+          end
+        else
+          where_ray cond, value, mode, strict
+        end
+      end
+
+
+      def where_in(cond, values)
+        case values.length
+          when 0
+            WHERE_NONE
+          when 1
+            where_eq cond, values[0]
+          else
+            ["#{cond.sql.column_name} IN (?)".freeze, [values]]
+        end
+      end
+
+      def where_eq(cond, value = attr_value(cond))
+        [%Q(#{cond.sql.column_name} = ?).freeze, [value]]
+      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.sql.column_name} #{op}#{'=' unless strict} ?".freeze, [from]]
+      end
+
+      WHERE_IDENTITY = [''.freeze, [].freeze].freeze
+      WHERE_NONE     = ['∅'.freeze, [].freeze].freeze
+
+      def attr_value(cond)
+        point.record.send cond.name
+      end
+    end
+  end
+end

data/lib/order_query/version.rb

@@ -1,3 +1,3 @@
 module OrderQuery
-  VERSION = '0.1.3'
+  VERSION = '0.2.0'
 end

data/spec/order_query_spec.rb

@@ -1,6 +1,11 @@
 require 'spec_helper'
 
-# Simple example
+# Bare model
+class User < ActiveRecord::Base
+  include OrderQuery
+end
+
+# Simple model
 class Post < ActiveRecord::Base
   include OrderQuery
   order_query :order_list, [
@@ -14,7 +19,7 @@ def create_post(attr = {})
   Post.create!({pinned: false, published_at: Time.now}.merge(attr))
 end
 
-# Advanced example
+# Advanced model
 class Issue < ActiveRecord::Base
   DISPLAY_ORDER = [
       [:priority, %w(high medium low), complete: true],
@@ -36,15 +41,15 @@ def create_issue(attr = {})
   Issue.create!({priority: 'high', votes: 3, suspicious_votes: 0, updated_at: Time.now}.merge(attr))
 end
 
-def with_wrap_top_level(value)
-  builder = OrderQuery::WhereBuilder
+def wrap_top_level_or(value)
+  conf = ::OrderQuery
   around do |ex|
-    was = builder.wrap_top_level_or
+    was = conf.wrap_top_level_or
     begin
-      builder.wrap_top_level_or = value
+      conf.wrap_top_level_or = value
       ex.run
     ensure
-      builder.wrap_top_level_or = was
+      conf.wrap_top_level_or = was
     end
   end
 end
@@ -53,7 +58,7 @@ 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
+      wrap_top_level_or wrap_top_level_or
 
       context 'Issue test model' do
         t        = Time.now
@@ -113,21 +118,21 @@ describe 'OrderQuery' do
           expect(Issue.id_order_asc.count).to eq(2)
         end
 
-        it '.order_by_query works on a list of ids' do
+        it '.order_by 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
+          expect(Issue.order_by([[:id, ids]]).size).to eq ids.length
         end
 
-        it '.order_by_query preserves previous' do
+        it '.order_by 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
+          expect(Issue.where(active: false).order_by([[:id, :desc]])).to be_empty
+          expect(Issue.where(active: true).order_by([[:id, :desc]]).size).to eq 1
         end
 
-        it '#relative_order_by_query falls back to scope when order condition is missing self' do
+        it '#order_by 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)
+          expect(a.order_by(Issue.display_order, [[:priority, ['wontfix', 'askbob']], [:id, :desc]]).next).to eq(b)
         end
 
         before do
@@ -187,4 +192,39 @@ describe 'OrderQuery' do
       end
     end
   end
+
+  context 'SQL generation' 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')).order_by([[:updated_at, :desc], [:id, :desc]]).after
+        expect(after_scope.to_sql).to include('<=')
+      end
+    end
+
+    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')).order_by([[:updated_at, :desc], [:id, :desc]]).after
+        expect(after_scope.to_sql).to_not include('<=')
+      end
+    end
+
+    before do
+      User.delete_all
+    end
+
+    before :all do
+      ActiveRecord::Schema.define do
+        self.verbose = false
+        create_table :users do |t|
+          t.datetime :updated_at, null: false
+        end
+      end
+    end
+
+    after :all do
+      ActiveRecord::Migration.drop_table :users
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: order_query
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Gleb Mazovetskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-04 00:00:00.000000000 Z
+date: 2014-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -78,11 +78,13 @@ files:
 - README.md
 - Rakefile
 - lib/order_query.rb
-- lib/order_query/order_condition.rb
-- lib/order_query/order_space.rb
-- lib/order_query/relative_order.rb
+- lib/order_query/condition.rb
+- lib/order_query/point.rb
+- lib/order_query/space.rb
+- lib/order_query/sql/condition.rb
+- lib/order_query/sql/order_by.rb
+- lib/order_query/sql/where.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

data/lib/order_query/order_condition.rb

@@ -1,71 +0,0 @@
-module OrderQuery
-  class OrderCondition
-    attr_reader :name, :order, :order_order, :options, :scope
-
-    # @option spec [String] :unique    Mark the attribute as unique to avoid redundant conditions
-    # @option spec [String] :complete  Mark the condition's domain as complete to avoid redundant conditions (only for array conditions)
-    def initialize(scope, spec)
-      spec         = spec.dup
-      options      = spec.extract_options!
-      @name        = spec[0]
-      @order       = spec[1] || :asc
-      @order_order = spec[2] || :desc
-      @options     = options
-      @scope       = scope
-      @unique      = if options.key?(:unique)
-                       !!options[:unique]
-                     else
-                       name.to_s == scope.primary_key
-                     end
-      @complete    = if options.key?(:complete)
-                       !!options[:complete]
-                     else
-                       !list?
-                     end
-    end
-
-    def unique?
-      @unique
-    end
-
-    def complete?
-      @complete
-    end
-
-    # @return [Boolean] whether order is specified as a list of values
-    def list?
-      order.is_a?(Enumerable)
-    end
-
-    # @param [Object] value
-    # @param [:before, :after] mode
-    # @return [Array] valid order values before / after passed (depending on the mode)
-    def filter_values(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
-      @col_name_sql ||= begin
-        sql = options[:sql]
-        if sql
-          sql = sql.call if sql.respond_to?(:call)
-          sql
-        else
-          scope.connection.quote_table_name(scope.table_name) + '.' + scope.connection.quote_column_name(name)
-        end
-      end
-    end
-  end
-end

data/lib/order_query/order_space.rb

@@ -1,74 +0,0 @@
-require 'order_query/order_condition'
-module OrderQuery
-  # Combine order specification with a scope
-  class OrderSpace
-    attr_reader :conditions
-
-    # @param [ActiveRecord::Relation] scope
-    # @param [Array<Array<Symbol,String>>] order_spec
-    def initialize(scope, order_spec)
-      @scope = scope
-      @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
-
-    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
-
-    # @return [Array<String>]
-    def order_by_reverse_sql_clauses
-      swap = {'DESC' => 'ASC', 'ASC' => 'DESC'}
-      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
-      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/where_builder.rb

@@ -1,124 +0,0 @@
-# coding: utf-8
-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)
-      # pairs of [x0, y0]
-      pairs = order.conditions.map { |cond|
-        [where_relative(cond, mode, true), (where_eq(cond) unless cond.unique?)].reject { |x|
-          x.nil? || x == WHERE_IDENTITY || x == WHERE_NONE
-        }.compact
-      }
-      query = group_operators pairs
-      return query unless self.class.wrap_top_level_or
-      # Wrap top level OR clause for performance, see https://github.com/glebm/order_query/issues/3
-      top_pair_idx = pairs.index(&:present?)
-      if top_pair_idx && pairs[top_pair_idx].length == 2 && (top_level_cond = order.conditions[top_pair_idx])
-        join_terms 'AND'.freeze, where_relative(top_level_cond, mode, false), wrap_parens(query)
-      else
-        query
-      end
-    end
-
-    # Join condition pairs internally with OR, and nested within each other with AND
-    # @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
-        join_terms 'AND'.freeze, disjunctive, (rest.length == 1 ? rest_grouped : wrap_parens(rest_grouped))
-      else
-        disjunctive
-      end
-    end
-
-    def wrap_parens(t)
-      ["(#{t[0]})", t[1]]
-    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
-
-    # @param [:before or :after] mode
-    # @return [query, params] return query conditions for attribute values before / after the current one
-    def where_relative(cond, mode, strict = true, skip_complete = true)
-      value = attr_value cond
-      if cond.list?
-        values = cond.filter_values(value, mode, strict)
-        if cond.complete? && values.length == cond.order.length
-          WHERE_IDENTITY
-        else
-          where_in cond, values
-        end
-      else
-        where_ray cond, value, mode, strict
-      end
-    end
-
-
-    def where_in(cond, values)
-      case values.length
-        when 0
-          WHERE_NONE
-        when 1
-          where_eq cond, values[0]
-        else
-          ["#{cond.col_name_sql} IN (?)".freeze, [values]]
-      end
-    end
-
-    def where_eq(cond, value = attr_value(cond))
-      [%Q(#{cond.col_name_sql} = ?).freeze, [value]]
-    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
-
-    WHERE_IDENTITY = [''.freeze, [].freeze].freeze
-    WHERE_NONE = ['∅'.freeze, [].freeze].freeze
-
-    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