Reintegrate AS::ParameterFilter::CompiledFilter

`ActiveSupport::ParameterFilter::CompiledFilter` was originally
extracted in 79e91cc as a performance
optimization.  Its purpose was to avoid redundantly checking
`@filters.empty?`.  However, redundant checks can be avoided by using
separate `ParameterFilter` methods, rather than allocating a separate
`CompiledFilter` object.  Therefore, this commit reintegrates
`CompiledFilter` back into `ParameterFilter`.

Additionally, lazy compilation of filters predates the extraction of
`ParameterFilter` from `ActionDispatch::Http::FilterParameters` in
e466354.  However, since
`ActionDispatch::Http::FilterParameters` lazily allocates a
`ParameterFilter` instance, there is no benefit to `ParameterFilter`
also lazily compiling filters.  Therefore, this commit switches from
lazy compilation to eager compilation.

Together, these changes yield a small performance increase:

**Benchmark script**

  ```ruby
  # frozen_string_literal: true
  require "benchmark/ips"
  require "benchmark/memory"
  require "active_support"
  require "active_support/parameter_filter"

  ootb = [:passw, :secret, :token, :_key, :crypt, :salt, :certificate, :otp, :ssn]
  mixed = [:passw, "secret", /token/, :crypt, "salt", /certificate/, "user.otp", /user\.ssn/, proc {}]

  params = {
    "user" => {
      "name" => :name,
      "email" => :email,
      "password" => :password,
      "ssn" => :ssn,
      "locations" => [
        { "city" => :city, "country" => :country },
        { "city" => :city, "country" => :country },
      ],
    }
  }

  Benchmark.ips do |x|
    x.report("ootb") do
      ActiveSupport::ParameterFilter.new(ootb).filter(params)
    end

    x.report("mixed") do
      ActiveSupport::ParameterFilter.new(mixed).filter(params)
    end
  end
  ```

**Before**

  ```
  Warming up --------------------------------------
                  ootb     2.032k i/100ms
                 mixed     1.521k i/100ms
  Calculating -------------------------------------
                  ootb     20.315k (± 1.3%) i/s -    101.600k in   5.001939s
                 mixed     15.142k (± 1.2%) i/s -     76.050k in   5.023077s
  ```

**After**

  ```
  Warming up --------------------------------------
                  ootb     2.163k i/100ms
                 mixed     1.604k i/100ms
  Calculating -------------------------------------
                  ootb     21.478k (± 1.2%) i/s -    108.150k in   5.036188s
                 mixed     16.052k (± 0.8%) i/s -     81.804k in   5.096656s
  ```

Author: jonathanhefner

activesupport/lib/active_support/parameter_filter.rb

@@ -40,97 +40,83 @@ class ParameterFilter
     #
     # * <tt>:mask</tt> - A replaced object when filtered. Defaults to <tt>"[FILTERED]"</tt>.
     def initialize(filters = [], mask: FILTERED)
-      @filters = filters
       @mask = mask
+      compile_filters!(filters)
     end
 
     # Mask value of +params+ if key matches one of filters.
     def filter(params)
-      compiled_filter.call(params)
+      @no_filters ? params.dup : call(params)
     end
 
     # Returns filtered value for given key. For +Proc+ filters, third block argument is not populated.
     def filter_param(key, value)
-      @filters.empty? ? value : compiled_filter.value_for_key(key, value)
+      @no_filters ? value : value_for_key(key, value)
     end
 
   private
-    def compiled_filter
-      @compiled_filter ||= CompiledFilter.compile(@filters, mask: @mask)
-    end
-
-    class CompiledFilter # :nodoc:
-      def self.compile(filters, mask:)
-        return lambda { |params| params.dup } if filters.empty?
-
-        strings, regexps, blocks, deep_regexps, deep_strings = [], [], [], nil, nil
-
-        filters.each do |item|
-          case item
-          when Proc
-            blocks << item
-          when Regexp
-            if item.to_s.include?("\\.")
-              (deep_regexps ||= []) << item
-            else
-              regexps << item
-            end
+    def compile_filters!(filters)
+      @no_filters = filters.empty?
+      return if @no_filters
+
+      @regexps, strings = [], []
+      @deep_regexps, deep_strings = nil, nil
+      @blocks = nil
+
+      filters.each do |item|
+        case item
+        when Proc
+          (@blocks ||= []) << item
+        when Regexp
+          if item.to_s.include?("\\.")
+            (@deep_regexps ||= []) << item
           else
-            s = Regexp.escape(item.to_s)
-            if s.include?("\\.")
-              (deep_strings ||= []) << s
-            else
-              strings << s
-            end
+            @regexps << item
+          end
+        else
+          s = Regexp.escape(item.to_s)
+          if s.include?("\\.")
+            (deep_strings ||= []) << s
+          else
+            strings << s
           end
         end
-
-        regexps << Regexp.new(strings.join("|"), true) unless strings.empty?
-        (deep_regexps ||= []) << Regexp.new(deep_strings.join("|"), true) if deep_strings&.any?
-
-        new regexps, deep_regexps, blocks, mask: mask
-      end
-
-      attr_reader :regexps, :deep_regexps, :blocks
-
-      def initialize(regexps, deep_regexps, blocks, mask:)
-        @regexps = regexps
-        @deep_regexps = deep_regexps&.any? ? deep_regexps : nil
-        @blocks = blocks
-        @mask = mask
       end
 
-      def call(params, full_parent_key = nil, original_params = params)
-        filtered_params = params.class.new
+      @regexps << Regexp.new(strings.join("|"), true) unless strings.empty?
+      (@deep_regexps ||= []) << Regexp.new(deep_strings.join("|"), true) if deep_strings
+    end
 
-        params.each do |key, value|
-          filtered_params[key] = value_for_key(key, value, full_parent_key, original_params)
-        end
+    def call(params, full_parent_key = nil, original_params = params)
+      filtered_params = params.class.new
 
-        filtered_params
+      params.each do |key, value|
+        filtered_params[key] = value_for_key(key, value, full_parent_key, original_params)
       end
 
-      def value_for_key(key, value, full_parent_key = nil, original_params = nil)
-        if deep_regexps
-          full_key = full_parent_key ? "#{full_parent_key}.#{key}" : key.to_s
-        end
+      filtered_params
+    end
 
-        if regexps.any? { |r| r.match?(key.to_s) }
-          value = @mask
-        elsif deep_regexps&.any? { |r| r.match?(full_key) }
-          value = @mask
-        elsif value.is_a?(Hash)
-          value = call(value, full_key, original_params)
-        elsif value.is_a?(Array)
-          value = value.map { |v| value_for_key(key, v, full_parent_key, original_params) }
-        elsif blocks.any?
-          key = key.dup if key.duplicable?
-          value = value.dup if value.duplicable?
-          blocks.each { |b| b.arity == 2 ? b.call(key, value) : b.call(key, value, original_params) }
-        end
+    def value_for_key(key, value, full_parent_key = nil, original_params = nil)
+      if @deep_regexps
+        full_key = full_parent_key ? "#{full_parent_key}.#{key}" : key.to_s
+      end
 
-        value
+      if @regexps.any? { |r| r.match?(key.to_s) }
+        value = @mask
+      elsif @deep_regexps&.any? { |r| r.match?(full_key) }
+        value = @mask
+      elsif value.is_a?(Hash)
+        value = call(value, full_key, original_params)
+      elsif value.is_a?(Array)
+        value = value.map { |v| value_for_key(key, v, full_parent_key, original_params) }
+      elsif @blocks
+        key = key.dup if key.duplicable?
+        value = value.dup if value.duplicable?
+        @blocks.each { |b| b.arity == 2 ? b.call(key, value) : b.call(key, value, original_params) }
       end
+
+      value
     end
   end
 end