Ticket #10835: 0002-added-optimisation-code.patch

a/actionpack/lib/action_controller/routing.rb

@@ -7 +7 @@
-require 'action_controller/routing/segments'
-require 'action_controller/routing/builder'
-require 'action_controller/routing/route_set'
+require 'action_controller/routing/recognition_optimisation'
-
-module ActionController
-  # == Routing

/dev/null

@@ +1 @@
+module ActionController
+  module Routing
+    # Route recognition is slow due to one-by-one iterating over
+    # a whole routeset (each map.resources generates at least 14 routes)
+    # and matching weird regexps on each step.
+    #
+    # We optimize this by moving through forwarding prefix anchors first,
+    # and stupidly iterating thru routes when anchors' prefix is matched.
+    # In other words, we're skipping a bunch of routes with a same prefix
+    # if that prefix doesn't match.
+    #
+    # Example. Given the routes:
+    # /posts/
+    # /posts/:id
+    # /posts/:id/comments
+    # /posts/blah
+    # /users/
+    # /users/:id
+    # 
+    # request_uri = /users/123
+    #
+    # There will be only 3 iterations: 
+    #  1) test for /posts prefix, skip all /posts/* routes
+    #  2) test for /users/
+    #  3) test for /users/:id => success
+        
+    class RouteSet
+      def recognize_path(path, environment={})
+        result = recognize_optimized(path, environment) and return result
+        
+        # Route was not recognized. Try to find out why (maybe wrong verb).
+        allows = HTTP_METHODS.select { |verb| routes.find { |r| r.recognize(path, :method => verb) } }
+                  
+        if environment[:method] && !HTTP_METHODS.include?(environment[:method])
+          raise NotImplemented.new(*allows)
+        elsif !allows.empty?
+          raise MethodNotAllowed.new(*allows)
+        else
+          raise RoutingError, "No route matches #{path.inspect} with #{environment.inspect}"
+        end
+      end
+      
+      def recognize_optimized(path, env)
+        (compile_recognize_optimized!; @compiled_recognize_optimized=true) unless @compiled_recognize_optimized
+        
+        anch = @first_anchor
+        loop do
+          r = anch.recognize(path, env) and return r
+          anch = anch.next_anchor
+          break unless anch
+        end
+        nil
+      end
+      
+      # one-level version.
+      def compile_recognize_optimized!
+        
+        @first_anchor = current_anchor = PrefixAnchor.new(routes, 0)
+        i = 0
+        routes.each do |route|
+          # init linked list
+          pfx = prefix_for_anchor(route.segments)
+          unless current_anchor.extend(pfx)
+            new_anchor = PrefixAnchor.new(routes, current_anchor.last_index+1)
+            current_anchor.next_anchor = new_anchor
+            new_anchor.extend(pfx)
+            current_anchor = new_anchor
+          end
+        end
+      end
+      
+      def prefix_for_anchor(segments)
+        return "" if segments.size == 1 && DividerSegment === segments[0]
+        return "/"+segments[1].value if StaticSegment === segments[1]
+        return :dynamic
+      end
+    end
+      
+    # Contains a prefix to test for. 
+    # If the test fails, all the anchor's routes are skipped.
+    # Otherwise, all of them are iterated.
+    class PrefixAnchor
+      attr_accessor :next_anchor
+      
+      def initialize(rs, start = 0)
+        @routes = rs
+        @range  = (start..start)
+        @just_inited   = true
+      end
+      def extend(pfx)
+        return false if @prefix && pfx != @prefix
+        @prefix = pfx
+        @len = pfx == :dynamic ? -1 : pfx.size
+        @range = (@range.first..(@range.last + (@just_inited ? 0 : 1)))
+        @just_inited = false
+        true
+      end
+      def last_index
+        @range.last
+      end
+      def recognize(path, env)
+        # prefix not matched
+        if (@len > 0 && path[0, @len] != @prefix || @len == 0 && path !~ /^\/*$/)
+          return nil 
+        end
+        @range.each do |i|
+          route = @routes[i]
+          result = route.recognize(path, env) and return result
+        end
+        nil
+      end
+    end
+  end
+end

a/actionpack/lib/action_controller/routing/route_set.rb

@@ -208 +208 @@
-        named_routes.clear
-        @combined_regexp = nil
-        @routes_by_controller = nil
+        # This will force routing/recognition_optimization.rb 
+        # to refresh optimisations.
+        @compiled_recognize_optimized = nil
-      end
-
-      def install_helpers(destinations = [ActionController::Base, ActionView::Base], regenerate_code = false)