easy_filters 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9c4d6be28e25fe3be62cf50ab45d044a7ca7083d
+  data.tar.gz: e221ccf98fa4c6fcc69cb60786997af1d5fb3712
+SHA512:
+  metadata.gz: 0c24d10fbf0d42b5079a7e843ae0b4d98cb13c64e7e28cf66d4c6ee549f058690adf1492a88a341517368e28a9f5e9e8689690f9a651db873831576daab4f0a6
+  data.tar.gz: 946460bf9331eebe0578d072636168003598afdb9db9358629e043c37a2dc76a98f0fa1df5ef9c73e120f7398aa23708f1587af72f20ce10e4cc7d2c13e6d7ad

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in easy_filters.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 German Olle
+
+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,82 @@
+# EasyFilters
+
+This gem provides a simple API for defining dynamic persistent(in session) filters based on active record models.
+This was extracted from el_dia_backend
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+
+    gem 'easy_filters'
+
+```
+
+And then execute:
+
+```bash
+
+    $ bundle
+```
+
+## Usage
+
+EasyFilters expects you to define the following methods:
+
+```ruby
+class ArticlesFilter < ModelFilter
+
+  # Default values for this filter.
+  def self.defaults
+    { body: nil, date_from: nil, date_to: nil }
+  end
+
+  # Model class to be filtered.
+  def model
+    Article
+  end
+end
+
+```
+
+* __defaults__: defines the fields that will be used for filtering and its defaults values
+* __model__: returns the target class to be filtered
+
+### Customizing filtering strategy
+
+For defining the parts of the query that will filter each each field,
+define a method named `filter_by_#{field_name}`. 
+The field __must__ be present in the defaults array.
+
+Each `filter_by_*` method receives 2 params:
+* __scope__: The actual query.
+* __value__: The value for the current field
+
+For example:  
+
+```ruby
+class ArticlesFilter < ModelFilter
+   
+  #(...) previously defined methods
+
+  # Custom filter method for :body field.
+  def filter_by_body(scope, value)
+    matcher = "%#{value}%"
+    scope.where('body like ? OR body like ?', matcher, matcher)
+  end
+
+  # The following 2 filter_by builds an from/to/between date filter:
+
+  # Custom filter method for :date_from field.
+  def filter_by_date_from(scope, value)
+    scope.joins(:editions).where('editions.date >= ?', Date.parse(value))
+  end
+
+  # Custom filter method for :date_to field.
+  def filter_by_date_to(scope, value)
+    scope.joins(:editions).where('editions.date <= ?', Date.parse(value))
+  end
+end
+
+```

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rake/testtask'
+require 'active_record'
+require 'sqlite3'
+
+desc 'Create table structure for testing'
+task :migrate do
+  ActiveRecord::Base.establish_connection(adapter:  'sqlite3', database: 'db/easy_filters_test.sqlite3') 
+  ActiveRecord::Schema.define do
+    create_table :articles do |t|
+      t.string      :slug,      null: false, index: true
+      t.text        :heading
+      t.text        :title,     null: false
+      t.boolean     :show_time, null: false, default: false
+      t.date        :date
+
+      t.timestamps
+    end
+  end
+end  
+
+desc 'Run tests'
+Rake::TestTask.new :test do |t|
+  ActiveRecord::Base.establish_connection(adapter:  'sqlite3', database: 'db/easy_filters_test.sqlite3')
+
+  Rake::Task[:migrate].invoke unless ActiveRecord::Base.connection.table_exists? 'articles'
+
+  t.libs << 'spec'
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task default: :test

data/easy_filters.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'easy_filters/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "easy_filters"
+  spec.version       = EasyFilters::VERSION
+  spec.authors       = ["German Olle"]
+  spec.email         = ["golle@cespi.unlp.edu.ar"]
+  spec.summary       = "This gem implement a base model filter to declare your owns filters writing a single file"
+  spec.description   = "Define a model class, allowing declare a subclass of this and implement simple methods to filter each field model"
+  spec.homepage      = "http://rubygems.org/gems/easy_filters"
+  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 "rake",    "~> 0"
+  spec.add_development_dependency "sqlite3", "~> 0"
+
+  spec.add_dependency 'activerecord',        "~> 4.0"
+end

data/lib/easy_filters.rb

@@ -0,0 +1,2 @@
+require "easy_filters/filter"
+require "easy_filters/model_filter"

data/lib/easy_filters/filter.rb

@@ -0,0 +1,148 @@
+module EasyFilters
+  # Base class for any object used for keeping filtering logic + criteria together.
+  #
+  # This class provides the following functionality out-of-the-box:
+  #
+  #   - Automatic values sanitizing: The values passed to the #initialize method
+  #     will be fed into #sanitize and the result of that process will be used for
+  #     setting the filter values.
+  #   - Hash-like accessors: Any value for the filters can be get/set via []/[]=,
+  #     just like Hashes.
+  #
+  # For examples, please:
+  # @see ArticlesFilter
+  # @see SupplementFilter
+  class Filter
+    
+    # Default values. This method should be overridden
+    # when in need to specify particular defaults for a
+    # subclass.
+    def self.defaults
+      {}
+    end
+
+    # Global key that will contain the values for any filter class
+    # inside the store or the request values source.
+    # In extension, the store options should be structured
+    # like this:
+    #     {
+    #       :"#{Filter.global_key}" => {
+    #         :"#{@filter.key}" => {
+    #           :value => 'for a filter field'
+    #         }
+    #       }
+    #     }
+    def self.global_key
+      :filter
+    end
+    
+    # Particular key that will contain the values for this specific
+    # filter class in the store/request values source - under the
+    # Filter#global_key main key.
+    # In extension, the store options should be structured
+    # like this:
+    #     {
+    #       :"#{Filter.global_key}" => {
+    #         :"#{@filter.key}" => {
+    #           :value => 'for a filter field'
+    #         }
+    #       }
+    #     }
+    def self.key
+      self.name.to_sym
+    end
+
+    # Initialize a new filter with the given options.
+    def initialize(options = {})
+      @options = { values: nil, store: nil, persist: false }.merge options
+
+      # This is the order of precedence:
+      # values => store => defaults
+      actual = options[:values]
+      store  = options[:store]
+      
+      source = self.class.defaults
+      
+      source = store[self.class.global_key][key] if store && store[self.class.global_key] && store[self.class.global_key][key]
+      source = actual if actual
+
+      self.values = sanitize source
+
+      self
+    end
+
+    # Conditionally clean up some values after the initialization is finished
+    # Note:
+    #   These method have sense when the subclasses uses it, 
+    #   Filter class will not allows to pass any value 
+    #   due that the defaults is an empty hash so the valid keys is an empty array
+    def sanitize(values)
+      valid_keys = self.class.defaults.keys
+      values.inject(self.class.defaults) do |carry, (k, v)|
+        carry[k] = v if valid_keys.include?(k) && !v.blank?
+        carry
+      end
+    end
+    
+    # Instance method used for convenience. Just a wrapper for the
+    # class method #key.
+    def key
+      self.class.key
+    end
+    
+    # Filter field value accessor. Provides a Hash-like API for
+    # getting the values set to the different fields of this filter.
+    # Will return the value set for :key or nil.
+    def [] key
+      values[key] if values.has_key? key
+    end
+
+    # Filter field value writer. Provides a Hash-like API for
+    # setting the values of the filter fields.
+    def []=(key, value)
+      values[key] = value
+    end
+
+    # Answer whether any filter values have been applied. Will return
+    # true if the current values differ from the default ones.
+    def any?
+      self.class.defaults != self.values
+    end
+
+    # Gets the values for this filter.
+    def values
+      @values
+    end
+
+    # Sets the values for this filter to :new_values.
+    # Will persist if the :persist option was set to true when creating
+    # this object and a valid store has been provided.
+    def values=(new_values)
+      @values = new_values
+
+      # Define getters for each of the new_values
+      new_values.each do |key, value|
+        self.class.send(:define_method, key, proc { self[key] }) unless self.respond_to? key
+      end
+
+      self.persist! @options[:store] if @options[:store] && @options[:persist]
+    end
+
+    # Persist the current values to the given :store.
+    def persist!(store)
+      store[self.class.global_key] ||= {}
+      store[self.class.global_key][self.class.key] = self.values
+    end
+
+    # Clear the values of the filters - set them to the defaults.
+    def clear!
+      self.values = self.class.defaults
+    end
+
+    # Get all the matching records to the current filter criteria.
+    # This method must be implemented in subclasses.
+    def all
+      throw NotImplementedError
+    end
+  end
+end

data/lib/easy_filters/model_filter.rb

@@ -0,0 +1,75 @@
+module EasyFilters 
+  # Base class for ActiveRecord-bound filter classes.
+  # Subclasses must implement the #model method and optionally add
+  # custom filtering methods, as explained below in the #apply_to method.
+  class ModelFilter < Filter
+    # Get the model class to which the filters will be applied.
+    # This method must be overridden in subclasses.
+    def model
+      raise NotImplementedError
+    end
+
+    # Get all the matching records to the current filter criteria.
+    def all
+      matches = model.send(scope)
+      matches = apply_to matches
+    end
+    
+    # Get the scope that will start the filter criteria as a symbol.
+    # The default scope is :all.
+    def scope
+      :all
+    end
+
+    # Applies the filter criteria specified for the different fields to :matches,
+    # an ActiveRecordRelation which should start by matching all the "filterable"
+    # records.
+    #
+    # Each field will be processed in the following way:
+    # 1. Check if self responds to a custom filter method of the form: "filter_by_<FIELD_NAME>". If it does,
+    #    delegate the filtering of records by that field to the method. Such a method must return the updated
+    #    ActiveRecordRelation.
+    #    For instance, if the field name is "slug", its custom filter method will be named "filter_by_slug":
+    #
+    #     def filter_by_slug(partial, value)
+    #       partial.where(slug: value)
+    #     end
+    #
+    # 2. If no custom filter method is available for the field, check for a default filter method by the class
+    #    of the value. Supported classes out-of-the-box are:
+    #
+    #    - String:    Will search with a 'like "%value%"'.
+    #
+    # 3. Otherwise, leave the logic up to ActiveRecord. Will add a where constraint like follows:
+    #
+    #     partial.where(field.to_sym => value)
+    #
+    def apply_to(matches)
+      values.inject(matches) do |partial, pair|
+        field, value = pair
+        unless value.blank?
+          type = value.class.name.downcase
+          custom_filter_method = "filter_by_#{field}"
+          default_filter_method = "filter_#{type}_field"
+          if self.respond_to? custom_filter_method
+            # Custom filtering
+            partial = self.send custom_filter_method, partial, value
+          elsif self.respond_to? default_filter_method
+            # Default method filtering
+            partial = self.send default_filter_method, partial, field, value
+          else
+            # Leave it up to AR and its magic
+            partial = partial.where(field.to_sym => value)
+          end
+        end
+
+        partial
+      end
+    end
+
+    # Filters String fields using LIKE.
+    def filter_string_field(partial, field, value)
+      partial.where("#{field} like ?", "%#{value}%")
+    end
+  end
+ end 

data/lib/easy_filters/version.rb

@@ -0,0 +1,3 @@
+module EasyFilters
+  VERSION = "0.0.1"
+end

data/spec/filter_spec.rb

@@ -0,0 +1,143 @@
+require 'minitest_helper'
+
+module EasyFilters
+  describe Filter do
+    before do
+      @filter = Filter.new
+    end
+
+    after do
+      @filter.clear!
+    end
+
+    it ":defaults should return a hash with default filter values" do
+      assert_instance_of Hash, Filter.defaults, ':defaults does not return a Hash'
+      assert Filter.defaults.empty?,            ':defaults does not return an empty set of defaults values'
+    end
+
+    it ":key should return a representative symbol" do
+      assert_same 'EasyFilters::Filter'.to_sym, Filter.key, ':key does not return a representative symbol'
+    end
+
+    it ":[]= should set values under :key key" do
+      @filter[:name] = 'test value'
+
+      assert_equal 'test value', @filter[:name], ':[]= does not set the passed in :value at :key'
+    end
+
+    it ":[] should access the values under :key key" do
+      @filter[:surname] = 'some test value'
+
+      assert_equal 'some test value', @filter[:surname], ':[] does not access previously-set values'
+    end
+
+    it ":[] should return nil if :key is not set" do
+      assert @filter[:non_existing_key].nil?, ':[] does not return nil? for non-existant keys'
+    end
+
+    it ":any? should return false if there's no filter applied" do
+      assert !@filter.any?, ':any? returns true when no filters are applied'
+    end
+
+    it ":any? should return true if there's a filter applied" do
+      @filter[:some] = 'value'
+      assert @filter.any?, ':any? returns false when there are filters applied'
+    end
+
+    it ":values should return a hash representation of the values applied to the filter" do
+      @filter[:some] = 'value'
+      @filter[:test] = 'data'
+
+      expected = { some: 'value', test: 'data' }
+
+      assert_equal expected, @filter.values, ':values does not return the values applied to the filter'
+    end
+
+    it ":persist! should store filter values in the provided store" do
+      session_mock = {}
+      @filter[:name] = 'value'
+      @filter.persist! session_mock
+
+      expected = { name: 'value' }
+
+      assert session_mock.has_key?(Filter.global_key),                        ':persist! does not create a namespaced hash of values in the store'
+      assert session_mock[Filter.global_key].has_key?(Filter.key),            ':persist! does not add specific values for the unique key of the filters class'
+      assert_equal @filter.values, session_mock[Filter.global_key][Filter.key]
+    end
+
+    it ":initialize should not take values from store if these are invalid" do
+      expected = {}
+      session_mock = { filter: { Filter: { invalid_key: 'no valid value' } } }
+
+      @filter = Filter.new store: session_mock
+
+      assert_equal expected, @filter.values, ':initialize taked the values from the store'
+    end
+
+    it ":initialize should take values from defaults if the store doesn't have any values" do
+      session_mock = nil
+
+      @filter = Filter.new store: session_mock
+
+      assert_equal Filter.defaults, @filter.values, ':initialize did not take the values from the defaults'
+    end
+
+    it ":initialize should not prioritize passed in values over any other value source if these are invalid" do
+      expected = {}
+      value = { invalid_key: 'invalid value' }
+      session_mock = { filter: { Filter: {} } }
+
+      @filter = Filter.new store: session_mock, values: value
+
+      assert_equal expected, @filter.values, ':initialize taked the passed invalid values'
+    end
+
+    it ":initialize should not persist values by default even when a :store option is provided" do
+      store_mock = {}
+      expected = {}
+
+      @filter = Filter.new values: { this_value: 'will not be persisted' }, store: store_mock
+
+      assert_equal expected, store_mock, ':initialize persists values by default'
+    end
+
+    it ":initialize should not persist values if a valid store is provided and instructed to but the passed value is invalid" do
+      store_mock = {}
+      expected = {}
+      value = { look_me: "I will fail" }
+
+      @filter = Filter.new values: value, store: store_mock, persist: true
+
+      assert store_mock.has_key?(Filter.global_key),                        'The values were not persisted as expected in the store: missing global filter namespace'
+      assert store_mock[Filter.global_key].has_key?(Filter.key),        'The values were not persisted as expected in the store: missing specific filter key'
+      assert_equal expected, store_mock[Filter.global_key][Filter.key]
+    end
+
+    it ":clear! should reset the filter values to :defaults" do
+      @filter = Filter.new values: { other: 'values' }
+      @filter.clear!
+
+      assert_equal Filter.defaults, @filter.values, 'Filter values were not reset to the defaults'
+    end
+
+    it ":clear! should persist the reset filters if filter was created with persist option set to true" do
+      store_mock = { filter: { :'EasyFilters::Filter' => { look_ma: "I'm gonna disappear!" } } }
+
+      @filter = Filter.new store: store_mock, persist: true
+      @filter.clear!
+
+      assert_equal Filter.defaults, store_mock[:filter][:'EasyFilters::Filter'], 'Filter values reset was not persisted'
+    end
+
+    it ":clear! shouldn't persist the reset filters if filter was created with persist option set to false" do
+      expected = { look_ma: "I'm gonna disappear!" }
+      store_mock = { filter: { Filter: expected } }
+
+      @filter = Filter.new store: store_mock, persist: false
+      @filter.clear!
+
+      assert_equal Filter.defaults, @filter.values,        'Filter values were not reset'
+      assert_equal expected, store_mock[:filter][:Filter], 'Filter values reset was not persisted'
+    end
+  end
+end

data/spec/minitest_helper.rb

@@ -0,0 +1,17 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'bundler'
+Bundler.require :default, ENV['RACK_ENV'].to_sym
+
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'active_record'
+require 'sqlite3'
+
+ActiveRecord::Base.establish_connection({
+  adapter:  'sqlite3',
+  database: 'db/easy_filters_test.sqlite3'
+})
+
+class Article < ActiveRecord::Base
+end

data/spec/model_filter_spec.rb

@@ -0,0 +1,102 @@
+require 'minitest_helper'
+
+module EasyFilters
+  describe ModelFilter do
+    def create_article(params = {})
+      defaults = { slug: 'title-one', heading: 'heading one', title: 'title one', show_time: false, date: '2013-01-04' }
+      Article.create! defaults.merge params
+    end
+
+    before do
+      @filter = ModelFilter.new
+      # Overriding #model method in order to make the class testable
+      class << @filter
+        def model
+          Article
+        end
+      end
+    end
+
+    after do
+      @filter.clear!
+      Article.delete_all
+    end
+
+    it ":model should fail because there is no default model attached to the filter" do
+      filter = ModelFilter.new
+
+      assert_raises NotImplementedError, 'The base class has a default model attached to it' do
+        filter.model
+      end
+    end
+
+    it ":all should return all records by default" do
+      assert_equal Article.all, @filter.all, 'Some records were left out by a vanilla :all'
+    end
+
+    it ":all should apply the filters when it values for them provided" do
+      create_article
+      @filter[:slug] = 'one'
+
+      assert_equal 1, @filter.all.count, ':all did not apply the filters specified'
+    end
+
+    it ":apply_to should not modify the matches ARRelation if no non-nil values are set" do
+      @filter[:slug] = nil
+      @filter[:title] = nil
+
+      arr = Article.all
+
+      assert_same arr, @filter.apply_to(arr), 'The ActiveRecordRelation passed in to :apply_to is modified even with nil values'
+    end
+
+    it ":apply_to should use custom filter methods when they are available" do
+      @filter[:heading] = 'heading'
+
+      class << @filter
+        def filter_by_heading(partial, value)
+          partial.where(heading: "not #{value}")
+        end
+      end
+
+      arr = Article.all
+
+      assert_equal 0, @filter.apply_to(arr).count, 'The filter was not applied'
+    end
+
+    it ":apply_to should filter string values using a LIKE query by default" do
+      # This scenario should only match one title: 'title one'
+      create_article(title: 'title one')
+      create_article(title: 'title two')
+      @filter[:title] = 'one'
+      arr = Article.all
+
+      assert_equal 1, @filter.apply_to(arr).count, 'The filter was not applied in the expected way'
+
+      @filter.clear!
+
+      # This scenario should match both of the titles: 'title one' and 'title two'
+      @filter[:title] = 'title'
+      assert_equal 2, @filter.apply_to(arr).count, 'The filter was not applied in the expected way'
+    end
+
+    it ":apply_to sould use a default filtering strategy when using Date values" do
+      create_article(date: '2013-01-01')
+      create_article(date: '2013-02-01', show_time: true)
+
+      # DateTime
+      @filter[:date] = '2013-01-01'
+      assert_equal 1, @filter.apply_to(Article.all).count, 'A DateTime value is not handled correctly'
+    end
+
+
+    it ":apply_to sould use a default filtering strategy when using Boolean values" do
+      create_article(date: '2013-01-01')
+      create_article(date: '2013-02-01', show_time: true)
+
+      # Boolean
+      @filter[:show_time] = true
+      assert_equal 1, @filter.apply_to(Article.all).count, 'A Boolean value is not handled correctly'
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: easy_filters
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- German Olle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-01 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: rake
+  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: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Define a model class, allowing declare a subclass of this and implement
+  simple methods to filter each field model
+email:
+- golle@cespi.unlp.edu.ar
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- db/easy_filters_test.sqlite3
+- easy_filters.gemspec
+- lib/easy_filters.rb
+- lib/easy_filters/filter.rb
+- lib/easy_filters/model_filter.rb
+- lib/easy_filters/version.rb
+- spec/filter_spec.rb
+- spec/minitest_helper.rb
+- spec/model_filter_spec.rb
+homepage: http://rubygems.org/gems/easy_filters
+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.2.2
+signing_key: 
+specification_version: 4
+summary: This gem implement a base model filter to declare your owns filters writing
+  a single file
+test_files:
+- spec/filter_spec.rb
+- spec/minitest_helper.rb
+- spec/model_filter_spec.rb