scopable 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a92105be0449f880038bc7d58e0af2d2a1873531
-  data.tar.gz: 2718a557dda1ec4d724ea0f9ab231fe0ffd45a43
+  metadata.gz: db1ac9caa504b39e2c3bd583a410c40cbe822c5a
+  data.tar.gz: a06474713343b047e5bd2b3004fe356a6c19d0f2
 SHA512:
-  metadata.gz: 7c0cadb182a7e2171f6e4d97db016bcad90e6d6a2abc7d9f5146827643699bc21190e5a3ac92c7f977ed5ae3b103e3eb9228d2aca4fb89bfb2f259501a988971
-  data.tar.gz: dbcb6bffaeea5d1101b0385ccc9537604552506e73fa97a3c3a3c607618aabd57ff85b384b5908d79bad23bf651112d68c5b411dd3793390ec0f7d9a03ff5eaa
+  metadata.gz: 8e90dc92efeed46a6def9c9ed3efe173e998f37618283d8fd2a2113eb2e1af6a7d74dbf65373e2a41b25817f68b6c3ca17f65296eb8b9e3a6bd498f4f633d4c8
+  data.tar.gz: f28f405579fe0e12c3dcde190e9fc3d1951e4ef1eb65277c9da13e054fa0b52e1fce7fc5efe4e11ee5037153434e54ee51a8d3e04885e19a125188482995f65d

data/.codeclimate.yml

@@ -0,0 +1,17 @@
+---
+engines:
+  rubocop:
+    enabled: true
+  brakeman:
+    enabled: true
+  duplication:
+    enabled: true
+    config:
+      languages:
+      - ruby
+
+ratings:
+   paths:
+   - "lib/**.rb"
+exclude_paths:
+- spec/**/*

data/.gitignore

@@ -1,5 +1,4 @@
 .DS_Store
-
 /.bundle/
 /.yardoc
 /Gemfile.lock
@@ -10,6 +9,7 @@
 /spec/reports/
 /tmp/
 *.bundle
+*.gem
 *.so
 *.o
 *.a

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,10 @@
+Style/Documentation:
+  Enabled: no
+Metrics/LineLength:
+  Max: 128
+Metrics/MethodLength:
+  Max: 32
+Style/Lambda:
+  EnforcedStyle: literal
+Style/EmptyCaseCondition:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,4 @@
+---
+language: ruby
+rvm:
+  - 2.3.1

data/Gemfile

@@ -1,5 +1,3 @@
 source 'https://rubygems.org'
-
 gemspec
-
-gem 'activesupport', '~> 4.2.0'
+gem 'codeclimate-test-reporter', group: :test, require: nil

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2015 Arthur Corenzan
+Copyright (c) 2015-2017 Arthur Corenzan
 
 MIT License
 

data/README.md

@@ -1,6 +1,10 @@
 # Scopable
 
-> Apply scopes to your query based on available parameters
+> Apply or skip model scopes based on options and request parameters.
+
+[![Code Climate](https://codeclimate.com/github/haggen/scopable/badges/gpa.svg?1)](https://codeclimate.com/github/haggen/scopable)
+[![Test Coverage](https://codeclimate.com/github/haggen/scopable/badges/coverage.svg?1)](https://codeclimate.com/github/haggen/scopable/coverage)
+[![Build](https://travis-ci.org/haggen/scopable.svg)](https://travis-ci.org/haggen/scopable)
 
 ## Installation
 
@@ -12,11 +16,15 @@ gem 'scopable'
 
 And then execute:
 
-    $ bundle
+```shell
+$ bundle
+```
 
-Or install it yourself as:
+Or install it yourself with:
 
-    $ gem install scopable
+```shell
+$ gem install scopable
+```
 
 ## Usage
 
@@ -26,7 +34,7 @@ Configure scopes in your controller:
 class PostsController < ApplicationController
   include Scopable
 
-  scope :search, :param => :q
+  scope :search, param: :q
 
   # ...
 end
@@ -40,10 +48,73 @@ def index
 end
 ```
 
-Now, whenever the parameter `q` is present at `params`, it will call `#search` on your model passing its value as argument.
+Now whenever the parameter `q` is present in `params`, `#search` will be called on your model passing the parameter's value as argument.
+
+Another example:
+
+```ruby
+class PostController < ApplicationController
+  include Scopable
+
+  scope :by_date, param: :date do |relation, value|
+    relation.where(created_at: Date.parse(value))
+  end
+
+  scope :by_author, param: :author
+
+  scope :order, force: { created_at: :desc }
+
+  def index
+    @posts = scoped(Post, params)
+  end
+end
+```
+
+Now say your URL look like this:
+
+```
+/posts?date=2016-1-6&author=2
+```
+
+The resulting relation would be:
+
+```ruby
+Post.where(created_at: '6/1/2016').by_author(2).order(created_at: :desc)
+```
+
+**Note that order matters!** The scopes will be applied in the same order they are configured.
+
+Also note values like `true/false`, `on/off`, `yes/no` are treated like boolean, and when the value is evaluated to `true` or `false` the scope is called with no arguments, or skipped, respectively.
+
+```ruby
+scope :active
+```
+
+With a URL like this:
 
-TODO: Add more examples.
-TODO: Layout `scope` options.
+```ruby
+/?active=yes
+```
+
+Would be equivalent to:
+
+```ruby
+Model.active
+```
+
+## Options
+
+No option is required. By default it assumes both scope and parameter have the same name.
+
+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.
+`:required` | Calls `#none` on the model if parameter is absent and no default value is given.
+`:only`     | The scope will only be applied to these actions.
+`:except`   | The scope will be applied to all actions except these.
+`&block`    | Block will be called in the context of the action and will be given the current relation and evaluated value.
 
 ## Contributing
 
@@ -52,3 +123,7 @@ TODO: Layout `scope` options.
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
+
+## License
+
+See [LICENSE.txt](LICENSE.txt).

data/Rakefile

@@ -1,2 +1,3 @@
-require "bundler/gem_tasks"
-
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+task default: :spec

data/lib/scopable.rb

@@ -1,60 +1,90 @@
-require "scopable/version"
-
 module Scopable
   extend ActiveSupport::Concern
 
-  included do
-    cattr_reader :scopes do
-      Hash.new
-    end
-
-    helper_method :active_scopes
-  end
-
-  def active_scopes
-    scopes.map do |name, scope|
-      name if scope[:active]
-    end.compact
+  def scopes
+    self.class.scopes
   end
 
-  def scoped(resource, params)
-    scopes.reduce(resource) do |resource, scope|
+  def scoped(model, params)
+    scopes.reduce(model) do |relation, scope|
       name, scope = *scope
 
-      param, force, default, except, only, fn = scope.values_at(:param, :force, :default, :except, :only, :fn)
+      # Controller actions where this scope should be applied.
+      # Accepts either a literal value or a lambda. nil with disable the option.
+      only = scope[:only]
+      only = instance_exec(&only) if only.respond_to?(:call)
+
+      # Enfore :only option.
+      break relation unless only.nil? || Array.wrap(only).map(&:to_s).include?(action_name)
+
+      # Controller actions where this scope should be ignored.
+      # Accepts either a literal value or a lambda. nil with disable the option.
+      except = scope[:except]
+      except = instance_exec(&except) if except.respond_to?(:call)
+
+      # Enfore :except option.
+      break relation if except.present? && Array.wrap(except).map(&:to_s).include?(action_name)
+
+      # Name of the request parameters which value will be used in this scope.
+      # Defaults to the name of the scope.
+      param = scope.fetch(:param, name)
+
+      # Use the value from the request parameter or fall back to the default.
+      value = params[param]
 
-      force = self.instance_exec(&force) if force.respond_to?(:call)
+      # If parameter is not present use the :default option.
+      # Accepts either a literal value or a lambda.
+      value = scope[:default] if value.nil?
 
-      param = param || name
-      value = force || params[param] || default
+      # Forces the scope to use the given value given in the :force option.
+      # Accepts either a literal value or a lambda.
+      value = scope[:force] if scope.key?(:force)
 
-      value = nil if except.present? && Array.wrap(except).map(&:to_s).include?(action_name)
-      value = nil unless only.nil? || Array.wrap(only).map(&:to_s).include?(action_name)
+      # If either :default or :force options were procs, evaluate them.
+      value = instance_exec(&value) if value.respond_to?(:call)
 
-      if value.nil? || value.to_s =~ /\A(false|no|off)\z/
-        scope.update(:active => false)
-        resource
+      # The :required option makes sure there's a value present, otherwise return an empty scope (Model#none).
+      required = scope[:required]
+      required = instance_exec(&required) if required.respond_to?(:call)
+
+      # Enforce the :required option.
+      return relation.none if required && value.nil?
+
+      # Parses values like 'on/off', 'true/false', and 'yes/no' to an actual boolean value.
+      case value.to_s
+      when /\A(false|no|off)\z/
+        value = false
+      when /\A(true|yes|on)\z/
+        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 = scope[:block]
+
+      if block.nil? && value.nil?
+        break relation
+      end
+
+      case
+      when block.present?
+        instance_exec(relation, value, &block)
+      when value == true
+        relation.send(name)
       else
-        scope.update(:active => true)
-
-        value = nil if value == 'nil'
-
-        if fn
-          self.instance_exec(resource, value, &fn)
-        else
-          if value.to_s =~ /\A(true|yes|on)\z/
-            resource.send(name)
-          else
-            resource.send(name, value)
-          end
-        end
+        relation.send(name, value)
       end
     end
   end
 
   module ClassMethods
-    def scope(name, opts = {}, &fn)
-      scopes.store name, opts.merge(:fn => fn)
+    def scopes
+      @scopes ||= {}
+    end
+
+    def scope(name, options = {}, &block)
+      scopes.store name, options.merge(block: block)
     end
   end
 end

data/lib/scopable/version.rb

@@ -1,3 +1,3 @@
 module Scopable
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/scopable.gemspec

@@ -4,22 +4,24 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'scopable/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "scopable"
+  spec.name          = 'scopable'
   spec.version       = Scopable::VERSION
-  spec.authors       = ["Arthur Corenzan"]
-  spec.email         = ["arthur@corenzan.com"]
-  spec.summary       = %q{Apply scopes to your query based on available parameters}
+  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.homepage      = "https://github.com/haggen/scopable"
-  spec.license       = "MIT"
+  spec.homepage      = 'https://github.com/haggen/scopable'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency "activesupport", ">= 3.2", "< 5.0"
+  spec.add_runtime_dependency 'activesupport', '>= 3.2'
+  # spec.add_runtime_dependency 'railties', '>= 4.2.0', '< 5.1'
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
 end

data/spec/scopable_spec.rb

@@ -0,0 +1,281 @@
+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, with and without matching parameters.
+  #
+  describe 'with one optional scope' do
+    let :controller do
+      Class.new(Controller) do
+        scope :search
+      end
+    end
+
+    context 'without matching parameters' do
+      subject :action do
+        controller.new
+      end
+
+      it 'should skip the scope' do
+        expect(action.relation.scopes).to be_empty
+      end
+    end
+
+    context 'with one matching parameter' 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
+  end
+
+  #
+  # Test two optional scopes, with 0, 1, and 2 matching parameters.
+  #
+  describe 'with two optional scope' do
+    let :controller do
+      Class.new(Controller) do
+        scope :search
+        scope :page
+      end
+    end
+
+    context 'with no matching parameters' do
+      subject :action do
+        controller.new
+      end
+
+      it 'should skip the scope' do
+        expect(action.relation.scopes).to be_empty
+      end
+    end
+
+    context 'with one matching parameter' do
+      subject :action do
+        controller.new(nil, search: 'test')
+      end
+
+      it 'should apply one of the scopes' do
+        expect(action.relation.scopes.size).to eq(1)
+        expect(action.relation.scopes).to include(search: 'test')
+      end
+    end
+
+    context 'with two matching parameters' do
+      subject :action do
+        controller.new(nil, search: 'test', page: 2)
+      end
+
+      it 'should apply both scopes' do
+        expect(action.relation.scopes.size).to eq(2)
+        expect(action.relation.scopes).to include(search: 'test', page: 2)
+      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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,19 @@
+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

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

metadata

@@ -1,63 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: scopable
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Arthur Corenzan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-20 00:00:00.000000000 Z
+date: 2017-02-27 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'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - arthur@corenzan.com
@@ -65,7 +73,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
+- .codeclimate.yml
+- .gitignore
+- .rspec
+- .rubocop.yml
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -73,6 +85,10 @@ files:
 - 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
 homepage: https://github.com/haggen/scopable
 licenses:
 - MIT
@@ -83,18 +99,22 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
-summary: Apply scopes to your query based on available parameters
-test_files: []
+summary: Apply or skip model scopes based on options and request parameters.
+test_files:
+- spec/scopable_spec.rb
+- spec/spec_helper.rb
+- spec/support/controller.rb
+- spec/support/model.rb