Avoid #any? since via is usually singular

`Route#matches? currently calls `#any?` to match the Route's array of
request method matchers against the request. Even though the array of
matching request methods is often only one element, every Route ends up
paying the cost of `#any?`.

This commit addresses this cost by specializing the matcher to always be
a single object. For Routes with only one matching request method, the
matcher can be called directly. For Routes with multiple matching
request methods, a new Matcher was introduced to iterate the matchers as
before.

Author: skipkayhil

actionpack/lib/action_dispatch/journey/route.rb

@@ -38,29 +38,50 @@ def self.call(_); true; end
           def self.verb; ""; end
         end
 
+        class Or
+          attr_reader :verb
+
+          def initialize(verbs)
+            @verbs = verbs
+            @verb = @verbs.map(&:verb).join("|")
+          end
+
+          def call(req)
+            @verbs.any? { |v| v.call req }
+          end
+        end
+
         VERB_TO_CLASS = VERBS.each_with_object(all: All) do |verb, hash|
           klass = const_get verb
           hash[verb]                 = klass
           hash[verb.downcase]        = klass
           hash[verb.downcase.to_sym] = klass
         end
-      end
 
-      def self.verb_matcher(verb)
-        VerbMatchers::VERB_TO_CLASS.fetch(verb) do
+        VERB_TO_CLASS.default_proc = proc do |_, verb|
           VerbMatchers::Unknown.new verb.to_s.dasherize.upcase
         end
+
+        def self.for(verbs)
+          if verbs.any? { |v| VERB_TO_CLASS[v] == All }
+            All
+          elsif verbs.one?
+            VERB_TO_CLASS[verbs.first]
+          else
+            Or.new(verbs.map { |v| VERB_TO_CLASS[v] })
+          end
+        end
       end
 
       ##
       # +path+ is a path constraint.
       # `constraints` is a hash of constraints to be applied to this route.
-      def initialize(name:, app: nil, path:, constraints: {}, required_defaults: [], defaults: {}, request_method_match: nil, precedence: 0, scope_options: {}, internal: false, source_location: nil)
+      def initialize(name:, app: nil, path:, constraints: {}, required_defaults: [], defaults: {}, via: nil, precedence: 0, scope_options: {}, internal: false, source_location: nil)
         @name        = name
         @app         = app
         @path        = path
 
-        @request_method_match = request_method_match
+        @request_method_match = via && VerbMatchers.for(via)
         @constraints = constraints
         @defaults    = defaults
         @required_defaults = nil
@@ -146,7 +167,7 @@ def dispatcher?
       end
 
       def matches?(request)
-        match_verb(request) &&
+        @request_method_match.call(request) &&
         constraints.all? { |method, value|
           case value
           when Regexp, String
@@ -168,21 +189,12 @@ def ip
       end
 
       def requires_matching_verb?
-        !@request_method_match.all? { |x| x == VerbMatchers::All }
+        @request_method_match != VerbMatchers::All
       end
 
       def verb
-        verbs.join("|")
+        @request_method_match.verb
       end
-
-      private
-        def verbs
-          @request_method_match.map(&:verb)
-        end
-
-        def match_verb(request)
-          @request_method_match.any? { |m| m.call request }
-        end
     end
   end
   # :startdoc:

actionpack/lib/action_dispatch/routing/mapper.rb

@@ -183,7 +183,7 @@ def initialize(set:, ast:, controller:, default_action:, to:, formatted:, via:,
         def make_route(name, precedence)
           Journey::Route.new(name: name, app: application, path: path, constraints: conditions,
                              required_defaults: required_defaults, defaults: defaults,
-                             request_method_match: request_method, precedence: precedence,
+                             via: @via, precedence: precedence,
                              scope_options: scope_options, internal: @internal, source_location: route_source_location)
         end
 
@@ -204,11 +204,6 @@ def build_conditions(current_conditions, request_class)
         end
         private :build_conditions
 
-        def request_method
-          @via.map { |x| Journey::Route.verb_matcher(x) }
-        end
-        private :request_method
-
         private
           def intern(object)
             object.is_a?(String) ? -object : object