order_query 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02a08c0101e3e15512098357d8e9159941b2606f
-  data.tar.gz: a11460b00d5f8e3dc16dc28f0fc264d4c17f1fef
+  metadata.gz: be66ba349bb0a4819d39ee8f01d8bfa12e82177e
+  data.tar.gz: 56637889ea73d1f90e70dcd72e09431eb357f1e1
 SHA512:
-  metadata.gz: 9e450de5cb30e692f068ae9551459879a3315c9feed3527809a50f82412954ce258a495f54bbefa18f04e1a823310fd1eba55d44caf1d623bb94ac7712e0f905
-  data.tar.gz: b2c92a65bdb70275836a7fede9c457056fdbb9ba7fe768a8fe3b5608790264dec600ad857f504135a7d465905fa3201d7c740f03b71546d68bbd8ea1e92090af
+  metadata.gz: c8f9fe60869ae746f9d095dfc549f651b994ded8b75875cd60761e9e7683cdcb6968834916ae6eb881b3dc684f26220adf4e873948923b8e41daee90b11d6671
+  data.tar.gz: b068a5d7bcc50af28dbdff396adca897f8f502640fcad0f162f1ea9ee4424c9a9cf1afde85837261908bd984a9339bbb6fdce50477d0aa9ed99b394cabf2e53a

data/CHANGES.md

@@ -1,6 +1,12 @@
+## 0.3.1
+
+* Automatically add primary key when there is no unique column for the order
+* Remove `complete` option
+* Fix Rubinius compatibility
+
 ## 0.3.0
 
-* `order_query` now accepts conditions as varargs. Array form is still supported.
+* `order_query` now accepts columns as varargs. Array form is still supported.
 * `order_by` renamed to `seek`
 
 ## 0.2.1

data/MIT-LICENSE

@@ -6,7 +6,7 @@ a copy of this software and associated documentation files (the
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
+the following columns:
 
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.

data/README.md

@@ -12,12 +12,12 @@ It uses [keyset pagination](http://use-the-index-luke.com/no-offset) to achieve
 Add to Gemfile:
 
 ```ruby
-gem 'order_query', '~> 0.3.0'
+gem 'order_query', '~> 0.3.1'
 ```
 
 ## Usage
 
-Define named order conditions with `order_query`:
+Define named order columns with `order_query`:
 
 ```ruby
 class Post < ActiveRecord::Base
@@ -29,7 +29,7 @@ class Post < ActiveRecord::Base
 end
 ```
 
-Order query accepts a list of order conditions as varargs or one array, each one specified as:
+Order query accepts a list of order columns as varargs or one array, each one specified as:
 
 ```ruby
 [<attribute name>, (attribute values in order), (:asc or :desc), (options hash)]
@@ -40,7 +40,6 @@ Available options:
 | option     | description                                                                |
 |------------|----------------------------------------------------------------------------|
 | unique     | Unique attribute. Default: `true` for primary key, `false` otherwise.      |
-| complete   | Specified attribute values are the only possible values. Default: `true`.  |
 | sql        | Customize attribute value SQL                                              |
 
 
@@ -87,9 +86,9 @@ post  = posts.find(42)
 post.order_home(posts) #=> #<OrderQuery::Point>
 ```
 
-### Dynamic conditions
+### Dynamic columns
 
-Query with dynamic order conditions using the `seek(*spec)` class method:
+Query with dynamic order columns using the `seek(*spec)` class method:
 
 ```ruby
 space = Post.visible.seek([:id, :desc]) #=> #<OrderQuery::Space>
@@ -124,7 +123,7 @@ class Post < ActiveRecord::Base
     [:priority, %w(high medium low)],
     # A method and custom SQL can be used instead of an attribute
     [:valid_votes_count, :desc, sql: '(votes - suspicious_votes)'],
-    # Default sort order for non-array conditions is :asc, just like SQL
+    # Default sort order for non-array columns is :asc, just like SQL
     [:updated_at, :desc],
     # pass unique: true for unique attributes to get more optimized queries
     # unique is true by default for primary_key
@@ -153,7 +152,7 @@ ORDER BY
 LIMIT 1
 ```
 
-The actual query is a bit different because `order_query` wraps the top-level `OR` with a (redundant) non-strict condition `x0' AND (x0 OR ...)`
+The actual query is a bit different because `order_query` wraps the top-level `OR` with a (redundant) non-strict column `x0' AND (x0 OR ...)`
 for [performance reasons](https://github.com/glebm/order_query/issues/3).
 This can be disabled with `OrderQuery.wrap_top_level_or = false`.
 

data/lib/order_query/{condition.rb → column.rb}

@@ -1,13 +1,12 @@
 # coding: utf-8
-require 'order_query/sql/condition'
+require 'order_query/sql/column'
 module OrderQuery
-  # An order condition (sort column)
-  class Condition
+  # An order column (sort column)
+  class Column
     attr_reader :name, :order, :order_enum, :options
     delegate :column_name, :quote, to: :@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)
+    # @option spec [String] :unique    Mark the attribute as unique to avoid redundant columns
     def initialize(spec, scope)
       spec    = spec.dup
       options = spec.extract_options!
@@ -24,18 +23,13 @@ module OrderQuery
           complete: true
       )
       @unique   = @options[:unique]
-      @complete = @options[:complete]
-      @sql      = SQL::Condition.new(self, scope)
+      @sql      = SQL::Column.new(self, scope)
     end
 
     def unique?
       @unique
     end
 
-    def complete?
-      @complete
-    end
-
     # @param [Object] value
     # @param [:before, :after] side
     # @return [Array] valid order values before / after passed (depending on the side)
@@ -54,7 +48,7 @@ module OrderQuery
         end
       else
         # default to all if current is not in sort order values
-        ord
+        []
       end
     end
 
@@ -63,7 +57,6 @@ module OrderQuery
           @name,
           (@order_enum.inspect if order_enum),
           ('unique' if @unique),
-          ('complete' if order_enum && complete?),
           (column_name if options[:sql]),
           {desc: '▼', asc: '▲'}[@order]
       ].compact

data/lib/order_query/space.rb

@@ -1,17 +1,22 @@
-require 'order_query/condition'
+require 'order_query/column'
 require 'order_query/sql/order_by'
 module OrderQuery
   # Order specification and a scope
   class Space
-    # @return [Array<OrderQuery::Condition>]
-    attr_reader :conditions
+    # @return [Array<OrderQuery::Column>]
+    attr_reader :columns
 
     # @param [ActiveRecord::Relation] base_scope
     # @param [Array<Array<Symbol,String>>, OrderQuery::Spec] order_spec
     def initialize(base_scope, order_spec)
       @base_scope   = base_scope
-      @conditions   = order_spec.map { |cond_spec| Condition.new(cond_spec, base_scope) }
-      @order_by_sql = SQL::OrderBy.new(@conditions)
+      @columns   = order_spec.map { |cond_spec| Column.new(cond_spec, base_scope) }
+      # 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)
+      end
+      @order_by_sql = SQL::OrderBy.new(@columns)
     end
 
     # @return [Point]
@@ -19,12 +24,12 @@ module OrderQuery
       Point.new(record, self)
     end
 
-    # @return [ActiveRecord::Relation] scope ordered by conditions
+    # @return [ActiveRecord::Relation] scope ordered by columns
     def scope
       @scope ||= @base_scope.order(@order_by_sql.build)
     end
 
-    # @return [ActiveRecord::Relation] scope ordered by conditions in reverse
+    # @return [ActiveRecord::Relation] scope ordered by columns in reverse
     def scope_reverse
       @scope_reverse ||= @base_scope.order(@order_by_sql.build_reverse)
     end
@@ -42,7 +47,7 @@ module OrderQuery
     delegate :count, :empty?, to: :@base_scope
 
     def inspect
-      "#<OrderQuery::Space @conditions=#{@conditions.inspect} @base_scope=#{@base_scope.inspect}>"
+      "#<OrderQuery::Space @columns=#{@columns.inspect} @base_scope=#{@base_scope.inspect}>"
     end
   end
 end

data/lib/order_query/sql/{condition.rb → column.rb}

@@ -1,20 +1,20 @@
 module OrderQuery
   module SQL
-    class Condition
-      attr_reader :condition, :scope
+    class Column
+      attr_reader :column, :scope
 
-      def initialize(condition, scope)
-        @condition = condition
+      def initialize(column, scope)
+        @column = column
         @scope = scope
       end
 
       def column_name
         @column_name ||= begin
-          sql = condition.options[:sql]
+          sql = column.options[:sql]
           if sql
             sql.respond_to?(:call) ? sql.call : sql
           else
-            connection.quote_table_name(scope.table_name) + '.' + connection.quote_column_name(condition.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,9 +1,9 @@
 module OrderQuery
   module SQL
     class OrderBy
-      # @param [Array<Condition>]
-      def initialize(conditions)
-        @conditions = conditions
+      # @param [Array<Column>]
+      def initialize(columns)
+        @columns = columns
       end
 
       # @return [String]
@@ -20,10 +20,10 @@ module OrderQuery
 
       # @return [Array<String>]
       def order_by_sql_clauses
-        @conditions.map { |cond| condition_clause cond }
+        @columns.map { |cond| column_clause cond }
       end
 
-      def condition_clause(cond)
+      def column_clause(cond)
         dir_sql = sort_direction_sql cond.order
         col_sql = cond.column_name
         if cond.order_enum

data/lib/order_query/sql/where.rb

@@ -7,13 +7,13 @@ module OrderQuery
 
       # @param [OrderQuery::Point] point
       def initialize(point)
-        @point      = point
-        @conditions = point.space.conditions
+        @point   = point
+        @columns = point.space.columns
       end
 
-      # Join condition pairs with OR, and nest within each other with AND
+      # Join column pairs with OR, and nest within each other with AND
       # @param [:before or :after] side
-      # @return [query, parameters] WHERE conditions 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,14 +21,14 @@ module OrderQuery
       #       ... ))
       def build(side)
         # generate pairs of terms such as sales < 5, sales = 5
-        parts = @conditions.map { |cond|
-          [where_side(cond, side, true), where_tie(cond)].reject { |x| x == WHERE_IDENTITY }
+        terms = @columns.map { |col|
+          [where_side(col, side, true), where_tie(col)].reject { |x| x == WHERE_IDENTITY }
         }
         # group pairwise with OR, and nest with AND
-        query = foldr_terms parts.map { |terms| join_terms 'OR'.freeze, *terms }, 'AND'.freeze
+        query = foldr_terms terms.map { |pair| join_terms 'OR'.freeze, *pair }, 'AND'.freeze
         if ::OrderQuery.wrap_top_level_or
           # wrap in a redundant AND clause for performance
-          query = wrap_top_level_or query, parts, side
+          query = wrap_top_level_or query, terms, side
         end
         query
       end
@@ -44,7 +44,7 @@ module OrderQuery
         end
       end
 
-      # joins terms with an operator
+      # 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([], :+)]
@@ -63,61 +63,55 @@ module OrderQuery
       #    (sales < 5 OR
       #       (sales = 5 AND ...)))
       # Read more at https://github.com/glebm/order_query/issues/3
-      def wrap_top_level_or(query, pairs, side)
-        top_pair_idx = pairs.index(&:present?)
-        if top_pair_idx &&
-            (top_pair = pairs[top_pair_idx]).length == 2 &&
-            top_pair.first != (redundant_cond = where_side(@conditions[top_pair_idx], side, false))
-          join_terms 'AND'.freeze, redundant_cond, wrap_term_with_parens(query)
+      def wrap_top_level_or(query, terms, side)
+        top_term_i = terms.index(&:present?)
+        if top_term_i && terms[top_term_i].length == 2 &&
+            (cond = where_side(@columns[top_term_i], side, false)) != WHERE_IDENTITY
+          join_terms 'AND'.freeze, cond, wrap_term_with_parens(query)
         else
           query
         end
       end
 
-      # @return [query, params] tie-breaker unless condition is unique
-      def where_tie(cond)
-        if cond.unique?
+      # @return [query, params] tie-breaker unless column is unique
+      def where_tie(col)
+        if col.unique?
           WHERE_IDENTITY
         else
-          where_eq(cond)
+          where_eq(col)
         end
       end
 
       # @param [:before or :after] side
-      # @return [query, params] return query conditions for attribute values before / after the current one
-      def where_side(cond, side, strict = true, value = point.value(cond))
-        if cond.order_enum
-          values = cond.enum_side(value, side, strict)
-          if cond.complete? && values.length == cond.order_enum.length
-            WHERE_IDENTITY
-          else
-            where_in cond, values
-          end
+      # @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)
         else
-          where_ray cond, value, side, strict
+          where_ray col, value, side, strict
         end
       end
 
-      def where_in(cond, values)
+      def where_in(col, values)
         case values.length
           when 0
             WHERE_IDENTITY
           when 1
-            where_eq cond, values[0]
+            where_eq col, values[0]
           else
-            ["#{cond.column_name} IN (?)".freeze, [values]]
+            ["#{col.column_name} IN (?)".freeze, [values]]
         end
       end
 
-      def where_eq(cond, value = point.value(cond))
-        [%Q(#{cond.column_name} = ?).freeze, [value]]
+      def where_eq(col, value = point.value(col))
+        [%Q(#{col.column_name} = ?).freeze, [value]]
       end
 
-      def where_ray(cond, from, mode, strict = true)
+      def where_ray(col, from, mode, strict = true)
         ops = %w(< >)
         ops = ops.reverse if mode == :after
-        op  = {asc: ops[0], desc: ops[1]}[cond.order || :asc]
-        ["#{cond.column_name} #{op}#{'=' unless strict} ?".freeze, [from]]
+        op  = {asc: ops[0], desc: ops[1]}[col.order || :asc]
+        ["#{col.column_name} #{op}#{'=' unless strict} ?".freeze, [from]]
       end
 
       WHERE_IDENTITY = [''.freeze, [].freeze].freeze

data/lib/order_query/version.rb

@@ -1,3 +1,3 @@
 module OrderQuery
-  VERSION = '0.3.0'
+  VERSION = '0.3.1'
 end

data/lib/order_query.rb

@@ -66,10 +66,10 @@ module OrderQuery
       scope name, -> {
         send(space_method).scope
       }
-      scope :"#{name}_reverse", -> {
+      scope "#{name}_reverse", -> {
         send(space_method).scope_reverse
       }
-      define_singleton_method "#{name}_at", -> (record) {
+      define_singleton_method "#{name}_at", ->(record) {
         send(space_method).at(record)
       }
       define_method(name) { |scope = nil|
@@ -81,6 +81,6 @@ module OrderQuery
   class << self
     attr_accessor :wrap_top_level_or
   end
-  # Wrap top-level or with an AND and a redundant condition for performance
+  # Wrap top-level or with an AND and a redundant column for performance
   self.wrap_top_level_or = true
 end

data/spec/order_query_spec.rb

@@ -9,7 +9,7 @@ end
 class Post < ActiveRecord::Base
   include OrderQuery
   order_query :order_list,
-              [:pinned, [true, false], complete: true],
+              [:pinned, [true, false]],
               [:published_at, :desc],
               [:id, :desc]
 end
@@ -21,7 +21,8 @@ end
 # Advanced model
 class Issue < ActiveRecord::Base
   DISPLAY_ORDER = [
-      [:priority, %w(high medium low), complete: true],
+      [:pinned, [true, false]],
+      [:priority, %w(high medium low)],
       [:valid_votes_count, :desc, sql: '(votes - suspicious_votes)'],
       [:updated_at, :desc],
       [:id, :desc]
@@ -63,9 +64,11 @@ describe 'OrderQuery' do
         t        = Time.now
         datasets = [
             [
+                ['high', 5, 0, t, true],
+                ['high', 5, 1, t, true],
                 ['high', 5, 0, t],
+                ['high', 5, 0, t - 1.day],
                 ['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]
@@ -85,7 +88,7 @@ describe 'OrderQuery' do
         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])
+              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)
@@ -161,7 +164,7 @@ describe 'OrderQuery' do
           end
         end
 
-        it '#seek falls back to scope when order condition is missing self' 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)
@@ -176,6 +179,7 @@ describe 'OrderQuery' do
             self.verbose = false
 
             create_table :issues do |t|
+              t.column :pinned, :boolean, null: false, default: false
               t.column :priority, :string
               t.column :votes, :integer
               t.column :suspicious_votes, :integer

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: order_query
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Gleb Mazovetskiy
@@ -78,10 +78,10 @@ files:
 - README.md
 - Rakefile
 - lib/order_query.rb
-- lib/order_query/condition.rb
+- lib/order_query/column.rb
 - lib/order_query/point.rb
 - lib/order_query/space.rb
-- lib/order_query/sql/condition.rb
+- lib/order_query/sql/column.rb
 - lib/order_query/sql/order_by.rb
 - lib/order_query/sql/where.rb
 - lib/order_query/version.rb