scoped_from 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88f3cb11e67b82da5d005daacea281154d2818ba
-  data.tar.gz: 981bb72c4e756353749084e3503ab9b03469cfd4
+  metadata.gz: 91ae1b8a113e2c3b176c538a4d83870913cdb16c
+  data.tar.gz: e06f1e812ed6ed939eaa37b90dab44728225d2b7
 SHA512:
-  metadata.gz: 82a281b707f6eb1d102131e06c9da5dcf7dec0a178d2ecc0b034e84589dc7ec4267362c56be037792011e809c6e1eb2200f2d6f0bce92af0576fc08b2e6378d1
-  data.tar.gz: 79c0f7e9e6b4ab871aa2243fae328f004a6a1aa8ebb4bb750d1a58903e8e059626dd52f65d0e0fb5e9937f2df67f5513a19262a0a77dc14952c6c1947faa6cf6
+  metadata.gz: e8c903abd9c23d0a66c4956119c810eef2523be47e7cec2772fe5afa3345e716516fd015d084da3d4cd27a1f5e5437054fe60005c0ca8ae3c66ceea96300f12d
+  data.tar.gz: 7eedfbdca7944970a41fffd50806c6788406bff4f37b9f1f533e3af4ef3ee03596340f79b57ce7e5c149e5507de2cd4432411d158f82d229cc11411af95e7722

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.0.2

data/scoped_from.gemspec

@@ -9,13 +9,12 @@ Gem::Specification.new do |s|
   s.description = 'Provides a simple mapping between Active Record scopes and controller parameters for Ruby On Rails 4'
   s.license = 'MIT'
 
-  s.rubyforge_project = 'scoped_from'
-
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.files = `git ls-files | grep -vE '^(spec/|test/|\\.|Gemfile|Rakefile)'`.split("\n")
   s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
 
+  s.required_ruby_version = '>= 2.0.0'
+
   s.add_dependency 'activerecord', '>= 5.0.0', '< 5.1.0'
   s.add_dependency 'activesupport', '>= 5.0.0', '< 5.1.0'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scoped_from
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Alexis Toulotte
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-22 00:00:00.000000000 Z
+date: 2017-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -157,30 +157,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- Gemfile
 - MIT-LICENSE
 - README.mdown
-- Rakefile
 - VERSION
 - lib/scoped_from.rb
 - lib/scoped_from/active_record.rb
 - lib/scoped_from/query.rb
 - scoped_from.gemspec
-- spec/mocks/comment.rb
-- spec/mocks/comment_query.rb
-- spec/mocks/post.rb
-- spec/mocks/user.rb
-- spec/mocks/user_query.rb
-- spec/mocks/vote.rb
-- spec/mocks/vote_query.rb
-- spec/scoped_from/active_record_spec.rb
-- spec/scoped_from/query_spec.rb
-- spec/scoped_from_spec.rb
-- spec/spec_helper.rb
-- spec/support/bootstrap/database.rb
-- spec/support/macros/user_macro.rb
 homepage: https://github.com/alexistoulotte/scoped_from
 licenses:
 - MIT
@@ -193,15 +176,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: scoped_from
-rubygems_version: 2.5.1
+rubyforge_project: 
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Mapping between scopes and parameters for Rails

data/.gitignore

@@ -1,7 +0,0 @@
-.DS_Store
-.byebug_history
-/.bundle/
-/.ruby-version
-/Gemfile.lock
-/pkg/
-/spec/test.sqlite3

data/.rspec

@@ -1,2 +0,0 @@
---colour
---order random

data/Gemfile

@@ -1,3 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec

data/Rakefile

@@ -1,10 +0,0 @@
-require 'bundler'
-require 'rspec/core/rake_task'
-
-Bundler::GemHelper.install_tasks
-
-desc 'Default: runs specs.'
-task default: :spec
-
-desc 'Run all specs in spec directory.'
-RSpec::Core::RakeTask.new(:spec)

data/spec/mocks/comment.rb

@@ -1,2 +0,0 @@
-class Comment < ActiveRecord::Base
-end

data/spec/mocks/comment_query.rb

@@ -1,2 +0,0 @@
-class CommentQuery < ScopedFrom::Query
-end

data/spec/mocks/post.rb

@@ -1,2 +0,0 @@
-class Post < ActiveRecord::Base
-end

data/spec/mocks/user.rb

@@ -1,8 +0,0 @@
-class User < ActiveRecord::Base
-
-  scope :enabled, -> { where(enabled: true) }
-  scope :search, -> (pattern) { where('firstname LIKE ? OR lastname LIKE ?', "%#{pattern}%", "%#{pattern}%") }
-  scope :created_between, -> (after, before) { where('created_at >= ? AND created_at <= ?', after, before) }
-  scope :latest, -> { where('created_at >= ?', 1.week.ago) }
-
-end

data/spec/mocks/user_query.rb

@@ -1,2 +0,0 @@
-class UserQuery < String
-end

data/spec/mocks/vote.rb

@@ -1,2 +0,0 @@
-class Vote < ActiveRecord::Base
-end

data/spec/mocks/vote_query.rb

@@ -1,2 +0,0 @@
-module VoteQuery
-end

data/spec/scoped_from/active_record_spec.rb

@@ -1,125 +0,0 @@
-require 'spec_helper'
-
-describe ScopedFrom::ActiveRecord do
-
-  describe '#scope_with_one_argument?' do
-
-    it 'is true if scope has one argument' do
-      expect(User.scope_with_one_argument?(:search)).to be(true)
-      expect(User.scope_with_one_argument?('search')).to be(true)
-    end
-
-    it 'is false if scope has no argument' do
-      expect(User.scope_with_one_argument?(:latest)).to be(false)
-      expect(User.scope_with_one_argument?('latest')).to be(false)
-    end
-
-    it 'is false if scope has more than one argument' do
-      expect(User.scope_with_one_argument?(:created_between)).to be(false)
-      expect(User.scope_with_one_argument?('created_between')).to be(false)
-    end
-
-    it 'is false if scope is not a proc' do
-      expect(User.scope_with_one_argument?(:enabled)).to be(false)
-      expect(User.scope_with_one_argument?('enabled')).to be(false)
-    end
-
-    it 'is false if scope does not exist' do
-      expect(User.scope_with_one_argument?(:foo)).to be(false)
-      expect(User.scope_with_one_argument?('foo')).to be(false)
-    end
-
-  end
-
-  describe 'scope_without_argument?' do
-
-    it 'is true if scope has no argument' do
-      expect(User.scope_without_argument?(:latest)).to be(true)
-      expect(User.scope_without_argument?('latest')).to be(true)
-    end
-
-    it 'is true if scope is not a proc' do
-      expect(User.scope_without_argument?(:enabled)).to be(true)
-      expect(User.scope_without_argument?('enabled')).to be(true)
-    end
-
-    it 'is false if scope has one argument' do
-      expect(User.scope_without_argument?(:search)).to be(false)
-      expect(User.scope_without_argument?('search')).to be(false)
-    end
-
-    it 'is false if scope has more than one argument' do
-      expect(User.scope_without_argument?(:created_between)).to be(false)
-      expect(User.scope_without_argument?('created_between')).to be(false)
-    end
-
-    it 'is false if scope does not exist' do
-      expect(User.scope_without_argument?(:foo)).to be(false)
-      expect(User.scope_without_argument?('foo')).to be(false)
-    end
-
-  end
-
-  describe '#scoped_from' do
-
-    it 'just build a new query and return its scope' do
-      query = double(:query)
-      expect(query).to receive(:relation).and_return(42)
-      expect(ScopedFrom::Query).to receive(:new).with(User, 'foo', except: 'bam').and_return(query)
-      expect(User.scoped_from('foo', except: 'bam')).to eq(42)
-    end
-
-    it 'build scopes' do
-      expect(User.scoped_from(search: 'jane')).to eq([users(:jane)])
-      expect(User.scoped_from(search: 'john')).to eq([users(:john)])
-    end
-
-    it 'can be chained with other scopes' do
-      expect(User.scoped_from(search: 'jane')).to eq([users(:jane)])
-      expect(User.enabled.scoped_from(search: 'jane')).to eq([])
-    end
-
-    it 'can be used with order as parameter' do
-      expect(User.scoped_from(order: 'firstname').first).to eq(users(:jane))
-      expect(User.scoped_from(order: 'firstname.desc').first).to eq(users(:john))
-    end
-
-    it 'builds a ScopedFrom::Query' do
-      expect(User.scoped_from({}).query.class).to be(ScopedFrom::Query)
-    end
-
-    it 'builds a ScopedFrom::Query if #{RecordClassName}Query is not defined' do
-      expect(Post.scoped_from({}).query.class).to be(ScopedFrom::Query)
-      expect(Object.const_defined?('PostQuery')).to be(false)
-      expect {
-        PostQuery
-      }.to raise_error(NameError, 'uninitialized constant PostQuery')
-    end
-
-    it 'builds a #{Class}Query if #{RecordClassName}Query is defined and is a ScopedFrom::Query' do
-      expect(Comment.scoped_from({}).query.class).to be(CommentQuery)
-      expect(Comment.where(foo: 'bar').scoped_from({}).query.class).to be(CommentQuery)
-      expect(CommentQuery).to be_a(Class)
-      expect(CommentQuery.ancestors).to include(ScopedFrom::Query)
-    end
-
-    it 'builds a ScopedFrom::Query if #{RecordClassName}Query is defined but not a subclass of ScopedFrom::Query' do
-      expect(User.scoped_from({}).query.class).to be(ScopedFrom::Query)
-      expect(Object.const_defined?('UserQuery')).to be(true)
-      expect(UserQuery).to be_a(Class)
-      expect(UserQuery.ancestors).not_to include(ScopedFrom::Query)
-    end
-
-    it 'builds a ScopedFrom::Query if #{RecordClassName}Query is defined but is a module' do
-      expect(Vote.scoped_from({}).query.class).to be(ScopedFrom::Query)
-      expect(Object.const_defined?('VoteQuery')).to be(true)
-      expect(VoteQuery).to be_a(Module)
-    end
-
-    it 'is accepts ActionController::Parameters' do
-      expect(User.scoped_from(ActionController::Parameters.new(search: 'jane'))).to eq([users(:jane)])
-    end
-
-  end
-
-end

data/spec/scoped_from/query_spec.rb

@@ -1,490 +0,0 @@
-require 'spec_helper'
-
-describe ScopedFrom::Query do
-
-  def query(relation = User, params = {}, options = {})
-    ScopedFrom::Query.new(relation, params, options)
-  end
-
-  describe '#false?' do
-
-    it 'is true if false is given' do
-      expect(query.send(:false?, false)).to be(true)
-    end
-
-    it 'is true if "false" is given' do
-      expect(query.send(:false?, 'false')).to be(true)
-      expect(query.send(:false?, 'False')).to be(true)
-    end
-
-    it 'is true if "0" is given' do
-      expect(query.send(:false?, '0')).to be(true)
-    end
-
-    it 'is true if "off" is given' do
-      expect(query.send(:false?, 'off')).to be(true)
-      expect(query.send(:false?, 'OFF ')).to be(true)
-    end
-
-    it 'is true if "no" is given' do
-      expect(query.send(:false?, 'no')).to be(true)
-      expect(query.send(:false?, ' No ')).to be(true)
-    end
-
-    it 'is true if "n" is given' do
-      expect(query.send(:false?, 'n')).to be(true)
-      expect(query.send(:false?, 'N ')).to be(true)
-    end
-
-    it 'is false if true is given' do
-      expect(query.send(:false?, true)).to be(false)
-    end
-
-    it 'is false if "true" is given' do
-      expect(query.send(:false?, 'true')).to be(false)
-      expect(query.send(:false?, 'TrUe')).to be(false)
-    end
-
-    it 'is false if "1" is given' do
-      expect(query.send(:false?, '1')).to be(false)
-    end
-
-    it 'is false if "on" is given' do
-      expect(query.send(:false?, "on")).to be(false)
-      expect(query.send(:false?, "On")).to be(false)
-    end
-
-    it 'is false otherwise' do
-      expect(query.send(:false?, 42)).to be(false)
-      expect(query.send(:false?, 'bam')).to be(false)
-    end
-
-  end
-
-  describe '#initialize' do
-
-    it 'invokes .all method on given class' do
-      expect(User).to receive(:all)
-      ScopedFrom::Query.new(User, {})
-    end
-
-    it 'does not invokes .all method on given relation' do
-      relation = User.all
-      expect(relation).not_to receive(:all)
-      ScopedFrom::Query.new(relation, {})
-    end
-
-  end
-
-  describe '#invoke_param' do
-
-    it 'returns given scope if it has no scope with specified name' do
-      expect(query.send(:invoke_param, User, :foo, true)).to eq(User)
-    end
-
-    it 'returns given scope if scope takes more than 1 argument' do
-      expect(query.send(:invoke_param, User, :created_between, true)).to eq(User)
-    end
-
-    it 'invokes scope without arguments if scope takes no arguments' do
-      expect(query.send(:invoke_param, User.all, :enabled, true)).to eq([users(:john)])
-      expect(query.send(:invoke_param, User.all, :enabled, ' 1 ')).to eq([users(:john)])
-      expect(query.send(:invoke_param, User.all, :enabled, 'off')).to eq([users(:john)])
-    end
-
-    it 'invokes scope with value has argument if scope takes one argument' do
-      expect(query.send(:invoke_param, User.all, :search, 'doe')).to eq([users(:john), users(:jane)])
-      expect(query.send(:invoke_param, User.all, :search, 'john')).to eq([users(:john)])
-      expect(query.send(:invoke_param, User.all, :search, 'jane')).to eq([users(:jane)])
-    end
-
-    it 'scope on column conditions' do
-      expect(query.send(:invoke_param, User.all, :firstname, 'Jane')).to eq([users(:jane)])
-    end
-
-    it 'invokes "order"' do
-      expect(query.send(:invoke_param, User.all, :order, 'firstname.asc')).to eq([users(:jane), users(:john)])
-      expect(query.send(:invoke_param, User.all, :order, 'firstname.desc')).to eq([users(:john), users(:jane)])
-    end
-
-  end
-
-  describe '#options' do
-
-    it 'is set at initialization' do
-      expect(ScopedFrom::Query.new(User, {}, bar: 'foo').instance_variable_get(:@options)).to eq(bar: 'foo')
-    end
-
-    it 'keys are symbolized' do
-      expect(ScopedFrom::Query.new(User, {}, 'bar' => 'foo').instance_variable_get(:@options)).to eq(bar: 'foo')
-    end
-
-  end
-
-  describe '#order_column' do
-
-    it 'is column specified into "order" parameter' do
-      expect(query(User, order: 'firstname').order_column).to eq('firstname')
-      expect(query(User, order: 'lastname.desc').order_column).to eq('lastname')
-    end
-
-    it 'is nil if column does not exist' do
-      expect(query(User, order: 'foo').order_column).to be_nil
-    end
-
-    it 'is nil if "order" param is not specified' do
-      expect(query(User, search: 'foo').order_column).to be_nil
-    end
-
-  end
-
-  describe '#order_direction' do
-
-    it 'is direction specified into "order" parameter' do
-      expect(query(User, order: 'firstname.asc').order_direction).to eq('asc')
-      expect(query(User, order: 'firstname.desc').order_direction).to eq('desc')
-    end
-
-    it 'is "asc" if direction is not specified' do
-      expect(query(User, order: 'firstname').order_direction).to eq('asc')
-    end
-
-    it 'is "asc" if direction is invalid' do
-      expect(query(User, order: 'firstname.foo').order_direction).to eq('asc')
-    end
-
-    it 'is direction even specified in another case' do
-      expect(query(User, order: 'firstname.ASc').order_direction).to eq('asc')
-      expect(query(User, order: 'firstname.DeSC').order_direction).to eq('desc')
-    end
-
-    it 'is nil if column does not exist' do
-      expect(query(User, order: 'foo.desc').order_direction).to be_nil
-    end
-
-    it 'is nil if "order" param is not specified' do
-      expect(query(User, search: 'foo').order_direction).to be_nil
-    end
-
-  end
-
-  describe '#params' do
-
-    it 'returns params specified at initialization' do
-      expect(query(User, search: 'foo', 'enabled' => true).params).to eq({ 'search' => 'foo', 'enabled' => true })
-    end
-
-    it 'returns an hash with indifferent access' do
-      expect(query(User, 'search' => 'bar').params).to be_a(ActiveSupport::HashWithIndifferentAccess)
-      expect(query(User, 'search' => 'bar').params[:search]).to eq('bar')
-      expect(query(User, search: 'bar').params['search']).to eq('bar')
-    end
-
-    it 'can be converted to query string' do
-      expect(query(User, search: ['foo', 'bar'], 'enabled' => '1').params.to_query).to eq('enabled=true&search%5B%5D=foo&search%5B%5D=bar')
-    end
-
-  end
-
-  describe '#params=' do
-
-    it 'does not fails if nil is given' do
-      expect(query(User, nil).params).to eq({})
-    end
-
-    it 'removes values that are not scopes' do
-      expect(query(User, foo: 'bar', 'search' => 'foo', enabled: true).params).to eq({ 'search' => 'foo', 'enabled' => true })
-    end
-
-    it 'is case sensitive' do
-      expect(query(User, 'Enabled' => true, "SEARCH" => 'bar').params).to be_empty
-    end
-
-    it 'parse query string' do
-      expect(query(User, 'search=foo%26baz&latest=true').params).to eq({ 'search' => 'foo&baz', 'latest' => true })
-    end
-
-    it 'removes blank values from query string' do
-      expect(query(User, 'search=baz&toto=&bar=%20').params).to eq({ 'search' => 'baz' })
-    end
-
-    it 'unescapes UTF-8 chars' do
-      expect(query(User, 'search=%C3%A9').params).to eq({ 'search' => 'é' })
-    end
-
-    it 'can have multiple values (from hash)' do
-      expect(query(User, search: ['bar', 'baz']).params).to eq({ 'search' => ['bar', 'baz'] })
-    end
-
-    it 'can have multiple values (from query string)' do
-      expect(query(User, 'search=bar&search=baz').params).to eq({ 'search' => ['bar', 'baz'] })
-    end
-
-    it 'converts value to true (or remove it) if scope takes no argument' do
-      expect(query(User, latest: 'y').params).to eq({ 'latest' => true })
-      expect(query(User, latest: 'no').params).to eq({})
-    end
-
-    it 'converts value to true (or false) if column is a boolean one' do
-      expect(query(User, admin: 'y').params).to eq({ 'admin' => true })
-      expect(query(User, admin: 'False').params).to eq({ 'admin' => false })
-      expect(query(User, admin: 'bar').params).to eq({})
-      expect(query(User, admin: ['y', false]).params).to eq({})
-    end
-
-    it 'converts array value to true (or remove it) if scope takes no argument' do
-      expect(query(User, latest: true).params).to eq({ 'latest' => true })
-      expect(query(User, latest: ['Yes']).params).to eq({ 'latest' => true })
-      expect(query(User, latest: ['no', 'yes']).params).to eq({})
-      expect(query(User, latest: ['no', nil]).params).to eq({})
-      expect(query(User, latest: ['fo']).params).to eq({})
-    end
-
-    it 'flats array' do
-      expect(query(User, search: [nil, ['bar', '', 'foo', ["\n ", 'baz']]]).params).to eq({ 'search' => [nil, 'bar', '', 'foo', "\n ", 'baz'] })
-    end
-
-    it 'change array with a single value in one value' do
-      expect(query(User, search: ['bar']).params).to eq({ 'search' => 'bar' })
-    end
-
-    it 'does not modify given hash' do
-      hash = { search: 'foo', enabled: '1', bar: 'foo' }
-      query(User, hash)
-      expect(hash).to eq({ search: 'foo', enabled: '1', bar: 'foo' })
-    end
-
-    it 'does not modify given array' do
-      items = ['bar', 'foo', nil]
-      query(User, search: items)
-      expect(items).to eq(['bar', 'foo', nil])
-    end
-
-    it 'accepts :only option' do
-      expect(query(User, { search: 'bar', enabled: 'true' }, only: [:search]).params).to eq({ 'search' => 'bar' })
-      expect(query(User, { search: 'bar', enabled: 'true' }, only: 'search').params).to eq({ 'search' => 'bar' })
-      expect(query(User, { search: 'bar', firstname: 'Jane', enabled: 'true' }, only: 'search').params).to eq({ 'search' => 'bar' })
-      expect(query(User, { search: 'bar', firstname: 'Jane', enabled: 'true' }, only: ['search', :firstname]).params).to eq({ 'search' => 'bar', 'firstname' => 'Jane' })
-    end
-
-    it 'accepts :except option' do
-      expect(query(User, { search: 'bar', enabled: true }, except: [:search]).params).to eq({ 'enabled' => true })
-      expect(query(User, { search: 'bar', enabled: true }, except: 'search').params).to eq({ 'enabled' => true })
-      expect(query(User, { search: 'bar', firstname: 'Jane', enabled: true }, except: 'search').params).to eq({ 'enabled' => true, 'firstname' => 'Jane' })
-      expect(query(User, { search: 'bar', firstname: 'Jane', enabled: true }, except: ['search', :firstname]).params).to eq({ 'enabled' => true })
-    end
-
-    it 'accepts a query instance' do
-      expect(query(User, query(User, search: 'toto')).params).to eq({ 'search' => 'toto' })
-    end
-
-    it 'preserve blank values' do
-      expect(query(User, { search: "\n ", 'enabled' => true }).params).to eq({ 'search' => "\n ", 'enabled' => true })
-    end
-
-    it 'preserve blank values from array' do
-      expect(query(User, { 'search' => ["\n ", 'toto', 'titi'] }).params).to eq({ 'search' => ["\n ", 'toto', 'titi'] })
-      expect(query(User, { 'search' => [] }).params).to eq({})
-    end
-
-    it 'also preserve blank on query string' do
-      expect(query(User, 'search=%20&enabled=true&search=foo').params).to eq({ 'search' => [' ', 'foo'], 'enabled' => true })
-    end
-
-    it 'includes column values' do
-      expect(query(User, 'firstname' => 'Jane', 'foo' => 'bar').params).to eq({ 'firstname' => 'Jane' })
-      expect(query(User, firstname: 'Jane', 'foo' => 'bar').params).to eq({ 'firstname' => 'Jane' })
-    end
-
-    it 'exclude column values if :exclude_columns option is specified' do
-      expect(query(User, { enabled: true, 'firstname' => 'Jane', 'foo' => 'bar' }, exclude_columns: true).params).to eq({ 'enabled' => true })
-      expect(query(User, { enabled: true, firstname: 'Jane', foo: 'bar' }, exclude_columns: true).params).to eq({ 'enabled' => true })
-    end
-
-    it 'scopes have priority on columns' do
-      expect(query(User, enabled: false).params).to eq({})
-    end
-
-    it 'maps an "order"' do
-      expect(query(User, { 'order' => 'firstname.asc' }).params).to eq({ 'order' => 'firstname.asc' })
-    end
-
-    it 'does not map "order" if column is invalid' do
-      expect(query(User, { 'order' => 'foo.asc' }).params).to eq({})
-    end
-
-    it 'use "asc" order direction by default' do
-      expect(query(User, { 'order' => 'firstname' }).params).to eq({ 'order' => 'firstname.asc' })
-    end
-
-    it 'use "asc" order direction if invalid' do
-      expect(query(User, { 'order' => 'firstname.bar' }).params).to eq({ 'order' => 'firstname.asc' })
-    end
-
-    it 'use "desc" order direction if specified' do
-      expect(query(User, { 'order' => 'firstname.desc' }).params).to eq({ 'order' => 'firstname.desc' })
-    end
-
-    it 'order direction is case insensitive' do
-      expect(query(User, { 'order' => 'firstname.Asc' }).params).to eq({ 'order' => 'firstname.asc' })
-      expect(query(User, { 'order' => 'firstname.DESC' }).params).to eq({ 'order' => 'firstname.desc' })
-    end
-
-    it 'order can be specified as symbol' do
-      expect(query(User, { order: 'firstname.desc' }).params).to eq({ 'order' => 'firstname.desc' })
-    end
-
-    it "order is case sensitive" do
-      expect(query(User, { 'Order' => 'firstname.desc' }).params).to eq({})
-    end
-
-    it 'many order can be specified' do
-      expect(query(User, { 'order' => ['firstname.Asc', 'lastname.DESC'] }).params).to eq({ 'order' => ['firstname.asc', 'lastname.desc'] })
-      expect(query(User, { 'order' => ['firstname.Asc', 'firstname.desc'] }).params).to eq({ 'order' => 'firstname.asc' })
-      expect(query(User, { 'order' => ['firstname.Asc', 'lastname.DESC', 'firstname.desc'] }).params).to eq({ 'order' => ['firstname.asc', 'lastname.desc'] })
-      expect(query(User, { 'order' => ['firstname.Asc', 'foo', 'lastname.DESC', 'firstname.desc'] }).params).to eq({ 'order' => ['firstname.asc', 'lastname.desc'] })
-    end
-
-    it 'order can be delimited by a space' do
-      expect(query(User, { 'order' => 'firstname ASC' }).params).to eq({ 'order' => 'firstname.asc' })
-    end
-
-    it 'order can be delimited by any white space' do
-      expect(query(User, { 'order' => "firstname\nASC" }).params).to eq({ 'order' => 'firstname.asc' })
-      expect(query(User, { 'order' => "firstname\t   ASC" }).params).to eq({ 'order' => 'firstname.asc' })
-    end
-
-    it 'order can be delimited by a ":"' do
-      expect(query(User, { 'order' => "firstname:ASC" }).params).to eq({ 'order' => 'firstname.asc' })
-    end
-
-    it 'order can be delimited by more than one delimiter' do
-      expect(query(User, { 'order' => "firstname :.  ASC" }).params).to eq({ 'order' => 'firstname.asc' })
-    end
-
-  end
-
-  describe '#relation' do
-
-    it 'does not execute any query' do
-      expect(User).not_to receive(:connection)
-      query(User, enabled: true).relation
-    end
-
-    it 'works with scopes with a lambda without arguments' do
-      users(:jane).update_attribute(:created_at, 10.days.ago)
-      expect(query(User, latest: true).relation).to eq([users(:john)])
-      expect(query(User, latest: false).relation).to eq([users(:john), users(:jane)])
-    end
-
-    it 'does not modify relation specified at initialization' do
-      relation = User.search('foo')
-      q = query(relation, enabled: true)
-      expect {
-        expect {
-          q.relation
-        }.not_to change { q.instance_variable_get('@relation') }
-      }.not_to change { relation }
-    end
-
-    it 'returns relation specified at construction if params are empty' do
-      expect(query.relation).not_to eq(User)
-      expect(query.relation).to eq(User.all)
-    end
-
-    it 'invokes many times relation if an array is given' do
-      expect(query(User, search: ['John', 'Doe']).relation).to eq([users(:john)])
-      expect(query(User, search: ['John', 'Done']).relation).to eq([])
-      expect(query(User, search: ['John', 'Doe']).params).to eq({ 'search' => ['John', 'Doe'] })
-    end
-
-    it 'invokes many times relation if given twice (as string & symbol)' do
-      expect(query(User, search: 'John', 'search' => 'Done').params['search']).to contain_exactly('John', 'Done')
-      expect(query(User, search: 'John', 'search' => ['Did', 'Done']).params['search']).to contain_exactly('John', 'Did', 'Done')
-    end
-
-    it 'invokes last order if an array is given' do
-      create_user(:jane2, firstname: 'Jane', lastname: 'Zoe')
-
-      expect(query(User, order: ['lastname', 'firstname']).relation).to eq([users(:jane), users(:john), users(:jane2)])
-      expect(query(User, order: ['lastname', 'firstname.desc']).relation).to eq([users(:john), users(:jane), users(:jane2)])
-      expect(query(User, order: ['firstname', 'lastname.desc']).relation).to eq([users(:jane2), users(:jane), users(:john)])
-      expect(query(User, order: ['firstname.desc', 'lastname']).relation.order_values.map(&:class)).to eq([Arel::Nodes::Descending, Arel::Nodes::Ascending])
-      expect(query(User, order: ['firstname.desc', 'lastname']).relation.order_values.map(&:expr).map(&:name)).to eq(['firstname', 'lastname'])
-    end
-
-    it 'defines #query method on returned relation' do
-      expect(query(User).relation).to respond_to(:query)
-    end
-
-    it 'does not define #query method for future relations' do
-      expect(query(User).relation.query).to be_present
-      expect(User).not_to respond_to(:query)
-      expect(User.all).not_to respond_to(:query)
-      expect(User.enabled).not_to respond_to(:query)
-    end
-
-    it 'defined #query method returns query' do
-      q = query(User)
-      expect(q.relation.query).to be_a(ScopedFrom::Query)
-      expect(q.relation.query).to be(q)
-    end
-
-  end
-
-  describe '#true?' do
-
-    it 'is true if true is given' do
-      expect(query.send(:true?, true)).to be(true)
-    end
-
-    it 'is true if "true" is given' do
-      expect(query.send(:true?, 'true')).to be(true)
-      expect(query.send(:true?, 'True')).to be(true)
-    end
-
-    it 'is true if "1" is given' do
-      expect(query.send(:true?, '1')).to be(true)
-    end
-
-    it 'is true if "on" is given' do
-      expect(query.send(:true?, 'on')).to be(true)
-      expect(query.send(:true?, 'ON ')).to be(true)
-    end
-
-    it 'is true if "yes" is given' do
-      expect(query.send(:true?, 'yes')).to be(true)
-      expect(query.send(:true?, ' Yes ')).to be(true)
-    end
-
-    it 'is true if "y" is given' do
-      expect(query.send(:true?, 'y')).to be(true)
-      expect(query.send(:true?, 'Y ')).to be(true)
-    end
-
-    it 'is false if false is given' do
-      expect(query.send(:true?, false)).to be(false)
-    end
-
-    it 'is false if "false" is given' do
-      expect(query.send(:true?, 'false')).to be(false)
-      expect(query.send(:true?, 'FsALSE')).to be(false)
-    end
-
-    it 'is false if "0" is given' do
-      expect(query.send(:true?, '0')).to be(false)
-    end
-
-    it 'is false if "off" is given' do
-      expect(query.send(:true?, "off")).to be(false)
-      expect(query.send(:true?, "Off")).to be(false)
-    end
-
-    it 'is false otherwise' do
-      expect(query.send(:true?, 42)).to be(false)
-      expect(query.send(:true?, 'bam')).to be(false)
-    end
-
-  end
-
-end

data/spec/scoped_from_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe ScopedFrom do
-
-  describe '.version' do
-
-    subject { ScopedFrom.version }
-
-    it { should be_a(String) }
-    it { should match(/^\d+\.\d+(\.\d+)?/) }
-
-    it 'is freezed' do
-      expect {
-        ScopedFrom.version.gsub!('.', '#')
-      }.to raise_error(/can't modify frozen string/i)
-    end
-
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,27 +0,0 @@
-ENV["RAILS_ENV"] ||= 'test'
-
-require File.expand_path("#{__dir__}/../lib/scoped_from")
-require 'action_controller'
-require 'byebug'
-
-# Support
-Dir["#{__dir__}/support/**/*.rb"].each { |f| require File.expand_path(f) }
-
-# Mocks
-ActiveSupport::Dependencies.autoload_paths << "#{__dir__}/mocks"
-
-RSpec.configure do |config|
-  config.raise_errors_for_deprecations!
-
-  config.include(UserMacro)
-
-  config.before(:each) do
-    Comment.delete_all
-    Post.delete_all
-    User.delete_all
-    Vote.delete_all
-
-    create_user(:john, firstname: 'John', lastname: 'Doe', enabled: true, admin: true)
-    create_user(:jane, firstname: 'Jane', lastname: 'Doe', enabled: false, admin: false)
-  end
-end

data/spec/support/bootstrap/database.rb

@@ -1,12 +0,0 @@
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: File.expand_path("#{__dir__}/../../test.sqlite3"), timeout: 5000)
-
-ActiveRecord::Base.connection.create_table(:comments, force: true)
-ActiveRecord::Base.connection.create_table(:posts, force: true)
-ActiveRecord::Base.connection.create_table(:users, force: true) do |t|
-  t.string :firstname, null: false
-  t.string :lastname, null: false
-  t.boolean :enabled, null: false, default: false
-  t.boolean :admin, null: false, default: false
-  t.timestamps null: false
-end
-ActiveRecord::Base.connection.create_table(:votes, force: true)

data/spec/support/macros/user_macro.rb

@@ -1,13 +0,0 @@
-module UserMacro
-
-  USERS = {}
-
-  def create_user(label, attributes)
-    USERS[label] = User.create!(attributes)
-  end
-
-  def users(label)
-    USERS[label]
-  end
-
-end