filterrific 5.2.3 → 5.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67e7935ca4ceb8fce5778b36879ee941aef8105f23e8a211d070eb6c8cc2cd82
-  data.tar.gz: 5285cb9d2f1c18988f00a82b51733cccbbef67fe02f9f673754a3c2387117c56
+  metadata.gz: a63c202db5dce43d16d986ad31a50abc21752cb7bd66771fce52c2ddc7a2614d
+  data.tar.gz: '090e98ad1d561910bbefd0095be81e8b0c622e29cd8cba5b12471379b9023b65'
 SHA512:
-  metadata.gz: 797e8e2c763a3949277f1fd1e1bd2521adbac190175286331c59dd7cba17636c41ffeb6dda91325cb45bfe97c497934124b8a92c9d3ebd625a8744068337d6e5
-  data.tar.gz: 4272dfb90de22d22e494a9d1d800daec913ba1a64a3f7e3c399ee6e91de11aa4b82e569ad2dbd9c75f9da9b71a88860046333a6c19cc39a2e8a711da92d88a4b
+  metadata.gz: 2d74dc358e308d4d84f04c6637bcd7c682b2ff671d9e11b36d9c9384434b4670d963e945ba80314e6e6e497fc54f7873b37e674bd5794d7f1b298c3912ac2190
+  data.tar.gz: b8731da2f59b0d70838c412fdacc1cbf103c76c1eba8668df5253a4d35948e7b60dd9f9bfbb8a021c1c11efe5ab7b945dca3f6490c0b58b66847a3a09dde717c

data/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 Filterrific major versions match the Ruby on Rails major versions they work with.
 
+## [5.2.4] - Jan 30, 2023
+
+* Remove JS dependency on jquery
+* Make code compliant with standard.rb rules
+
 ## [5.2.3] - Mar. 18, 2022
 
 * Added support for Rails 7

data/Rakefile

@@ -1,17 +1,17 @@
 begin
-  require 'bundler/setup'
+  require "bundler/setup"
 rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
 end
 
 Bundler::GemHelper.install_tasks
 
-require 'rake/testtask'
+require "rake/testtask"
 Rake::TestTask.new do |test|
-  test.libs << 'spec'
-  test.pattern = 'spec/**/*_spec.rb'
+  test.libs << "spec"
+  test.pattern = "spec/**/*_spec.rb"
   test.verbose = true
 end
 
-require 'wwtd/tasks'
-task default: 'wwtd:local'
+require "wwtd/tasks"
+task default: "wwtd:local"

data/app/assets/javascripts/filterrific/filterrific.js

@@ -0,0 +1,172 @@
+/**
+ * Javascript behaviors for Filterrific.
+ * http://filterrific.clearcove.ca
+ *
+ * Released under the MIT license
+ *
+ */
+
+// Create global Filterrific namespace
+if (typeof Filterrific === 'undefined') {
+  var Filterrific = {};
+}
+
+// Define function to submit Filterrific filter form
+Filterrific.submitFilterForm = function() {
+  var form = Filterrific.findParents(this, '#filterrific_filter')[0];
+
+  // send before event
+  form.dispatchEvent(new Event('loadingFilterrificResults'));
+
+  // turn on spinner
+  document.querySelector('.filterrific_spinner').style.display = 'block';
+
+  // Abort previous XMLHttpRequest request
+  if (Filterrific.lastRequest && Filterrific.lastRequest.readyState != 4) {
+    Filterrific.lastRequest.abort();
+  }
+
+  // Submit XMLHttpRequest request
+  Filterrific.lastRequest = Filterrific.prepareRequest(form);
+  Filterrific.lastRequest.send();
+};
+
+Filterrific.prepareRequest = function(form) {
+  var url = form.getAttribute('action'),
+      formData = new FormData(form),
+      params = new URLSearchParams(formData),
+      xhr = new XMLHttpRequest();
+
+  if (url.indexOf('?') < 0) {
+    url += '?' + params;
+  } else {
+    url += '&' + params;
+  }
+
+  xhr.open("GET", url, true);
+  xhr.setRequestHeader('Accept', 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript, */*; q=0.01');
+  xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+  xhr.onreadystatechange = function() {
+    if (xhr.readyState === XMLHttpRequest.DONE) {
+        return Filterrific.processResponse(form, xhr);
+      }
+  }
+
+  return xhr;
+}
+
+Filterrific.processResponse = function(form, xhr) {
+  var rawResponse = (_ref = xhr.response) != null ? _ref : xhr.responseText,
+      type = xhr.getResponseHeader('Content-Type'),
+      response;
+
+  if (typeof rawResponse === 'string' && typeof type === 'string') {
+      if (type.match(/\bjson\b/)) {
+        try {
+          response = JSON.parse(rawResponse);
+        } catch (_error) {}
+      } else if (type.match(/\b(?:java|ecma)script\b/)) {
+        script = document.createElement('script');
+        script.setAttribute('nonce', Filterrific.cspNonce());
+        script.text = rawResponse;
+        document.head.appendChild(script).parentNode.removeChild(script);
+      } else if (type.match(/\b(xml|html|svg)\b/)) {
+        parser = new DOMParser();
+        type = type.replace(/;.+/, '');
+        try {
+          response = parser.parseFromString(rawResponse, type);
+        } catch (_error) {}
+      }
+  }
+
+  // send after event
+  form.dispatchEvent(new Event('loadedFilterrificResults'));
+  document.querySelector('.filterrific_spinner').style.display = 'none';
+
+  return response;
+}
+
+Filterrific.cspNonce = function() {
+  return document.querySelector("meta[name=csp-nonce]")?.content
+}
+
+Filterrific.findParents = function(elem, selector) {
+  var elements = [];
+  var ishaveselector = selector !== undefined;
+
+  while ((elem = elem.parentElement) !== null) {
+    if (elem.nodeType !== Node.ELEMENT_NODE) {
+      continue;
+    }
+
+    if (!ishaveselector || elem.matches(selector)) {
+      elements.push(elem);
+    }
+  }
+
+  return elements;
+};
+
+Filterrific.observe_field = function(inputs_selector, frequency, callback) {
+  frequency = frequency * 1000;
+
+  document.querySelectorAll(inputs_selector).forEach(input => {
+    var prev = input.value;
+    var check = function() {
+      // if removed clear the interval and don't fire the callback
+      if (removed()) {
+        if(ti) clearInterval(ti);
+        return;
+      }
+      var val = input.value;
+      if (prev != val) {
+        prev = val;
+
+        // invokes the callback on $this
+        if (callback && typeof callback === 'function') {
+          callback.call(input);
+        }
+      }
+    };
+
+    var removed = function() {
+      return input.closest('html').length == 0
+    };
+
+    var reset = function() {
+      if (ti) {
+        clearInterval(ti);
+        ti = setInterval(check, frequency);
+      }
+    };
+    check();
+    var ti = setInterval(check, frequency); // invoke check periodically
+    // reset counter after user interaction
+    // mousemove is for selects
+    input.addEventListener('keyup', reset);
+    input.addEventListener('click', reset);
+    input.addEventListener('mousemove', reset);
+  })
+};
+
+
+Filterrific.init = function() {
+  // Add change event handler to all Filterrific filter inputs.
+  var filterrificForm = document.querySelector('#filterrific_filter');
+  filterrificForm.querySelectorAll('input, textarea, select, textarea').forEach(input => {
+    input.addEventListener('change', Filterrific.submitFilterForm)
+  })
+
+  // Add periodic observer to selected inputs.
+  // Use this for text fields you want to observe for change, e.g., a search input.
+  Filterrific.observe_field(
+    ".filterrific-periodically-observed",
+    0.5,
+    Filterrific.submitFilterForm
+  );
+};
+
+
+// Initialize event observers on document ready and turbolinks page:load
+document.addEventListener('turbolinks:load', Filterrific.init);
+document.addEventListener('DOMContentLoaded', Filterrific.init)

data/lib/filterrific/action_controller_extension.rb

@@ -1,13 +1,11 @@
-# -*- coding: utf-8 -*-
 #
 # Adds Filterrific methods ActionController instances
 #
 module Filterrific
   module ActionControllerExtension
-
     include HasResetFilterrificUrlMixin
 
-  protected
+    protected
 
     # @param model_class [Class]
     # @param filterrific_params [ActionController::Params, Hash] typically the
@@ -33,29 +31,29 @@ module Filterrific
     def initialize_filterrific(model_class, filterrific_params, opts = {})
       f_params = (filterrific_params || {}).stringify_keys
       opts = opts.stringify_keys
-      pers_id = if false == opts['persistence_id']
+      pers_id = if opts["persistence_id"] == false
         nil
       else
-        opts['persistence_id'] || compute_default_persistence_id
+        opts["persistence_id"] || compute_default_persistence_id
       end
 
-      if (f_params.delete('reset_filterrific'))
+      if f_params.delete("reset_filterrific")
         # Reset query and session_persisted params
-        session[pers_id] = nil  if pers_id
-        redirect_to url_for({})  and return false # requires `or return` in calling action.
+        session[pers_id] = nil if pers_id
+        redirect_to url_for({}) and return false # requires `or return` in calling action.
       end
 
       f_params = compute_filterrific_params(model_class, f_params, opts, pers_id)
 
       filterrific = Filterrific::ParamSet.new(model_class, f_params)
-      filterrific.select_options = opts['select_options']
-      session[pers_id] = filterrific.to_hash  if pers_id
+      filterrific.select_options = opts["select_options"]
+      session[pers_id] = filterrific.to_hash if pers_id
       filterrific
     end
 
     # Computes a default persistence id based on controller and action name
     def compute_default_persistence_id
-      [controller_name, action_name].join('#')
+      [controller_name, action_name].join("#")
     end
 
     # Computes filterrific params using a number of strategies. Limits params
@@ -68,17 +66,17 @@ module Filterrific
     #   Defaults to true.
     # @param persistence_id [String, nil]
     def compute_filterrific_params(model_class, filterrific_params, opts, persistence_id)
-      opts = { "sanitize_params" => true }.merge(opts.stringify_keys)
+      opts = {"sanitize_params" => true}.merge(opts.stringify_keys)
       r = (
         filterrific_params.presence || # start with passed in params
         (persistence_id && session[persistence_id].presence) || # then try session persisted params if persistence_id is present
-        opts['default_filter_params'] || # then use passed in opts
+        opts["default_filter_params"] || # then use passed in opts
         model_class.filterrific_default_filter_params # finally use model_class defaults
       ).stringify_keys
-      r.slice!(*opts['available_filters'].map(&:to_s))  if opts['available_filters']
+      r.slice!(*opts["available_filters"].map(&:to_s)) if opts["available_filters"]
       # Sanitize params to prevent reflected XSS attack
       if opts["sanitize_params"]
-        r.each { |k,v| r[k] = sanitize_filterrific_param(r[k]) }
+        r.each { |k, v| r[k] = sanitize_filterrific_param(r[k]) }
       end
       r
     end
@@ -94,7 +92,7 @@ module Filterrific
         val.map { |e| sanitize_filterrific_param(e) }
       when Hash
         # Return Hash
-        val.inject({}) { |m, (k,v)| m[k] = sanitize_filterrific_param(v); m }
+        val.each_with_object({}) { |(k, v), m| m[k] = sanitize_filterrific_param(v); }
       when NilClass
         # Nothing to do, use val as is
         val
@@ -105,6 +103,5 @@ module Filterrific
         val
       end
     end
-
   end
 end

data/lib/filterrific/action_view_extension.rb

@@ -1,10 +1,8 @@
-# -*- coding: utf-8 -*-
 #
 # Adds Filterrific view helpers to ActionView instances
 #
 module Filterrific
   module ActionViewExtension
-
     include HasResetFilterrificUrlMixin
 
     # Sets all options on form_for to defaults that work with Filterrific
@@ -17,8 +15,8 @@ module Filterrific
       options[:html][:method] ||= :get
       options[:html][:id] ||= :filterrific_filter
       options[:url] ||= url_for(
-        :controller => controller.controller_name,
-        :action => controller.action_name
+        controller: controller.controller_name,
+        action: controller.action_name
       )
       form_for(record, options, &block)
     end
@@ -27,7 +25,7 @@ module Filterrific
     def render_filterrific_spinner
       %(
         <span class="filterrific_spinner" style="display:none;">
-          #{ image_tag('filterrific/filterrific-spinner.gif', alt: '', role: 'presentation') }
+          #{image_tag("filterrific/filterrific-spinner.gif", alt: "", role: "presentation")}
         </span>
       ).html_safe
     end
@@ -65,23 +63,25 @@ module Filterrific
     #     Override the target URL attributes to be used for `url_for`. Default: {} (current URL).
     def filterrific_sorting_link(filterrific, sort_key, opts = {})
       opts = {
-        :active_column_class => 'filterrific_current_sort_column',
-        :inactive_column_class => 'filterrific_sort_column',
-        :ascending_indicator => '⬆',
-        :default_sort_direction => 'asc',
-        :descending_indicator => '⬇',
-        :html_attrs => {},
-        :label => sort_key.to_s.humanize,
-        :sorting_scope_name => :sorted_by,
-        :url_for_attrs => {},
-        :as => :filterrific
+        active_column_class: "filterrific_current_sort_column",
+        inactive_column_class: "filterrific_sort_column",
+        ascending_indicator: "⬆",
+        default_sort_direction: "asc",
+        descending_indicator: "⬇",
+        html_attrs: {},
+        label: sort_key.to_s.humanize,
+        sorting_scope_name: :sorted_by,
+        url_for_attrs: {},
+        as: :filterrific
       }.merge(opts)
       opts.merge!(
-        :html_attrs => opts[:html_attrs].with_indifferent_access,
-        :current_sorting => (current_sorting = filterrific.send(opts[:sorting_scope_name])),
-        :current_sort_key => current_sorting ? current_sorting.gsub(/_asc|_desc/, '') : nil,
-        :current_sort_direction => current_sorting ? (current_sorting =~ /_desc\z/ ? 'desc' : 'asc') : nil,
-        :current_sort_direction_indicator => (current_sorting =~ /_desc\z/ ? opts[:descending_indicator] : opts[:ascending_indicator]),
+        html_attrs: opts[:html_attrs].with_indifferent_access,
+        current_sorting: (current_sorting = filterrific.send(opts[:sorting_scope_name])),
+        current_sort_key: current_sorting ? current_sorting.gsub(/_asc|_desc/, "") : nil,
+        current_sort_direction: if current_sorting
+                                  current_sorting.end_with?("_desc") ? "desc" : "asc"
+                                end,
+        current_sort_direction_indicator: (current_sorting.end_with?("_desc") ? opts[:descending_indicator] : opts[:ascending_indicator])
       )
       new_sort_key = sort_key.to_s
       if new_sort_key == opts[:current_sort_key]
@@ -93,7 +93,7 @@ module Filterrific
       end
     end
 
-  protected
+    protected
 
     # Renders HTML to reverse sort order on currently sorted column.
     # @param filterrific [Filterrific::ParamSet]
@@ -102,20 +102,20 @@ module Filterrific
     # @return [String] an HTML fragment
     def filterrific_sorting_link_reverse_order(filterrific, new_sort_key, opts)
       # current sort column, toggle search_direction
-      new_sort_direction = 'asc' == opts[:current_sort_direction] ? 'desc' : 'asc'
-      new_sorting = safe_join([new_sort_key, new_sort_direction], '_')
+      new_sort_direction = opts[:current_sort_direction] == "asc" ? "desc" : "asc"
+      new_sorting = safe_join([new_sort_key, new_sort_direction], "_")
       css_classes = safe_join([
         opts[:active_column_class],
         opts[:html_attrs].delete(:class)
-      ].compact, ' ')
+      ].compact, " ")
       new_filterrific_params = filterrific.to_hash
-                                          .with_indifferent_access
-                                          .merge(opts[:sorting_scope_name] => new_sorting)
+        .with_indifferent_access
+        .merge(opts[:sorting_scope_name] => new_sorting)
       url_for_attrs = opts[:url_for_attrs].merge(opts[:as] => new_filterrific_params)
       link_to(
-        safe_join([opts[:label], opts[:current_sort_direction_indicator]], ' '),
+        safe_join([opts[:label], opts[:current_sort_direction_indicator]], " "),
         url_for(url_for_attrs),
-        opts[:html_attrs].reverse_merge(:class => css_classes, :method => :get, :remote => true)
+        opts[:html_attrs].reverse_merge(class: css_classes, method: :get, remote: true)
       )
     end
 
@@ -126,21 +126,20 @@ module Filterrific
     # @return [String] an HTML fragment
     def filterrific_sorting_link_new_column(filterrific, new_sort_key, opts)
       new_sort_direction = opts[:default_sort_direction]
-      new_sorting = safe_join([new_sort_key, new_sort_direction], '_')
+      new_sorting = safe_join([new_sort_key, new_sort_direction], "_")
       css_classes = safe_join([
         opts[:inactive_column_class],
         opts[:html_attrs].delete(:class)
-      ].compact, ' ')
+      ].compact, " ")
       new_filterrific_params = filterrific.to_hash
-                                          .with_indifferent_access
-                                          .merge(opts[:sorting_scope_name] => new_sorting)
+        .with_indifferent_access
+        .merge(opts[:sorting_scope_name] => new_sorting)
       url_for_attrs = opts[:url_for_attrs].merge(opts[:as] => new_filterrific_params)
       link_to(
         opts[:label],
         url_for(url_for_attrs),
-        opts[:html_attrs].reverse_merge(:class => css_classes, :method => :get, :remote => true)
+        opts[:html_attrs].reverse_merge(class: css_classes, method: :get, remote: true)
       )
     end
-
   end
 end

data/lib/filterrific/active_record_extension.rb

@@ -1,12 +1,10 @@
-# -*- coding: utf-8 -*-
 #
 # Adds Filterrific methods to ActiveRecord::Base model_class.
 #
-require 'filterrific/param_set'
+require "filterrific/param_set"
 
 module Filterrific
   module ActiveRecordExtension
-
     # Adds Filterrific behavior to class when called like so:
     #
     # filterrific(
@@ -34,7 +32,6 @@ module Filterrific
       validate_filterrific_available_filters
       assign_filterrific_default_filter_params(opts)
       validate_filterrific_default_filter_params
-
     end
 
     # Returns ActiveRecord relation based on filterrific_param_set.
@@ -46,7 +43,7 @@ module Filterrific
       unless filterrific_param_set.is_a?(Filterrific::ParamSet)
         raise(
           ArgumentError,
-          "Invalid Filterrific::ParamSet: #{ filterrific_param_set.inspect }"
+          "Invalid Filterrific::ParamSet: #{filterrific_param_set.inspect}"
         )
       end
 
@@ -69,7 +66,7 @@ module Filterrific
       ar_rel
     end
 
-  protected
+    protected
 
     # Defines a :sorted_by scope based on attrs
     # @param attrs [Hash] with keys as
@@ -83,7 +80,7 @@ module Filterrific
     # @return [void]
     def assign_filterrific_available_filters(opts)
       self.filterrific_available_filters = (
-        filterrific_available_filters + (opts['available_filters'] || [])
+        filterrific_available_filters + (opts["available_filters"] || [])
       ).map(&:to_s).uniq.sort
     end
 
@@ -97,7 +94,7 @@ module Filterrific
 
     def assign_filterrific_default_filter_params(opts)
       self.filterrific_default_filter_params = (
-        opts['default_filter_params'] || {}
+        opts["default_filter_params"] || {}
       ).stringify_keys
     end
 
@@ -106,9 +103,8 @@ module Filterrific
       if (
         inv_fdfps = filterrific_default_filter_params.keys - filterrific_available_filters
       ).any?
-        raise(ArgumentError, "Invalid default filter params: #{ inv_fdfps.inspect }")
+        raise(ArgumentError, "Invalid default filter params: #{inv_fdfps.inspect}")
       end
     end
-
   end
 end

data/lib/filterrific/engine.rb

@@ -1,16 +1,13 @@
-# -*- coding: utf-8 -*-
+require "filterrific/param_set"
 
-require 'filterrific/param_set'
+require "filterrific/has_reset_filterrific_url_mixin"
 
-require 'filterrific/has_reset_filterrific_url_mixin'
-
-require 'filterrific/action_controller_extension'
-require 'filterrific/action_view_extension'
-require 'filterrific/active_record_extension'
+require "filterrific/action_controller_extension"
+require "filterrific/action_view_extension"
+require "filterrific/active_record_extension"
 
 module Filterrific
   class Engine < ::Rails::Engine
-
     # It's an engine so that we can add javascript and image assets
     # to the asset pipeline.
 
@@ -27,6 +24,5 @@ module Filterrific
     ActiveSupport.on_load :active_record do
       extend Filterrific::ActiveRecordExtension
     end
-
   end
 end

data/lib/filterrific/has_reset_filterrific_url_mixin.rb

@@ -1,16 +1,13 @@
-# -*- coding: utf-8 -*-
 #
 # Adds reset_filterrific_url to controllers and views
 #
 module Filterrific
   module HasResetFilterrificUrlMixin
-
     # Returns a url that can be used to reset the Filterrific params
     def reset_filterrific_url(opts = {})
       url_for(
-        { filterrific: { reset_filterrific: true } }.merge(opts)
+        {filterrific: {reset_filterrific: true}}.merge(opts)
       )
     end
-
   end
 end

data/lib/filterrific/param_set.rb

@@ -1,13 +1,9 @@
-# -*- coding: utf-8 -*-
-
-require 'active_support/all'
-require 'digest/sha1'
+require "active_support/all"
+require "digest/sha1"
 
 module Filterrific
-
   # FilterParamSet is a container to store FilterParams
   class ParamSet
-
     attr_accessor :model_class
     attr_accessor :select_options
 
@@ -27,16 +23,16 @@ module Filterrific
       # You might wonder "what if I want to change only one thing from the defaults?"
       # Persistence, baby. By the time you submit changes to one filter, all the others
       # will be already initialized with the defaults.
-      filterrific_params = model_class.filterrific_default_filter_params  if filterrific_params.blank?
+      filterrific_params = model_class.filterrific_default_filter_params if filterrific_params.blank?
       if defined?(ActionController::Parameters) && filterrific_params.is_a?(ActionController::Parameters)
         permissible_filter_params = []
         model_class.filterrific_available_filters.each do |p|
-          if filterrific_params[p].is_a?(ActionController::Parameters)
-            permissible_filter_params << { p => filterrific_params[p].keys }
+          permissible_filter_params << if filterrific_params[p].is_a?(ActionController::Parameters)
+            {p => filterrific_params[p].keys}
           elsif filterrific_params[p].is_a?(Array)
-            permissible_filter_params << { p => [] }
+            {p => []}
           else
-            permissible_filter_params << p
+            p
           end
         end
         filterrific_params = filterrific_params.permit(permissible_filter_params).to_h.stringify_keys
@@ -60,14 +56,13 @@ module Filterrific
     def to_hash
       {}.tap { |h|
         model_class.filterrific_available_filters.each do |filter_name|
-          param_value = self.send(filter_name)
-          case
-          when param_value.blank?
+          param_value = send(filter_name)
+          if param_value.blank?
             # do nothing
-          when param_value.is_a?(Proc)
+          elsif param_value.is_a?(Proc)
             # evaluate Proc so it can be serialized
             h[filter_name] = param_value.call
-          when param_value.is_a?(OpenStruct)
+          elsif param_value.is_a?(OpenStruct)
             # convert OpenStruct to hash
             h[filter_name] = param_value.marshal_dump
           else
@@ -83,25 +78,24 @@ module Filterrific
       to_hash.to_json
     end
 
-  protected
+    protected
 
     # Conditions params: Evaluates Procs and type casts integer values.
     # @param fp [Hash] the filterrific params hash
     # @return[Hash] the conditioned params hash
     def condition_filterrific_params(fp)
       fp.each do |key, val|
-        case
-        when val.is_a?(Proc)
+        if val.is_a?(Proc)
           # evaluate Procs
           fp[key] = val.call
-        when val.is_a?(Array)
+        elsif val.is_a?(Array)
           # type cast integers in the array
-          fp[key] = fp[key].map { |e| e =~ integer_detector_regex ? e.to_i : e }
-        when val.is_a?(Hash)
+          fp[key] = fp[key].map { |e| e.to_s.match?(integer_detector_regex) ? e.to_i : e }
+        elsif val.is_a?(Hash)
           # type cast Hash to OpenStruct so that nested params render correctly
           # in the form
           fp[key] = OpenStruct.new(fp[key])
-        when val.is_a?(String) && val =~ integer_detector_regex
+        elsif val.is_a?(String) && val.match?(integer_detector_regex)
           # type cast integer
           fp[key] = fp[key].to_i
         end
@@ -121,10 +115,8 @@ module Filterrific
       model_class.filterrific_available_filters.each do |filter_name|
         self.class.send(:attr_accessor, filter_name)
         v = fp[filter_name]
-        self.send("#{ filter_name }=", v)  if v.present?
+        send("#{filter_name}=", v) if v.present?
       end
     end
-
   end
-
 end

data/lib/filterrific/version.rb

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 module Filterrific
-  VERSION = "5.2.3"
+  VERSION = "5.2.4"
 end