sortable-by 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b5117bc573fa2cf18ccee9dec86c53cd09920af83463e161ad97c34a50c87c4
-  data.tar.gz: 47bed91f217dfc04a5d9180040a18a163e0f2da6597059bb73ce8390c01d5d6e
+  metadata.gz: bc4cdc4741e458addb43e7d95a66f12695cf601f4178d188de2fa5197d6dc199
+  data.tar.gz: b1c4bb549dcdea2ca6879d5c4e360b75d099171ed2a3b1bd4e28fa89e0b968d9
 SHA512:
-  metadata.gz: 68712cabc1e8d2bc54d4716d27cd896170fad207448814a0c784f7a018bd2da8b0fad7d26ba1cfca8cb884969665f014c3aa0912c457fbb2465a1fa4c7214c5c
-  data.tar.gz: 9d9b0f42b50c94cbcd36eec6cb2b1c1367150943a6c252092d84d45b3aecdb5ea1431ff227faa68db045b32fc02983f4d0bcb41fa1619a9f28d4a1ffd1789666
+  metadata.gz: 381a3fbb778b6540e44f76de77b733781f26686848342235b865608bcaa5aaa5878bbf184de2386570568642c637d419ffe7a68eb980ecd7e084eaf8564ad98c
+  data.tar.gz: 705e4e7a6eae3f496ae2e84f3d2f818c4a0c2341d2e93bdb7ebde678bbc32d0f8b7c4375447168025c222bd466dde5ba72cd2624690ef5c5c99c03cb66c094e3

data/.gitignore

@@ -1,3 +1,4 @@
 spec/tmp
 pkg
 *.gem
+.rake_tasks~

data/.rubocop.yml

@@ -1,15 +1,26 @@
 AllCops:
   TargetRubyVersion: 2.2
 
+Naming/MemoizedInstanceVariableName:
+  Enabled: false
+
 Metrics/AbcSize:
   Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/PerceivedComplexity:
+  Enabled: false
 Naming/FileName:
   Exclude: [lib/sortable-by.rb]
+Metrics/BlockLength:
+  Exclude: [spec/**]
 Metrics/MethodLength:
-  Max: 20
+  Enabled: false
 Metrics/LineLength:
   Max: 120
 
+Style/NumericLiterals:
+  Exclude: [spec/**]
 Style/TrailingCommaInArguments:
   EnforcedStyleForMultiline: consistent_comma
 Style/TrailingCommaInArrayLiteral:

data/.travis.yml

@@ -3,6 +3,5 @@ rvm:
   - 2.2
   - 2.3
   - 2.4
-  - 2.5
 gemfile:
   - Gemfile

data/Gemfile.lock

@@ -1,37 +1,37 @@
 PATH
   remote: .
   specs:
-    sortable-by (0.10.0)
+    sortable-by (0.11.0)
       activerecord
       activesupport
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (5.1.5)
-      activesupport (= 5.1.5)
-    activerecord (5.1.5)
-      activemodel (= 5.1.5)
-      activesupport (= 5.1.5)
-      arel (~> 8.0)
-    activesupport (5.1.5)
+    activemodel (5.2.0)
+      activesupport (= 5.2.0)
+    activerecord (5.2.0)
+      activemodel (= 5.2.0)
+      activesupport (= 5.2.0)
+      arel (>= 9.0)
+    activesupport (5.2.0)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (~> 0.7)
+      i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    arel (8.0.0)
+    arel (9.0.0)
     ast (2.4.0)
     concurrent-ruby (1.0.5)
     diff-lcs (1.3)
-    i18n (0.9.5)
+    i18n (1.0.0)
       concurrent-ruby (~> 1.0)
     minitest (5.11.3)
     parallel (1.12.1)
-    parser (2.5.0.4)
+    parser (2.5.0.5)
       ast (~> 2.4.0)
     powerpack (0.1.1)
     rainbow (3.0.0)
-    rake (12.3.0)
+    rake (12.3.1)
     rspec (3.7.0)
       rspec-core (~> 3.7.0)
       rspec-expectations (~> 3.7.0)
@@ -45,7 +45,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.7.0)
     rspec-support (3.7.1)
-    rubocop (0.53.0)
+    rubocop (0.54.0)
       parallel (~> 1.10)
       parser (>= 2.5)
       powerpack (~> 0.1)

data/README.md

@@ -13,38 +13,75 @@ Add `gem 'sortable-by'` to your Gemfile.
 
 ## Usage
 
-Simple use case:
+Simple:
 
 ```ruby
-class Foo < ActiveRecord::Base
-  sortable_by :title, :updated_at, default: { updated_at: :desc }
+class Post < ActiveRecord::Base
+  sortable_by :title, :id
 end
 
-Foo.sorted_by "-updated_at,title" # => ORDER BY foos.updated_at DESC, foos.title ASC
-Foo.sorted_by "bad,title"         # => ORDER BY foos.title ASC
-Foo.sorted_by nil                 # => ORDER BY foos.updated_at DESC
+Post.sorted_by('title')     # => ORDER BY posts.title ASC
+Post.sorted_by('-title')    # => ORDER BY posts.title DESC
+Post.sorted_by('bad,title') # => ORDER BY posts.title ASC
+Post.sorted_by(nil)         # => ORDER BY posts.title ASC
 ```
 
-Aliases and composition:
+Case-insensitive:
 
 ```ruby
-class Foo < ActiveRecord::Base
-  sortable_by semver: %i[major minor patch], default: { id: :asc }
+class Post < ActiveRecord::Base
+  sortable_by do |x|
+    x.field :title, as: arel_table[:title].lower
+    x.field :id
+  end
 end
 
-Foo.sorted_by "semver"   # => ORDER BY foos.major ASC, foos.minor ASC, foos.patch ASC
-Foo.sorted_by "-semver"  # => ORDER BY foos.major DESC, foos.minor DESC, foos.patch DESC
-Foo.sorted_by nil        # => ORDER BY foos.id ASC
+Post.sorted_by('title') # => ORDER BY LOWER(posts.title) ASC
 ```
 
-Custom functions:
+With custom default:
 
 ```ruby
-class Foo < ActiveRecord::Base
-  sortable_by insensitive: Arel::Nodes::NamedFunction.new('LOWER', [arel_table[:title]]), default: { id: :asc }
+class Post < ActiveRecord::Base
+  sortable_by :id, :topic, :created_at, default: 'topic,-created_at'
 end
 
-Foo.sorted_by "insensitive"   # => ORDER BY LOWER(foos.title) ASC
-Foo.sorted_by "-insensitive"  # => ORDER BY LOWER(foos.title) DESC
-Foo.sorted_by nil             # => ORDER BY foos.id ASC
+Post.sorted_by(nil) # => ORDER BY posts.topic ASC, posts.created_at DESC
+```
+
+Composition:
+
+```ruby
+class App < ActiveRecord::Base
+  sortable_by :name, default: '-version' do |x|
+    x.field :version, as: %i[major minor patch]]
+  end
+end
+
+App.sorted_by('version') # => ORDER BY apps.major ASC, apps.minor ASC, apps.patch ASC
+App.sorted_by(nil)       # => ORDER BY apps.major DESC, apps.minor DESC, apps.patch DESC
+```
+
+Associations (eager load):
+
+```ruby
+class Product < ActiveRecord::Base
+  belongs_to :shop
+  sortable_by do |x|
+    x.field :name, as: arel_table[:name].lower
+    x.field :shop, as: Shop.arel_table[:name].lower, eager_load: :shop
+    x.default 'shop,name'
+  end
+end
+```
+
+Associations (custom scope):
+
+```
+class Product < ActiveRecord::Base
+  belongs_to :shop
+  sortable_by do |x|
+    x.field :shop, as: Shop.arel_table[:name].lower, scope: -> { joins(:shop) }
+  end
+end
 ```

data/Rakefile

@@ -6,4 +6,4 @@ require 'rubocop/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 RuboCop::RakeTask.new(:rubocop)
 
-task default: :spec
+task default: %i[spec rubocop]

data/lib/sortable_by.rb

@@ -1,71 +1,44 @@
 require 'active_record'
-require 'active_support/concern'
-require 'set'
 
 module ActiveRecord # :nodoc:
-  module SortableByHelper # :nodoc:
-    extend ActiveSupport::Concern
+  module SortableBy # :nodoc:
+    class Config # :nodoc:
+      attr_reader :_fields, :_default
 
-    included do
-      class_attribute :_sortable_by_scope_options, instance_accessor: false
-      sortable_by
-    end
-
-    def self.validate_custom_scope!(custom, original = custom)
-      case custom
-      when true, Arel::Nodes::Node, String, Symbol
-        nil # OK
-      when Array
-        custom.each do |v|
-          validate_custom_scope!(v, original)
-        end
-      else
-        raise ArgumentError, "Option #{original.inspect} contains unexpected values."
+      def initialize
+        @_fields  = {}
+        @_default = nil
       end
-    end
 
-    def self.order_clause(name, rank, value)
-      case value
-      when true
-        { name => rank }
-      when String, Symbol
-        { value => rank }
-      when Arel::Nodes::Node
-        value.send(rank)
-      when Array
-        value.map { |v| order_clause(name, rank, v) }
+      def dup
+        duplicate = self.class.new
+        duplicate.instance_variable_set :@_fields, _fields.deep_dup
+        duplicate.instance_variable_set :@_default, _default.deep_dup
+        duplicate
       end
-    end
 
-    module ClassMethods # :nodoc:
-      # Copy _sortable_by_scope_options on inheritance.
-      def inherited(base) #:nodoc:
-        base._sortable_by_scope_options = _sortable_by_scope_options.deep_dup
-        super
+      def field(name, opts = {})
+        name = name.to_s
+        @_fields[name] = Field.new(name, opts)
+        @_default ||= name
       end
 
-      # Provide a whitelist and options for sorted_by
-      def sortable_by(*whitelist)
-        self._sortable_by_scope_options ||= { scopes: {}, default: { id: :asc } }
-
-        opts = whitelist.extract_options!
-        default = opts.delete(:default)
-        self._sortable_by_scope_options[:default] = default if default
-
-        whitelist.each do |attr|
-          self._sortable_by_scope_options[:scopes][attr.to_s] = true
-        end
-        opts.each do |attr, custom|
-          SortableByHelper.validate_custom_scope!(custom)
-          self._sortable_by_scope_options[:scopes][attr.to_s] = custom
+      def default(expr)
+        # legacy support
+        if expr.is_a?(Hash)
+          expr = expr.map do |field, dir|
+            [(dir == :desc ? '-' : ''), field].join
+          end.join(',')
         end
+
+        @_default = expr.to_s
       end
 
-      # @param [String] expr the sort expr
-      # @return [ActiveRecord::Relation] the scoped relation
-      def sorted_by(expr)
-        relation = self
-        matches = expr.to_s.split(',').count do |name|
+      protected
+
+      def order(relation, expr, fallback = true)
+        matched = false
+        expr.to_s.split(',').each do |name|
           name.strip!
 
           rank = :asc
@@ -74,23 +47,142 @@ module ActiveRecord # :nodoc:
             name = name[1..-1]
           end
 
-          value  = self._sortable_by_scope_options[:scopes][name]
-          clause = SortableByHelper.order_clause(name, rank, value)
-          relation = relation.order(clause) if clause
-          clause
+          field = _fields[name]
+          next unless field
+
+          matched  = true
+          relation = field.order(relation, rank)
         end
 
-        if matches.zero?
-          default  = self._sortable_by_scope_options[:default]
-          relation = relation.order(default)
+        relation = order(relation, _default, false) if fallback && !matched && _default
+        relation
+      end
+    end
+
+    class Field # :nodoc:
+      def initialize(name, opts = {})
+        @cols = Array.wrap(opts[:as])
+        @eager_load = Array.wrap(opts[:eager_load]).presence
+
+        # validate custom_scope
+        @custom_scope = opts[:scope]
+        if @custom_scope && !@custom_scope.is_a?(Proc)
+          raise ArgumentError, "Invalid sortable-by field '#{name}': scope must be a Proc."
         end
 
+        # normalize cols
+        @cols.push name if @cols.empty?
+        @cols.each do |col|
+          case col
+          when String, Symbol, Arel::Attributes::Attribute, Arel::Nodes::Node
+            next
+          when Proc
+            unless col.arity == 2
+              raise ArgumentError, "Invalid sortable-by field '#{name}': proc must accept 2 arguments."
+            end
+          else
+            raise ArgumentError, "Invalid sortable-by field '#{name}': invalid type #{col.class}."
+          end
+        end
+      end
+
+      def order(relation, rank)
+        @cols.each do |col|
+          case col
+          when String, Symbol
+            relation = relation.order(col => rank)
+          when Arel::Nodes::Node, Arel::Attributes::Attribute
+            relation = relation.order(col.send(rank))
+          when Proc
+            relation = col.call(relation, rank)
+          end
+        end
+
+        relation = relation.eager_load(*@eager_load) if @eager_load
+        relation = relation.instance_eval(&@custom_scope) if @custom_scope
         relation
       end
     end
+
+    def self.extended(base) # :nodoc:
+      base.class_attribute :_sortable_by_config, instance_accessor: false, instance_predicate: false
+      base._sortable_by_config = Config.new
+    end
+
+    def inherited(base) # :nodoc:
+      base._sortable_by_config = _sortable_by_config.deep_dup
+      super
+    end
+
+    # Declare sortable attributes and scopes. Examples:
+    #
+    #   # Simple
+    #   class Post < ActiveRecord::Base
+    #     sortable_by :title, :id
+    #   end
+    #
+    #   # Case-insensitive
+    #   class Post < ActiveRecord::Base
+    #     sortable_by do |x|
+    #       x.field :title, as: arel_table[:title].lower
+    #       x.field :id
+    #     end
+    #   end
+    #
+    #   # With default
+    #   class Post < ActiveRecord::Base
+    #     sortable_by :id, :topic, :created_at,
+    #       default: 'topic,-created_at'
+    #   end
+    #
+    #   # Composition
+    #   class App < ActiveRecord::Base
+    #     sortable_by :name, default: '-version' do |x|
+    #       x.field :version, as: %i[major minor patch]]
+    #     end
+    #   end
+    #
+    #   # Associations (eager load)
+    #   class Product < ActiveRecord::Base
+    #     belongs_to :shop
+    #
+    #     sortable_by do |x|
+    #       x.field :name
+    #       x.field :shop, as: Shop.arel_table[:name].lower, eager_load: :shop
+    #       x.default 'shop,name'
+    #     end
+    #   end
+    #
+    #   # Associations (custom scope)
+    #   class Product < ActiveRecord::Base
+    #     belongs_to :shop
+    #
+    #     sortable_by do |x|
+    #       x.field :shop, as: Shop.arel_table[:name].lower, scope: -> { joins(:shop) }
+    #     end
+    #   end
+    #
+    def sortable_by(*attributes)
+      config  = _sortable_by_config
+      opts    = attributes.extract_options!
+      default = opts.delete(:default)
+
+      attributes.each do |name|
+        config.field(name, opts)
+      end
+      config.default(default) if default
+      yield config if block_given?
+      config
+    end
+
+    # @param [String] expr the sort expr
+    # @return [ActiveRecord::Relation] the scoped relation
+    def sorted_by(expr)
+      _sortable_by_config.send :order, self, expr
+    end
   end
 
   class Base # :nodoc:
-    include SortableByHelper
+    extend SortableBy
   end
 end

data/sortable-by.gemspec

@@ -1,7 +1,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'sortable-by'
-  s.version     = '0.10.0'
+  s.version     = '0.11.0'
   s.authors     = ['Dimitrij Denissenko']
   s.email       = ['dimitrij@blacksquaremedia.com']
   s.summary     = 'Generate white-listed sort scopes from URL parameter values'

data/spec/sortable_by_spec.rb

@@ -1,28 +1,86 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.expand_path('./spec_helper', __dir__)
+
+describe ActiveRecord::SortableBy do
+  before do
+    c = ActiveRecord::Base.connection
+    c.tables.each do |t|
+      c.update "DELETE FROM #{t}"
+    end
+  end
 
-describe ActiveRecord::SortableByHelper do
   it 'should have config' do
-    expect(Foo._sortable_by_scope_options).to include(:default, :scopes)
-    expect(Foo._sortable_by_scope_options[:default]).to eq(title: :asc)
-    expect(Foo._sortable_by_scope_options[:scopes]).to be_instance_of(Hash)
-    expect(Foo._sortable_by_scope_options[:scopes]).to include('title', 'age', 'semver', 'insensitive')
-    expect(Bar._sortable_by_scope_options).to eq(default: { id: :asc }, scopes: {})
+    expect(Post._sortable_by_config._fields.keys).to match_array(%w[title created])
+    expect(Post._sortable_by_config._default).to eq('-created')
+    expect(SubPost._sortable_by_config._fields.keys).to match_array(%w[title created])
+    expect(SubPost._sortable_by_config._default).to eq('-created')
+
+    expect(App._sortable_by_config._fields.keys).to match_array(%w[name version])
+    expect(App._sortable_by_config._default).to eq('name')
+
+    expect(Shop._sortable_by_config._fields.keys).to be_empty
+    expect(Shop._sortable_by_config._default).to be_nil
+
+    expect(Product._sortable_by_config._fields.keys).to match_array(%w[name shop])
+    expect(Product._sortable_by_config._default).to eq('shop,name')
+  end
+
+  it 'should simply order' do
+    Post.create! title: 'A', created_at: Time.at(1515151500)
+    Post.create! title: 'b', created_at: Time.at(1515151600)
+    Post.create! title: 'C', created_at: Time.at(1515151400)
+
+    expect(Post.sorted_by(nil).pluck(:title)).to eq(%w[b A C])
+    expect(Post.sorted_by('').pluck(:title)).to eq(%w[b A C])
+    expect(Post.sorted_by('invalid').pluck(:title)).to eq(%w[b A C])
+
+    expect(Post.sorted_by('-created').pluck(:title)).to eq(%w[b A C])
+    expect(Post.sorted_by('created').pluck(:title)).to eq(%w[C A b])
+
+    expect(Post.sorted_by('title').pluck(:title)).to eq(%w[A C b])
+    expect(Post.sorted_by('-title').pluck(:title)).to eq(%w[b C A])
+    expect(Post.sorted_by('   title ').pluck(:title)).to eq(%w[A C b])
   end
 
-  it 'should generate scopes' do
-    expect(Foo.sorted_by('title').pluck(:title)).to eq(%w[A B C b])
-    expect(Foo.sorted_by('-title').pluck(:title)).to eq(%w[b C B A])
-    expect(Foo.sorted_by('age,title').pluck(:title)).to eq(%w[B A b C])
-    expect(Foo.sorted_by('invalid , -age').pluck(:title)).to eq(%w[C b A B])
-    expect(Foo.sorted_by('insensitive,age').pluck(:title)).to eq(%w[A B b C])
-    expect(Foo.sorted_by('-insensitive,age').pluck(:title)).to eq(%w[C B b A])
-    expect(Foo.sorted_by('semver').pluck(:title)).to eq(%w[b B C A])
-    expect(Foo.sorted_by('-semver').pluck(:title)).to eq(%w[A C B b])
-    expect(Foo.sorted_by('').pluck(:title)).to eq(%w[A B C b])
-    expect(Foo.sorted_by(nil).pluck(:title)).to eq(%w[A B C b])
-
-    expect(Bar.sorted_by('').pluck(:title)).to eq(%w[Y X])
-    expect(Bar.sorted_by('title').pluck(:title)).to eq(%w[Y X])
-    expect(Bar.where(title: 'X').sorted_by('title').pluck(:title)).to eq(%w[X])
+  it 'should support STI inheritance and overrides' do
+    SubPost.create! title: 'A', created_at: Time.at(1515151700)
+    SubPost.create! title: 'b', created_at: Time.at(1515151600)
+    Post.create! title: 'C', created_at: Time.at(1515151400)
+    SubPost.create! title: 'D', created_at: Time.at(1515151500)
+
+    expect(Post.sorted_by(nil).pluck(:title)).to eq(%w[A b D C])
+    expect(SubPost.sorted_by(nil).pluck(:title)).to eq(%w[A b D])
+    expect(SubPost.sorted_by('-created').pluck(:title)).to eq(%w[A b D])
+    expect(SubPost.sorted_by('created').pluck(:title)).to eq(%w[D b A])
+
+    expect(Post.sorted_by('title').pluck(:title)).to eq(%w[A C D b])
+    expect(SubPost.sorted_by('title').pluck(:title)).to eq(%w[A b D])
+  end
+
+  it 'should support composition' do
+    App.create! name: 'E', major: 0, minor: 9, patch: 2
+    App.create! name: 'A', major: 1, minor: 0, patch: 1
+    App.create! name: 'D', major: 1, minor: 0, patch: 6
+    App.create! name: 'C', major: 1, minor: 1, patch: 0
+    App.create! name: 'B', major: 2, minor: 2, patch: 0
+
+    expect(App.sorted_by(nil).pluck(:name)).to eq(%w[A B C D E])
+    expect(App.sorted_by('version').pluck(:name)).to eq(%w[E A D C B])
+    expect(App.sorted_by('-version').pluck(:name)).to eq(%w[B C D A E])
+  end
+
+  it 'should support associations' do
+    y = Shop.create! name: 'Y'
+    x = Shop.create! name: 'X'
+
+    Product.create! name: 'a', shop_id: y.id
+    Product.create! name: 'B', shop_id: y.id, active: false
+    Product.create! name: 'c', shop_id: x.id
+    Product.create! name: 'D', shop_id: y.id
+    Product.create! name: 'e', shop_id: x.id
+    Product.create! name: 'f', shop_id: x.id, active: false
+
+    expect(Product.sorted_by(nil).pluck(:name)).to eq(%w[c e f a B D])
+    expect(Product.where(active: true).sorted_by(nil).pluck(:name)).to eq(%w[c e a D])
+    expect(Product.sorted_by('name').pluck(:name)).to eq(%w[a B c D e f])
   end
 end

data/spec/spec_helper.rb

@@ -7,36 +7,64 @@ ActiveRecord::Base.configurations['test'] = {
   'database' => ':memory:',
 }
 ActiveRecord::Base.establish_connection :test
-ActiveRecord::Base.connection.create_table :foos do |t|
-  t.string :title
-  t.integer :age
 
-  t.integer :major
-  t.integer :minor
+ActiveRecord::Base.connection.create_table :posts do |t|
+  t.string :type
+  t.string :title, null: false
+  t.timestamp :created_at, null: false
 end
 
-ActiveRecord::Base.connection.create_table :bars do |t|
-  t.string :title
+class Post < ActiveRecord::Base
+  sortable_by :title, default: '-created' do |s|
+    s.field :created, as: arel_table[:created_at]
+  end
 end
 
-ActiveRecord::Base.connection.create_table :boos do |t|
-  t.string :title
+class SubPost < Post
+  sortable_by do |s|
+    s.field :title, as: arel_table[:title].lower
+  end
 end
 
-class Foo < ActiveRecord::Base
-  sortable_by :title, :age,
-              insensitive: Arel::Nodes::NamedFunction.new('LOWER', [arel_table[:title]]),
-              semver: %i[major minor],
-              default: { title: :asc }
+# ---------------------------------------------------------------------
+
+ActiveRecord::Base.connection.create_table :apps do |t|
+  t.string :name, null: false
+  t.integer :major, null: false
+  t.integer :minor, null: false
+  t.integer :patch, null: false
+end
+
+class App < ActiveRecord::Base
+  sortable_by :name do |s|
+    s.field :version, as: %i[major minor patch]
+  end
+end
+
+# ---------------------------------------------------------------------
+
+ActiveRecord::Base.connection.create_table :shops do |t|
+  t.string :name, null: false
 end
 
-class Bar < ActiveRecord::Base
+class Shop < ActiveRecord::Base
 end
 
-Foo.create! title: 'A', age: 25, major: 10, minor: 1
-Foo.create! title: 'B', age: 24, major: 8, minor: 3
-Foo.create! title: 'b', age: 26, major: 0, minor: 2
-Foo.create! title: 'C', age: 27, major: 8, minor: 6
+# ---------------------------------------------------------------------
+
+ActiveRecord::Base.connection.create_table :products do |t|
+  t.string :name, null: false
+  t.integer :shop_id, null: false
+  t.boolean :active, null: false, default: true
+  t.foreign_key :shops
+end
 
-Bar.create! title: 'Y'
-Bar.create! title: 'X'
+class Product < ActiveRecord::Base
+  belongs_to :shop
+
+  sortable_by do |s|
+    s.field :name, as: arel_table[:name].lower
+    s.field :shop, as: Shop.arel_table[:name].lower, eager_load: :shop
+    s.default 'shop,name'
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sortable-by
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Dimitrij Denissenko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-19 00:00:00.000000000 Z
+date: 2018-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord