Update ParameterFilter to yield original parameters

actionpack/lib/action_dispatch/http/parameter_filter.rb

@@ -56,23 +56,23 @@ def initialize(regexps, deep_regexps, blocks)
           @blocks = blocks
         end
 
-        def call(original_params, parents = [])
-          filtered_params = original_params.class.new
+        def call(params, parents = [], original_params = params)
+          filtered_params = params.class.new
 
-          original_params.each do |key, value|
+          params.each do |key, value|
             parents.push(key) if deep_regexps
             if regexps.any? { |r| key =~ r }
               value = FILTERED
             elsif deep_regexps && (joined = parents.join(".")) && deep_regexps.any? { |r| joined =~ r }
               value = FILTERED
             elsif value.is_a?(Hash)
-              value = call(value, parents)
+              value = call(value, parents, original_params)
             elsif value.is_a?(Array)
-              value = value.map { |v| v.is_a?(Hash) ? call(v, parents) : v }
+              value = value.map { |v| v.is_a?(Hash) ? call(v, parents, original_params) : v }
             elsif blocks.any?
               key = key.dup if key.duplicable?
               value = value.dup if value.duplicable?
-              blocks.each { |b| b.call(key, value) }
+              blocks.each { |b| b.arity == 2 ? b.call(key, value) : b.call(key, value, original_params) }
             end
             parents.pop if deep_regexps
 

actionpack/test/dispatch/request_test.rb

@@ -1078,10 +1078,13 @@ class RequestParameterFilter < BaseRequestTest
       filter_words << lambda { |key, value|
         value.reverse! if key =~ /bargain/
       }
+      filter_words << lambda { |key, value, original_params|
+        value.replace("world!") if original_params["barg"]["blah"] == "bar" && key == "hello"
+      }
 
       parameter_filter = ActionDispatch::Http::ParameterFilter.new(filter_words)
-      before_filter["barg"] = { :bargain => "gain", "blah" => "bar", "bar" => { "bargain" => { "blah" => "foo" } } }
-      after_filter["barg"]  = { :bargain => "niag", "blah" => "[FILTERED]", "bar" => { "bargain" => { "blah" => "[FILTERED]" } } }
+      before_filter["barg"] = { :bargain => "gain", "blah" => "bar", "bar" => { "bargain" => { "blah" => "foo", "hello" => "world" } } }
+      after_filter["barg"]  = { :bargain => "niag", "blah" => "[FILTERED]", "bar" => { "bargain" => { "blah" => "[FILTERED]", "hello" => "world!" } } }
 
       assert_equal after_filter, parameter_filter.filter(before_filter)
     end