filterameter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 97bc00d12d3a953cbedcfa92a1b8c469ef442936ebaac28157fd4a88cb8dc62c
+  data.tar.gz: f7233773047377d725a047e3b01b159f097ecbece898b83d824b197e6146db61
+SHA512:
+  metadata.gz: e19b7c776809225651165bf7714ca7820cb5c3824138ff798842d4b99cf67c58d92eb077070d9959874aa6ebf2352c2b5cf34f6c223241c64b36d4dc7b2ee59e
+  data.tar.gz: d24c6b1abe68ef70cbb03c8abecda1147f1dc889b2b7cd90062c35245f1c442d07ff6562866cb4d097b0bc2e3572cc02c5c5a406a146f7af91fa85b3abc883c9

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2019 Todd Kummer
+
+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,96 @@
+# Filterameter
+Declarative Filter Parameters for Rails Controllers.
+
+## Usage
+Declare filters at the top of controllers to increase readability and reduce boilerplate code. Filters can be declared for attributes, scopes, or attributes from singular associations (`belongs_to` or `has_one`). Validations can also be assigned.
+
+```ruby
+  filter :color
+  filter :size, validates: { inclusion: { in: %w[Small Medium Large] }, unless: -> { size.is_a? Array } }
+  filter :brand_name, association: :brand, name: :name
+  filter :on_sale, association: :price, validates: [{ numericality: { greater_than: 0 } },
+                                                    { numericality: { less_than: 100 } }]
+```
+
+### Filtering Options
+
+The following options can be specified for each filter.
+
+#### name
+If the name of the parameter is different than the name of the attribute or scope, then use the name parameter to specify the name of the attribute or scope. For example, if the attribute name is `current_status` but the filter is exposed simply as `status` use the following:
+
+```ruby
+filter :status, name: :current_status
+```
+
+#### association
+If the attribute or scope is nested, it can be referenced by naming the association. Only singular associations are valid. For example, if the manager_id attribute lives on an employee's department record, use the following:
+
+```ruby
+filter :manager_id, association: :department
+```
+
+#### validates
+If the filter value should be validated, use the `validates` option along with [ActiveModel validations](https://api.rubyonrails.org/classes/ActiveModel/Validations/ClassMethods.html#method-i-validates). Here's an example of the inclusion validator being used to restrict sizes:
+
+```ruby
+filter :size, validates: { inclusion: { in: %w[Small Medium Large] }, unless: -> { size.is_a? Array } }
+```
+
+Note that the `inclusion` validator does not allow arrays to be specified. If the filter should allow multiple values to be specified, then the validation needs to be disabled when the value an array.
+
+### Configuring Controllers
+
+Rails conventions are used to determine the controller's model as well as the name of the instance variable to apply the filters to. For example, the PhotosController will use the variable `@photos` to store a query against the Photo model. If the conventions do not provide the correct info, they can be overridden with the following two methods:
+
+#### filter_model
+Provide the name of the model. This method also allows the variable name to be optionally provided as the second parameter.
+
+```ruby
+filter_model 'Picture'
+```
+
+#### filter_query_var_name
+Provide the name of the instance variable. For example, if the query is stored as `@data`, use the following:
+
+```ruby
+filter_query_var_name :data
+```
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'filterameter'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install filterameter
+```
+
+
+## Running Tests
+
+Tests are written in RSpec and the dummy app uses a docker database. First, start the database and prepare it from the dummy folder.
+
+```bash
+cd spec/dummy
+docker-compose up -d
+bundle exec rails db:test:prepare
+cd ../..
+```
+
+Run the tests from the main directory
+
+```bash
+bundle exec rspec
+```
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Filterameter'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'

data/lib/filterameter/configuration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Filterameter
+  # = Configuration
+  #
+  # Class Configuration stores the following settings:
+  # - action_on_undeclared_parameters
+  # - action_on_validation_failure
+  #
+  # == Action on Undeclared Parameters
+  # Occurs when the filter parameter contains any keys that are not defined. Valid actions are :log, :raise, and
+  # false (do not take action). By default, development will log, test will raise, and production will do nothing.
+  #
+  # == Action on Validation Failure
+  # Occurs when a filter parameter fails a validation. Valid actions are :log, :raise, and false (do not take action).
+  # By default, development will log, test will raise, and production will do nothing.
+  class Configuration
+    attr_accessor :action_on_undeclared_parameters, :action_on_validation_failure
+
+    def initialize
+      @action_on_undeclared_parameters =
+        @action_on_validation_failure =
+          if Rails.env.development?
+            :log
+          elsif Rails.env.test?
+            :raise
+          else
+            false
+          end
+    end
+  end
+end

data/lib/filterameter/controller_filters.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+
+require 'active_support/rails'
+require 'action_dispatch'
+require 'action_controller/metal/live'
+require 'action_controller/metal/strong_parameters'
+
+require 'filterameter/filter_factory'
+require 'filterameter/filter_declaration'
+require 'filterameter/log_subscriber'
+require 'filterameter/parameters_base'
+
+module Filterameter
+  # = Controller Filters
+  #
+  # Class ControllerFilters stores the configuration declared via class-level method calls such as the list of
+  # filters and the optionally declared model class. Each controller will have one instance of the controller
+  # declarations stored as a class variable.
+  class ControllerFilters
+    attr_writer :query_variable_name
+
+    def initialize(controller_name, controller_path)
+      @controller_name = controller_name
+      @controller_path = controller_path
+      @declarations = {}
+      @filters = Hash.new { |hash, key| hash[key] = filter_factory.build(@declarations[key]) }
+    end
+
+    def model_class=(model_class)
+      @model_class = model_class.is_a?(String) ? model_class.constantize : model_class
+    end
+
+    def add_filter(parameter_name, options)
+      @declarations[parameter_name.to_s] = Filterameter::FilterDeclaration.new(parameter_name, options)
+    end
+
+    def query_variable_name
+      @query_variable_name ||= model_class.model_name.plural
+    end
+
+    def build_query(filter_params)
+      valid_filters(filter_params).reduce(model_class.all) do |query, (name, value)|
+        @filters[name].apply(query, value)
+      end
+    end
+
+    private
+
+    def model_class
+      @model_class ||= @controller_name.classify.safe_constantize ||
+                       @controller_path.classify.safe_constantize ||
+                       raise(Filterameter::Exceptions::CannotDetermineModelError.new(@controller_name,
+                                                                                     @controller_path))
+    end
+
+    # lazy so that model_class can be optionally set
+    def filter_factory
+      @filter_factory ||= Filterameter::FilterFactory.new(model_class)
+    end
+
+    def valid_filters(filter_params)
+      remove_invalid_values(
+        remove_undeclared_filters(filter_params)
+      )
+    end
+
+    def remove_undeclared_filters(filter_params)
+      filter_params.slice(*declared_parameter_names).tap do |declared_parameters|
+        handle_undeclared_parameters(filter_params) if declared_parameters.size != filter_params.size
+      end
+    end
+
+    def handle_undeclared_parameters(filter_params)
+      action = Filterameter.configuration.action_on_undeclared_parameters
+      return unless action
+
+      undeclared_parameter_names = filter_params.keys - declared_parameter_names
+      case action
+      when :log
+        ActiveSupport::Notifications.instrument('undeclared_parameters.filterameter', keys: undeclared_parameter_names)
+      when :raise
+        raise Filterameter::Exceptions::UndeclaredParameterError, undeclared_parameter_names
+      end
+    end
+
+    def remove_invalid_values(filter_params)
+      validator = validator_class.new(filter_params)
+      return filter_params if validator.valid?
+
+      case Filterameter.configuration.action_on_validation_failure
+      when :log
+        ActiveSupport::Notifications.instrument('validation_failure.filterameter', errors: validator.errors)
+      when :raise
+        raise Filterameter::Exceptions::ValidationError, validator.errors
+      end
+
+      filter_params.except(*validator.errors.keys.map(&:to_s))
+    end
+
+    def declared_parameter_names
+      @declared_parameter_names ||= @declarations.keys
+    end
+
+    def validator_class
+      @validator_class ||= Filterameter::ParametersBase.build_sub_class(@declarations.values)
+    end
+  end
+end

data/lib/filterameter/declarative_filters.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'filterameter/controller_filters'
+
+module Filterameter
+  # = Declarative Filters
+  #
+  # module DeclarativeFilters provides a controller DSL to declare filters along with any validations.
+  module DeclarativeFilters
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :build_filtered_query, only: :index
+    end
+
+    class_methods do
+      def filter_model(model_class, query_var_name = nil)
+        controller_filters.model_class = model_class
+        filter_query_var_name(query_var_name) if query_var_name.present?
+      end
+
+      def filter_query_var_name(query_variable_name)
+        controller_filters.query_variable_name = query_variable_name
+      end
+
+      def filter(name, options = {})
+        controller_filters.add_filter(name, options)
+      end
+
+      def filters(*names)
+        names.each { |name| filter(name) }
+      end
+
+      def controller_filters
+        @controller_filters ||= Filterameter::ControllerFilters.new(controller_name, controller_path)
+      end
+    end
+
+    private
+
+    def build_filtered_query
+      instance_variable_set("@#{self.class.controller_filters.query_variable_name}",
+                            self.class.controller_filters.build_query(params.to_unsafe_h.fetch(:filter, {})))
+    end
+  end
+end

data/lib/filterameter/exceptions/cannot_determine_model_error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Filterameter
+  module Exceptions
+    # = Cannot Determine Model Error
+    #
+    # Class CannotDetermineModelError is raised when the model class cannot be determined from either the controller
+    # name or controller path. This is a setup issue; the resolution is for the controller to specify the model class
+    # explicitly by adding a call to `filter_model`.
+    class CannotDetermineModelError < FilterameterError
+      def initialize(name, path)
+        super "Cannot determine model name from controller name #{value_and_classify(name)} " \
+          "or path #{value_and_classify(path)}. Declare the model explicitly with filter_model."
+      end
+
+      private
+
+      def value_and_classify(value)
+        "(#{value} => #{value.classify})"
+      rescue StandardError
+        value
+      end
+    end
+  end
+end

data/lib/filterameter/exceptions/undeclared_parameter_error.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Filterameter
+  module Exceptions
+    # = Undeclared Parameter Error
+    #
+    # Class UndeclaredParameterError is raised when a request contains filter parameters that have not been declared.
+    # Configuration setting `action_on_undeclared_parameters` determines whether or not the exception is raised.
+    class UndeclaredParameterError < FilterameterError
+      attr_reader :keys
+
+      def initialize(keys)
+        @keys = keys
+      end
+
+      def message
+        "The following filter parameter(s) have not been declared: #{keys}"
+      end
+    end
+  end
+end

data/lib/filterameter/exceptions/validation_error.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Filterameter
+  module Exceptions
+    # = Validation Error
+    #
+    # Class ValidationError is raised when a specified parameter fails a validation. Configuration setting
+    # `action_on_validation_failure` determines whether or not the exception is raised.
+    class ValidationError < FilterameterError
+      attr_reader :errors
+
+      def initialize(errors)
+        @errors = errors
+      end
+
+      def message
+        "The following parameter(s) failed validation: #{errors.full_messages}"
+      end
+    end
+  end
+end

data/lib/filterameter/exceptions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Filterameter
+  module Exceptions
+    class FilterameterError < StandardError
+    end
+  end
+end
+
+require 'filterameter/exceptions/cannot_determine_model_error'
+require 'filterameter/exceptions/validation_error'
+require 'filterameter/exceptions/undeclared_parameter_error'

data/lib/filterameter/filter_declaration.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/array/wrap'
+
+module Filterameter
+  # = Filter Declaration
+  #
+  # Class FilterDeclaration captures the filter declaration within the controller.
+  class FilterDeclaration
+    attr_reader :name, :parameter_name, :association, :validations
+
+    def initialize(parameter_name, options)
+      @parameter_name = parameter_name.to_s
+
+      validate_options(options)
+      @name = options.fetch(:name, parameter_name).to_s
+      @association = options[:association]
+      @filter_on_empty = options.fetch(:filter_on_empty, false)
+      @validations = Array.wrap(options[:validates])
+    end
+
+    def nested?
+      @association.present?
+    end
+
+    def validations?
+      !@validations.empty?
+    end
+
+    def filter_on_empty?
+      @filter_on_empty
+    end
+
+    private
+
+    def validate_options(options)
+      options.assert_valid_keys(:name, :association, :filter_on_empty, :validates)
+    end
+  end
+end

data/lib/filterameter/filter_factory.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'filterameter/filters/attribute_filter'
+require 'filterameter/filters/conditional_scope_filter'
+require 'filterameter/filters/nested_filter'
+require 'filterameter/filters/scope_filter'
+
+module Filterameter
+  # = Filter Factory
+  #
+  # Class FilterFactory builds a filter from a FilterDeclaration.
+  class FilterFactory
+    def initialize(model_class)
+      @model_class = model_class
+    end
+
+    def build(declaration)
+      model = declaration.nested? ? model_from_association(declaration.association) : @model_class
+      filter = build_filter(model, declaration.name)
+
+      declaration.nested? ? Filterameter::Filters::NestedFilter.new(declaration.association, model, filter) : filter
+    end
+
+    private
+
+    def build_filter(model, name)
+      # checking dangerous_class_method? excludes any names that cannot be scope names, such as "name"
+      if model.respond_to?(name) && !model.dangerous_class_method?(name)
+        Filterameter::Filters::ScopeFilter.new(name)
+      else
+        Filterameter::Filters::AttributeFilter.new(name)
+      end
+    end
+
+    # TODO: rescue then raise custom error with cause
+    def model_from_association(association)
+      [association].flatten.reduce(@model_class) { |memo, name| memo.reflect_on_association(name).klass }
+      # rescue StandardError => e
+    end
+  end
+end

data/lib/filterameter/filters/attribute_filter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Filterameter
+  module Filters
+    # = Attribute Filter
+    #
+    # Class AttributeFilter leverages ActiveRecord's where query method to add criteria for an attribute.
+    class AttributeFilter
+      def initialize(attribute_name)
+        @attribute_name = attribute_name
+      end
+
+      def apply(query, value)
+        query.where(@attribute_name => value)
+      end
+    end
+  end
+end

data/lib/filterameter/filters/conditional_scope_filter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Filterameter
+  module Filters
+    # = Conditional Scope Filter
+    #
+    # Class ConditionalScopeFilter applies the scope if the parameter is not false.
+    class ConditionalScopeFilter
+      def initialize(scope_name)
+        @scope_name = scope_name
+      end
+
+      def apply(query, value)
+        return query unless ActiveModel::Type::Boolean.new.cast(value)
+
+        query.send(@scope_name)
+      end
+    end
+  end
+end

data/lib/filterameter/filters/nested_filter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Filterameter
+  module Filters
+    # = Nested Attribute Filter
+    #
+    # Class NestedFilter joins the nested table(s) then merges the filter to the association's model.
+    class NestedFilter
+      def initialize(joins_values, association_model, attribute_filter)
+        @joins_values = joins_values
+        @association_model = association_model
+        @attribute_filter = attribute_filter
+      end
+
+      def apply(query, value)
+        query.joins(@joins_values)
+             .merge(@attribute_filter.apply(@association_model, value))
+      end
+    end
+  end
+end

data/lib/filterameter/filters/scope_filter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Filterameter
+  module Filters
+    # = Scope Filter
+    #
+    # Class ScopeFilter applies the named scope passing in the parameter value.
+    class ScopeFilter
+      def initialize(scope_name)
+        @scope_name = scope_name
+      end
+
+      def apply(query, value)
+        query.send(@scope_name, value)
+      end
+    end
+  end
+end

data/lib/filterameter/log_subscriber.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Filterameter
+  # = Log Subscriber
+  #
+  # Class LogSubscriber provides instrumentation for events.
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def validation_failure(event)
+      debug do
+        errors = event.payload[:errors]
+        (['  The following filter validation errors occurred:'] + errors.full_messages).join("\n  - ")
+      end
+    end
+
+    def undeclared_parameters(event)
+      debug do
+        keys = event.payload[:keys]
+        "  Undeclared filter parameter#{'s' if keys.size > 1}: #{keys.map { |e| ":#{e}" }.join(', ')}"
+      end
+    end
+  end
+end
+
+Filterameter::LogSubscriber.attach_to :filterameter

data/lib/filterameter/parameters_base.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'active_model/attribute_assignment'
+require 'active_model/validations'
+
+module Filterameter
+  # = Parameters
+  #
+  # Class Parameters is sub-classed to provide controller-specific validations.
+  class ParametersBase
+    include ActiveModel::Validations
+
+    def self.build_sub_class(declarations)
+      Class.new(self).tap do |sub_class|
+        declarations.select(&:validations?).each do |declaration|
+          sub_class.add_validation(declaration.parameter_name, declaration.validations)
+        end
+      end
+    end
+
+    def self.name
+      'ControllerParameters'
+    end
+
+    def self.add_validation(parameter_name, validations)
+      attr_accessor parameter_name
+
+      default_options = { allow_nil: true }
+      validations.each do |validation|
+        validates parameter_name, default_options.merge(validation)
+      end
+    end
+
+    def initialize(attributes)
+      attributes.each { |k, v| assign_attribute(k, v) }
+    end
+
+    private
+
+    def assign_attribute(key, value)
+      setter = :"#{key}="
+      public_send(setter, value) if respond_to?(setter)
+    end
+  end
+end

data/lib/filterameter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Filterameter
+  VERSION = '0.1.0'
+end

data/lib/filterameter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'filterameter/configuration'
+require 'filterameter/declarative_filters'
+require 'filterameter/exceptions'
+
+# = Filterameter
+#
+# Module Filterameter can be mixed into a controller to provide the DSL to describe each controller's filters.
+#
+# The model class must be declared if it cannot be derived. It can be derived if (A) the model is not namespaced and its
+# name matches the controller name (for example BrandsController -> Brand) or (B) both the controller and model share
+# the same namespace and name.
+module Filterameter
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.reset
+    @configuration = Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end

data/lib/tasks/filterameter_tasks.rake

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# desc "Explaining what the task does"
+# task :filterameter do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: filterameter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Todd Kummer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.2
+- !ruby/object:Gem::Dependency
+  name: pg
+  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: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.77'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.77'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: Enable filter parameters to be declared in controllers.
+email:
+- todd@rockridgesolutions.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/filterameter.rb
+- lib/filterameter/configuration.rb
+- lib/filterameter/controller_filters.rb
+- lib/filterameter/declarative_filters.rb
+- lib/filterameter/exceptions.rb
+- lib/filterameter/exceptions/cannot_determine_model_error.rb
+- lib/filterameter/exceptions/undeclared_parameter_error.rb
+- lib/filterameter/exceptions/validation_error.rb
+- lib/filterameter/filter_declaration.rb
+- lib/filterameter/filter_factory.rb
+- lib/filterameter/filters/attribute_filter.rb
+- lib/filterameter/filters/conditional_scope_filter.rb
+- lib/filterameter/filters/nested_filter.rb
+- lib/filterameter/filters/scope_filter.rb
+- lib/filterameter/log_subscriber.rb
+- lib/filterameter/parameters_base.rb
+- lib/filterameter/version.rb
+- lib/tasks/filterameter_tasks.rake
+homepage: https://github.com/RockSolt/filterameter
+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: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: Declarative Filter Parameters for Rails Controllers
+test_files: []