has_scope 0.7.2 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b023c16c60cb24ca941d55d69be48713962b661a68b92f32a0af40bf952686ea
-  data.tar.gz: 45b61de129e41764aa08bbcbd17c1287a83542d2171cc69ad8452a6da4f22085
+  metadata.gz: abf0ad461389302c6eef573bc313b2f0753a7dfaa02c23fdf685acce47be111c
+  data.tar.gz: 79209897cf738ba373be55f2b9fe4543d15880ae466c9a577e23cc1abb06ee3d
 SHA512:
-  metadata.gz: 35392817be681d709e897972514b215be8860f2b00216745cba37931c77aa27dbf1fc13f56b1cbc775210c266de902b4a79023a8637b8736089669543ee73b9e
-  data.tar.gz: 8ce1d74c2cfb9a76d4c7a60752aee0d86ede19ba778f7e28983eb77b446162d60091ee7ff3437025b0c841bb75e7f34de8dc4fddfdbd99331dd66707d28b7af5
+  metadata.gz: 04a17d0ea9ee72e18ad98fa79c9d4e3a856219673fe066d1326df8b12af29a22f80282f0ec4cb8de9e25653d5f1179137fa4a8475d5fd8bf247ff12f3ab8c20e
+  data.tar.gz: 87978f08fed8aec6fe006b0d9faee4704b831a11b8b61b1c1211537965d4cd59a85784229d0e3260c49bd7f1313591ba48ac2feb0580417cb69ca1c60d435ad4

data/README.md

@@ -1,36 +1,56 @@
 ## HasScope
 
 [![Gem Version](https://fury-badge.herokuapp.com/rb/has_scope.svg)](http://badge.fury.io/rb/has_scope)
-[![Build Status](https://api.travis-ci.org/plataformatec/has_scope.svg?branch=master)](http://travis-ci.org/plataformatec/has_scope)
-[![Code Climate](https://codeclimate.com/github/plataformatec/has_scope.svg)](https://codeclimate.com/github/plataformatec/has_scope)
 
-Has scope allows you to map incoming controller parameters to named scopes in your resources.
-Imagine the following model called graduations:
+_HasScope_ allows you to dynamically apply named scopes to your resources based on an incoming set of parameters.
+
+The most common usage is to map incoming controller parameters to named scopes for filtering resources, but it can be used anywhere.
+
+## Installation
+
+Add `has_scope` to your bundle
+
+```ruby
+bundle add has_scope
+```
+
+or add it manually to your Gemfile if you prefer.
+
+```ruby
+gem 'has_scope'
+```
+
+## Examples
+
+For the following examples we'll use a model called graduations:
 
 ```ruby
 class Graduation < ActiveRecord::Base
-  scope :featured, -> { where(:featured => true) }
-  scope :by_degree, -> degree { where(:degree => degree) }
+  scope :featured, -> { where(featured: true) }
+  scope :by_degree, -> degree { where(degree: degree) }
   scope :by_period, -> started_at, ended_at { where("started_at = ? AND ended_at = ?", started_at, ended_at) }
 end
 ```
 
-You can use those named scopes as filters by declaring them on your controller:
+### Usage 1: Rails Controllers
+
+_HasScope_ exposes the `has_scope` method automatically in all your controllers. This is used to declare the scopes a controller action can use to filter a resource:
 
 ```ruby
 class GraduationsController < ApplicationController
-  has_scope :featured, :type => :boolean
+  has_scope :featured, type: :boolean
   has_scope :by_degree
+  has_scope :by_period, using: %i[started_at ended_at], type: :hash
 end
 ```
 
-Now, if you want to apply them to an specific resource, you just need to call `apply_scopes`:
+To apply the scopes to a specific resource, you just need to call `apply_scopes`:
 
 ```ruby
 class GraduationsController < ApplicationController
-  has_scope :featured, :type => :boolean
+  has_scope :featured, type: :boolean
   has_scope :by_degree
-  has_scope :by_period, :using => [:started_at, :ended_at], :type => :hash
+  has_scope :by_period, using: %i[started_at ended_at], type: :hash
 
   def index
     @graduations = apply_scopes(Graduation).all
@@ -38,36 +58,128 @@ class GraduationsController < ApplicationController
 end
 ```
 
-Then for each request:
+Then for each request to the `index` action, _HasScope_ will automatically apply the scopes as follows:
 
-```
-/graduations
-#=> acts like a normal request
+``` ruby
+# GET /graduations
+# No scopes applied
+#=> brings all graduations
+apply_scopes(Graduation).all == Graduation.all
 
-/graduations?featured=true
-#=> calls the named scope and bring featured graduations
+# GET /graduations?featured=true
+# The "featured' scope is applied
+#=> brings featured graduations
+apply_scopes(Graduation).all == Graduation.featured
 
-/graduations?by_period[started_at]=20100701&by_period[ended_at]=20101013
+# GET /graduations?by_period[started_at]=20100701&by_period[ended_at]=20101013
 #=> brings graduations in the given period
+apply_scopes(Graduation).all == Graduation.by_period('20100701', '20101013')
 
-/graduations?featured=true&by_degree=phd
+# GET /graduations?featured=true&by_degree=phd
 #=> brings featured graduations with phd degree
+apply_scopes(Graduation).all == Graduation.featured.by_degree('phd')
+
+# GET /graduations?finished=true&by_degree=phd
+#=> brings only graduations with phd degree because we didn't declare finished in our controller as a permitted scope
+apply_scopes(Graduation).all == Graduation.by_degree('phd')
 ```
 
-You can retrieve all the scopes applied in one action with `current_scopes` method.
-In the last case, it would return: { :featured => true, :by_degree => "phd" }.
+#### Check for currently applied scopes
 
-## Installation
+_HasScope_ creates a helper method called `current_scopes` to retrieve all the scopes applied. As it's a helper method, you'll be able to access it in the controller action or the view rendered in that action.
 
-Add `has_scope` to your Gemfile or install it from Rubygems.
+Coming back to one of the examples above:
 
 ```ruby
-gem 'has_scope'
+# GET /graduations?featured=true&by_degree=phd
+#=> brings featured graduations with phd degree
+apply_scopes(Graduation).all == Graduation.featured.by_degree('phd')
+```
+
+Calling `current_scopes` after `apply_scopes` in the controller action or view would return the following:
+
+```
+current_scopes
+#=> { featured: true, by_degree: 'phd' }
+```
+
+### Usage 2: Standalone Mode
+
+_HasScope_ can also be used in plain old Ruby objects (PORO). To implement the previous example using this approach, create a bare object and include `HasScope` to get access to its features:
+
+> Note: We'll create a simple version of a query object for this example as this type of object can have multiple different implementations.
+
+
+```ruby
+class GraduationsSearchQuery
+  include HasScope
+  # ...
+end
+```
+
+Next, declare the scopes to be used the same way:
+
+```ruby
+class GraduationsSearchQuery
+  include HasScope
+
+  has_scope :featured, type: :boolean
+  has_scope :by_degree
+  has_scope :by_period, using: %i[started_at ended_at], type: :hash
+  # ...
+end
+```
+
+Now, allow your object to perform the query by exposing a method that will use `apply_scopes`:
+
+```ruby
+class GraduationsSearchQuery
+  include HasScope
+
+  has_scope :featured, type: :boolean
+  has_scope :by_degree
+  has_scope :by_period, using: %i[started_at ended_at], type: :hash
+
+  def perform(collection: Graduation, params: {})
+    apply_scopes(collection, params)
+  end
+end
+```
+
+Note that `apply_scopes` receives a `Hash` as a second argument, which represents the incoming params that determine which scopes should be applied to the model/collection. It defaults to `params` for compatibility with controllers, which is why it's not necessary to pass that second argument in the controller context.
+
+Now in your controller you can call the `GraduationsSearchQuery` with the incoming parameters from the controller:
+
+```ruby
+class GraduationsController < ApplicationController
+  def index
+    graduations_query = GraduationsSearchQuery.new
+    @graduations = graduations_query.perform(collection: Graduation, params: params)
+  end
+end
+```
+
+#### Accessing `current_scopes`
+
+In the controller context, `current_scopes` is made available as a helper method to the controller and view, but it's a `protected` method of _HasScope_'s implementation, to prevent it from becoming publicly accessible outside of _HasScope_ itself. This means that the object implementation showed above has access to `current_scopes` internally, but it's not exposed to other objects that interact with it.
+
+If you need to access `current_scopes` elsewhere, you can change the method visibility like so:
+
+```ruby
+class GraduationsSearchQuery
+  include HasScope
+
+  # ...
+
+  public :current_scopes
+
+  # ...
+end
 ```
 
 ## Options
 
-HasScope supports several options:
+`has_scope` supports several options:
 
 * `:type` - Checks the type of the parameter sent.
   By default, it does not allow hashes or arrays to be given,
@@ -83,23 +195,23 @@ HasScope supports several options:
 
 * `:using` - The subkeys to be used as args when type is a hash.
 
-* `:if` - Specifies a method, proc or string to call to determine if the scope should apply.
+* `:in` - A shortcut for combining the `:using` option with nested hashes.
 
-* `:unless` - Specifies a method, proc or string to call to determine if the scope should NOT apply.
+* `:if` - Specifies a method or proc to call to determine if the scope should apply. Passing a string is deprecated and it will be removed in a future version.
+
+* `:unless` - Specifies a method or proc to call to determine if the scope should NOT apply. Passing a string is deprecated and it will be removed in a future version.
 
 * `:default` - Default value for the scope. Whenever supplied the scope is always called.
 
 * `:allow_blank` - Blank values are not sent to scopes by default. Set to true to overwrite.
 
-* `:in` - A shortcut for combining the `:using` option with nested hashes.
-
 ## Boolean usage
 
 If `type: :boolean` is set it just calls the named scope, without any arguments, when parameter
 is set to a "true" value. `'true'` and `'1'` are parsed as `true`, everything else as `false`.
 
-When boolean scope is set up with `allow_blank: true`, it will call the scope
-with the value as usual scope.
+When boolean scope is set up with `allow_blank: true`, it will call the scope with the value as
+any usual scope.
 
 ```ruby
 has_scope :visible, type: :boolean
@@ -110,15 +222,23 @@ scope :visible, -> { where(visible: true) }
 scope :active, ->(value = true) { where(active: value) }
 ```
 
+_Note_: it is not possible to apply a boolean scope with just the query param being present, e.g.
+`?active`, that's not considered a "true" value (the param value will be `nil`), and thus the
+scope will be called with `false` as argument. In order for the scope to receive a `true` argument
+the param value must be set to one of the "true" values above, e.g. `?active=true` or `?active=1`.
+
 ## Block usage
 
-`has_scope` also accepts a block. The controller, current scope and value are yielded
-to the block so the user can apply the scope on its own. This is useful in case we
-need to manipulate the given value:
+`has_scope` also accepts a block in case we need to manipulate the given value and/or call the scope in some custom way. Usually three arguments are passed to the block:
+- The instance of the controller or object where it's included
+- The current scope chain
+- The value of the scope to apply
+
+> 💡 We suggest you name the first argument depending on how you're using _HasScope_. If it's the controller, use the word "controller". If it's a query object for example, use "query", or something meaningful for that context (or simply use "context"). In the following examples, we'll use controller for simplicity.
 
 ```ruby
 has_scope :category do |controller, scope, value|
-  value != "all" ? scope.by_category(value) : scope
+  value != 'all' ? scope.by_category(value) : scope
 end
 ```
 
@@ -126,7 +246,7 @@ When used with booleans without `:allow_blank`, it just receives two arguments
 and is just invoked if true is given:
 
 ```ruby
-has_scope :not_voted_by_me, :type => :boolean do |controller, scope|
+has_scope :not_voted_by_me, type: :boolean do |controller, scope|
   scope.not_voted_by(controller.current_user.id)
 end
 ```
@@ -159,10 +279,22 @@ scope :available, ->(*) { where(blocked: false) }
 This will allow usual users to get only available items, but admins will
 be able to access blocked items too.
 
+## Check which scopes have been applied
+
+To check which scopes have been applied, you can call `current_scopes` from the controller or view.
+This returns a hash with the scope name as the key and the scope value as the value.
+
+For example, if a boolean `:active` scope has been applied, `current_scopes` will return `{ active: true }`.
+
+## Supported Ruby / Rails versions
+
+We intend to maintain support for all Ruby / Rails versions that haven't reached end-of-life.
+
+For more information about specific versions please check [Ruby](https://www.ruby-lang.org/en/downloads/branches/)
+and [Rails](https://guides.rubyonrails.org/maintenance_policy.html) maintenance policies, and our test matrix.
+
 ## Bugs and Feedback
 
 If you discover any bugs or want to drop a line, feel free to create an issue on GitHub.
 
-http://github.com/plataformatec/has_scope/issues
-
-MIT License. Copyright 2009-2016 Plataformatec. http://blog.plataformatec.com.br
+MIT License. Copyright 2009-2019 Plataformatec. http://blog.plataformatec.com.br

data/lib/has_scope/version.rb

@@ -1,3 +1,3 @@
 module HasScope
-  VERSION = "0.7.2"
+  VERSION = "0.8.1"
 end

data/lib/has_scope.rb

@@ -1,17 +1,20 @@
+require 'active_support'
+require 'action_controller'
+
 module HasScope
   TRUE_VALUES = ["true", true, "1", 1]
 
   ALLOWED_TYPES = {
-    :array   => [[ Array ]],
-    :hash    => [[Hash, ActionController::Parameters]],
-    :boolean => [[ Object ], -> v { TRUE_VALUES.include?(v) }],
-    :default => [[ String, Numeric ]],
+    array:   [[ Array ]],
+    hash:    [[ Hash, ActionController::Parameters ]],
+    boolean: [[ Object ], -> v { TRUE_VALUES.include?(v) }],
+    default: [[ String, Numeric ]],
   }
 
   def self.included(base)
     base.class_eval do
       extend ClassMethods
-      class_attribute :scopes_configuration, :instance_writer => false
+      class_attribute :scopes_configuration, instance_writer: false
       self.scopes_configuration = {}
     end
   end
@@ -36,6 +39,8 @@ module HasScope
     # * <tt>:using</tt> - If type is a hash, you can provide :using to convert the hash to
     #                     a named scope call with several arguments.
     #
+    # * <tt>:in</tt> - A shortcut for combining the `:using` option with nested hashes.
+    #
     # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
     #                  if the scope should apply
     #
@@ -57,7 +62,7 @@ module HasScope
     #     value != "all" ? scope.by_category(value) : scope
     #   end
     #
-    #   has_scope :not_voted_by_me, :type => :boolean do |controller, scope|
+    #   has_scope :not_voted_by_me, type: :boolean do |controller, scope|
     #     scope.not_voted_by(controller.current_user.id)
     #   end
     #
@@ -69,6 +74,10 @@ module HasScope
       if options.key?(:in)
         options[:as] = options[:in]
         options[:using] = scopes
+
+        if options.key?(:default) && !options[:default].is_a?(Hash)
+          options[:default] = scopes.each_with_object({}) { |scope, hash| hash[scope] = options[:default] }
+        end
       end
 
       if options.key?(:using)
@@ -87,7 +96,7 @@ module HasScope
       self.scopes_configuration = scopes_configuration.dup
 
       scopes.each do |scope|
-        scopes_configuration[scope] ||= { :as => scope, :type => :default, :block => block }
+        scopes_configuration[scope] ||= { as: scope, type: :default, block: block }
         scopes_configuration[scope] = self.scopes_configuration[scope].merge(options)
       end
     end
@@ -97,16 +106,16 @@ module HasScope
 
   # Receives an object where scopes will be applied to.
   #
-  #   class GraduationsController < InheritedResources::Base
-  #     has_scope :featured, :type => true, :only => :index
-  #     has_scope :by_degree, :only => :index
+  #   class GraduationsController < ApplicationController
+  #     has_scope :featured, type: true, only: :index
+  #     has_scope :by_degree, only: :index
   #
   #     def index
   #       @graduations = apply_scopes(Graduation).all
   #     end
   #   end
   #
-  def apply_scopes(target, hash=params)
+  def apply_scopes(target, hash = params)
     scopes_configuration.each do |scope, options|
       next unless apply_scope_to_action?(options)
       key = options[:as]
@@ -120,12 +129,20 @@ module HasScope
         end
       end
 
-      value = parse_value(options[:type], key, value)
+      value = parse_value(options[:type], value)
       value = normalize_blanks(value)
 
-      if call_scope && (value.present? || options[:allow_blank])
+      if value && options.key?(:using)
+        scope_value = value.values_at(*options[:using])
+        call_scope &&= scope_value.all?(&:present?) || options[:allow_blank]
+      else
+        scope_value = value
+        call_scope &&= value.present? || options[:allow_blank]
+      end
+
+      if call_scope
         current_scopes[key] = value
-        target = call_scope_by_type(options[:type], scope, target, value, options)
+        target = call_scope_by_type(options[:type], scope, target, scope_value, options)
       end
     end
 
@@ -133,7 +150,7 @@ module HasScope
   end
 
   # Set the real value for the current scope if type check.
-  def parse_value(type, key, value) #:nodoc:
+  def parse_value(type, value) #:nodoc:
     klasses, parser = ALLOWED_TYPES[type]
     if klasses.any? { |klass| value.is_a?(klass) }
       parser ? parser.call(value) : value
@@ -160,8 +177,7 @@ module HasScope
 
     if type == :boolean && !options[:allow_blank]
       block ? block.call(self, target) : target.send(scope)
-    elsif value && options.key?(:using)
-      value = value.values_at(*options[:using])
+    elsif options.key?(:using)
       block ? block.call(self, target, value) : target.send(scope, *value)
     else
       block ? block.call(self, target, value) : target.send(scope, value)
@@ -185,6 +201,11 @@ module HasScope
   def applicable?(string_proc_or_symbol, expected) #:nodoc:
     case string_proc_or_symbol
     when String
+      ActiveSupport::Deprecation.warn <<-DEPRECATION.squish
+        [HasScope] Passing a string to determine if the scope should be applied
+        is deprecated and it will be removed in a future version of HasScope.
+      DEPRECATION
+
       eval(string_proc_or_symbol) == expected
     when Proc
       string_proc_or_symbol.call(self) == expected

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: has_scope
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.1
 platform: ruby
 authors:
 - José Valim
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-04-10 00:00:00.000000000 Z
+date: 2023-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -77,13 +77,15 @@ files:
 - README.md
 - lib/has_scope.rb
 - lib/has_scope/version.rb
-- test/has_scope_test.rb
-- test/test_helper.rb
 homepage: http://github.com/plataformatec/has_scope
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/heartcombo/has_scope
+  changelog_uri: https://github.com/heartcombo/has_scope/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/heartcombo/has_scope
+  bug_tracker_uri: https://github.com/heartcombo/has_scope/issues
+post_install_message:
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -92,18 +94,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.7
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.4.5
+signing_key:
 specification_version: 4
 summary: Maps controller filters to your resource scopes.
-test_files:
-- test/test_helper.rb
-- test/has_scope_test.rb
+test_files: []

data/test/has_scope_test.rb

@@ -1,375 +0,0 @@
-require 'test_helper'
-
-HasScope::ALLOWED_TYPES[:date] = [[String], -> v { Date.parse(v) rescue nil }]
-
-class Tree; end
-
-class TreesController < ApplicationController
-  has_scope :color, :unless => :show_all_colors?
-  has_scope :only_tall, :type => :boolean, :only => :index, :if => :restrict_to_only_tall_trees?
-  has_scope :shadown_range, :default => 10, :except => [ :index, :show, :new ]
-  has_scope :root_type, :as => :root, :allow_blank => true
-  has_scope :planted_before, :default => proc { Date.today }
-  has_scope :planted_after, :type => :date
-  has_scope :calculate_height, :default => proc {|c| c.session[:height] || 20 }, :only => :new
-  has_scope :paginate, :type => :hash
-  has_scope :args_paginate, :type => :hash, :using => [:page, :per_page]
-  has_scope :categories, :type => :array
-  has_scope :title, :in => :q
-  has_scope :content, :in => :q
-  has_scope :conifer, type: :boolean, :allow_blank => true
-
-  has_scope :only_short, :type => :boolean do |controller, scope|
-    scope.only_really_short!(controller.object_id)
-  end
-
-  has_scope :by_category do |controller, scope, value|
-    scope.by_given_category(controller.object_id, value + "_id")
-  end
-
-  def index
-    @trees = apply_scopes(Tree).all
-  end
-
-  def new
-    @tree = apply_scopes(Tree).new
-  end
-
-  def show
-    @tree = apply_scopes(Tree).find(params[:id])
-  end
-
-  alias :edit :show
-
-  protected
-    def restrict_to_only_tall_trees?
-      true
-    end
-
-    def show_all_colors?
-      false
-    end
-
-    if ActionPack::VERSION::MAJOR == 5
-      def default_render
-        render body: action_name
-      end
-    else
-      # TODO: Remove this when we only support Rails 5.
-      def default_render
-        render text: action_name
-      end
-    end
-end
-
-class BonsaisController < TreesController
-  has_scope :categories, :if => :categories?
-
-  protected
-    def categories?
-      false
-    end
-end
-
-class HasScopeTest < ActionController::TestCase
-  tests TreesController
-
-  def test_boolean_scope_is_called_when_boolean_param_is_true
-    Tree.expects(:only_tall).with().returns(Tree).in_sequence
-    Tree.expects(:all).returns([mock_tree]).in_sequence
-    get :index, :only_tall => 'true'
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ :only_tall => true }, current_scopes)
-  end
-
-  def test_boolean_scope_is_not_called_when_boolean_param_is_false
-    Tree.expects(:only_tall).never
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :only_tall => 'false'
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ }, current_scopes)
-  end
-
-  def test_boolean_scope_with_allow_blank_is_called_when_boolean_param_is_true
-    Tree.expects(:conifer).with(true).returns(Tree).in_sequence
-    Tree.expects(:all).returns([mock_tree]).in_sequence
-    get :index, :conifer => 'true'
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ :conifer => true }, current_scopes)
-  end
-
-  def test_boolean_scope_with_allow_blank_is_called_when_boolean_param_is_false
-    Tree.expects(:conifer).with(false).returns(Tree).in_sequence
-    Tree.expects(:all).returns([mock_tree]).in_sequence
-    get :index, :conifer => 'not_true'
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ :conifer => false }, current_scopes)
-  end
-
-  def test_boolean_scope_with_allow_blank_is_not_called_when_boolean_param_is_not_present
-    Tree.expects(:conifer).never
-    Tree.expects(:all).returns([mock_tree])
-    get :index
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ }, current_scopes)
-  end
-
-  def test_scope_is_called_only_on_index
-    Tree.expects(:only_tall).never
-    Tree.expects(:find).with('42').returns(mock_tree)
-    get :show, :only_tall => 'true', :id => '42'
-    assert_equal(mock_tree, assigns(:@tree))
-    assert_equal({ }, current_scopes)
-  end
-
-  def test_scope_is_skipped_when_if_option_is_false
-    @controller.stubs(:restrict_to_only_tall_trees?).returns(false)
-    Tree.expects(:only_tall).never
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :only_tall => 'true'
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ }, current_scopes)
-  end
-
-  def test_scope_is_skipped_when_unless_option_is_true
-    @controller.stubs(:show_all_colors?).returns(true)
-    Tree.expects(:color).never
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :color => 'blue'
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ }, current_scopes)
-  end
-
-  def test_scope_is_called_except_on_index
-    Tree.expects(:shadown_range).never
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :shadown_range => 20
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ }, current_scopes)
-  end
-
-  def test_scope_is_called_with_arguments
-    Tree.expects(:color).with('blue').returns(Tree).in_sequence
-    Tree.expects(:all).returns([mock_tree]).in_sequence
-    get :index, :color => 'blue'
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ :color => 'blue' }, current_scopes)
-  end
-
-  def test_scope_is_not_called_if_blank
-    Tree.expects(:color).never
-    Tree.expects(:all).returns([mock_tree]).in_sequence
-    get :index, :color => ''
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ }, current_scopes)
-  end
-
-  def test_scope_is_called_when_blank_if_allow_blank_is_given
-    Tree.expects(:root_type).with('').returns(Tree)
-    Tree.expects(:all).returns([mock_tree]).in_sequence
-    get :index, :root => ''
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ :root => '' }, current_scopes)
-  end
-
-  def test_multiple_scopes_are_called
-    Tree.expects(:only_tall).with().returns(Tree)
-    Tree.expects(:color).with('blue').returns(Tree)
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :color => 'blue', :only_tall => 'true'
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ :color => 'blue', :only_tall => true }, current_scopes)
-  end
-
-  def test_scope_of_type_hash
-    hash = { "page" => "1", "per_page" => "10" }
-    Tree.expects(:paginate).with(hash).returns(Tree)
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :paginate => hash
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ paginate: hash }, current_scopes)
-  end
-
-  def test_scope_of_type_hash_with_using
-    hash = { "page" => "1", "per_page" => "10" }
-    Tree.expects(:args_paginate).with("1", "10").returns(Tree)
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :args_paginate => hash
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ :args_paginate => hash }, current_scopes)
-  end
-
-  def test_hash_with_blank_values_is_ignored
-    hash = { "page" => "", "per_page" => "" }
-    Tree.expects(:paginate).never
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :paginate => hash
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ }, current_scopes)
-  end
-
-  def test_nested_hash_with_blank_values_is_ignored
-    hash = { "parent" => {"children" => ""} }
-    Tree.expects(:paginate).never
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :paginate => hash
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ }, current_scopes)
-  end
-
-  def test_nested_blank_array_param_is_ignored
-    hash = { "parent" => [""] }
-    Tree.expects(:paginate).never
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :paginate => hash
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ }, current_scopes)
-  end
-
-  def test_scope_of_type_array
-    array = %w(book kitchen sport)
-    Tree.expects(:categories).with(array).returns(Tree)
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :categories => array
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ :categories => array }, current_scopes)
-  end
-
-  def test_array_of_blank_values_is_ignored
-    Tree.expects(:categories).never
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :categories => [""]
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ }, current_scopes)
-  end
-
-  def test_scope_of_invalid_type_silently_fails
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :paginate => "1"
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ }, current_scopes)
-  end
-
-  def test_scope_is_called_with_default_value
-    Tree.expects(:shadown_range).with(10).returns(Tree).in_sequence
-    Tree.expects(:find).with('42').returns(mock_tree).in_sequence
-    get :edit, :id => '42'
-    assert_equal(mock_tree, assigns(:@tree))
-    assert_equal({ :shadown_range => 10 }, current_scopes)
-  end
-
-  def test_default_scope_value_can_be_overwritten
-    Tree.expects(:shadown_range).with('20').returns(Tree).in_sequence
-    Tree.expects(:find).with('42').returns(mock_tree).in_sequence
-    get :edit, :id => '42', :shadown_range => '20'
-    assert_equal(mock_tree, assigns(:@tree))
-    assert_equal({ :shadown_range => '20' }, current_scopes)
-  end
-
-  def test_scope_with_different_key
-    Tree.expects(:root_type).with('outside').returns(Tree).in_sequence
-    Tree.expects(:find).with('42').returns(mock_tree).in_sequence
-    get :show, :id => '42', :root => 'outside'
-    assert_equal(mock_tree, assigns(:@tree))
-    assert_equal({ :root => 'outside' }, current_scopes)
-  end
-
-  def test_scope_with_default_value_as_a_proc_without_argument
-    Date.expects(:today).returns("today")
-    Tree.expects(:planted_before).with("today").returns(Tree)
-    Tree.expects(:all).returns([mock_tree])
-    get :index
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ :planted_before => "today" }, current_scopes)
-  end
-
-  def test_scope_with_default_value_as_proc_with_argument
-    session[:height] = 100
-    Tree.expects(:calculate_height).with(100).returns(Tree).in_sequence
-    Tree.expects(:new).returns(mock_tree).in_sequence
-    get :new
-    assert_equal(mock_tree, assigns(:@tree))
-    assert_equal({ :calculate_height => 100 }, current_scopes)
-  end
-
-  def test_scope_with_custom_type
-    parsed = Date.civil(2014,11,11)
-    Tree.expects(:planted_after).with(parsed).returns(Tree)
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :planted_after => "2014-11-11"
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ :planted_after => parsed }, current_scopes)
-  end
-
-  def test_scope_with_boolean_block
-    Tree.expects(:only_really_short!).with(@controller.object_id).returns(Tree)
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :only_short => 'true'
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ :only_short => true }, current_scopes)
-  end
-
-  def test_scope_with_other_block_types
-    Tree.expects(:by_given_category).with(@controller.object_id, 'for_id').returns(Tree)
-    Tree.expects(:all).returns([mock_tree])
-    get :index, :by_category => 'for'
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ :by_category => 'for' }, current_scopes)
-  end
-
-  def test_scope_with_nested_hash_and_in_option
-    hash = { 'title' => 'the-title', 'content' => 'the-content' }
-    Tree.expects(:title).with('the-title').returns(Tree)
-    Tree.expects(:content).with('the-content').returns(Tree)
-    Tree.expects(:all).returns([mock_tree])
-    get :index, q: hash
-    assert_equal([mock_tree], assigns(:@trees))
-    assert_equal({ q: hash }, current_scopes)
-  end
-
-  def test_overwritten_scope
-    assert_nil(TreesController.scopes_configuration[:categories][:if])
-    assert_equal(:categories?, BonsaisController.scopes_configuration[:categories][:if])
-  end
-
-  protected
-
-    if ActionPack::VERSION::MAJOR == 5
-      # TODO: Remove this when we only support Rails 5.
-      def get(action, params = {})
-        super action, params: params
-      end
-    end
-
-    def mock_tree(stubs={})
-      @mock_tree ||= mock(stubs)
-    end
-
-    def current_scopes
-      @controller.send :current_scopes
-    end
-
-    def assigns(ivar)
-      @controller.instance_variable_get(ivar)
-    end
-end
-
-class TreeHugger
-  include HasScope
-
-  has_scope :color
-
-  def by_color
-    apply_scopes(Tree, :color => 'blue')
-  end
-
-end
-
-class HasScopeOutsideControllerTest < ActiveSupport::TestCase
-
-  def test_has_scope_usable_outside_controller
-    Tree.expects(:color).with('blue')
-    TreeHugger.new.by_color
-  end
-
-end

data/test/test_helper.rb

@@ -1,33 +0,0 @@
-require 'bundler/setup'
-
-require 'minitest/autorun'
-require 'mocha'
-require 'mocha/mini_test'
-
-# Configure Rails
-ENV['RAILS_ENV'] = 'test'
-
-require 'active_support'
-require 'active_support/core_ext/string/strip'
-require 'action_controller'
-require 'action_dispatch/middleware/flash'
-
-$:.unshift File.expand_path('../../lib', __FILE__)
-require 'has_scope'
-
-HasScope::Routes = ActionDispatch::Routing::RouteSet.new
-HasScope::Routes.draw do
-  get '/:controller(/:action(/:id))'
-end
-
-class ApplicationController < ActionController::Base
-  include HasScope::Routes.url_helpers
-end
-
-class ActiveSupport::TestCase
-  self.test_order = :random if respond_to?(:test_order=)
-
-  setup do
-    @routes = HasScope::Routes
-  end
-end