halorgium-actionpack 3.0.pre

data/lib/abstract_controller/localized_cache.rb

@@ -0,0 +1,49 @@
+module AbstractController
+  class HashKey
+    @hash_keys = Hash.new {|h,k| h[k] = Hash.new {|h,k| h[k] = {} } }
+
+    def self.get(klass, formats, locale)
+      @hash_keys[klass][formats][locale] ||= new(klass, formats, locale)
+    end
+
+    attr_accessor :hash
+    def initialize(klass, formats, locale)
+      @formats, @locale = formats, locale
+      @hash = [formats, locale].hash
+    end
+
+    alias_method :eql?, :equal?
+
+    def inspect
+      "#<HashKey -- formats: #{@formats.inspect} locale: #{@locale.inspect}>"
+    end
+  end
+
+  module LocalizedCache
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def clear_template_caches!
+        ActionView::Partials::PartialRenderer::TEMPLATES.clear
+        template_cache.clear
+        super
+      end
+
+      def template_cache
+        @template_cache ||= Hash.new {|h,k| h[k] = {} }
+      end
+    end
+
+    def render(options)
+      Thread.current[:format_locale_key] = HashKey.get(self.class, formats, I18n.locale)
+      super
+    end
+
+    private
+
+      def with_template_cache(name)
+        self.class.template_cache[Thread.current[:format_locale_key]][name] ||= super
+      end
+
+  end
+end

data/lib/abstract_controller/logger.rb

@@ -0,0 +1,61 @@
+require 'active_support/core_ext/logger'
+require 'active_support/benchmarkable'
+
+module AbstractController
+  module Logger
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :logger
+      extend ActiveSupport::Benchmarkable
+    end
+
+    # A class that allows you to defer expensive processing
+    # until the logger actually tries to log. Otherwise, you are
+    # forced to do the processing in advance, and send the
+    # entire processed String to the logger, which might
+    # just discard the String if the log level is too low.
+    #
+    # TODO: Require that Rails loggers accept a block.
+    class DelayedLog < ActiveSupport::BasicObject
+      def initialize(&block)
+        @str, @block = nil, block
+      end
+
+      def method_missing(*args, &block)
+        unless @str
+          @str, @block = @block.call, nil
+        end
+        @str.send(*args, &block)
+      end
+    end
+
+    # Override process_action in the AbstractController::Base
+    # to log details about the method.
+    def process_action(action)
+      result = ActiveSupport::Notifications.instrument(:process_action,
+                :controller => self, :action => action) do
+        super
+      end
+
+      if logger
+        log = DelayedLog.new do
+          "\n\nProcessing #{self.class.name}\##{action_name} " \
+          "to #{request.formats} (for #{request_origin}) " \
+          "[#{request.method.to_s.upcase}]"
+        end
+
+        logger.info(log)
+      end
+
+      result
+    end
+
+  private
+    # Returns the request origin with the IP and time. This needs to be cached,
+    # otherwise we would get different results for each time it calls.
+    def request_origin
+      @request_origin ||= "#{request.remote_ip} at #{Time.now.to_s(:db)}"
+    end
+  end
+end

data/lib/abstract_controller/rendering_controller.rb

@@ -0,0 +1,188 @@
+require "abstract_controller/logger"
+
+module AbstractController
+  module RenderingController
+    extend ActiveSupport::Concern
+
+    include AbstractController::Logger
+
+    included do
+      attr_internal :formats
+      extlib_inheritable_accessor :_view_paths
+      self._view_paths ||= ActionView::PathSet.new
+    end
+
+    # An instance of a view class. The default view class is ActionView::Base
+    #
+    # The view class must have the following methods:
+    # View.for_controller[controller] Create a new ActionView instance for a 
+    #   controller
+    # View#render_partial[options]
+    #   - responsible for setting options[:_template]
+    #   - Returns String with the rendered partial
+    #   options<Hash>:: see _render_partial in ActionView::Base
+    # View#render_template[template, layout, options, partial]
+    #   - Returns String with the rendered template
+    #   template<ActionView::Template>:: The template to render
+    #   layout<ActionView::Template>:: The layout to render around the template
+    #   options<Hash>:: See _render_template_with_layout in ActionView::Base
+    #   partial<Boolean>:: Whether or not the template to render is a partial
+    #
+    # Override this method in a to change the default behavior.
+    def view_context
+      @_view_context ||= ActionView::Base.for_controller(self)
+    end
+
+    # Mostly abstracts the fact that calling render twice is a DoubleRenderError.
+    # Delegates render_to_body and sticks the result in self.response_body.
+    def render(*args)
+      if response_body
+        raise AbstractController::DoubleRenderError, "OMG"
+      end
+
+      self.response_body = render_to_body(*args)
+    end
+
+    # Raw rendering of a template to a Rack-compatible body.
+    #
+    # ==== Options
+    # _partial_object<Object>:: The object that is being rendered. If this
+    #   exists, we are in the special case of rendering an object as a partial.
+    #
+    # :api: plugin
+    def render_to_body(options = {})
+      # TODO: Refactor so we can just use the normal template logic for this
+      if options.key?(:partial)
+        view_context.render_partial(options)
+      else
+        _determine_template(options)
+        _render_template(options)
+      end
+    end
+
+    # Raw rendering of a template to a string. Just convert the results of
+    # render_to_body into a String.
+    #
+    # :api: plugin
+    def render_to_string(options = {})
+      AbstractController::RenderingController.body_to_s(render_to_body(options))
+    end
+
+    # Renders the template from an object.
+    #
+    # ==== Options
+    # _template<ActionView::Template>:: The template to render
+    # _layout<ActionView::Template>:: The layout to wrap the template in (optional)
+    # _partial<TrueClass, FalseClass>:: Whether or not the template to be rendered is a partial
+    def _render_template(options)
+      view_context.render_template(options)
+    end
+
+    # The list of view paths for this controller. See ActionView::ViewPathSet for
+    # more details about writing custom view paths.
+    def view_paths
+      _view_paths
+    end
+
+    # Return a string representation of a Rack-compatible response body.
+    def self.body_to_s(body)
+      if body.respond_to?(:to_str)
+        body
+      else
+        strings = []
+        body.each { |part| strings << part.to_s }
+        body.close if body.respond_to?(:close)
+        strings.join
+      end
+    end
+
+  private
+
+    # Take in a set of options and determine the template to render
+    #
+    # ==== Options
+    # _template<ActionView::Template>:: If this is provided, the search is over
+    # _template_name<#to_s>:: The name of the template to look up. Otherwise,
+    #   use the current action name.
+    # _prefix<String>:: The prefix to look inside of. In a file system, this corresponds
+    #   to a directory.
+    # _partial<TrueClass, FalseClass>:: Whether or not the file to look up is a partial
+    def _determine_template(options)
+      if options.key?(:text)
+        options[:_template] = ActionView::TextTemplate.new(options[:text], format_for_text)
+      elsif options.key?(:inline)
+        handler = ActionView::Template.handler_class_for_extension(options[:type] || "erb")
+        template = ActionView::Template.new(options[:inline], "inline #{options[:inline].inspect}", handler, {})
+        options[:_template] = template
+      elsif options.key?(:template)
+        options[:_template_name] = options[:template]
+      elsif options.key?(:file)
+        options[:_template_name] = options[:file]
+      end
+
+      name = (options[:_template_name] || action_name).to_s
+
+      options[:_template] ||= with_template_cache(name) do
+        find_template(name, { :formats => formats }, options)
+      end
+    end
+
+    def find_template(name, details, options)
+      view_paths.find(name, details, options[:_prefix], options[:_partial])
+    end
+
+    def template_exists?(name, details, options)
+      view_paths.exists?(name, details, options[:_prefix], options[:_partial])
+    end
+
+    def with_template_cache(name)
+      yield
+    end
+
+    def format_for_text
+      Mime[:text]
+    end
+
+    module ClassMethods
+      def clear_template_caches!
+      end
+      
+      # Append a path to the list of view paths for this controller.
+      #
+      # ==== Parameters
+      # path<String, ViewPath>:: If a String is provided, it gets converted into 
+      # the default view path. You may also provide a custom view path 
+      # (see ActionView::ViewPathSet for more information)
+      def append_view_path(path)
+        self.view_paths << path
+      end
+
+      # Prepend a path to the list of view paths for this controller.
+      #
+      # ==== Parameters
+      # path<String, ViewPath>:: If a String is provided, it gets converted into 
+      # the default view path. You may also provide a custom view path 
+      # (see ActionView::ViewPathSet for more information)
+      def prepend_view_path(path)
+        clear_template_caches!
+        self.view_paths.unshift(path)
+      end
+
+      # A list of all of the default view paths for this controller.
+      def view_paths
+        self._view_paths
+      end
+
+      # Set the view paths.
+      #
+      # ==== Parameters
+      # paths<ViewPathSet, Object>:: If a ViewPathSet is provided, use that;
+      #   otherwise, process the parameter into a ViewPathSet.
+      def view_paths=(paths)
+        clear_template_caches!
+        self._view_paths = paths.is_a?(ActionView::PathSet) ?
+                            paths : ActionView::Base.process_view_paths(paths)
+      end
+    end
+  end
+end

data/lib/action_controller.rb

@@ -0,0 +1,72 @@
+module ActionController
+  autoload :Base,                 "action_controller/base"
+  autoload :Benchmarking,         "action_controller/metal/benchmarking"
+  autoload :ConditionalGet,       "action_controller/metal/conditional_get"
+  autoload :Configuration,        "action_controller/metal/configuration"
+  autoload :Head,                 "action_controller/metal/head"
+  autoload :Helpers,              "action_controller/metal/helpers"
+  autoload :HideActions,          "action_controller/metal/hide_actions"
+  autoload :Layouts,              "action_controller/metal/layouts"
+  autoload :Metal,                "action_controller/metal"
+  autoload :Middleware,           "action_controller/middleware"
+  autoload :RackConvenience,      "action_controller/metal/rack_convenience"
+  autoload :Rails2Compatibility,  "action_controller/metal/compatibility"
+  autoload :Redirector,           "action_controller/metal/redirector"
+  autoload :RenderingController,  "action_controller/metal/rendering_controller"
+  autoload :RenderOptions,        "action_controller/metal/render_options"
+  autoload :Rescue,               "action_controller/metal/rescuable"
+  autoload :Responder,            "action_controller/metal/responder"
+  autoload :Session,              "action_controller/metal/session"
+  autoload :Testing,              "action_controller/metal/testing"
+  autoload :UrlFor,               "action_controller/metal/url_for"
+
+  autoload :Caching,           'action_controller/caching'
+  autoload :Dispatcher,        'action_controller/dispatch/dispatcher'
+  autoload :Integration,       'action_controller/deprecated/integration_test'
+  autoload :IntegrationTest,   'action_controller/deprecated/integration_test'
+  autoload :MimeResponds,      'action_controller/metal/mime_responds'
+  autoload :PerformanceTest,   'action_controller/deprecated/performance_test'
+  autoload :PolymorphicRoutes, 'action_controller/polymorphic_routes'
+  autoload :RecordIdentifier,  'action_controller/record_identifier'
+  autoload :Routing,           'action_controller/deprecated'
+  autoload :SessionManagement, 'action_controller/metal/session_management'
+  autoload :TestCase,          'action_controller/testing/test_case'
+  autoload :TestProcess,       'action_controller/testing/process'
+  autoload :UrlRewriter,       'action_controller/url_rewriter'
+  autoload :UrlWriter,         'action_controller/url_rewriter'
+
+  autoload :Verification,             'action_controller/metal/verification'
+  autoload :Flash,                    'action_controller/metal/flash'
+  autoload :RequestForgeryProtection, 'action_controller/metal/request_forgery_protection'
+  autoload :Streaming,                'action_controller/metal/streaming'
+  autoload :HttpAuthentication,       'action_controller/metal/http_authentication'
+  autoload :FilterParameterLogging,   'action_controller/metal/filter_parameter_logging'
+  autoload :Translation,              'action_controller/translation'
+  autoload :Cookies,                  'action_controller/metal/cookies'
+
+  autoload :ActionControllerError,    'action_controller/metal/exceptions'
+  autoload :RenderError,              'action_controller/metal/exceptions'
+  autoload :RoutingError,             'action_controller/metal/exceptions'
+  autoload :MethodNotAllowed,         'action_controller/metal/exceptions'
+  autoload :NotImplemented,           'action_controller/metal/exceptions'
+  autoload :UnknownController,        'action_controller/metal/exceptions'
+  autoload :MissingFile,              'action_controller/metal/exceptions'
+  autoload :RenderError,              'action_controller/metal/exceptions'
+  autoload :SessionOverflowError,     'action_controller/metal/exceptions'
+  autoload :UnknownHttpMethod,        'action_controller/metal/exceptions'
+end
+
+autoload :HTML, 'action_controller/vendor/html-scanner'
+autoload :AbstractController, 'abstract_controller'
+
+require 'action_dispatch'
+require 'action_view'
+
+# Common ActiveSupport usage in ActionController
+require "active_support/concern"
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/load_error'
+require 'active_support/core_ext/module/attr_internal'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/name_error'
+require 'active_support/inflector'

data/lib/action_controller/base.rb

@@ -0,0 +1,168 @@
+module ActionController
+  class Base < Metal
+    abstract!
+
+    include AbstractController::Callbacks
+    include AbstractController::Logger
+
+    include ActionController::Helpers
+    include ActionController::HideActions
+    include ActionController::UrlFor
+    include ActionController::Redirector
+    include ActionController::RenderingController
+    include ActionController::RenderOptions::All
+    include ActionController::Layouts
+    include ActionController::ConditionalGet
+    include ActionController::RackConvenience
+    include ActionController::Benchmarking
+    include ActionController::Configuration
+
+    # Legacy modules
+    include SessionManagement
+    include ActionDispatch::StatusCodes
+    include ActionController::Caching
+    include ActionController::MimeResponds
+
+    # Rails 2.x compatibility
+    include ActionController::Rails2Compatibility
+
+    include ActionController::Cookies
+    include ActionController::Session
+    include ActionController::Flash
+    include ActionController::Verification
+    include ActionController::RequestForgeryProtection
+    include ActionController::Streaming
+    include ActionController::HttpAuthentication::Basic::ControllerMethods
+    include ActionController::HttpAuthentication::Digest::ControllerMethods
+    include ActionController::FilterParameterLogging
+    include ActionController::Translation
+
+    # TODO: Extract into its own module
+    # This should be moved together with other normalizing behavior
+    module ImplicitRender
+      def send_action(*)
+        ret = super
+        default_render unless response_body
+        ret
+      end
+
+      def default_render
+        render
+      end
+
+      def method_for_action(action_name)
+        super || begin
+          if template_exists?(action_name.to_s, {:formats => formats}, :_prefix => controller_path)
+            "default_render"
+          end
+        end
+      end
+    end
+
+    include ImplicitRender
+
+    include ActionController::Rescue
+
+    def self.inherited(klass)
+      ::ActionController::Base.subclasses << klass.to_s
+      super
+    end
+
+    def self.subclasses
+      @subclasses ||= []
+    end
+
+    def _normalize_options(action = nil, options = {}, &blk)
+      if action.is_a?(Hash)
+        options, action = action, nil
+      elsif action.is_a?(String) || action.is_a?(Symbol)
+        key = case action = action.to_s
+        when %r{^/} then :file
+        when %r{/}  then :template
+        else             :action
+        end
+        options.merge! key => action
+      elsif action
+        options.merge! :partial => action
+      end
+
+      if options.key?(:action) && options[:action].to_s.index("/")
+        options[:template] = options.delete(:action)
+      end
+
+      if options[:status]
+        options[:status] = interpret_status(options[:status]).to_i
+      end
+
+      options[:update] = blk if block_given?
+      options
+    end
+
+    def render(action = nil, options = {}, &blk)
+      options = _normalize_options(action, options, &blk)
+      super(options)
+    end
+
+    def render_to_string(action = nil, options = {}, &blk)
+      options = _normalize_options(action, options, &blk)
+      super(options)
+    end
+
+    # 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
+    #
+    # 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?
+
+      status = if options.is_a?(Hash) && options.key?(:status)
+        interpret_status(options.delete(:status))
+      elsif response_status.key?(:status)
+        interpret_status(response_status[:status])
+      else
+        302
+      end
+
+      url = 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
+
+      super(url, status)
+    end
+  end
+end