Rails 2.2.2

Updated to Rails 2.2.2.
Added a couple more Ruby 1.9 fixes, but that's pretty much at a standstill,
until one gets Maruku and HTML5lib working right under Ruby 1.9.

vendor/rails/actionpack/lib/action_controller/routing/builder.rb

@@ -1,23 +1,16 @@
 module ActionController
   module Routing
     class RouteBuilder #:nodoc:
-      attr_accessor :separators, :optional_separators
+      attr_reader :separators, :optional_separators
+      attr_reader :separator_regexp, :nonseparator_regexp, :interval_regexp
 
       def initialize
-        self.separators = Routing::SEPARATORS
-        self.optional_separators = %w( / )
-      end
+        @separators = Routing::SEPARATORS
+        @optional_separators = %w( / )
 
-      def separator_pattern(inverted = false)
-        "[#{'^' if inverted}#{Regexp.escape(separators.join)}]"
-      end
-
-      def interval_regexp
-        Regexp.new "(.*?)(#{separators.source}|$)"
-      end
-
-      def multiline_regexp?(expression)
-        expression.options & Regexp::MULTILINE == Regexp::MULTILINE
+        @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
@@ -30,7 +23,7 @@ module ActionController
         rest, segments = path, []
 
         until rest.empty?
-          segment, rest = segment_for rest
+          segment, rest = segment_for(rest)
           segments << segment
         end
         segments
@@ -39,20 +32,20 @@ module ActionController
       # 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:(\w+)/
-            key = $1.to_sym
-            case key
-              when :controller then ControllerSegment.new(key)
-              else DynamicSegment.new key
-            end
-          when /\A\*(\w+)/ then PathSegment.new($1.to_sym, :optional => true)
-          when /\A\?(.*?)\?/
-            StaticSegment.new($1, :optional => true)
-          when /\A(#{separator_pattern(:inverted)}+)/ then StaticSegment.new($1)
-          when Regexp.new(separator_pattern) then
-            DividerSegment.new($&, :optional => (optional_separators.include? $&))
-        end
+        segment =
+          case string
+            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
 
@@ -98,7 +91,7 @@ module ActionController
             if requirement.source =~ %r{\A(\\A|\^)|(\\Z|\\z|\$)\Z}
               raise ArgumentError, "Regexp anchor characters are not allowed in routing requirements: #{requirement.inspect}"
             end
-            if multiline_regexp?(requirement)
+            if requirement.multiline?
               raise ArgumentError, "Regexp multiline option not allowed in routing requirements: #{requirement.inspect}"
             end
             segment.regexp = requirement

vendor/rails/actionpack/lib/action_controller/routing/optimisations.rb

@@ -20,14 +20,20 @@ module ActionController
 
       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_condition
-          'false'
+        def guard_conditions
+          ["false"]
         end
 
         def generation_code
@@ -36,6 +42,7 @@ module ActionController
 
         def source_code
           if applicable?
+            guard_condition = (GLOBAL_GUARD_CONDITIONS + guard_conditions).join(" && ")
             "return #{generation_code} if #{guard_condition}\n"
           else
             "\n"
@@ -57,14 +64,14 @@ module ActionController
       # return a string like "/people/#{@person.to_param}"
       # rather than triggering the expensive logic in +url_for+.
       class PositionalArguments < Optimiser
-        def guard_condition
+        def guard_conditions
           number_of_arguments = route.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
-            "(!defined?(default_url_options) || default_url_options.blank?) && defined?(request) && request && args.size == 1 && !args.first.is_a?(Hash)"
+            ["args.size == 1", "!args.first.is_a?(Hash)"]
           else
-            "(!defined?(default_url_options) || default_url_options.blank?) && defined?(request) && request && args.size == #{number_of_arguments}"
+            ["args.size == #{number_of_arguments}"]
           end
         end
 
@@ -98,8 +105,9 @@ module ActionController
       # above, but it supports additional query parameters as the last
       # argument
       class PositionalArgumentsWithAdditionalParams < PositionalArguments
-        def guard_condition
-          "(!defined?(default_url_options) || default_url_options.blank?) && defined?(request) && request && args.size == #{route.segment_keys.size + 1} && !args.last.has_key?(:anchor) && !args.last.has_key?(:port) && !args.last.has_key?(:host)"
+        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,

vendor/rails/actionpack/lib/action_controller/routing/recognition_optimisation.rb

@@ -148,18 +148,12 @@ module ActionController
               end
               nil
             end
-          }, __FILE__, __LINE__
+          }, '(recognize_optimized)', 1
         end
 
         def clear_recognize_optimized!
           remove_recognize_optimized!
-
-          class << self
-            def recognize_optimized(path, environment)
-              write_recognize_optimized!
-              recognize_optimized(path, environment)
-            end
-          end
+          write_recognize_optimized!
         end
 
         def remove_recognize_optimized!

vendor/rails/actionpack/lib/action_controller/routing/route.rb

@@ -219,7 +219,7 @@ module ActionController
           next_capture = 1
           extraction = segments.collect do |segment|
             x = segment.match_extraction(next_capture)
-            next_capture += Regexp.new(segment.regexp_chunk).number_of_captures
+            next_capture += segment.number_of_captures
             x
           end
           extraction.compact

vendor/rails/actionpack/lib/action_controller/routing/route_set.rb

@@ -168,6 +168,7 @@ module ActionController
             #
             @module.module_eval <<-end_eval # We use module_eval to avoid leaks
               def #{selector}(*args)
+
                 #{generate_optimisation_block(route, kind)}
 
                 opts = if args.empty? || Hash === args.first

vendor/rails/actionpack/lib/action_controller/routing/routing_ext.rb

@@ -27,6 +27,10 @@ class Regexp #:nodoc:
     Regexp.new("|#{source}").match('').captures.length
   end
 
+  def multiline?
+    options & MULTILINE == MULTILINE
+  end
+
   class << self
     def optionalize(pattern)
       case unoptionalize(pattern)

vendor/rails/actionpack/lib/action_controller/routing/segments.rb

@@ -13,6 +13,10 @@ module ActionController
         @is_optional = false
       end
 
+      def number_of_captures
+        Regexp.new(regexp_chunk).number_of_captures
+      end
+
       def extraction_code
         nil
       end
@@ -84,6 +88,10 @@ module ActionController
         optional? ? Regexp.optionalize(chunk) : chunk
       end
 
+      def number_of_captures
+        0
+      end
+
       def build_pattern(pattern)
         escaped = Regexp.escape(value)
         if optional? && ! pattern.empty?
@@ -194,10 +202,16 @@ module ActionController
         end
       end
 
+      def number_of_captures
+        if regexp
+          regexp.number_of_captures + 1
+        else
+          1
+        end
+      end
+
       def build_pattern(pattern)
-        chunk = regexp_chunk
-        chunk = "(#{chunk})" if Regexp.new(chunk).number_of_captures == 0
-        pattern = "#{chunk}#{pattern}"
+        pattern = "#{regexp_chunk}#{pattern}"
         optional? ? Regexp.optionalize(pattern) : pattern
       end
 
@@ -230,6 +244,10 @@ module ActionController
         "(?i-:(#{(regexp || Regexp.union(*possible_names)).source}))"
       end
 
+      def number_of_captures
+        1
+      end
+
       # Don't URI.escape the controller name since it may contain slashes.
       def interpolation_chunk(value_code = local_name)
         "\#{#{value_code}.to_s}"
@@ -275,6 +293,10 @@ module ActionController
         regexp || "(.*)"
       end
 
+      def number_of_captures
+        regexp ? regexp.number_of_captures : 1
+      end
+
       def optionality_implied?
         true
       end