scopable 1.1.4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f2ceee764d1cb24f319eb1013a1e99af71f2e51
-  data.tar.gz: 8d79497d0ac281967f13c74c41d0f6b7c7ab7af3
+  metadata.gz: cfe1737f95ddf82cad3f7e18880a932269e8c024
+  data.tar.gz: 7c72a34e7fc98dc5c18a9203a0f58162eb408d16
 SHA512:
-  metadata.gz: cb49a404433b3bd4124fddc3843e0c2e374b9d8f82c1ff856fd70bf34de6d829cfe63a0049d7569485bb9688482ebec2048145a64ff14695a13cc7b7175654a7
-  data.tar.gz: e38b3c2f659179047f611aa63b74203e50eb2a77580aae139a446589c55e6b4a415c428f5cdff4858e5b12961e301eb730b28c75158aa79343241c4558c6ac8c
+  metadata.gz: ce1539106fde92d8387bcebe041dcaea5e4aecb4400bce5c4c236ff44759c12634083098e047aa938c8963a7ba74fafa51c77f9839dfd3b24180b8efa853b2e4
+  data.tar.gz: 17c57c0f4a9b4a66d814163f525474690fae38e41d737171450da1bb0d0addc234f1afe84ccc101eb9439a0f3fdf116c2b3929113dfd632c2a5e31aba527d250

data/.codeclimate.yml

@@ -10,4 +10,4 @@ ratings:
   paths:
   - "lib/**.rb"
 exclude_paths:
-- spec/**/*
+- test/**/*

data/.rubocop.yml

@@ -229,6 +229,7 @@ Metrics/CyclomaticComplexity:
                  A complexity metric that is strongly correlated to the number
                  of test cases needed to validate a method.
   Enabled: true
+  Max: 18
 
 Metrics/LineLength:
   Description: 'Limit lines to 80 characters.'
@@ -528,7 +529,7 @@ Style/DefWithParentheses:
   StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#method-parens'
   Enabled: false
 
-Style/DeprecatedHashMethods:
+Style/PreferredHashMethods:
   Description: 'Checks for use of deprecated Hash methods.'
   StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#hash-key'
   Enabled: false
@@ -1154,13 +1155,3 @@ Style/WordArray:
   Description: 'Use %w or %W for arrays of words.'
   StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#percent-w'
   Enabled: false
-Style/Documentation:
-  Enabled: no
-Metrics/LineLength:
-  Max: 128
-Metrics/MethodLength:
-  Max: 36
-Style/Lambda:
-  EnforcedStyle: literal
-Style/EmptyCaseCondition:
-  Enabled: false

data/.travis.yml

@@ -1,4 +1,19 @@
----
+env:
+  global:
+    - CC_TEST_REPORTER_ID=f8045f650e554707d513f10ef3ba1ed386d711797ffaf44a8610d96f7de7b1da
+    - GIT_COMMITTED_AT=$(if [ "$TRAVIS_PULL_REQUEST" == "false" ]; then git log -1 --pretty=format:%ct; else git log -1 --skip 1 --pretty=format:%ct; fi)
 language: ruby
 rvm:
-  - 2.3.4
+  - 2.4.1
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+script:
+  - bundle exec rake
+  # Preferably you will run test-reporter on branch update events. But
+  # if you setup travis to build PR updates only, you don't need to run
+  # the line below
+  - if [ "$TRAVIS_PULL_REQUEST" == "false" ]; then ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT; fi
+  # In the case where travis is setup to build PR updates only,
+  # uncomment the line below
+  # - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

data/Gemfile

@@ -1,6 +1,2 @@
 source 'https://rubygems.org'
 gemspec
-group :test do
-  gem 'simplecov'
-  gem 'codeclimate-test-reporter', '~> 1.0.0'
-end

data/LICENSE.md

@@ -0,0 +1,9 @@
+# The MIT License (MIT)
+
+Copyright © 2013 Arthur Corenzan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including 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 above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,126 +1,124 @@
-[![RubyGems](https://img.shields.io/gem/dt/scopable.svg?style=flat-square)](https://rubygems.org/gems/scopable)
-[![Build](https://img.shields.io/travis/corenzan/scopable.svg?style=flat-square)](https://travis-ci.org/corenzan/scopable)
-[![Code Climate](https://img.shields.io/codeclimate/github/corenzan/scopable.svg?style=flat-square)](https://codeclimate.com/github/corenzan/scopable)
-[![Test Coverage](https://img.shields.io/codeclimate/coverage/github/corenzan/scopable.svg?style=flat-square)](https://codeclimate.com/github/corenzan/scopable/coverage)
+[![RubyGems](https://img.shields.io/gem/dt/scopable.svg?style=flat)](https://rubygems.org/gems/scopable)
+[![Build](https://img.shields.io/travis/corenzan/scopable.svg?style=flat)](https://travis-ci.org/corenzan/scopable)
+[![Code Climate](https://img.shields.io/codeclimate/github/corenzan/scopable.svg?style=flat)](https://codeclimate.com/github/corenzan/scopable)
+[![Test Coverage](https://img.shields.io/codeclimate/coverage/github/corenzan/scopable.svg?style=flat)](https://codeclimate.com/github/corenzan/scopable/coverage)
 
 # Scopable
 
-> Apply or skip model scopes based on options and request parameters.
+> Easy parametric query building in Rails.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Simply add it to your Gemfile.
 
 ```ruby
 gem 'scopable'
 ```
 
-And then execute:
+And update your Gems.
 
 ```shell
-$ bundle install
+$ bundle update
 ```
 
-Or install it yourself with:
+Please note that as of version 2.0 **the API has drastically changed**. If you're **already using version 1.x** and don't want to update your application right now, you should stick with it:
 
-```shell
-$ gem install scopable
+```ruby
+gem 'scopable', '~> 1.0'
 ```
 
-## Usage
+## About
 
-First you need to set scopes in your controller:
+**Scopable** is useful when you need to build one or more queries based on incoming parameters in the request. Very much like [has_scope](https://github.com/plataformatec/has_scope) except it's decoupled from the controller, making it easier to test and much more flexible.
 
-```ruby
-class PostsController < ApplicationController
-  include Scopable
+### Example
 
-  scope :search, param: :q
+Say you have a model and a controller for your blog. Something like this:
 
-  # ...
-end
+```
+└── app
+    ├── models
+        └── post.rb
+    └── controllers
+        └── posts_controller.rb
 ```
 
-Then apply them when querying the model:
+First let's create a new directory named `scopes` along with `models` and `controllers`. There you create a file called `post_scope.rb`, and inside it you define a class that inherits from `Scopable`.
 
 ```ruby
-class PostsController < ApplicationController
-  include Scopable
-
-  scope :search, param: :q
+class PostScope < Scopable
+  model Post
 
-  def index
-    @posts = scoped(Post, params)
+  scope :search do
+    where('title LIKE ?', value)
   end
-end
-```
-
-Now whenever the parameter `q` is present in `params`, the scope `#search` will be called on your model and given the value of `params[:q]` as argument. Otherwise you would have to write something like this:
 
-```ruby
-  if params[:q].present?
-    @posts = Post.search(params[:q])
-  else
-    @posts = Post.all
+  scope :published_on do
+    where(published_at: value.to_time)
   end
+end
 ```
 
-What would be fine, except you usually have multiple scopes, that might get combined depending on the presence or absence of parameters to produce the final query. Look how simple it becomes when using Scopable:
+Finally, in `PostsController` you use `PostScope.resolve` to conditionally resolve the scopes based on given parameters.
 
 ```ruby
-class PostController < ApplicationController
-  include Scopable
-
-  # Filter by category.
-  scope :category do |relation, value|
-    relation.where(category_id: value.to_i)
+class PostsController < ApplicationController
+  def index
+    @posts = PostScope.resolve(scope_params)
   end
 
-  # Fix N+1.
-  scope :includes, force: :author
-
-  # Pagination.
-  scope :page, default: 1
-
-  # Sort by creation date.
-  scope :order, force: { created_at: :desc }
+  private
 
-  def index
-    @posts = scoped(Post, params)
+  def scope_params
+    params.permit(:search, :published_on).to_h
   end
 end
 ```
 
-Now say a request is made looking like this:
+Now when any combination of the parameters `search` and `published_on` are present, their respective conditions are going to be applied on the relation. i.e. If your request path looks like this:
 
 ```
-/posts?category=2
+/?search=bananas&published_on=2007-07-19
 ```
 
-The resulting query would be:
+`@posts` will look like this:
 
-```ruby
-Post.where(category_id: 2).includes(:author).page(1).order(created_at: :desc)
+```
+Post.where('title LIKE ?', 'bananas').where(published_on: '2007-07-19 00:00:00 +0000')
 ```
 
-Please note that **order matters**. The scopes will be applied in the same order they are configured.
-
-Also values like `true/false`, `on/off`, `yes/no` are **cast as boolean**, and when given a boolean value the scope is either called with no arguments or skipped entirely. For instance, if you set a scope like `scope :draft` then request the URL `/posts?draft=yes` it would be like just calling `Post.draft`. But if you request `/posts?draft=no` it does nothing.
-
-### Options
+You can also pass some options when you're defining scopes for more advanced use cases. Read on.
 
-No option is required. By default it assumes both scope and parameter have the same name.
+#### Options
 
 Key         | Description
 ------------|--------------------------------------------------------------------------------------------------------------
 `:param`    | Name of the parameter that activates the scope.
 `:default`  | Default value for the scope in case the parameter is missing.
-`:force`    | Force a value to the scope regardless of the request parameters.
+`:value`    | Force a value to the scope regardless of the request parameters.
 `:required` | Calls `#none` on the model if parameter is absent (blank or nil) and there's no default value set.
-`:only`     | String, Symbol or an Array of those. The scope will **only** be applied to these actions.
-`:except`   | String, Symbol or an Array of those. The scope will be applied to all actions **except** these.
-`&block`    | Block will be called in the context of the controller's action and will be given two parameters: the current relation and evaluated value.
+`:if`       | ...
+`:unless`   | ...
+`&block`    | Block will be used to produce the resulting relation with two parameters: the relation at this step and the scope value from params.
+
+## Collaboration
+
+If you'd like to contribute to the project, in any form, you're most welcome, but please bear in mind that as it is with any open-source software your suggestions are subject to the discretion of the project maintainers, and what you see as an issue, someone else may see as a feature.
+
+We encourage you to:
+
+- Open a new issue with suggestions, concerns, or problems you may have.
+- Chip in existing discussions and present your opinion on the subject.
+- Send pull-requests with test covered bug fixes or new features.
+- Send pull-requests with new tests you miss in the suite.
+
+Remember to:
+
+- Be respectful.
+- Use proper grammar in discussions and in commit messages.
+- Follow the established coding style.
+- Explain why you're making the changes in a pull-request.
 
 ## License
 
-See [LICENSE](LICENSE).
+[The MIT License](LICENSE.md) © 2013 Arthur Corenzan

data/Rakefile

@@ -1,3 +1,4 @@
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new('spec')
-task default: :spec
+task :test do
+  require_relative 'test/test_helper.rb'
+end
+task default: :test

data/lib/scopable.rb

@@ -1,56 +1,50 @@
-module Scopable
-  extend ActiveSupport::Concern
+require 'active_support'
+require 'active_support/core_ext'
 
-  def scopes
-    self.class.scopes
-  end
-
-  def scoped(model, params)
-    scopes.reduce(model) do |relation, scope|
-      name, options = *scope
-
-      # Controller actions where this scope should be applied.
-      # Accepts either a literal value or a lambda. nil with disable the option.
-      only = options[:only]
-      only = instance_exec(&only) if only.respond_to?(:call)
-
-      # Enfore :only option.
-      next relation unless only.nil? || Array.wrap(only).map(&:to_s).include?(action_name)
+class Scopable
+  attr_reader :model, :scopes
 
-      # Controller actions where this scope should be ignored.
-      # Accepts either a literal value or a lambda. nil with disable the option.
-      except = options[:except]
-      except = instance_exec(&except) if except.respond_to?(:call)
-
-      # Enfore :except option.
-      next relation if except.present? && Array.wrap(except).map(&:to_s).include?(action_name)
+  def initialize(model = nil, scopes = nil)
+    @model = model || self.class.model
+    @scopes = scopes || self.class.scopes
+  end
 
-      # Name of the request parameters which value will be used in this scope.
-      # Defaults to the name of the scope.
-      param = options.fetch(:param, name)
+  def delegator(relation, value, params)
+    SimpleDelegator.new(relation).tap do |delegator|
+      delegator.define_singleton_method(:value) do
+        value
+      end
+      delegator.define_singleton_method(:params) do
+        params
+      end
+    end
+  end
 
-      # Use the value from the request parameter or fall back to the default.
-      value = params[param]
+  def resolve(params = {})
+    params = params.with_indifferent_access
 
-      # If parameter is not present use the :default option.
-      # Accepts either a literal value or a lambda.
-      value = options[:default] if value.nil?
+    scopes.reduce(model) do |relation, scope|
+      name, options = *scope
 
-      # Forces the scope to use the given value given in the :force option.
-      # Accepts either a literal value or a lambda.
-      value = options[:force] if options.key?(:force)
+      # Resolve param name.
+      param = options[:param] || name
 
-      # If either :default or :force options were procs, evaluate them.
-      value = instance_exec(&value) if value.respond_to?(:call)
+      # Resolve a value for the scope.
+      value = options[:value] || params[param] || options[:default]
 
-      # The :required option makes sure there's a value present, otherwise return an empty scope (Model#none).
-      required = options[:required]
-      required = instance_exec(&required) if required.respond_to?(:call)
+      # When value is empty treat it as nil.
+      value = nil if value.respond_to?(:empty?) && value.empty?
 
-      # Enforce the :required option.
-      break relation.none if required && value.nil?
+      # When a nil value was given either skip the scope or bail with #none (if the required options was used).
+      if value.nil?
+        if options[:required]
+          break relation.none
+        else
+          next relation
+        end
+      end
 
-      # Parses values like 'on/off', 'true/false', and 'yes/no' to an actual boolean value.
+      # Cast boolean-like strings.
       case value.to_s
       when /\A(false|no|off)\z/
         value = false
@@ -58,20 +52,20 @@ module Scopable
         value = true
       end
 
-      # For advanced scopes that require more than a method call on the model.
-      # When a block is given, it is ran no matter the scope value.
-      # The proc will be given the model being scoped and the resulting value from the
-      # options above, and it'll be executed inside the context of the controller's action.
-      block = options[:block]
+      # Enforce 'if' option.
+      if options[:if]
+        next relation unless delegator(relation, value, params).instance_exec(&options[:if])
+      end
 
-      if block.nil? && value.blank?
-        next relation
+      # Enforce 'unless' option.
+      if options[:unless]
+        next relation if delegator(relation, value, params).instance_exec(&options[:unless])
       end
 
-      case
-      when block.present?
-        instance_exec(relation, value, &block)
-      when value == true
+      # When a block is present, use that, otherwise call the scope method.
+      if options[:block].present?
+        delegator(relation, value, params).instance_exec(&options[:block])
+      elsif value == true
         relation.send(name)
       else
         relation.send(name, value)
@@ -79,13 +73,19 @@ module Scopable
     end
   end
 
-  module ClassMethods
-    def scopes
-      @scopes ||= {}
-    end
+  def self.resolve(params = {})
+    new.resolve(params)
+  end
 
-    def scope(name, options = {}, &block)
-      scopes.store name, options.merge(block: block)
-    end
+  def self.model(model = nil)
+    @model ||= model
+  end
+
+  def self.scopes
+    @scopes ||= {}
+  end
+
+  def self.scope(name, options = {}, &block)
+    scopes.store name, options.merge(block: block)
   end
 end

data/lib/scopable/version.rb

@@ -1,3 +1,3 @@
-module Scopable
-  VERSION = "1.1.4"
+class Scopable
+  VERSION = '2.0.0'.freeze
 end

data/scopable.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Scopable::VERSION
   spec.authors       = ['Arthur Corenzan']
   spec.email         = ['arthur@corenzan.com']
-  spec.summary       = %q{Apply or skip model scopes based on options and request parameters.}
-  spec.description   = %q{}
+  spec.summary       = 'Easy parametric query building in Rails.'
+  spec.description   = 'Scopable allows you to create objects that produce complex queries based on incoming parameters hash which are testable and easy to understand.'
   spec.homepage      = 'https://github.com/corenzan/scopable'
   spec.license       = 'MIT'
 
@@ -20,9 +20,10 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.2.2'
 
-  spec.add_runtime_dependency 'activesupport', '>= 3.2'
+  spec.add_runtime_dependency 'activesupport', '~> 5.0'
 
-  spec.add_development_dependency 'bundler', '~> 1.7'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.5'
+  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'minitest', '~> 5.10'
+  spec.add_development_dependency 'rubocop', '~> 0.49'
+  spec.add_development_dependency 'simplecov', '~> 0.14'
 end

data/test/scopable_test.rb

@@ -0,0 +1,139 @@
+class ScopableTest < Minitest::Test
+  extend ActiveSupport::Testing::Declarative
+
+  def assert_scope(scopable, scope, value)
+    assert_includes(scopable.scopes, scope)
+    assert_equal(value, scopable.scopes[scope])
+  end
+
+  def refute_scope(scopable, scope)
+    refute_includes(scopable.scopes, scope)
+    assert_nil(scopable.scopes[scope])
+  end
+
+  test 'initialize' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: {}, jumbo: {})
+    assert_equal(model, scopable.model)
+    assert_includes(scopable.scopes, :fuzzy)
+    assert_includes(scopable.scopes, :jumbo)
+  end
+
+  test 'dsl' do
+    model = Model.new
+    scopable = Class.new(Scopable) do
+      model model
+      scope :fuzzy
+      scope :jumbo
+    end
+    assert_equal(model, scopable.new.model)
+    assert_includes(scopable.new.scopes, :fuzzy)
+    assert_includes(scopable.new.scopes, :jumbo)
+  end
+
+  test 'one scope, matching parameter' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: {})
+    params = { fuzzy: 'fuzzy' }
+    assert_scope(scopable.resolve(params), :fuzzy, 'fuzzy')
+  end
+
+  test 'multiple scopes, matching parameters' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: {}, jumbo: {})
+    params = { fuzzy: 'fuzzy', jumbo: 'jumbo' }
+    assert_scope(scopable.resolve(params), :fuzzy, 'fuzzy')
+    assert_scope(scopable.resolve(params), :jumbo, 'jumbo')
+  end
+
+  test 'multiple scopes, missing one parameter' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: {}, jumbo: {})
+    params = { jumbo: 'jumbo' }
+    assert_scope(scopable.resolve(params), :jumbo, 'jumbo')
+    refute_scope(scopable.resolve(params), :fuzzy)
+  end
+
+  test 'matching param with blank value' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: {})
+    params = { fuzzy: '' }
+    refute_scope(scopable.resolve(params), :fuzzy)
+  end
+
+  test 'absent param' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: {})
+    refute_scope(scopable.resolve, :fuzzy)
+  end
+
+  test 'matching param with true-like value' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: {})
+    assert_scope(scopable.resolve(fuzzy: 'on'), :fuzzy, true)
+    assert_scope(scopable.resolve(fuzzy: 'yes'), :fuzzy, true)
+    assert_scope(scopable.resolve(fuzzy: 'true'), :fuzzy, true)
+  end
+
+  test 'matching param with false-like value' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: {})
+    assert_scope(scopable.resolve(fuzzy: 'no'), :fuzzy, false)
+    assert_scope(scopable.resolve(fuzzy: 'off'), :fuzzy, false)
+    assert_scope(scopable.resolve(fuzzy: 'false'), :fuzzy, false)
+  end
+
+  test 'param option' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: { param: :f })
+    params = { f: 'fuzzy' }
+    assert_scope(scopable.resolve(params), :fuzzy, 'fuzzy')
+  end
+
+  test 'value option' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: { value: 'fuzzy' })
+    assert_scope(scopable.resolve, :fuzzy, 'fuzzy')
+  end
+
+  test 'default option' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: { default: 'fuzzy' })
+    assert_scope(scopable.resolve, :fuzzy, 'fuzzy')
+    params = { fuzzy: 'jumbo' }
+    assert_scope(scopable.resolve(params), :fuzzy, 'jumbo')
+  end
+
+  test 'required option' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: { required: true })
+    assert_equal(:none, scopable.resolve)
+    params = { fuzzy: 'fuzzy' }
+    assert_scope(scopable.resolve(params), :fuzzy, 'fuzzy')
+  end
+
+  test 'if option' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: { if: -> { params[:quack] } })
+    params = { fuzzy: 'fuzzy' }
+    refute_scope(scopable.resolve(params), :fuzzy)
+    params = { fuzzy: 'fuzzy', quack: true }
+    assert_scope(scopable.resolve(params), :fuzzy, 'fuzzy')
+  end
+
+  test 'unless option' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: { unless: -> { params[:quack] } })
+    params = { fuzzy: 'fuzzy', quack: true }
+    refute_scope(scopable.resolve(params), :fuzzy)
+    params = { fuzzy: 'fuzzy' }
+    assert_scope(scopable.resolve(params), :fuzzy, 'fuzzy')
+  end
+
+  test 'block option' do
+    model = Model.new
+    scopable = Scopable.new(model, fuzzy: { block: -> { jumbo(value) } })
+    params = { fuzzy: 'fuzzy' }
+    assert_scope(scopable.resolve(params), :jumbo, 'fuzzy')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,34 @@
+require 'simplecov'
+
+# Generate coverage report.
+SimpleCov.start
+
+require 'minitest/autorun'
+require 'active_support/testing/declarative'
+
+# Mock model for testing scope chains.
+class Model
+  def scopes
+    @scopes ||= {}
+  end
+
+  def fuzzy(value = true)
+    scopes.store(:fuzzy, value)
+    self
+  end
+
+  def jumbo(value = true)
+    scopes.store(:jumbo, value)
+    self
+  end
+
+  def none
+    :none
+  end
+end
+
+# Load the Gem.
+require_relative '../lib/scopable'
+
+# Run test suite.
+require_relative 'scopable_test'

metadata

@@ -1,72 +1,87 @@
 --- !ruby/object:Gem::Specification
 name: scopable
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 2.0.0
 platform: ruby
 authors:
 - Arthur Corenzan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-28 00:00:00.000000000 Z
+date: 2017-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '5.10'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0.49'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0.49'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '0.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
-description: ''
+        version: '0.14'
+description: Scopable allows you to create objects that produce complex queries based
+  on incoming parameters hash which are testable and easy to understand.
 email:
 - arthur@corenzan.com
 executables: []
@@ -75,20 +90,17 @@ extra_rdoc_files: []
 files:
 - ".codeclimate.yml"
 - ".gitignore"
-- ".rspec"
 - ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
-- LICENSE
+- LICENSE.md
 - README.md
 - Rakefile
 - lib/scopable.rb
 - lib/scopable/version.rb
 - scopable.gemspec
-- spec/scopable_spec.rb
-- spec/spec_helper.rb
-- spec/support/controller.rb
-- spec/support/model.rb
+- test/scopable_test.rb
+- test/test_helper.rb
 homepage: https://github.com/corenzan/scopable
 licenses:
 - MIT
@@ -109,12 +121,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
-summary: Apply or skip model scopes based on options and request parameters.
+summary: Easy parametric query building in Rails.
 test_files:
-- spec/scopable_spec.rb
-- spec/spec_helper.rb
-- spec/support/controller.rb
-- spec/support/model.rb
+- test/scopable_test.rb
+- test/test_helper.rb

data/.rspec

@@ -1,2 +0,0 @@
---color
---require spec_helper

data/LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) 2015-2017 Arthur Corenzan
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-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 above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/scopable_spec.rb

@@ -1,302 +0,0 @@
-require 'active_support/all'
-require_relative '../lib/scopable.rb'
-require_relative 'support/controller.rb'
-require_relative 'support/model.rb'
-
-describe Scopable do
-  it 'creates class variable #scopes' do
-    expect(Controller).to respond_to(:scopes)
-    expect(Controller.scopes).to eq({})
-  end
-
-  it 'adds class method #scope' do
-    expect(Controller).to respond_to(:scope)
-  end
-
-  it 'adds instance method #scoped' do
-    expect(Controller.new).to respond_to(:scoped)
-  end
-
-  #
-  # Test single scope, no options.
-  #
-  describe 'with one optional scope' do
-    let :controller do
-      Class.new(Controller) do
-        scope :search
-      end
-    end
-
-    context 'with the parameter absent' do
-      subject :action do
-        controller.new
-      end
-
-      it 'should skip the scope' do
-        expect(action.relation.scopes).to be_empty
-      end
-    end
-
-    context 'with the parameter present' do
-      subject :action do
-        controller.new(nil, search: 'test')
-      end
-
-      it 'should apply the scope' do
-        expect(action.relation.scopes).to include(search: 'test')
-      end
-    end
-
-    context 'with the parameter present but blank' do
-      subject :action do
-        controller.new(nil, search: '')
-      end
-
-      it 'should skip the scope' do
-        expect(action.relation.scopes).to be_empty
-      end
-    end
-  end
-
-  #
-  # Test two optional scopes, with 0, 1, and 2 matching parameters.
-  #
-  describe 'with two optional scopes' do
-    let :controller do
-      Class.new(Controller) do
-        scope :color
-        scope :size
-      end
-    end
-
-    context 'without parameters' do
-      subject :action do
-        controller.new
-      end
-
-      it 'should skip the scopes' do
-        expect(action.relation.scopes).to be_empty
-      end
-    end
-
-    context 'with parameter matching the first scope' do
-      subject :action do
-        controller.new(nil, color: 'black')
-      end
-
-      it 'should apply only the first scope' do
-        expect(action.relation.scopes.size).to eq(1)
-        expect(action.relation.scopes).to include(color: 'black')
-      end
-    end
-
-    context 'with parameter matching the second scope' do
-      subject :action do
-        controller.new(nil, size: 'm')
-      end
-
-      it 'should apply only the second scope' do
-        expect(action.relation.scopes.size).to eq(1)
-        expect(action.relation.scopes).to include(size: 'm')
-      end
-    end
-
-    context 'with parameters matching both scopes' do
-      subject :action do
-        controller.new(nil, size: 'm', color: 'black')
-      end
-
-      it 'should apply both scopes' do
-        expect(action.relation.scopes.size).to eq(2)
-        expect(action.relation.scopes).to include(size: 'm', color: 'black')
-      end
-    end
-  end
-
-  #
-  # Test :required option.
-  #
-  describe 'with :required option' do
-    let :controller do
-      Class.new(Controller) do
-        scope :active, required: true
-      end
-    end
-
-    context 'with no matching parameters' do
-      subject :action do
-        controller.new
-      end
-
-      it 'should apply #none' do
-        expect(action.relation.scopes).to include(none: true)
-      end
-    end
-
-    context 'with one parameter matching' do
-      subject :action do
-        controller.new(nil, active: 'yes')
-      end
-
-      it 'should apply one of the scopes' do
-        expect(action.relation.scopes.size).to eq(1)
-        expect(action.relation.scopes).to include(active: true)
-      end
-    end
-  end
-
-  #
-  # Test :except option.
-  #
-  describe 'with :except option' do
-    let :controller do
-      Class.new(Controller) do
-        scope :filter, except: :index
-      end
-    end
-
-    context 'with matching parameter in the exception action' do
-      subject :action do
-        controller.new(:index, filter: 'yes')
-      end
-
-      it 'should skip the scope' do
-        expect(action.relation.scopes).to be_empty
-      end
-    end
-
-    context 'with matching parameter in a different action' do
-      subject :action do
-        controller.new(nil, filter: 'yes')
-      end
-
-      it 'should apply the scope' do
-        expect(action.relation.scopes).to include(filter: true)
-      end
-    end
-  end
-
-  #
-  # Test :only option.
-  #
-  describe 'with :only option' do
-    let :controller do
-      Class.new(Controller) do
-        scope :filter, only: :index
-      end
-    end
-
-    context 'with matching parameter in the only action' do
-      subject :action do
-        controller.new(:index, filter: 'yes')
-      end
-
-      it 'should apply the scope' do
-        expect(action.relation.scopes).to include(filter: true)
-      end
-    end
-
-    context 'with matching parameter in a different action' do
-      subject :action do
-        controller.new(nil, filter: 'yes')
-      end
-
-      it 'should skip the scope' do
-        expect(action.relation.scopes).to be_empty
-      end
-    end
-  end
-
-  #
-  # Test :param option.
-  #
-  describe 'with :param option' do
-    let :controller do
-      Class.new(Controller) do
-        scope :search, param: :q
-      end
-    end
-
-    context 'with matching parameter' do
-      subject :action do
-        controller.new(nil, q: 'test')
-      end
-
-      it 'should apply the scope' do
-        expect(action.relation.scopes).to include(search: 'test')
-      end
-    end
-
-    context 'without matching parameter' do
-      subject :action do
-        controller.new(nil, search: 'test')
-      end
-
-      it 'should skip the scope' do
-        expect(action.relation.scopes).to be_empty
-      end
-    end
-  end
-
-  #
-  # Test :default option.
-  #
-  describe 'with :default option' do
-    let :controller do
-      Class.new(Controller) do
-        scope :page, default: 1
-      end
-    end
-
-    context 'with matching parameter' do
-      subject :action do
-        controller.new(nil, page: 2)
-      end
-
-      it 'should overwrite the default value' do
-        expect(action.relation.scopes).to include(page: 2)
-      end
-    end
-
-    context 'without matching parameter' do
-      subject :action do
-        controller.new(nil)
-      end
-
-      it 'should use the default value' do
-        expect(action.relation.scopes).to include(page: 1)
-      end
-    end
-  end
-
-  #
-  # Test :force option.
-  #
-  describe 'with :force option' do
-    let :controller do
-      Class.new(Controller) do
-        scope :sort, force: :id
-      end
-    end
-
-    context 'without matching parameter' do
-      subject :action do
-        controller.new(nil)
-      end
-
-      it 'should use the forced value' do
-        expect(action.relation.scopes).to include(sort: :id)
-      end
-    end
-
-    context 'with matching parameter' do
-      subject :action do
-        controller.new(nil, sort: :name)
-      end
-
-      it 'should still use the forced value' do
-        expect(action.relation.scopes).to include(sort: :id)
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,99 +0,0 @@
-require 'simplecov'
-SimpleCov.start
-
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause
-# this file to always be loaded, without a need to explicitly require it in any
-# files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, consider making
-# a separate helper file that requires the additional dependencies and performs
-# the additional setup, and require it from the spec files that actually need
-# it.
-#
-# The `.rspec` file also contains a few flags that are not defaults but that
-# users commonly want.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
-  config.expect_with :rspec do |expectations|
-    # This option will default to `true` in RSpec 4. It makes the `description`
-    # and `failure_message` of custom matchers include text for helper methods
-    # defined using `chain`, e.g.:
-    #     be_bigger_than(2).and_smaller_than(4).description
-    #     # => "be bigger than 2 and smaller than 4"
-    # ...rather than:
-    #     # => "be bigger than 2"
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
-  config.mock_with :rspec do |mocks|
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended, and will default to
-    # `true` in RSpec 4.
-    mocks.verify_partial_doubles = true
-  end
-
-# The settings below are suggested to provide a good initial experience
-# with RSpec, but feel free to customize to your heart's content.
-=begin
-  # These two settings work together to allow you to limit a spec run
-  # to individual examples or groups you care about by tagging them with
-  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
-  # get run.
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
-  # Allows RSpec to persist some state between runs in order to support
-  # the `--only-failures` and `--next-failure` CLI options. We recommend
-  # you configure your source control system to ignore this file.
-  config.example_status_persistence_file_path = "spec/examples.txt"
-
-  # Limits the available syntax to the non-monkey patched syntax that is
-  # recommended. For more details, see:
-  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
-  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
-  config.disable_monkey_patching!
-
-  # This setting enables warnings. It's recommended, but in some cases may
-  # be too noisy due to issues in dependencies.
-  config.warnings = true
-
-  # Many RSpec users commonly either run the entire suite or an individual
-  # file, and it's useful to allow more verbose output when running an
-  # individual spec file.
-  if config.files_to_run.one?
-    # Use the documentation formatter for detailed output,
-    # unless a formatter has already been configured
-    # (e.g. via a command-line flag).
-    config.default_formatter = 'doc'
-  end
-
-  # Print the 10 slowest examples and example groups at the
-  # end of the spec run, to help surface which specs are running
-  # particularly slow.
-  config.profile_examples = 10
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
-=end
-end

data/spec/support/controller.rb

@@ -1,19 +0,0 @@
-class Controller
-  include Scopable
-
-  def initialize(action_name = nil, params = {})
-    @action_name, @params = action_name, params.freeze
-  end
-
-  def params
-    @params
-  end
-
-  def action_name
-    @action_name.to_s
-  end
-
-  def relation
-    scoped(Model.new, params)
-  end
-end

data/spec/support/model.rb

@@ -1,10 +0,0 @@
-class Model
-  def scopes
-    @scopes ||= {}
-  end
-
-  def method_missing(name, value = true)
-    scopes.store(name, value)
-    self
-  end
-end