active_record_filterable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f49388c51e77d6b3c1a9eebdb2707e9363ef933a76cc06426bca9c582bca7dc3
+  data.tar.gz: c08597f76c10fd643f78a5942d16d6a234767aad77fa34bceab29244bd130ed9
+SHA512:
+  metadata.gz: d19d09ee74bca4dd75550d7ddd96c1f8107f36244e73e7b5dff8b661adc9e4bd289411c7511dd74db1fb0d16f78945507eaf09cc1c64700b6c277961439a8157
+  data.tar.gz: 4196038390f371cddb094f6a6fb0d3803c1e50605f3ebbba7373c8acf92b298d315e4a0de4f464e2e09eb739df6c30f6460e8523a5b2e1856ccf8da34d7143c5

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+test.sqlite3
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+db

data/.travis.yml

@@ -0,0 +1,25 @@
+sudo: false
+language: ruby
+
+cache:
+  directories:
+    - vendor/bundle
+
+rvm:
+  - 2.6.0
+
+bundler_args: --jobs 3 --retry 3
+
+env:
+  - DATABASE=postgresql
+  - DATABASE=sqlite
+  - DATABASE=mysql
+before_script:
+  - sh -c "if [ '$DATABASE' = 'postgresql' ]; then psql -c 'CREATE DATABASE active_record_filterable_test;' -U postgres; fi"
+  - sh -c "if [ '$DATABASE' = 'postgresql' ]; then psql -d active_record_filterable_test -c 'CREATE EXTENSION unaccent;' -U postgres; fi"
+  - sh -c "if [ '$DATABASE' = 'mysql' ]; then mysql -e 'CREATE DATABASE IF NOT EXISTS active_record_filterable_test;'; fi"
+
+script: bundle exec rspec
+
+gemfile:
+  - Gemfile

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'pg', '>= 0.18', '< 2.0'
+  gem 'mysql2', '>= 0.5.0', '< 0.6.0'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Rafael Jurado
+
+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/README.md

@@ -0,0 +1,112 @@
+# ActiveRecord::Filterable
+![Build Status](https://travis-ci.org/nosolosoftware/active_record_filterable.svg?branch=master)
+
+Let you add scopes to active_record document for filters.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_record_filterable'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_record_filterable
+
+## Usage
+
+#### Model
+
+```ruby
+class City < ActiveRecord::Base
+  include ActiveRecord::Filterable
+
+  field :name
+  field :people
+
+  filter_by(:name)
+  filter_by(:people, ->(value) { where(:people.gt => value) })
+  filter_by(:people_range, (lambda do |range_start, range_end|
+    where(:people.lte => range_end,
+          :people.gte => range_start)
+  end))
+end
+
+City.create(name: 'city1', people: 100)
+City.create(name: 'city2', people: 1000)
+City.filter({name: 'city'}).count # => 2
+City.filter({name: 'city1'}).count # => 1
+City.filter({name: ''}).count # => 0
+City.filter({people: 500}) # => 1
+```
+
+#### Operator
+
+You can specify selector operator:
+
+* and (default operator)
+* or
+
+```ruby
+City.filter({name: 'city1', people: 1000}, 'and').count # => 0
+City.filter({name: 'city1', people: 1000}, 'or').count # => 1
+```
+
+#### Range
+
+Searches with more than one param is also available:
+
+```ruby
+City.filter(people_range: [500, 1000]).count # => 1
+```
+
+#### Rails controller
+
+```ruby
+class CitiesController
+  def index
+    respond_with City.filter(filter_params)
+  end
+
+  private
+
+  def filter_params
+    params.slice(:name, :people)
+  end
+end
+```
+
+#### Normalized values
+
+Searches without considering accents are also supported. 
+
+```ruby
+  filter_by_normalized :name
+```
+enables to do sth like:
+
+  ```ruby
+  City.filter(name_normalized: 'text with accents')
+  ```
+
+It also depends on which adapter you are using.
+
+* Postgresql: It makes use of [`unaccent`](https://www.postgresql.org/docs/9.1/static/unaccent.html). You need to activate in [your project](https://binarapps.com/blog/accent-insensitive-queries-in-rails-with-postgresql).
+* Mysql, SqlServer: you only need to select an [accent-insensitive collation](https://binarapps.com/blog/accent-insensitive-queries-in-rails-with-postgresql). In cases where this is not possible you could even write:
+    ```ruby
+    filter_by :name, (lambda do |value|
+      where("name LIKE ? COLLATE utf8_general_ci", "%#{value}%")
+    end)
+    ```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/active_record_filterable/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/active_record_filterable.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record_filterable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'active_record_filterable'
+  spec.version       = ActiveRecord::Filterable::VERSION
+  spec.authors       = ['Francisco Padillo']
+  spec.email         = ['fpadillo@nosolosoftware.es']
+  spec.summary       = 'Easy way to add scopes to your models.'
+  spec.description   = 'Easy way to add scopes to your models.'
+  spec.homepage      = ''
+  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.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_dependency 'activerecord', ['>= 3.0', '< 6.0']
+  spec.add_dependency 'activesupport', ['>= 3.0', '< 6.0']
+end

data/lib/active_record_filterable.rb

@@ -0,0 +1,5 @@
+require 'active_record_filterable/version'
+require 'active_record_filterable/filter'
+require 'active_record_filterable/filterable'
+
+ActiveRecord::Relation.send(:include, ActiveRecord::Filterable::Filter)

data/lib/active_record_filterable/filter.rb

@@ -0,0 +1,36 @@
+module ActiveRecord
+  module Filterable
+    module Filter
+      ##
+      # Applies params scopes to current scope
+      #
+      def filter(filtering_params, operator='and')
+        return all if filtering_params.blank?
+        criteria = nil
+
+        unscoped do
+          criteria = is_a?(ActiveRecord::Relation) ? self : all
+
+          filtering_params.each do |key, value|
+            next unless respond_to?("filter_with_#{key}")
+
+            # Add support for both kind of scopes: scope with multiple arguments and scope with
+            # one argument as array
+            value = [value] unless value.is_a?(Array) &&
+              scope_arities["filter_with_#{key}".to_sym] > 1
+
+            # check the number of arguments of filter scope
+            criteria =
+              if operator == 'and' || criteria.where_clause.empty?
+                criteria.public_send("filter_with_#{key}", *value)
+              else
+                criteria.or(all.public_send("filter_with_#{key}", *value))
+              end
+          end
+        end
+
+        criteria == self ? none : merge(criteria)
+      end
+    end
+  end
+end

data/lib/active_record_filterable/filterable.rb

@@ -0,0 +1,53 @@
+module ActiveRecord
+  module Filterable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute(:scope_arities)
+      self.scope_arities = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    # rubocop:disable Metrics/BlockLength
+    class_methods do
+      include Filter
+
+      def scope(name, scope_options, &block)
+        super
+        scope_arities[name] = scope_options.is_a?(Proc) ? scope_options.arity : -1
+      end
+
+      ##
+      # Adds attr scope
+      #
+      def filter_by(attr, filter=nil)
+        if filter
+          scope "filter_with_#{attr}", filter
+        else
+          scope "filter_with_#{attr}", ->(value) { where(attr => value) }
+        end
+      end
+
+      ##
+      # Adds attr scope using normalized values
+      #
+      def filter_by_normalized(attr)
+        normalized_name = (attr.to_s + '_normalized').to_sym
+        adapter_name = ActiveRecord::Base.connection.adapter_name.downcase
+
+        body =
+          if adapter_name.starts_with?('postgresql')
+            lambda { |value|
+              where("unaccent(#{attr}) ILIKE unaccent(?)", "%#{sanitize_sql_like(value)}%")
+            }
+          else
+            lambda { |value|
+              where("#{attr} LIKE ?", "%#{sanitize_sql_like(value)}%")
+            }
+          end
+
+        scope "filter_with_#{normalized_name}", body
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/active_record_filterable/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module Filterable
+    VERSION = '0.1.0'
+  end
+end

data/spec/filterable_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+RSpec.describe ActiveRecord::Filterable do
+  class City < ActiveRecord::Base
+    include ActiveRecord::Filterable
+
+    default_scope -> { where(active: true) }
+
+    filter_by :code
+    filter_by(:active)
+    filter_by(:name)
+    filter_by(:code)
+    filter_by(:people, ->(value) { where(City.arel_table[:people].gt(value)) })
+    filter_by(:people_in, ->(value) { where(people: value) })
+    filter_by(:people_range, (lambda do |range_start, range_end|
+      where(people: range_start..range_end)
+    end))
+    filter_by_normalized(:name)
+  end
+
+  before do
+    City.unscoped.destroy_all
+  end
+
+  context 'when use default operator' do
+    context 'when exact matching is used' do
+      before do
+        City.create(code: :code1)
+        City.create(code: :code2)
+      end
+
+      it 'filters' do
+        expect(City.filter(code: :code1).count).to eq(1)
+        expect(City.filter(code: :code1).first.code).to eq('code1')
+      end
+
+      it 'doesn\'t find anything with partial match' do
+        expect(City.filter(name: :city).count).to eq(0)
+      end
+    end
+
+    context 'when filter by nil' do
+      before do
+        City.create(name: 'city1')
+        City.create(name: 'city2')
+        City.create(active: false)
+      end
+
+      it 'respects default_scope' do
+        expect(City.filter(nil).count).to eq(2)
+      end
+
+      it 'ignores filter' do
+        expect(City.filter(nil).count).to eq(2)
+      end
+    end
+
+    context 'with invalid filter' do
+      before do
+        City.create(name: 'city1')
+        City.create(name: 'city2')
+        City.create(active: false)
+      end
+
+      it 'should respect default_scope' do
+        expect(City.filter(invalid: 'val').count).to eq(2)
+      end
+
+      it 'should ignore filter' do
+        expect(City.filter(invalid: 'val').count).to eq(2)
+      end
+    end
+
+    context 'when value is an array' do
+      before do
+        City.create(people: 100)
+        City.create(people: 500)
+        City.create(people: 500, active: false)
+        City.create(people: 1000)
+        City.create(people: 1000)
+      end
+
+      it 'receives all the values' do
+        expect(City.filter(people_range: [500, 1000]).count).to eq(3)
+      end
+
+      it 'does not break compatibility with filters receiving only one param as array' do
+        expect(City.filter(people_in: [500, 100]).count).to eq(2)
+      end
+    end
+
+    context 'when value is empty string' do
+      before do
+        City.create(people: 100)
+        City.create(people: 500)
+      end
+
+      it 'applies filter' do
+        expect(City.filter(people: '').count).to eq(0)
+      end
+    end
+
+    context 'when value is a Boolean' do
+      before do
+        City.create(name: 'city1')
+        City.create(name: 'city2', active: false)
+      end
+
+      it 'filters using a query' do
+        expect(City.unscoped.filter(active: false).count).to eq(1)
+      end
+    end
+
+    context 'when exact matching is used' do
+      before do
+        City.create(people: 100)
+        City.create(people: 1000)
+      end
+
+      it 'filters' do
+        expect(City.filter(people: 500).count).to eq(1)
+        expect(City.filter(people: 500).first.people).to eq(1000)
+      end
+    end
+
+    context 'when partial matching is used' do
+      before do
+        City.create(name: 'spaIn')
+        City.create(name: 'frAnce')
+        City.create(name: 'itály')
+        City.create(name: '_russian%')
+      end
+
+      it 'filters ignoring upcase' do
+        expect(City.filter(name_normalized: 'spain').first.name).to eq('spaIn')
+        expect(City.filter(name_normalized: 'france').first.name).to eq('frAnce')
+      end
+
+      it 'filters ignoring special characters', sqlite: false do
+        expect(City.filter(name_normalized: '%').first.name).to eq('_russian%')
+      end
+
+      it 'filters ignoring accents', sqlite: false do
+        expect(City.filter(name_normalized: 'italy').first.name).to eq('itály')
+      end
+    end
+
+    context 'when filter is applied on a scope' do
+      before do
+        City.create(name: '2', people: 100)
+        City.create(name: '1', people: 500)
+        City.create(name: '1', people: 1000)
+        City.create(name: '1', people: 1000)
+      end
+
+      it 'is maintained' do
+        expect(City.where(name: '2').filter(nil).count).to eq(1)
+      end
+    end
+
+    context 'when is applied in query' do
+      before do
+        City.create(name: 'city1', people: 100)
+        City.create(name: 'city2', people: 1000)
+        City.create(name: 'city3', people: 2000)
+      end
+
+      it 'respects previous selector' do
+        expect(City.where(name: 'city2').filter(people: '500').count).to eq(1)
+        expect(City.where(name: 'city2').filter(people: '500').first.name).to eq('city2')
+      end
+    end
+  end
+
+  context 'when use "and" operator' do
+    before do
+      City.create(name: 'city1', people: 100)
+      City.create(name: 'city2', people: 2000)
+    end
+
+    it 'filters' do
+      expect(City.filter({name: 'city1', people: '2000'}, 'and').count).to eq(0)
+    end
+  end
+
+  context 'when use "or" operator' do
+    before do
+      City.create(name: 'city1', people: 100)
+      City.create(name: 'city2', people: 2000)
+    end
+
+    it 'filters' do
+      expect(City.filter({name: 'city1', people: 500}, 'or').count).to eq(2)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,99 @@
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'bundler/setup'
+require 'active_support'
+require 'active_record'
+
+require 'active_record_filterable'
+
+db_config = YAML.safe_load(
+  File.open("#{__dir__}/support/database_#{ENV['DATABASE'] || 'sqlite'}.yml")
+)
+
+ActiveRecord::Base.establish_connection(db_config['test'])
+
+ActiveRecord::Base.connection.create_table(:cities, force: true, collate: :nocase) do |t|
+  t.boolean :active, default: true
+  t.string :code
+  t.string :name, collate: :nocase
+  t.integer :people
+
+  t.timestamps null: false
+end
+ActiveRecord::Base.connection.create_table(:votes, force: true)
+
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+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
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # This allows 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. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+  # 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!
+  # 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
+
+  config.filter_run_excluding(sqlite: ENV['DATABASE'] != 'sqlite')
+end

data/spec/support/database_mysql.yml

@@ -0,0 +1,5 @@
+test:
+  adapter: mysql2
+  database: active_record_filterable_test
+  pool: 5
+  timeout: 5000

data/spec/support/database_postgresql.yml

@@ -0,0 +1,6 @@
+test:
+  adapter: postgresql
+  username: postgres
+  database: active_record_filterable_test
+  pool: 5
+  timeout: 5000

data/spec/support/database_sqlite.yml

@@ -0,0 +1,5 @@
+test:
+  adapter: sqlite3
+  database: db/active_record_filterable_test.sqlite3
+  pool: 5
+  timeout: 5000

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: active_record_filterable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Francisco Padillo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: Easy way to add scopes to your models.
+email:
+- fpadillo@nosolosoftware.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_record_filterable.gemspec
+- lib/active_record_filterable.rb
+- lib/active_record_filterable/filter.rb
+- lib/active_record_filterable/filterable.rb
+- lib/active_record_filterable/version.rb
+- spec/filterable_spec.rb
+- spec/spec_helper.rb
+- spec/support/database_mysql.yml
+- spec/support/database_postgresql.yml
+- spec/support/database_sqlite.yml
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.7.3
+signing_key: 
+specification_version: 4
+summary: Easy way to add scopes to your models.
+test_files:
+- spec/filterable_spec.rb
+- spec/spec_helper.rb
+- spec/support/database_mysql.yml
+- spec/support/database_postgresql.yml
+- spec/support/database_sqlite.yml