actionpack 2.3.18 → 3.0.0.beta

data/lib/action_controller/metal/mime_responds.rb

@@ -0,0 +1,300 @@
+require 'abstract_controller/collector'
+require 'active_support/core_ext/class/attribute'
+
+module ActionController #:nodoc:
+  module MimeResponds #:nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :responder, :mimes_for_respond_to
+      self.responder = ActionController::Responder
+      clear_respond_to
+    end
+
+    module ClassMethods
+      # Defines mimes that are rendered by default when invoking respond_with.
+      #
+      # Examples:
+      #
+      #   respond_to :html, :xml, :json
+      #
+      # All actions on your controller will respond to :html, :xml and :json.
+      #
+      # But if you want to specify it based on your actions, you can use only and
+      # except:
+      #
+      #   respond_to :html
+      #   respond_to :xml, :json, :except => [ :edit ]
+      #
+      # The definition above explicits that all actions respond to :html. And all
+      # actions except :edit respond to :xml and :json.
+      #
+      # You can specify also only parameters:
+      #
+      #   respond_to :rjs, :only => :create
+      #
+      def respond_to(*mimes)
+        options = mimes.extract_options!
+
+        only_actions   = Array(options.delete(:only))
+        except_actions = Array(options.delete(:except))
+
+        new = mimes_for_respond_to.dup
+        mimes.each do |mime|
+          mime = mime.to_sym
+          new[mime]          = {}
+          new[mime][:only]   = only_actions   unless only_actions.empty?
+          new[mime][:except] = except_actions unless except_actions.empty?
+        end
+        self.mimes_for_respond_to = new.freeze
+      end
+
+      # Clear all mimes in respond_to.
+      #
+      def clear_respond_to
+        self.mimes_for_respond_to = ActiveSupport::OrderedHash.new.freeze
+      end
+    end
+
+    # Without web-service support, an action which collects the data for displaying a list of people
+    # might look something like this:
+    #
+    #   def index
+    #     @people = Person.find(:all)
+    #   end
+    #
+    # Here's the same action, with web-service support baked in:
+    #
+    #   def index
+    #     @people = Person.find(:all)
+    #
+    #     respond_to do |format|
+    #       format.html
+    #       format.xml { render :xml => @people.to_xml }
+    #     end
+    #   end
+    #
+    # What that says is, "if the client wants HTML in response to this action, just respond as we
+    # would have before, but if the client wants XML, return them the list of people in XML format."
+    # (Rails determines the desired response format from the HTTP Accept header submitted by the client.)
+    #
+    # Supposing you have an action that adds a new person, optionally creating their company
+    # (by name) if it does not already exist, without web-services, it might look like this:
+    #
+    #   def create
+    #     @company = Company.find_or_create_by_name(params[:company][:name])
+    #     @person  = @company.people.create(params[:person])
+    #
+    #     redirect_to(person_list_url)
+    #   end
+    #
+    # Here's the same action, with web-service support baked in:
+    #
+    #   def create
+    #     company  = params[:person].delete(:company)
+    #     @company = Company.find_or_create_by_name(company[:name])
+    #     @person  = @company.people.create(params[:person])
+    #
+    #     respond_to do |format|
+    #       format.html { redirect_to(person_list_url) }
+    #       format.js
+    #       format.xml  { render :xml => @person.to_xml(:include => @company) }
+    #     end
+    #   end
+    #
+    # If the client wants HTML, we just redirect them back to the person list. If they want Javascript
+    # (format.js), then it is an RJS request and we render the RJS template associated with this action.
+    # Lastly, if the client wants XML, we render the created person as XML, but with a twist: we also
+    # include the person's company in the rendered XML, so you get something like this:
+    #
+    #   <person>
+    #     <id>...</id>
+    #     ...
+    #     <company>
+    #       <id>...</id>
+    #       <name>...</name>
+    #       ...
+    #     </company>
+    #   </person>
+    #
+    # Note, however, the extra bit at the top of that action:
+    #
+    #   company  = params[:person].delete(:company)
+    #   @company = Company.find_or_create_by_name(company[:name])
+    #
+    # This is because the incoming XML document (if a web-service request is in process) can only contain a
+    # single root-node. So, we have to rearrange things so that the request looks like this (url-encoded):
+    #
+    #   person[name]=...&person[company][name]=...&...
+    #
+    # And, like this (xml-encoded):
+    #
+    #   <person>
+    #     <name>...</name>
+    #     <company>
+    #       <name>...</name>
+    #     </company>
+    #   </person>
+    #
+    # In other words, we make the request so that it operates on a single entity's person. Then, in the action,
+    # we extract the company data from the request, find or create the company, and then create the new person
+    # with the remaining data.
+    #
+    # Note that you can define your own XML parameter parser which would allow you to describe multiple entities
+    # in a single request (i.e., by wrapping them all in a single root node), but if you just go with the flow
+    # and accept Rails' defaults, life will be much easier.
+    #
+    # If you need to use a MIME type which isn't supported by default, you can register your own handlers in
+    # environment.rb as follows.
+    #
+    #   Mime::Type.register "image/jpg", :jpg
+    #
+    # Respond to also allows you to specify a common block for different formats by using any:
+    #
+    #   def index
+    #     @people = Person.find(:all)
+    #
+    #     respond_to do |format|
+    #       format.html
+    #       format.any(:xml, :json) { render request.format.to_sym => @people }
+    #     end
+    #   end
+    #
+    # In the example above, if the format is xml, it will render:
+    #
+    #   render :xml => @people
+    #
+    # Or if the format is json:
+    #
+    #   render :json => @people
+    #
+    # Since this is a common pattern, you can use the class method respond_to
+    # with the respond_with method to have the same results:
+    #
+    #   class PeopleController < ApplicationController
+    #     respond_to :html, :xml, :json
+    #
+    #     def index
+    #       @people = Person.find(:all)
+    #       respond_with(@person)
+    #     end
+    #   end
+    #
+    # Be sure to check respond_with and respond_to documentation for more examples.
+    #
+    def respond_to(*mimes, &block)
+      raise ArgumentError, "respond_to takes either types or a block, never both" if mimes.any? && block_given?
+
+      if response = retrieve_response_from_mimes(mimes, &block)
+        response.call
+      end
+    end
+
+    # respond_with wraps a resource around a responder for default representation.
+    # First it invokes respond_to, if a response cannot be found (ie. no block
+    # for the request was given and template was not available), it instantiates
+    # an ActionController::Responder with the controller and resource.
+    #
+    # ==== Example
+    #
+    #   def index
+    #     @users = User.all
+    #     respond_with(@users)
+    #   end
+    #
+    # It also accepts a block to be given. It's used to overwrite a default
+    # response:
+    #
+    #   def destroy
+    #     @user = User.find(params[:id])
+    #     flash[:notice] = "User was successfully created." if @user.save
+    #
+    #     respond_with(@user) do |format|
+    #       format.html { render }
+    #     end
+    #   end
+    #
+    # All options given to respond_with are sent to the underlying responder,
+    # except for the option :responder itself. Since the responder interface
+    # is quite simple (it just needs to respond to call), you can even give
+    # a proc to it.
+    #
+    def respond_with(*resources, &block)
+      raise "In order to use respond_with, first you need to declare the formats your " <<
+            "controller responds to in the class level" if self.class.mimes_for_respond_to.empty?
+
+      if response = retrieve_response_from_mimes(&block)
+        options = resources.extract_options!
+        options.merge!(:default_response => response)
+        (options.delete(:responder) || self.class.responder).call(self, resources, options)
+      end
+    end
+
+  protected
+
+    # Collect mimes declared in the class method respond_to valid for the
+    # current action.
+    #
+    def collect_mimes_from_class_level #:nodoc:
+      action = action_name.to_sym
+
+      self.class.mimes_for_respond_to.keys.select do |mime|
+        config = self.class.mimes_for_respond_to[mime]
+
+        if config[:except]
+          !config[:except].include?(action)
+        elsif config[:only]
+          config[:only].include?(action)
+        else
+          true
+        end
+      end
+    end
+
+    # Collects mimes and return the response for the negotiated format. Returns
+    # nil if :not_acceptable was sent to the client.
+    #
+    def retrieve_response_from_mimes(mimes=nil, &block)
+      collector = Collector.new { default_render }
+      mimes ||= collect_mimes_from_class_level
+      mimes.each { |mime| collector.send(mime) }
+      block.call(collector) if block_given?
+
+      if format = request.negotiate_mime(collector.order)
+        self.formats = [format.to_sym]
+        collector.response_for(format)
+      else
+        head :not_acceptable
+        nil
+      end
+    end
+
+    class Collector #:nodoc:
+      include AbstractController::Collector
+      attr_accessor :order
+
+      def initialize(&block)
+        @order, @responses, @default_response = [], {}, block
+      end
+
+      def any(*args, &block)
+        if args.any?
+          args.each { |type| send(type, &block) }
+        else
+          custom(Mime::ALL, &block)
+        end
+      end
+      alias :all :any
+
+      def custom(mime_type, &block)
+        mime_type = mime_type.is_a?(Mime::Type) ? mime_type : Mime::Type.lookup(mime_type.to_s)
+        @order << mime_type
+        @responses[mime_type] ||= block
+      end
+
+      def response_for(mime)
+        @responses[mime] || @responses[Mime::ALL] || @default_response
+      end
+    end
+  end
+end

data/lib/action_controller/metal/rack_delegation.rb

@@ -0,0 +1,35 @@
+require 'action_dispatch/http/request'
+require 'action_dispatch/http/response'
+
+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
+
+    def dispatch(action, env)
+      @_request = ActionDispatch::Request.new(env)
+      @_response = ActionDispatch::Response.new
+      @_response.request = request
+      super
+    end
+
+    def params
+      @_params ||= @_request.parameters
+    end
+
+    def response_body=(body)
+      response.body = body if response
+      super
+    end
+
+    def reset_session
+      @_request.reset_session
+    end
+  end
+end

data/lib/action_controller/metal/redirecting.rb

@@ -0,0 +1,90 @@
+module ActionController
+  class RedirectBackError < AbstractController::Error #:nodoc:
+    DEFAULT_MESSAGE = 'No HTTP_REFERER was set in the request to this action, so redirect_to :back could not be called successfully. If this is a test, make sure to specify request.env["HTTP_REFERER"].'
+
+    def initialize(message = nil)
+      super(message || DEFAULT_MESSAGE)
+    end
+  end
+
+  module Redirecting
+    extend ActiveSupport::Concern
+
+    include AbstractController::Logger
+    include ActionController::UrlFor
+
+    # Redirects the browser to the target specified in +options+. This parameter can take one of three forms:
+    #
+    # * <tt>Hash</tt> - The URL will be generated by calling url_for with the +options+.
+    # * <tt>Record</tt> - The URL will be generated by calling url_for with the +options+, which will reference a named URL for that record.
+    # * <tt>String</tt> starting with <tt>protocol://</tt> (like <tt>http://</tt>) - Is passed straight through as the target for redirection.
+    # * <tt>String</tt> not containing a protocol - The current protocol and host is prepended to the string.
+    # * <tt>:back</tt> - Back to the page that issued the request. Useful for forms that are triggered from multiple places.
+    #   Short-hand for <tt>redirect_to(request.env["HTTP_REFERER"])</tt>
+    #
+    # Examples:
+    #   redirect_to :action => "show", :id => 5
+    #   redirect_to post
+    #   redirect_to "http://www.rubyonrails.org"
+    #   redirect_to "/images/screenshot.jpg"
+    #   redirect_to articles_url
+    #   redirect_to :back
+    #
+    # The redirection happens as a "302 Moved" header unless otherwise specified.
+    #
+    # Examples:
+    #   redirect_to post_url(@post), :status => :found
+    #   redirect_to :action=>'atom', :status => :moved_permanently
+    #   redirect_to post_url(@post), :status => 301
+    #   redirect_to :action=>'atom', :status => 302
+    #
+    # It is also possible to assign a flash message as part of the redirection. There are two special accessors for commonly used the flash names
+    # +alert+ and +notice+ as well as a general purpose +flash+ bucket.
+    #
+    # Examples:
+    #   redirect_to post_url(@post), :alert => "Watch it, mister!"
+    #   redirect_to post_url(@post), :status=> :found, :notice => "Pay attention to the road"
+    #   redirect_to post_url(@post), :status => 301, :flash => { :updated_post_id => @post.id }
+    #   redirect_to { :action=>'atom' }, :alert => "Something serious happened"
+    #
+    # When using <tt>redirect_to :back</tt>, if there is no referrer,
+    # RedirectBackError will be raised. You may specify some fallback
+    # behavior for this case by rescuing RedirectBackError.
+    def redirect_to(options = {}, response_status = {}) #:doc:
+      raise ActionControllerError.new("Cannot redirect to nil!") if options.nil?
+      raise AbstractController::DoubleRenderError if response_body
+
+      self.status        = _extract_redirect_to_status(options, response_status)
+      self.location      = _compute_redirect_to_location(options)
+      self.response_body = "<html><body>You are being <a href=\"#{ERB::Util.h(location)}\">redirected</a>.</body></html>"
+    end
+
+    private
+      def _extract_redirect_to_status(options, response_status)
+        status = if options.is_a?(Hash) && options.key?(:status)
+          Rack::Utils.status_code(options.delete(:status))
+        elsif response_status.key?(:status)
+          Rack::Utils.status_code(response_status[:status])
+        else
+          302
+        end
+      end
+
+      def _compute_redirect_to_location(options)
+        case options
+        # 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+.-]*:.*}
+          options
+        when String
+          request.protocol + request.host_with_port + options
+        when :back
+          raise RedirectBackError unless refer = request.headers["Referer"]
+          refer
+        else
+          url_for(options)
+        end.gsub(/[\r\n]/, '')
+      end
+  end
+end

data/lib/action_controller/metal/renderers.rb

@@ -0,0 +1,95 @@
+require 'active_support/core_ext/class/attribute'
+
+module ActionController
+  def self.add_renderer(key, &block)
+    Renderers.add(key, &block)
+  end
+
+  module Renderers
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_renderers
+      self._renderers = {}.freeze
+    end
+
+    module ClassMethods
+      def _write_render_options
+        renderers = _renderers.map do |name, value|
+          <<-RUBY_EVAL
+            if options.key?(:#{name})
+              _process_options(options)
+              return _render_option_#{name}(options[:#{name}], options)
+            end
+          RUBY_EVAL
+        end
+
+        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          def _handle_render_options(options)
+            #{renderers.join}
+          end
+        RUBY_EVAL
+      end
+
+      def use_renderers(*args)
+        new = _renderers.dup
+        args.each do |key|
+          new[key] = RENDERERS[key]
+        end
+        self._renderers = new.freeze
+        _write_render_options
+      end
+      alias use_renderer use_renderers
+    end
+
+    def render_to_body(options)
+      _handle_render_options(options) || super
+    end
+
+    RENDERERS = {}
+    def self.add(key, &block)
+      define_method("_render_option_#{key}", &block)
+      RENDERERS[key] = block
+      All._write_render_options
+    end
+
+    module All
+      extend ActiveSupport::Concern
+      include Renderers
+
+      INCLUDED = []
+      included do
+        self._renderers = RENDERERS
+        _write_render_options
+        INCLUDED << self
+      end
+
+      def self._write_render_options
+        INCLUDED.each(&:_write_render_options)
+      end
+    end
+
+    add :json do |json, options|
+      json = ActiveSupport::JSON.encode(json) unless json.respond_to?(:to_str)
+      json = "#{options[:callback]}(#{json})" unless options[:callback].blank?
+      self.content_type ||= Mime::JSON
+      self.response_body  = json
+    end
+
+    add :js do |js, options|
+      self.content_type ||= Mime::JS
+      self.response_body  = js.respond_to?(:to_js) ? js.to_js : js
+    end
+
+    add :xml do |xml, options|
+      self.content_type ||= Mime::XML
+      self.response_body  = xml.respond_to?(:to_xml) ? xml.to_xml : xml
+    end
+
+    add :update do |proc, options|
+      generator = ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.new(view_context, &proc)
+      self.content_type = Mime::JS
+      self.response_body = generator.to_s
+    end
+  end
+end