filterrific 5.2.3 → 5.2.5

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.5"
 end

data/lib/filterrific.rb

@@ -1,11 +1,9 @@
-# -*- coding: utf-8 -*-
-
 if ![5,6,7].include?(Rails::VERSION::MAJOR)
   raise "\n\nThis version of Filterrific only works with Rails 5, 6 and 7.\nPlease see the Filterrific README for the correct version of Filterrific to use with your version of Rails!\n\n"
 end
 
-require 'filterrific/version'
-require 'filterrific/engine'
+require "filterrific/version"
+require "filterrific/engine"
 
 module Filterrific
 end

data/spec/filterrific/action_controller_extension_spec.rb

@@ -1,80 +1,84 @@
-require 'spec_helper'
-require 'filterrific/action_controller_extension'
-require 'action_view/helpers/sanitize_helper'
+require "spec_helper"
+require "filterrific/action_controller_extension"
+require "action_view/helpers/sanitize_helper"
 
 module Filterrific
+  class TestController
+    include ActionControllerExtension
+    def action_name
+      "index"
+    end
 
-  describe ActionControllerExtension do
+    def controller_name
+      "test_controller"
+    end
+    # In a production app the #helpers method makes Rails helpers available in
+    # a controller instance. For testing our module outside of rails, we just
+    # include the required helpers in the TestController class
+    # and then delegate #helpers to self.
+    include ActionView::Helpers::SanitizeHelper
+    def helpers
+      self
+    end
 
-    class TestController
-      include ActionControllerExtension
-      def action_name; 'index'; end
-      def controller_name; 'test_controller'; end
-      # In a production app the #helpers method makes Rails helpers available in
-      # a controller instance. For testing our module outside of rails, we just
-      # include the required helpers in the TestController class
-      # and then delegate #helpers to self.
-      include ActionView::Helpers::SanitizeHelper
-      def helpers; self; end
-      def session
-        {
-          'test_controller#index' => {
-            'filter1' => '1_from_session',
-            'filter2' => '2_from_session',
-          }
+    def session
+      {
+        "test_controller#index" => {
+          "filter1" => "1_from_session",
+          "filter2" => "2_from_session"
         }
-      end
+      }
     end
+  end
 
-    class TestModelClass
-      def self.filterrific_available_filters; %w[filter1 filter2]; end
-      def self.filterrific_default_filter_params
-        { 'filter1' => '1_from_model_defaults' }
-      end
+  class TestModelClass
+    def self.filterrific_available_filters
+      %w[filter1 filter2]
     end
 
-    describe '#initialize_filterrific' do
+    def self.filterrific_default_filter_params
+      {"filter1" => "1_from_model_defaults"}
+    end
+  end
 
-      it 'returns a Filterrific::ParamSet' do
+  describe ActionControllerExtension do
+    describe "#initialize_filterrific" do
+      it "returns a Filterrific::ParamSet" do
         TestController.new.send(
           :initialize_filterrific,
           TestModelClass,
-          { 'filter1' => 1, 'filter2' => 2 },
+          {"filter1" => 1, "filter2" => 2}
         ).must_be_instance_of(ParamSet)
       end
-
     end
 
-    describe '#compute_default_persistence_id' do
-
-      it 'computes the default persistence id from controller_name and action_name' do
+    describe "#compute_default_persistence_id" do
+      it "computes the default persistence id from controller_name and action_name" do
         TestController.new.send(
           :compute_default_persistence_id
-        ).must_equal('test_controller#index')
+        ).must_equal("test_controller#index")
       end
-
     end
 
-    describe '#compute_filterrific_params' do
-
-      it 'uses filterrific_params if given' do
+    describe "#compute_filterrific_params" do
+      it "uses filterrific_params if given" do
         TestController.new.send(
           :compute_filterrific_params,
           TestModelClass,
-          { 'filter1' => 1, 'filter2' => 2 },
-          { },
-          'test_controller#index'
-        ).must_equal({ 'filter1' => 1, 'filter2' => 2 })
+          {"filter1" => 1, "filter2" => 2},
+          {},
+          "test_controller#index"
+        ).must_equal({"filter1" => 1, "filter2" => 2})
       end
 
-      it 'uses session if filterrific_params are blank' do
+      it "uses session if filterrific_params are blank" do
         TestController.new.send(
           :compute_filterrific_params,
           TestModelClass,
           {},
-          { },
-          'test_controller#index',
-        ).must_equal({ 'filter1' => '1_from_session', 'filter2' => '2_from_session' })
+          {},
+          "test_controller#index"
+        ).must_equal({"filter1" => "1_from_session", "filter2" => "2_from_session"})
       end
 
       it "uses opts['default_filter_params'] if session is blank" do
@@ -82,9 +86,9 @@ module Filterrific
           :compute_filterrific_params,
           TestModelClass,
           {},
-          { 'default_filter_params' => { 'filter1' => '1_from_opts' } },
-          'non existent persistence id to skip session',
-        ).must_equal({ 'filter1' => '1_from_opts' })
+          {"default_filter_params" => {"filter1" => "1_from_opts"}},
+          "non existent persistence id to skip session"
+        ).must_equal({"filter1" => "1_from_opts"})
       end
 
       it "uses model default_filter_params if opts is blank" do
@@ -92,72 +96,66 @@ module Filterrific
           :compute_filterrific_params,
           TestModelClass,
           {},
-          { },
-          'non existent persistence id to skip session',
-        ).must_equal({ 'filter1' => '1_from_model_defaults' })
+          {},
+          "non existent persistence id to skip session"
+        ).must_equal({"filter1" => "1_from_model_defaults"})
       end
 
       it "limits filter params to opts['available_filters']" do
         TestController.new.send(
           :compute_filterrific_params,
           TestModelClass,
-          { 'filter1' => 1, 'filter2' => 2 },
-          { 'available_filters' => %w[filter1] },
-          'test_controller#index'
-        ).must_equal({ 'filter1' => 1 })
+          {"filter1" => 1, "filter2" => 2},
+          {"available_filters" => %w[filter1]},
+          "test_controller#index"
+        ).must_equal({"filter1" => 1})
       end
 
       it "sanitizes filterrific params by default" do
         TestController.new.send(
           :compute_filterrific_params,
           TestModelClass,
-          { 'filter1' => "1' <script>alert('xss attack!');</script>" },
-          { },
-          'test_controller#index'
-        ).must_equal({ 'filter1' => "1' alert('xss attack!');" })
+          {"filter1" => "1' <script>alert('xss attack!');</script>"},
+          {},
+          "test_controller#index"
+        ).must_equal({"filter1" => "1' alert('xss attack!');"})
       end
 
       it "sanitizes filterrific Array params" do
         TestController.new.send(
           :compute_filterrific_params,
           TestModelClass,
-          { 'filter1' => ["1' <script>alert('xss attack!');</script>", 3] },
-          { },
-          'test_controller#index'
-        ).must_equal({ 'filter1' => ["1' alert('xss attack!');", 3] })
+          {"filter1" => ["1' <script>alert('xss attack!');</script>", 3]},
+          {},
+          "test_controller#index"
+        ).must_equal({"filter1" => ["1' alert('xss attack!');", 3]})
       end
 
       it "sanitizes filterrific Hash params" do
         TestController.new.send(
           :compute_filterrific_params,
           TestModelClass,
-          { 'filter1' => { 1 => "1' <script>alert('xss attack!');</script>", 2 =>  3} },
-          { },
-          'test_controller#index'
-        ).must_equal({ 'filter1' => { 1 => "1' alert('xss attack!');", 2 => 3 } })
+          {"filter1" => {1 => "1' <script>alert('xss attack!');</script>", 2 => 3}},
+          {},
+          "test_controller#index"
+        ).must_equal({"filter1" => {1 => "1' alert('xss attack!');", 2 => 3}})
       end
 
       it "skips param sanitization if told so via options" do
         TestController.new.send(
           :compute_filterrific_params,
           TestModelClass,
-          { 'filter1' => "1' <script>alert('xss attack!');</script>" },
-          { :sanitize_params => false },
-          'test_controller#index'
-        ).must_equal({ 'filter1' => "1' <script>alert('xss attack!');</script>" })
+          {"filter1" => "1' <script>alert('xss attack!');</script>"},
+          {sanitize_params: false},
+          "test_controller#index"
+        ).must_equal({"filter1" => "1' <script>alert('xss attack!');</script>"})
       end
-
     end
 
-    describe '#reset_filterrific_url' do
-
-      it 'responds to #reset_filterrific_url' do
+    describe "#reset_filterrific_url" do
+      it "responds to #reset_filterrific_url" do
         TestController.new.must_respond_to(:reset_filterrific_url)
       end
-
     end
-
   end
 end
-
-

data/spec/filterrific/action_view_extension_spec.rb

@@ -1,29 +1,26 @@
-require 'spec_helper'
-require 'filterrific/action_view_extension'
+require "spec_helper"
+require "filterrific/action_view_extension"
 
 module Filterrific
+  class ViewContext
+    include ActionViewExtension
+  end
 
   describe ActionViewExtension do
-
-    class ViewContext
-      include ActionViewExtension
-    end
-
-    it 'responds to #form_for_filterrific' do
+    it "responds to #form_for_filterrific" do
       ViewContext.new.must_respond_to(:form_for_filterrific)
     end
 
-    it 'responds to #render_filterrific_spinner' do
+    it "responds to #render_filterrific_spinner" do
       ViewContext.new.must_respond_to(:render_filterrific_spinner)
     end
 
-    it 'responds to #filterrific_sorting_link' do
+    it "responds to #filterrific_sorting_link" do
       ViewContext.new.must_respond_to(:filterrific_sorting_link)
     end
 
-    it 'responds to #reset_filterrific_url' do
+    it "responds to #reset_filterrific_url" do
       ViewContext.new.must_respond_to(:reset_filterrific_url)
     end
-
   end
 end

data/spec/filterrific/active_record_extension_spec.rb

@@ -1,27 +1,23 @@
-require 'spec_helper'
-require 'active_record'
-require 'filterrific/active_record_extension'
+require "spec_helper"
+require "active_record"
+require "filterrific/active_record_extension"
 
 ActiveRecord::Base.extend Filterrific::ActiveRecordExtension
 
 module Filterrific
+  # Container for test data
+  class TestDataARES
+    def self.filterrific_available_filters
+      %w[search_query sorted_by with_country_id]
+    end
 
-  describe ActiveRecordExtension do
-
-    # Container for test data
-    class TestDataARES
-
-      def self.filterrific_available_filters
-        %w[search_query sorted_by with_country_id]
-      end
-
-      def self.filterrific_default_filter_params
-        { 'sorted_by' => 'name_asc' }
-      end
-
+    def self.filterrific_default_filter_params
+      {"sorted_by" => "name_asc"}
     end
+  end
 
-    let(:filterrific_class){
+  describe ActiveRecordExtension do
+    let(:filterrific_class) {
       Class.new(ActiveRecord::Base) do
         filterrific(
           available_filters: TestDataARES.filterrific_available_filters,
@@ -31,7 +27,6 @@ module Filterrific
     }
 
     describe "Class method extensions" do
-
       it "adds a 'filterrific' class method" do
         filterrific_class.must_respond_to(:filterrific)
       end
@@ -39,11 +34,9 @@ module Filterrific
       it "adds a 'filterrific_find' class method" do
         filterrific_class.must_respond_to(:filterrific_find)
       end
-
     end
 
     describe "Filterrific initialization" do
-
       it "initializes filterrific_available_filters" do
         filterrific_class.filterrific_available_filters.must_equal(
           TestDataARES.filterrific_available_filters
@@ -71,44 +64,37 @@ module Filterrific
           Class.new(ActiveRecord::Base) do
             filterrific(
               available_filters: [:one, :two],
-              default_filter_params:{ three: '' }
+              default_filter_params: {three: ""}
             )
           end
         }.must_raise(ArgumentError)
       end
-
     end
 
     describe "filterrific_find" do
-
       it "raises when given invalid params" do
         proc {
-          filterrific_class.filterrific_find('an invalid argument')
+          filterrific_class.filterrific_find("an invalid argument")
         }.must_raise(ArgumentError)
       end
-
     end
-
   end
 
-  describe "Single Table Inheritance" do
-
-    class Daddy < ActiveRecord::Base
-      filterrific(available_filters: [:one, :two])
-    end
+  class Daddy < ActiveRecord::Base
+    filterrific(available_filters: [:one, :two])
+  end
 
-    class Girl < Daddy
-      filterrific(available_filters: [:three, :four])
-    end
+  class Girl < Daddy
+    filterrific(available_filters: [:three, :four])
+  end
 
-    %w(one two).each do |value|
+  describe "Single Table Inheritance" do
+    %w[one two].each do |value|
       it { Daddy.filterrific_available_filters.must_include value }
     end
 
-    %w(three four).each do |value|
+    %w[three four].each do |value|
       it { Girl.filterrific_available_filters.must_include value }
     end
-
   end
-
 end