actionpack 2.3.18 → 3.0.0.beta

data/lib/action_controller/routing/builder.rb

@@ -1,197 +0,0 @@
-module ActionController
-  module Routing
-    class RouteBuilder #:nodoc:
-      attr_reader :separators, :optional_separators
-      attr_reader :separator_regexp, :nonseparator_regexp, :interval_regexp
-
-      def initialize
-        @separators = Routing::SEPARATORS
-        @optional_separators = %w( / )
-
-        @separator_regexp = /[#{Regexp.escape(separators.join)}]/
-        @nonseparator_regexp = /\A([^#{Regexp.escape(separators.join)}]+)/
-        @interval_regexp = /(.*?)(#{separator_regexp}|$)/
-      end
-
-      # Accepts a "route path" (a string defining a route), and returns the array
-      # of segments that corresponds to it. Note that the segment array is only
-      # partially initialized--the defaults and requirements, for instance, need
-      # to be set separately, via the +assign_route_options+ method, and the
-      # <tt>optional?</tt> method for each segment will not be reliable until after
-      # +assign_route_options+ is called, as well.
-      def segments_for_route_path(path)
-        rest, segments = path, []
-
-        until rest.empty?
-          segment, rest = segment_for(rest)
-          segments << segment
-        end
-        segments
-      end
-
-      # A factory method that returns a new segment instance appropriate for the
-      # format of the given string.
-      def segment_for(string)
-        segment =
-          case string
-            when  /\A\.(:format)?\// 
-              OptionalFormatSegment.new
-            when /\A:(\w+)/
-              key = $1.to_sym
-              key == :controller ? ControllerSegment.new(key) : DynamicSegment.new(key)
-            when /\A\*(\w+)/
-              PathSegment.new($1.to_sym, :optional => true)
-            when /\A\?(.*?)\?/
-              StaticSegment.new($1, :optional => true)
-            when nonseparator_regexp
-              StaticSegment.new($1)
-            when separator_regexp
-              DividerSegment.new($&, :optional => optional_separators.include?($&))
-          end
-        [segment, $~.post_match]
-      end
-
-      # Split the given hash of options into requirement and default hashes. The
-      # segments are passed alongside in order to distinguish between default values
-      # and requirements.
-      def divide_route_options(segments, options)
-        options = options.except(:path_prefix, :name_prefix)
-
-        if options[:namespace]
-          options[:controller] = "#{options.delete(:namespace).sub(/\/$/, '')}/#{options[:controller]}"
-        end
-
-        requirements = (options.delete(:requirements) || {}).dup
-        defaults     = (options.delete(:defaults)     || {}).dup
-        conditions   = (options.delete(:conditions)   || {}).dup
-
-        validate_route_conditions(conditions)
-
-        path_keys = segments.collect { |segment| segment.key if segment.respond_to?(:key) }.compact
-        options.each do |key, value|
-          hash = (path_keys.include?(key) && ! value.is_a?(Regexp)) ? defaults : requirements
-          hash[key] = value
-        end
-
-        [defaults, requirements, conditions]
-      end
-
-      # Takes a hash of defaults and a hash of requirements, and assigns them to
-      # the segments. Any unused requirements (which do not correspond to a segment)
-      # are returned as a hash.
-      def assign_route_options(segments, defaults, requirements)
-        route_requirements = {} # Requirements that do not belong to a segment
-
-        segment_named = Proc.new do |key|
-          segments.detect { |segment| segment.key == key if segment.respond_to?(:key) }
-        end
-
-        requirements.each do |key, requirement|
-          segment = segment_named[key]
-          if segment
-            raise TypeError, "#{key}: requirements on a path segment must be regular expressions" unless requirement.is_a?(Regexp)
-            if requirement.source =~ %r{\A(\\A|\^)|(\\Z|\\z|\$)\Z}
-              raise ArgumentError, "Regexp anchor characters are not allowed in routing requirements: #{requirement.inspect}"
-            end
-            if requirement.multiline?
-              raise ArgumentError, "Regexp multiline option not allowed in routing requirements: #{requirement.inspect}"
-            end
-            segment.regexp = requirement
-          else
-            route_requirements[key] = requirement
-          end
-        end
-
-        defaults.each do |key, default|
-          segment = segment_named[key]
-          raise ArgumentError, "#{key}: No matching segment exists; cannot assign default" unless segment
-          segment.is_optional = true
-          segment.default = default.to_param if default
-        end
-
-        assign_default_route_options(segments)
-        ensure_required_segments(segments)
-        route_requirements
-      end
-
-      # Assign default options, such as 'index' as a default for <tt>:action</tt>. This
-      # method must be run *after* user supplied requirements and defaults have
-      # been applied to the segments.
-      def assign_default_route_options(segments)
-        segments.each do |segment|
-          next unless segment.is_a? DynamicSegment
-          case segment.key
-            when :action
-              if segment.regexp.nil? || segment.regexp.match('index').to_s == 'index'
-                segment.default ||= 'index'
-                segment.is_optional = true
-              end
-            when :id
-              if segment.default.nil? && segment.regexp.nil? || segment.regexp =~ ''
-                segment.is_optional = true
-              end
-          end
-        end
-      end
-
-      # Makes sure that there are no optional segments that precede a required
-      # segment. If any are found that precede a required segment, they are
-      # made required.
-      def ensure_required_segments(segments)
-        allow_optional = true
-        segments.reverse_each do |segment|
-          allow_optional &&= segment.optional?
-          if !allow_optional && segment.optional?
-            unless segment.optionality_implied?
-              warn "Route segment \"#{segment.to_s}\" cannot be optional because it precedes a required segment. This segment will be required."
-            end
-            segment.is_optional = false
-          elsif allow_optional && segment.respond_to?(:default) && segment.default
-            # if a segment has a default, then it is optional
-            segment.is_optional = true
-          end
-        end
-      end
-
-      # Construct and return a route with the given path and options.
-      def build(path, options)
-        # Wrap the path with slashes
-        path = "/#{path}" unless path[0] == ?/
-        path = "#{path}/" unless path[-1] == ?/
-
-        prefix = options[:path_prefix].to_s.gsub(/^\//,'')
-        path = "/#{prefix}#{path}" unless prefix.blank?
-
-        segments = segments_for_route_path(path)
-        defaults, requirements, conditions = divide_route_options(segments, options)
-        requirements = assign_route_options(segments, defaults, requirements)
-
-        # TODO: Segments should be frozen on initialize
-        segments.each { |segment| segment.freeze }
-
-        route = Route.new(segments, requirements, conditions)
-
-        if !route.significant_keys.include?(:controller)
-          raise ArgumentError, "Illegal route: the :controller must be specified!"
-        end
-
-        route.freeze
-      end
-
-      private
-        def validate_route_conditions(conditions)
-          if method = conditions[:method]
-            [method].flatten.each do |m|
-              if m == :head
-                raise ArgumentError, "HTTP method HEAD is invalid in route conditions. Rails processes HEAD requests the same as GETs, returning just the response headers"
-              end
-
-              unless HTTP_METHODS.include?(m.to_sym)
-                raise ArgumentError, "Invalid HTTP method specified in route conditions: #{conditions.inspect}"
-              end
-            end
-          end
-        end
-    end
-  end
-end

data/lib/action_controller/routing/optimisations.rb

@@ -1,130 +0,0 @@
-module ActionController
-  module Routing
-    # Much of the slow performance from routes comes from the
-    # complexity of expiry, <tt>:requirements</tt> matching, defaults providing
-    # and figuring out which url pattern to use.  With named routes
-    # we can avoid the expense of finding the right route.  So if
-    # they've provided the right number of arguments, and have no
-    # <tt>:requirements</tt>, we can just build up a string and return it.
-    #
-    # To support building optimisations for other common cases, the
-    # generation code is separated into several classes
-    module Optimisation
-      def generate_optimisation_block(route, kind)
-        return "" unless route.optimise?
-        OPTIMISERS.inject("") do |memo, klazz|
-          memo << klazz.new(route, kind).source_code
-          memo
-        end
-      end
-
-      class Optimiser
-        attr_reader :route, :kind
-        GLOBAL_GUARD_CONDITIONS = [
-          "(!defined?(default_url_options) || default_url_options.blank?)",
-          "(!defined?(controller.default_url_options) || controller.default_url_options.blank?)",
-          "defined?(request)",
-          "request"
-          ]
-
-        def initialize(route, kind)
-          @route = route
-          @kind  = kind
-        end
-
-        def guard_conditions
-          ["false"]
-        end
-
-        def generation_code
-          'nil'
-        end
-
-        def source_code
-          if applicable?
-            guard_condition = (GLOBAL_GUARD_CONDITIONS + guard_conditions).join(" && ")
-            "return #{generation_code} if #{guard_condition}\n"
-          else
-            "\n"
-          end
-        end
-
-        # Temporarily disabled <tt>:url</tt> optimisation pending proper solution to
-        # Issues around request.host etc.
-        def applicable?
-          true
-        end
-      end
-
-      # Given a route
-      #
-      #   map.person '/people/:id'
-      #
-      # If the user calls <tt>person_url(@person)</tt>, we can simply
-      # return a string like "/people/#{@person.to_param}"
-      # rather than triggering the expensive logic in +url_for+.
-      class PositionalArguments < Optimiser
-        def guard_conditions
-          number_of_arguments = route.required_segment_keys.size
-          # if they're using foo_url(:id=>2) it's one
-          # argument, but we don't want to generate /foos/id2
-          if number_of_arguments == 1
-            ["args.size == 1", "!args.first.is_a?(Hash)"]
-          else
-            ["args.size == #{number_of_arguments}"]
-          end
-        end
-
-        def generation_code
-          elements = []
-          idx = 0
-
-          if kind == :url
-            elements << '#{request.protocol}'
-            elements << '#{request.host_with_port}'
-          end
-
-          elements << '#{ActionController::Base.relative_url_root if ActionController::Base.relative_url_root}'
-
-          # The last entry in <tt>route.segments</tt> appears to *always* be a
-          # 'divider segment' for '/' but we have assertions to ensure that
-          # we don't include the trailing slashes, so skip them.
-          (route.segments.size == 1 ? route.segments : route.segments[0..-2]).each do |segment|
-            if segment.is_a?(DynamicSegment)
-              elements << segment.interpolation_chunk("args[#{idx}].to_param")
-              idx += 1
-            else
-              elements << segment.interpolation_chunk
-            end
-          end
-          %("#{elements * ''}")
-        end
-      end
-
-      # This case is mostly the same as the positional arguments case
-      # above, but it supports additional query parameters as the last
-      # argument
-      class PositionalArgumentsWithAdditionalParams < PositionalArguments
-        def guard_conditions
-          ["args.size == #{route.segment_keys.size + 1}"] +
-          UrlRewriter::RESERVED_OPTIONS.collect{ |key| "!args.last.has_key?(:#{key})" }
-        end
-
-        # This case uses almost the same code as positional arguments,
-        # but add a question mark and args.last.to_query on the end,
-        # unless the last arg is empty
-        def generation_code
-          super.insert(-2, '#{\'?\' + args.last.to_query unless args.last.empty?}')
-        end
-
-        # To avoid generating "http://localhost/?host=foo.example.com" we
-        # can't use this optimisation on routes without any segments
-        def applicable?
-          super && route.segment_keys.size > 0
-        end
-      end
-
-      OPTIMISERS = [PositionalArguments, PositionalArgumentsWithAdditionalParams]
-    end
-  end
-end

data/lib/action_controller/routing/recognition_optimisation.rb

@@ -1,167 +0,0 @@
-module ActionController
-  module Routing
-    # BEFORE:   0.191446860631307 ms/url
-    # AFTER:    0.029847304022858 ms/url
-    # Speed up: 6.4 times
-    #
-    # 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 skipping all URI segments that 100% sure can't
-    # be matched, moving deeper in a tree of routes (where node == segment)
-    # until first possible match is accured. In such case, we start walking
-    # a flat list of routes, matching them with accurate matcher.
-    # So, first step: search a segment tree for the first relevant index.
-    # Second step: iterate routes starting with that index.
-    #
-    # How tree is walked? We can do a recursive tests, but it's smarter:
-    # We just create a tree of if-s and elsif-s matching segments.
-    #
-    # We have segments of 3 flavors:
-    # 1) nil (no segment, route finished)
-    # 2) const-dot-dynamic (like "/posts.:xml", "/preview.:size.jpg")
-    # 3) const (like "/posts", "/comments")
-    # 4) dynamic ("/:id", "file.:size.:extension")
-    #
-    # We split incoming string into segments and iterate over them.
-    # When segment is nil, we drop immediately, on a current node index.
-    # When segment is equal to some const, we step into branch.
-    # If none constants matched, we step into 'dynamic' branch (it's a last).
-    # If we can't match anything, we drop to last index on a level.
-    #
-    # Note: we maintain the original routes order, so we finish building
-    #       steps on a first dynamic segment.
-    #
-    #
-    # Example. Given the routes:
-    #   0 /posts/
-    #   1 /posts/:id
-    #   2 /posts/:id/comments
-    #   3 /posts/blah
-    #   4 /users/
-    #   5 /users/:id
-    #   6 /users/:id/profile
-    #
-    # request_uri = /users/123
-    #
-    # There will be only 4 iterations:
-    #  1) segm test for /posts prefix, skip all /posts/* routes
-    #  2) segm test for /users/
-    #  3) segm test for /users/:id
-    #     (jump to list index = 5)
-    #  4) full test for /users/:id => here we are!
-    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, environment.merge(: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 segment_tree(routes)
-        tree = [0]
-
-        i = -1
-        routes.each do |route|
-          i += 1
-          # not fast, but runs only once
-          segments = to_plain_segments(route.segments.inject("") { |str,s| str << s.to_s })
-
-          node  = tree
-          segments.each do |seg|
-            seg = :dynamic if seg && seg[0] == ?:
-            node << [seg, [i]] if node.empty? || node[node.size - 1][0] != seg
-            node = node[node.size - 1][1]
-          end
-        end
-        tree
-      end
-
-      def generate_code(list, padding='  ', level = 0)
-        # a digit
-        return padding + "#{list[0]}\n" if list.size == 1 && !(Array === list[0])
-
-        body = padding + "(seg = segments[#{level}]; \n"
-
-        i = 0
-        was_nil = false
-        list.each do |item|
-          if Array === item
-            i += 1
-            start = (i == 1)
-            tag, sub = item
-            if tag == :dynamic
-              body += padding + "#{start ? 'if' : 'elsif'} true\n"
-              body += generate_code(sub, padding + "  ", level + 1)
-              break
-            elsif tag == nil && !was_nil
-              was_nil = true
-              body += padding + "#{start ? 'if' : 'elsif'} seg.nil?\n"
-              body += generate_code(sub, padding + "  ", level + 1)
-            else
-              body += padding + "#{start ? 'if' : 'elsif'} seg == '#{tag}'\n"
-              body += generate_code(sub, padding + "  ", level + 1)
-            end
-          end
-        end
-        body += padding + "else\n"
-        body += padding + "  #{list[0]}\n"
-        body += padding + "end)\n"
-        body
-      end
-
-      # this must be really fast
-      def to_plain_segments(str)
-        str = str.dup
-        str.sub!(/^\/+/,'')
-        str.sub!(/\/+$/,'')
-        segments = str.split(/\.[^\/]+\/+|\/+|\.[^\/]+\Z/) # cut off ".format" also
-        segments << nil
-        segments
-      end
-
-      private
-        def write_recognize_optimized!
-          tree = segment_tree(routes)
-          body = generate_code(tree)
-
-          remove_recognize_optimized!
-
-          instance_eval %{
-            def recognize_optimized(path, env)
-              segments = to_plain_segments(path)
-              index = #{body}
-              return nil unless index
-              while index < routes.size
-                result = routes[index].recognize(path, env) and return result
-                index += 1
-              end
-              nil
-            end
-          }, '(recognize_optimized)', 1
-        end
-
-        def clear_recognize_optimized!
-          remove_recognize_optimized!
-          write_recognize_optimized!
-        end
-
-        def remove_recognize_optimized!
-          if respond_to?(:recognize_optimized)
-            class << self
-              remove_method :recognize_optimized
-            end
-          end
-        end
-    end
-  end
-end