actionpack 4.0.1 → 4.2.11.1

data/lib/action_dispatch/routing/routes_proxy.rb

@@ -8,8 +8,9 @@ module ActionDispatch
       attr_accessor :scope, :routes
       alias :_routes :routes
 
-      def initialize(routes, scope)
+      def initialize(routes, scope, helpers)
         @routes, @scope = routes, scope
+        @helpers = helpers
       end
 
       def url_options
@@ -19,16 +20,16 @@ module ActionDispatch
       end
 
       def respond_to?(method, include_private = false)
-        super || routes.url_helpers.respond_to?(method)
+        super || @helpers.respond_to?(method)
       end
 
       def method_missing(method, *args)
-        if routes.url_helpers.respond_to?(method)
+        if @helpers.respond_to?(method)
           self.class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{method}(*args)
               options = args.extract_options!
               args << url_options.merge((options || {}).symbolize_keys)
-              routes.url_helpers.#{method}(*args)
+              @helpers.#{method}(*args)
             end
           RUBY
           send(method, *args)

data/lib/action_dispatch/routing/url_for.rb

@@ -20,7 +20,7 @@ module ActionDispatch
     #
     #   <%= link_to('Click here', controller: 'users',
     #           action: 'new', message: 'Welcome!') %>
-    #   # => "/users/new?message=Welcome%21"
+    #   # => <a href="/users/new?message=Welcome%21">Click here</a>
     #
     # link_to, and all other functions that require URL generation functionality,
     # actually use ActionController::UrlFor under the hood. And in particular,
@@ -152,19 +152,27 @@ module ActionDispatch
         when nil
           _routes.url_for(url_options.symbolize_keys)
         when Hash
-          _routes.url_for(options.symbolize_keys.reverse_merge!(url_options))
+          route_name = options.delete :use_route
+          _routes.url_for(options.symbolize_keys.reverse_merge!(url_options),
+                         route_name)
         when String
           options
+        when Symbol
+          HelperMethodBuilder.url.handle_string_call self, options
+        when Array
+          components = options.dup
+          polymorphic_url(components, components.extract_options!)
+        when Class
+          HelperMethodBuilder.url.handle_class_call self, options
         else
-          polymorphic_url(options)
+          HelperMethodBuilder.url.handle_model_call self, options
         end
       end
 
       protected
 
       def optimize_routes_generation?
-        return @_optimized_routes if defined?(@_optimized_routes)
-        @_optimized_routes = _routes.optimize_routes_generation? && default_url_options.empty?
+        _routes.optimize_routes_generation? && default_url_options.empty?
       end
 
       def _with_routes(routes)
@@ -177,6 +185,12 @@ module ActionDispatch
       def _routes_context
         self
       end
+
+      private
+
+        def _generate_paths_by_default
+          true
+        end
     end
   end
 end

data/lib/action_dispatch/routing.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 require 'active_support/core_ext/object/to_param'
 require 'active_support/core_ext/regexp'
+require 'active_support/dependencies/autoload'
 
 module ActionDispatch
   # The routing module provides URL rewriting in native Ruby. It's a way to
@@ -11,7 +12,7 @@ module ActionDispatch
   # Think of creating routes as drawing a map for your requests. The map tells
   # them where to go based on some predefined pattern:
   #
-  #   AppName::Application.routes.draw do
+  #   Rails.application.routes.draw do
   #     Pattern 1 tells some request to go to one place
   #     Pattern 2 tell them to go to another
   #     ...
@@ -246,11 +247,13 @@ module ActionDispatch
   # Target specific controllers by prefixing the command with <tt>CONTROLLER=x</tt>.
   #
   module Routing
-    autoload :Mapper, 'action_dispatch/routing/mapper'
-    autoload :RouteSet, 'action_dispatch/routing/route_set'
-    autoload :RoutesProxy, 'action_dispatch/routing/routes_proxy'
-    autoload :UrlFor, 'action_dispatch/routing/url_for'
-    autoload :PolymorphicRoutes, 'action_dispatch/routing/polymorphic_routes'
+    extend ActiveSupport::Autoload
+
+    autoload :Mapper
+    autoload :RouteSet
+    autoload :RoutesProxy
+    autoload :UrlFor
+    autoload :PolymorphicRoutes
 
     SEPARATORS = %w( / . ? ) #:nodoc:
     HTTP_METHODS = [:get, :head, :post, :patch, :put, :delete, :options] #:nodoc:

data/lib/action_dispatch/testing/assertions/dom.rb

@@ -1,27 +1,3 @@
-require 'action_view/vendor/html-scanner'
+require 'active_support/deprecation'
 
-module ActionDispatch
-  module Assertions
-    module DomAssertions
-      # \Test two HTML strings for equivalency (e.g., identical up to reordering of attributes)
-      #
-      #   # assert that the referenced method generates the appropriate HTML string
-      #   assert_dom_equal '<a href="http://www.example.com">Apples</a>', link_to("Apples", "http://www.example.com")
-      def assert_dom_equal(expected, actual, message = nil)
-        expected_dom = HTML::Document.new(expected).root
-        actual_dom   = HTML::Document.new(actual).root
-        assert_equal expected_dom, actual_dom, message
-      end
-
-      # The negated form of +assert_dom_equivalent+.
-      #
-      #   # assert that the referenced method does not generate the specified HTML string
-      #   assert_dom_not_equal '<a href="http://www.example.com">Apples</a>', link_to("Oranges", "http://www.example.com")
-      def assert_dom_not_equal(expected, actual, message = nil)
-        expected_dom = HTML::Document.new(expected).root
-        actual_dom   = HTML::Document.new(actual).root
-        assert_not_equal expected_dom, actual_dom, message
-      end
-    end
-  end
-end
+ActiveSupport::Deprecation.warn("ActionDispatch::Assertions::DomAssertions has been extracted to the rails-dom-testing gem.")

data/lib/action_dispatch/testing/assertions/response.rb

@@ -27,6 +27,9 @@ module ActionDispatch
             assert @response.send("#{type}?"), message
           else
             code = Rack::Utils::SYMBOL_TO_STATUS_CODE[type]
+            if code.nil?
+              raise ArgumentError, "Invalid response type :#{type}"
+            end
             assert_equal code, @response.response_code, message
           end
         else
@@ -67,21 +70,12 @@ module ActionDispatch
         end
 
         def normalize_argument_to_redirection(fragment)
-          normalized = case fragment
-            when Regexp
-              fragment
-            when %r{^\w[A-Za-z\d+.-]*:.*}
-              fragment
-            when String
-              @request.protocol + @request.host_with_port + fragment
-            when :back
-              raise RedirectBackError unless refer = @request.headers["Referer"]
-              refer
-            else
-              @controller.url_for(fragment)
-            end
-
-          normalized.respond_to?(:delete) ? normalized.delete("\0\r\n") : normalized
+          if Regexp === fragment
+            fragment
+          else
+            handle = @controller || ActionController::Redirecting
+            handle._compute_redirect_to_location(@request, fragment)
+          end
         end
     end
   end

data/lib/action_dispatch/testing/assertions/routing.rb

@@ -38,18 +38,24 @@ module ActionDispatch
       #   # Test a custom route
       #   assert_recognizes({controller: 'items', action: 'show', id: '1'}, 'view/item1')
       def assert_recognizes(expected_options, path, extras={}, msg=nil)
-        request = recognized_request_for(path, extras)
+        if path.is_a?(Hash) && path[:method].to_s == "all"
+          [:get, :post, :put, :delete].each do |method|
+            assert_recognizes(expected_options, path.merge(method: method), extras, msg)
+          end
+        else
+          request = recognized_request_for(path, extras, msg)
 
-        expected_options = expected_options.clone
+          expected_options = expected_options.clone
 
-        expected_options.stringify_keys!
+          expected_options.stringify_keys!
 
-        msg = message(msg, "") {
-          sprintf("The recognized options <%s> did not match <%s>, difference:",
-                  request.path_parameters, expected_options)
-        }
+          msg = message(msg, "") {
+            sprintf("The recognized options <%s> did not match <%s>, difference:",
+                    request.path_parameters, expected_options)
+          }
 
-        assert_equal(expected_options, request.path_parameters, msg)
+          assert_equal(expected_options, request.path_parameters, msg)
+        end
       end
 
       # Asserts that the provided options can be used to generate the provided path. This is the inverse of +assert_recognizes+.
@@ -69,9 +75,9 @@ module ActionDispatch
       #
       #   # Asserts that the generated route gives us our custom route
       #   assert_generates "changesets/12", { controller: 'scm', action: 'show_diff', revision: "12" }
-      def assert_generates(expected_path, options, defaults={}, extras = {}, message=nil)
+      def assert_generates(expected_path, options, defaults={}, extras={}, message=nil)
         if expected_path =~ %r{://}
-          fail_on(URI::InvalidURIError) do
+          fail_on(URI::InvalidURIError, message) do
             uri = URI.parse(expected_path)
             expected_path = uri.path.to_s.empty? ? "/" : uri.path
           end
@@ -144,12 +150,6 @@ module ActionDispatch
           old_controller, @controller = @controller, @controller.clone
           _routes = @routes
 
-          # Unfortunately, there is currently an abstraction leak between AC::Base
-          # and AV::Base which requires having the URL helpers in both AC and AV.
-          # To do this safely at runtime for tests, we need to bump up the helper serial
-          # to that the old AV subclass isn't cached.
-          #
-          # TODO: Make this unnecessary
           @controller.singleton_class.send(:include, _routes.url_helpers)
           @controller.view_context_class = Class.new(@controller.view_context_class) do
             include _routes.url_helpers
@@ -165,7 +165,7 @@ module ActionDispatch
 
       # ROUTES TODO: These assertions should really work in an integration context
       def method_missing(selector, *args, &block)
-        if defined?(@controller) && @controller && @routes && @routes.named_routes.helpers.include?(selector)
+        if defined?(@controller) && @controller && defined?(@routes) && @routes && @routes.named_routes.route_defined?(selector)
           @controller.send(selector, *args, &block)
         else
           super
@@ -174,7 +174,7 @@ module ActionDispatch
 
       private
         # Recognizes the route for a given path.
-        def recognized_request_for(path, extras = {})
+        def recognized_request_for(path, extras = {}, msg)
           if path.is_a?(Hash)
             method = path[:method]
             path   = path[:path]
@@ -186,7 +186,7 @@ module ActionDispatch
           request = ActionController::TestRequest.new
 
           if path =~ %r{://}
-            fail_on(URI::InvalidURIError) do
+            fail_on(URI::InvalidURIError, msg) do
               uri = URI.parse(path)
               request.env["rack.url_scheme"] = uri.scheme || "http"
               request.host = uri.host if uri.host
@@ -200,7 +200,7 @@ module ActionDispatch
 
           request.request_method = method if method
 
-          params = fail_on(ActionController::RoutingError) do
+          params = fail_on(ActionController::RoutingError, msg) do
             @routes.recognize_path(path, { :method => method, :extras => extras })
           end
           request.path_parameters = params.with_indifferent_access
@@ -208,10 +208,10 @@ module ActionDispatch
           request
         end
 
-        def fail_on(exception_class)
+        def fail_on(exception_class, message)
           yield
         rescue exception_class => e
-          raise MiniTest::Assertion, e.message
+          raise Minitest::Assertion, message || e.message
         end
     end
   end