actionpack 2.3.18 → 3.0.0.beta

data/lib/action_controller/{streaming.rb → metal/streaming.rb}

@@ -1,9 +1,11 @@
-require 'active_support/core_ext/string/bytesize'
-
 module ActionController #:nodoc:
   # Methods for sending arbitrary data and for streaming files to the browser,
   # instead of rendering.
   module Streaming
+    extend ActiveSupport::Concern
+
+    include ActionController::Rendering
+
     DEFAULT_SEND_FILE_OPTIONS = {
       :type         => 'application/octet-stream'.freeze,
       :disposition  => 'attachment'.freeze,
@@ -86,12 +88,11 @@ module ActionController #:nodoc:
         @performed_render = false
 
         if options[:x_sendfile]
-          logger.info "Sending #{X_SENDFILE_HEADER} header #{path}" if logger
           head options[:status], X_SENDFILE_HEADER => path
         else
           if options[:stream]
+            # TODO : Make render :text => proc {} work with the new base
             render :status => options[:status], :text => Proc.new { |response, output|
-              logger.info "Streaming file #{path}" unless logger.nil?
               len = options[:buffer_size] || 4096
               File.open(path, 'rb') do |file|
                 while buf = file.read(len)
@@ -100,7 +101,6 @@ module ActionController #:nodoc:
               end
             }
           else
-            logger.info "Sending file #{path}" unless logger.nil?
             File.open(path, 'rb') { |file| render :status => options[:status], :text => file.read }
           end
         end
@@ -138,9 +138,7 @@ module ActionController #:nodoc:
       # data to the browser, then use <tt>render :text => proc { ... }</tt>
       # instead. See ActionController::Base#render for more information.
       def send_data(data, options = {}) #:doc:
-        logger.info "Sending data #{options[:filename]}" if logger
         send_file_headers! options.merge(:length => data.bytesize)
-        @performed_render = false
         render :status => options[:status], :text => data
       end
 
@@ -156,26 +154,29 @@ module ActionController #:nodoc:
         disposition <<= %(; filename="#{options[:filename]}") if options[:filename]
 
         content_type = options[:type]
+
         if content_type.is_a?(Symbol)
-          raise ArgumentError, "Unknown MIME type #{options[:type]}" unless Mime::EXTENSION_LOOKUP.has_key?(content_type.to_s)
-          content_type = Mime::Type.lookup_by_extension(content_type.to_s)
+          raise ArgumentError, "Unknown MIME type #{options[:type]}" unless Mime::EXTENSION_LOOKUP.key?(content_type.to_s)
+          self.content_type = Mime::Type.lookup_by_extension(content_type.to_s)
+        else
+          self.content_type = content_type
         end
-        content_type = content_type.to_s.strip # fixes a problem with extra '\r' with some browsers
 
         headers.merge!(
           'Content-Length'            => options[:length].to_s,
-          'Content-Type'              => content_type,
           'Content-Disposition'       => disposition,
           'Content-Transfer-Encoding' => 'binary'
         )
 
+        response.sending_file = true
+
         # Fix a problem with IE 6.0 on opening downloaded files:
         # If Cache-Control: no-cache is set (which Rails does by default),
         # IE removes the file it just downloaded from its cache immediately
         # after it displays the "open/save" dialog, which means that if you
         # hit "open" the file isn't there anymore when the application that
         # is called for handling the download is run, so let's workaround that
-        headers['Cache-Control'] = 'private' if headers['Cache-Control'] == 'no-cache'
+        response.cache_control[:public] ||= false
       end
   end
 end

data/lib/action_controller/metal/testing.rb

@@ -0,0 +1,42 @@
+module ActionController
+  module Testing
+    extend ActiveSupport::Concern
+
+    include RackDelegation
+
+    # TODO: Clean this up
+    def process_with_new_base_test(request, response)
+      @_request = request
+      @_response = response
+      @_response.request = request
+      ret = process(request.parameters[:action])
+      if cookies = @_request.env['action_dispatch.cookies']
+        cookies.write(@_response)
+      end
+      @_response.body ||= self.response_body
+      @_response.prepare!
+      set_test_assigns
+      ret
+    end
+
+    def set_test_assigns
+      @assigns = {}
+      (instance_variable_names - self.class.protected_instance_variables).each do |var|
+        name, value = var[1..-1], instance_variable_get(var)
+        @assigns[name] = value
+      end
+    end
+
+    # TODO : Rewrite tests using controller.headers= to use Rack env
+    def headers=(new_headers)
+      @_response ||= ActionDispatch::Response.new
+      @_response.headers.replace(new_headers)
+    end
+
+    module ClassMethods
+      def before_filters
+        _process_action_callbacks.find_all{|x| x.kind == :before}.map{|x| x.name}
+      end
+    end
+  end
+end

data/lib/action_controller/metal/url_for.rb

@@ -0,0 +1,157 @@
+require 'active_support/core_ext/class/attribute'
+
+module ActionController
+  # In <b>routes.rb</b> one defines URL-to-controller mappings, but the reverse
+  # is also possible: an URL can be generated from one of your routing definitions.
+  # URL generation functionality is centralized in this module.
+  #
+  # See ActionController::Routing and ActionController::Resources for general
+  # information about routing and routes.rb.
+  #
+  # <b>Tip:</b> If you need to generate URLs from your models or some other place,
+  # then ActionController::UrlFor is what you're looking for. Read on for
+  # an introduction.
+  #
+  # == URL generation from parameters
+  #
+  # As you may know, some functions - such as ActionController::Base#url_for
+  # and ActionView::Helpers::UrlHelper#link_to, can generate URLs given a set
+  # of parameters. For example, you've probably had the chance to write code
+  # like this in one of your views:
+  #
+  #   <%= link_to('Click here', :controller => 'users',
+  #           :action => 'new', :message => 'Welcome!') %>
+  #
+  #   #=> Generates a link to: /users/new?message=Welcome%21
+  #
+  # link_to, and all other functions that require URL generation functionality,
+  # actually use ActionController::UrlFor under the hood. And in particular,
+  # they use the ActionController::UrlFor#url_for method. One can generate
+  # the same path as the above example by using the following code:
+  #
+  #   include UrlFor
+  #   url_for(:controller => 'users',
+  #           :action => 'new',
+  #           :message => 'Welcome!',
+  #           :only_path => true)
+  #   # => "/users/new?message=Welcome%21"
+  #
+  # Notice the <tt>:only_path => true</tt> part. This is because UrlFor has no
+  # information about the website hostname that your Rails app is serving. So if you
+  # want to include the hostname as well, then you must also pass the <tt>:host</tt>
+  # argument:
+  #
+  #   include UrlFor
+  #   url_for(:controller => 'users',
+  #           :action => 'new',
+  #           :message => 'Welcome!',
+  #           :host => 'www.example.com')        # Changed this.
+  #   # => "http://www.example.com/users/new?message=Welcome%21"
+  #
+  # By default, all controllers and views have access to a special version of url_for,
+  # that already knows what the current hostname is. So if you use url_for in your
+  # controllers or your views, then you don't need to explicitly pass the <tt>:host</tt>
+  # argument.
+  #
+  # For convenience reasons, mailers provide a shortcut for ActionController::UrlFor#url_for.
+  # So within mailers, you only have to type 'url_for' instead of 'ActionController::UrlFor#url_for'
+  # in full. However, mailers don't have hostname information, and what's why you'll still
+  # have to specify the <tt>:host</tt> argument when generating URLs in mailers.
+  #
+  #
+  # == URL generation for named routes
+  #
+  # UrlFor also allows one to access methods that have been auto-generated from
+  # named routes. For example, suppose that you have a 'users' resource in your
+  # <b>routes.rb</b>:
+  #
+  #   map.resources :users
+  #
+  # This generates, among other things, the method <tt>users_path</tt>. By default,
+  # this method is accessible from your controllers, views and mailers. If you need
+  # to access this auto-generated method from other places (such as a model), then
+  # you can do that by including ActionController::UrlFor in your class:
+  #
+  #   class User < ActiveRecord::Base
+  #     include ActionController::UrlFor
+  #
+  #     def base_uri
+  #       user_path(self)
+  #     end
+  #   end
+  #
+  #   User.find(1).base_uri # => "/users/1"
+  #
+  module UrlFor
+    extend ActiveSupport::Concern
+
+    included do
+      ActionController::Routing::Routes.install_helpers(self)
+      class_attribute :default_url_options
+      self.default_url_options = {}
+    end
+
+    # Overwrite to implement a number of default options that all url_for-based methods will use. The default options should come in
+    # the form of a hash, just like the one you would use for url_for directly. Example:
+    #
+    #   def default_url_options(options)
+    #     { :project => @project.active? ? @project.url_name : "unknown" }
+    #   end
+    #
+    # As you can infer from the example, this is mostly useful for situations where you want to centralize dynamic decisions about the
+    # urls as they stem from the business domain. Please note that any individual url_for call can always override the defaults set
+    # by this method.
+    def default_url_options(options = nil)
+      self.class.default_url_options
+    end
+
+    def rewrite_options(options) #:nodoc:
+      if options.delete(:use_defaults) != false && (defaults = default_url_options(options))
+        defaults.merge(options)
+      else
+        options
+      end
+    end
+
+    # Generate a url based on the options provided, default_url_options and the
+    # routes defined in routes.rb.  The following options are supported:
+    #
+    # * <tt>:only_path</tt> - If true, the relative url is returned. Defaults to +false+.
+    # * <tt>:protocol</tt> - The protocol to connect to. Defaults to 'http'.
+    # * <tt>:host</tt> - Specifies the host the link should be targeted at.
+    #   If <tt>:only_path</tt> is false, this option must be
+    #   provided either explicitly, or via +default_url_options+.
+    # * <tt>:port</tt> - Optionally specify the port to connect to.
+    # * <tt>:anchor</tt> - An anchor name to be appended to the path.
+    # * <tt>:skip_relative_url_root</tt> - If true, the url is not constructed using the
+    #   +relative_url_root+ set in ActionController::Base.relative_url_root.
+    # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in "/archive/2009/"
+    #
+    # Any other key (<tt>:controller</tt>, <tt>:action</tt>, etc.) given to
+    # +url_for+ is forwarded to the Routes module.
+    #
+    # Examples:
+    #
+    #    url_for :controller => 'tasks', :action => 'testing', :host=>'somehost.org', :port=>'8080'    # => 'http://somehost.org:8080/tasks/testing'
+    #    url_for :controller => 'tasks', :action => 'testing', :host=>'somehost.org', :anchor => 'ok', :only_path => true    # => '/tasks/testing#ok'
+    #    url_for :controller => 'tasks', :action => 'testing', :trailing_slash=>true  # => 'http://somehost.org/tasks/testing/'
+    #    url_for :controller => 'tasks', :action => 'testing', :host=>'somehost.org', :number => '33'  # => 'http://somehost.org/tasks/testing?number=33'
+    def url_for(options = {})
+      options ||= {}
+      case options
+        when String
+          options
+        when Hash
+          _url_rewriter.rewrite(rewrite_options(options))
+        else
+          polymorphic_url(options)
+      end
+    end
+
+  protected
+
+    def _url_rewriter
+      ActionController::UrlRewriter
+    end
+  end
+end

data/lib/action_controller/{verification.rb → metal/verification.rb}

@@ -1,8 +1,8 @@
 module ActionController #:nodoc:
   module Verification #:nodoc:
-    def self.included(base) #:nodoc:
-      base.extend(ClassMethods)
-    end
+    extend ActiveSupport::Concern
+
+    include AbstractController::Callbacks, Flash, Rendering
 
     # This module provides a class-level method for specifying that certain
     # actions are guarded against being called without certain prerequisites
@@ -35,7 +35,7 @@ module ActionController #:nodoc:
     #            :add_flash => { "alert" => "Failed to create your message" },
     #            :redirect_to => :category_url
     #
-    # Note that these prerequisites are not business rules. They do not examine 
+    # Note that these prerequisites are not business rules. They do not examine
     # the content of the session or the parameters. That level of validation should
     # be encapsulated by your domain model or helper methods in the controller.
     module ClassMethods
@@ -43,44 +43,44 @@ module ActionController #:nodoc:
       # the user is redirected to a different action. The +options+ parameter
       # is a hash consisting of the following key/value pairs:
       #
-      # <tt>:params</tt>:: 
-      #   a single key or an array of keys that must be in the <tt>params</tt> 
+      # <tt>:params</tt>::
+      #   a single key or an array of keys that must be in the <tt>params</tt>
       #   hash in order for the action(s) to be safely called.
-      # <tt>:session</tt>:: 
-      #   a single key or an array of keys that must be in the <tt>session</tt> 
+      # <tt>:session</tt>::
+      #   a single key or an array of keys that must be in the <tt>session</tt>
       #   in order for the action(s) to be safely called.
-      # <tt>:flash</tt>:: 
-      #   a single key or an array of keys that must be in the flash in order 
+      # <tt>:flash</tt>::
+      #   a single key or an array of keys that must be in the flash in order
       #   for the action(s) to be safely called.
-      # <tt>:method</tt>:: 
-      #   a single key or an array of keys--any one of which must match the 
-      #   current request method in order for the action(s) to be safely called. 
-      #   (The key should be a symbol: <tt>:get</tt> or <tt>:post</tt>, for 
+      # <tt>:method</tt>::
+      #   a single key or an array of keys--any one of which must match the
+      #   current request method in order for the action(s) to be safely called.
+      #   (The key should be a symbol: <tt>:get</tt> or <tt>:post</tt>, for
       #   example.)
-      # <tt>:xhr</tt>:: 
-      #   true/false option to ensure that the request is coming from an Ajax 
-      #   call or not. 
-      # <tt>:add_flash</tt>:: 
-      #   a hash of name/value pairs that should be merged into the session's 
+      # <tt>:xhr</tt>::
+      #   true/false option to ensure that the request is coming from an Ajax
+      #   call or not.
+      # <tt>:add_flash</tt>::
+      #   a hash of name/value pairs that should be merged into the session's
       #   flash if the prerequisites cannot be satisfied.
-      # <tt>:add_headers</tt>:: 
-      #   a hash of name/value pairs that should be merged into the response's 
+      # <tt>:add_headers</tt>::
+      #   a hash of name/value pairs that should be merged into the response's
       #   headers hash if the prerequisites cannot be satisfied.
-      # <tt>:redirect_to</tt>:: 
-      #   the redirection parameters to be used when redirecting if the 
-      #   prerequisites cannot be satisfied. You can redirect either to named 
+      # <tt>:redirect_to</tt>::
+      #   the redirection parameters to be used when redirecting if the
+      #   prerequisites cannot be satisfied. You can redirect either to named
       #   route or to the action in some controller.
-      # <tt>:render</tt>:: 
+      # <tt>:render</tt>::
       #   the render parameters to be used when the prerequisites cannot be satisfied.
-      # <tt>:only</tt>:: 
-      #   only apply this verification to the actions specified in the associated 
+      # <tt>:only</tt>::
+      #   only apply this verification to the actions specified in the associated
       #   array (may also be a single value).
-      # <tt>:except</tt>:: 
-      #   do not apply this verification to the actions specified in the associated 
+      # <tt>:except</tt>::
+      #   do not apply this verification to the actions specified in the associated
       #   array (may also be a single value).
       def verify(options={})
-        before_filter :only => options[:only], :except => options[:except] do |c|
-          c.__send__ :verify_action, options
+        before_filter :only => options[:only], :except => options[:except] do
+          verify_action options
         end
       end
     end
@@ -94,31 +94,31 @@ module ActionController #:nodoc:
         apply_remaining_actions(options)               unless performed?
       end
     end
-    
+
     def prereqs_invalid?(options) # :nodoc:
-      verify_presence_of_keys_in_hash_flash_or_params(options) || 
-      verify_method(options) || 
+      verify_presence_of_keys_in_hash_flash_or_params(options) ||
+      verify_method(options) ||
       verify_request_xhr_status(options)
     end
- 
+
     def verify_presence_of_keys_in_hash_flash_or_params(options) # :nodoc:
-      [*options[:params] ].find { |v| params[v].nil?  } ||
+      [*options[:params] ].find { |v| v && params[v.to_sym].nil?  } ||
       [*options[:session]].find { |v| session[v].nil? } ||
       [*options[:flash]  ].find { |v| flash[v].nil?   }
     end
-    
+
     def verify_method(options) # :nodoc:
       [*options[:method]].all? { |v| request.method != v.to_sym } if options[:method]
     end
-    
+
     def verify_request_xhr_status(options) # :nodoc:
       request.xhr? != options[:xhr] unless options[:xhr].nil?
     end
-    
+
     def apply_redirect_to(redirect_to_option) # :nodoc:
       (redirect_to_option.is_a?(Symbol) && redirect_to_option != :back) ? self.__send__(redirect_to_option) : redirect_to_option
     end
-    
+
     def apply_remaining_actions(options) # :nodoc:
       case
         when options[:render]      ; render(options[:render])
@@ -127,4 +127,4 @@ module ActionController #:nodoc:
       end
     end
   end
-end
+end

data/lib/action_controller/middleware.rb

@@ -0,0 +1,38 @@
+module ActionController
+  class Middleware < Metal
+    class ActionMiddleware
+      def initialize(controller, app)
+        @controller, @app = controller, app
+      end
+
+      def call(env)
+        @controller.build(@app).dispatch(:index, env)
+      end
+    end
+
+    class << self
+      alias build new
+
+      def new(app)
+        ActionMiddleware.new(self, app)
+      end
+    end
+
+    attr_internal :app
+
+    def process(action)
+      response = super
+      self.status, self.headers, self.response_body = response if response.is_a?(Array)
+      response
+    end
+
+    def initialize(app)
+      super()
+      @_app = app
+    end
+    
+    def index
+      call(env)
+    end
+  end
+end