actionpack 3.0.0.beta → 3.0.0.beta2

data/lib/action_controller/metal/instrumentation.rb

@@ -20,7 +20,7 @@ module ActionController
         :params     => request.filtered_parameters,
         :formats    => request.formats.map(&:to_sym),
         :method     => request.method,
-        :path       => (request.request_uri rescue "unknown")
+        :path       => (request.fullpath rescue "unknown")
       }
 
       ActiveSupport::Notifications.instrument("action_controller.start_processing", raw_payload.dup)

data/lib/action_controller/metal/mime_responds.rb

@@ -261,7 +261,8 @@ module ActionController #:nodoc:
       block.call(collector) if block_given?
 
       if format = request.negotiate_mime(collector.order)
-        self.formats = [format.to_sym]
+        self.content_type ||= format.to_s
+        lookup_context.freeze_formats([format.to_sym])
         collector.response_for(format)
       else
         head :not_acceptable

data/lib/action_controller/metal/rack_delegation.rb

@@ -5,15 +5,10 @@ module ActionController
   module RackDelegation
     extend ActiveSupport::Concern
 
-    included do
-      delegate :session, :to => "@_request"
-      delegate :headers, :status=, :location=, :content_type=,
-               :status, :location, :content_type, :to => "@_response"
-      attr_internal :request
-    end
+    delegate :headers, :status=, :location=, :content_type=,
+             :status, :location, :content_type, :to => "@_response"
 
-    def dispatch(action, env)
-      @_request = ActionDispatch::Request.new(env)
+    def dispatch(action, request)
       @_response = ActionDispatch::Response.new
       @_response.request = request
       super

data/lib/action_controller/metal/redirecting.rb

@@ -11,6 +11,7 @@ module ActionController
     extend ActiveSupport::Concern
 
     include AbstractController::Logger
+    include ActionController::RackDelegation
     include ActionController::UrlFor
 
     # Redirects the browser to the target specified in +options+. This parameter can take one of three forms:
@@ -75,7 +76,7 @@ module ActionController
         # The scheme name consist of a letter followed by any combination of
         # letters, digits, and the plus ("+"), period ("."), or hyphen ("-")
         # characters; and is terminated by a colon (":").
-        when %r{^\w[\w\d+.-]*:.*}
+        when %r{^\w[\w+.-]*:.*}
           options
         when String
           request.protocol + request.host_with_port + options

data/lib/action_controller/metal/renderers.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/object/blank'
 
 module ActionController
   def self.add_renderer(key, &block)
@@ -19,7 +20,7 @@ module ActionController
           <<-RUBY_EVAL
             if options.key?(:#{name})
               _process_options(options)
-              return _render_option_#{name}(options[:#{name}], options)
+              return _render_option_#{name}(options.delete(:#{name}), options)
             end
           RUBY_EVAL
         end
@@ -87,8 +88,9 @@ module ActionController
     end
 
     add :update do |proc, options|
+      view_context = self.view_context
       generator = ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.new(view_context, &proc)
-      self.content_type = Mime::JS
+      self.content_type  = Mime::JS
       self.response_body = generator.to_s
     end
   end

data/lib/action_controller/metal/rendering.rb

@@ -2,68 +2,55 @@ module ActionController
   module Rendering
     extend ActiveSupport::Concern
 
-    included do
-      include AbstractController::Rendering
-      include AbstractController::LocalizedCache
-    end
+    include ActionController::RackDelegation
+    include AbstractController::Rendering
 
-    def process_action(*)
-      self.formats = request.formats.map {|x| x.to_sym}
+    # Before processing, set the request formats in current controller formats.
+    def process_action(*) #:nodoc:
+      self.formats = request.formats.map { |x| x.to_sym }
       super
     end
 
-    def render(*args)
-      if response_body
-        raise ::AbstractController::DoubleRenderError
-      end
-
-      args << {} unless args.last.is_a?(Hash)
-      super(*args)
-      self.content_type ||= args.last[:_template].mime_type.to_s
-      response_body
-    end
-
-    def render_to_body(options)
-      _process_options(options)
+    # Check for double render errors and set the content_type after rendering.
+    def render(*args) #:nodoc:
+      raise ::AbstractController::DoubleRenderError if response_body
       super
+      self.content_type ||= Mime[formats.first].to_s
+      response_body
     end
 
     private
 
-      def _render_partial(options)
-        options[:partial] = action_name if options[:partial] == true
-        options[:_details] = {:formats => formats}
-        super
+      # Normalize arguments by catching blocks and setting them on :update.
+      def _normalize_args(action=nil, options={}, &blk) #:nodoc:
+        options = super
+        options[:update] = blk if block_given?
+        options
       end
 
-      def format_for_text
-        formats.first
+      # Normalize both text and status options.
+      def _normalize_options(options) #:nodoc:
+        if options.key?(:text) && options[:text].respond_to?(:to_text)
+          options[:text] = options[:text].to_text
+        end
+
+        if options[:status]
+          options[:status] = Rack::Utils.status_code(options[:status])
+        end
+
+        super
       end
 
-      def _process_options(options)
+      # Process controller specific options, as status, content-type and location.
+      def _process_options(options) #:nodoc:
         status, content_type, location = options.values_at(:status, :content_type, :location)
+
         self.status = status if status
         self.content_type = content_type if content_type
         self.headers["Location"] = url_for(location) if location
-      end
-
-      def _normalize_options(action=nil, options={}, &blk)
-        case action
-        when NilClass
-        when Hash
-          options = super(action.delete(:action), action)
-        when String, Symbol
-          options = super
-        else
-          options.merge! :partial => action
-        end
-
-        if options[:status]
-          options[:status] = Rack::Utils.status_code(options[:status])
-        end
 
-        options[:update] = blk if block_given?
-        options
+        super
       end
+
   end
 end

data/lib/action_controller/metal/request_forgery_protection.rb

@@ -12,11 +12,10 @@ module ActionController #:nodoc:
     included do
       # Sets the token parameter name for RequestForgery. Calling +protect_from_forgery+
       # sets it to <tt>:authenticity_token</tt> by default.
-      cattr_accessor :request_forgery_protection_token
+      config.request_forgery_protection_token ||= :authenticity_token
 
       # Controls whether request forgergy protection is turned on or not. Turned off by default only in test mode.
-      class_attribute :allow_forgery_protection
-      self.allow_forgery_protection = true
+      config.allow_forgery_protection ||= true
 
       helper_method :form_authenticity_token
       helper_method :protect_against_forgery?
@@ -80,9 +79,47 @@ module ActionController #:nodoc:
         self.request_forgery_protection_token ||= :authenticity_token
         before_filter :verify_authenticity_token, options
       end
+
+      def request_forgery_protection_token
+        config.request_forgery_protection_token
+      end
+
+      def request_forgery_protection_token=(val)
+        config.request_forgery_protection_token = val
+      end
+
+      def allow_forgery_protection
+        config.allow_forgery_protection
+      end
+
+      def allow_forgery_protection=(val)
+        config.allow_forgery_protection = val
+      end
     end
 
     protected
+
+      def protect_from_forgery(options = {})
+        self.request_forgery_protection_token ||= :authenticity_token
+        before_filter :verify_authenticity_token, options
+      end
+
+      def request_forgery_protection_token
+        config.request_forgery_protection_token
+      end
+
+      def request_forgery_protection_token=(val)
+        config.request_forgery_protection_token = val
+      end
+
+      def allow_forgery_protection
+        config.allow_forgery_protection
+      end
+
+      def allow_forgery_protection=(val)
+        config.allow_forgery_protection = val
+      end
+
       # The actual before_filter that is used.  Modify this to change how you handle unverified requests.
       def verify_authenticity_token
         verified_request? || raise(ActionController::InvalidAuthenticityToken)
@@ -109,7 +146,7 @@ module ActionController #:nodoc:
       end
 
       def protect_against_forgery?
-        self.class.allow_forgery_protection
+        config.allow_forgery_protection
       end
   end
 end

data/lib/action_controller/metal/responder.rb

@@ -1,3 +1,5 @@
+require 'active_support/json'
+
 module ActionController #:nodoc:
   # Responder is responsible for exposing a resource to different mime requests,
   # usually depending on the HTTP verb. The responder is triggered when

data/lib/action_controller/metal/session_management.rb

@@ -2,44 +2,8 @@ module ActionController #:nodoc:
   module SessionManagement #:nodoc:
     extend ActiveSupport::Concern
 
-    include ActionController::Configuration
-
     module ClassMethods
-      # Set the session store to be used for keeping the session data between requests.
-      # By default, sessions are stored in browser cookies (<tt>:cookie_store</tt>),
-      # but you can also specify one of the other included stores (<tt>:active_record_store</tt>,
-      # <tt>:mem_cache_store</tt>, or your own custom class.
-      def session_store=(store)
-        if store == :active_record_store
-          self.session_store = ActiveRecord::SessionStore
-        else
-          @@session_store = store.is_a?(Symbol) ?
-            ActionDispatch::Session.const_get(store.to_s.camelize) :
-            store
-        end
-      end
-
-      # Returns the session store class currently used.
-      def session_store
-        if defined? @@session_store
-          @@session_store
-        else
-          ActionDispatch::Session::CookieStore
-        end
-      end
-
-      def session=(options = {})
-        self.session_store = nil if options.delete(:disabled)
-        session_options.merge!(options)
-      end
 
-      def session(*args)
-        ActiveSupport::Deprecation.warn(
-          "Disabling sessions for a single controller has been deprecated. " +
-          "Sessions are now lazy loaded. So if you don't access them, " +
-          "consider them off. You can still modify the session cookie " +
-          "options with request.session_options.", caller)
-      end
     end
   end
 end

data/lib/action_controller/metal/streaming.rb

@@ -9,18 +9,13 @@ module ActionController #:nodoc:
     DEFAULT_SEND_FILE_OPTIONS = {
       :type         => 'application/octet-stream'.freeze,
       :disposition  => 'attachment'.freeze,
-      :stream       => true,
-      :buffer_size  => 4096,
-      :x_sendfile   => false
     }.freeze
 
-    X_SENDFILE_HEADER = 'X-Sendfile'.freeze
-
     protected
-      # Sends the file, by default streaming it 4096 bytes at a time. This way the
-      # whole file doesn't need to be read into memory at once. This makes it
-      # feasible to send even large files. You can optionally turn off streaming
-      # and send the whole file at once.
+      # Sends the file. This uses a server-appropriate method (such as X-Sendfile)
+      # via the Rack::Sendfile middleware. The header to use is set via
+      # config.action_dispatch.x_sendfile_header, and defaults to "X-Sendfile".
+      # Your server can also configure this for you by setting the X-Sendfile-Type header.
       #
       # Be careful to sanitize the path parameter if it is coming from a web
       # page. <tt>send_file(params[:path])</tt> allows a malicious user to
@@ -31,24 +26,12 @@ module ActionController #:nodoc:
       #   Defaults to <tt>File.basename(path)</tt>.
       # * <tt>:type</tt> - specifies an HTTP content type. Defaults to 'application/octet-stream'. You can specify
       #   either a string or a symbol for a registered type register with <tt>Mime::Type.register</tt>, for example :json
-      # * <tt>:length</tt> - used to manually override the length (in bytes) of the content that
-      #   is going to be sent to the client. Defaults to <tt>File.size(path)</tt>.
       # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.
       #   Valid values are 'inline' and 'attachment' (default).
-      # * <tt>:stream</tt> - whether to send the file to the user agent as it is read (+true+)
-      #   or to read the entire file before sending (+false+). Defaults to +true+.
-      # * <tt>:buffer_size</tt> - specifies size (in bytes) of the buffer used to stream the file.
-      #   Defaults to 4096.
       # * <tt>:status</tt> - specifies the status code to send with the response. Defaults to '200 OK'.
       # * <tt>:url_based_filename</tt> - set to +true+ if you want the browser guess the filename from
       #   the URL, which is necessary for i18n filenames on certain browsers
       #   (setting <tt>:filename</tt> overrides this option).
-      # * <tt>:x_sendfile</tt> - uses X-Sendfile to send the file when set to +true+. This is currently
-      #   only available with Lighttpd/Apache2 and specific modules installed and activated. Since this
-      #   uses the web server to send the file, this may lower memory consumption on your server and
-      #   it will not block your application for further requests.
-      #   See http://blog.lighttpd.net/articles/2006/07/02/x-sendfile and
-      #   http://tn123.ath.cx/mod_xsendfile/ for details. Defaults to +false+.
       #
       # The default Content-Type and Content-Disposition headers are
       # set to download arbitrary binary files in as many browsers as
@@ -81,29 +64,16 @@ module ActionController #:nodoc:
       def send_file(path, options = {}) #:doc:
         raise MissingFile, "Cannot read file #{path}" unless File.file?(path) and File.readable?(path)
 
-        options[:length]   ||= File.size(path)
         options[:filename] ||= File.basename(path) unless options[:url_based_filename]
         send_file_headers! options
 
-        @performed_render = false
-
         if options[:x_sendfile]
-          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|
-              len = options[:buffer_size] || 4096
-              File.open(path, 'rb') do |file|
-                while buf = file.read(len)
-                  output.write(buf)
-                end
-              end
-            }
-          else
-            File.open(path, 'rb') { |file| render :status => options[:status], :text => file.read }
-          end
+          ActiveSupport::Deprecation.warn(":x_sendfile is no longer needed in send_file", caller)
         end
+
+        self.status = options[:status] || 200
+        self.content_type = options[:content_type] if options.key?(:content_type)
+        self.response_body = File.open(path, "rb")
       end
 
       # Sends the given binary data to the browser. This method is similar to
@@ -138,32 +108,35 @@ 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:
-        send_file_headers! options.merge(:length => data.bytesize)
-        render :status => options[:status], :text => data
+        send_file_headers! options.dup
+        render options.slice(:status, :content_type).merge(:text => data)
       end
 
     private
       def send_file_headers!(options)
         options.update(DEFAULT_SEND_FILE_OPTIONS.merge(options))
-        [:length, :type, :disposition].each do |arg|
+        [:type, :disposition].each do |arg|
           raise ArgumentError, ":#{arg} option required" if options[arg].nil?
         end
 
-        disposition = options[:disposition].dup || 'attachment'
+        if options.key?(:length)
+          ActiveSupport::Deprecation.warn("You do not need to provide the file's length", caller)
+        end
 
-        disposition <<= %(; filename="#{options[:filename]}") if options[:filename]
+        disposition = options[:disposition]
+        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.key?(content_type.to_s)
-          self.content_type = Mime::Type.lookup_by_extension(content_type.to_s)
+          extension = Mime[content_type]
+          raise ArgumentError, "Unknown MIME type #{options[:type]}" unless extension
+          self.content_type = extension
         else
           self.content_type = content_type
         end
 
         headers.merge!(
-          'Content-Length'            => options[:length].to_s,
           'Content-Disposition'       => disposition,
           'Content-Transfer-Encoding' => 'binary'
         )

data/lib/action_controller/metal/testing.rb

@@ -13,7 +13,6 @@ module ActionController
       if cookies = @_request.env['action_dispatch.cookies']
         cookies.write(@_response)
       end
-      @_response.body ||= self.response_body
       @_response.prepare!
       set_test_assigns
       ret

data/lib/action_controller/metal/url_for.rb

@@ -1,157 +1,20 @@
-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
+    include ActionDispatch::Routing::UrlFor
 
-    def rewrite_options(options) #:nodoc:
-      if options.delete(:use_defaults) != false && (defaults = default_url_options(options))
-        defaults.merge(options)
-      else
-        options
-      end
+    def url_options
+      super.reverse_merge(
+        :host => request.host_with_port,
+        :protocol => request.protocol,
+        :_path_segments => request.symbolized_path_parameters
+      ).merge(:script_name => request.script_name)
     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
+    def _router
+      raise "In order to use #url_for, you must include the helpers of a particular " \
+            "router. For instance, `include Rails.application.routes.url_helpers"
     end
   end
-end
+end