actionpack 3.2.19 → 4.2.11.3

data/lib/action_controller/metal/url_for.rb

@@ -1,47 +1,49 @@
-# Includes +url_for+ into the host class. The class has to provide a +RouteSet+ by implementing 
-# the <tt>_routes</tt> method. Otherwise, an exception will be raised.
-#
-# In addition to <tt>AbstractController::UrlFor</tt>, this module accesses the HTTP layer to define 
-# url options like the +host+. In order to do so, this module requires the host class
-# to implement +env+ and +request+, which need to be a Rack-compatible.
-#
-# Example:
-#
-#   class RootUrl
-#     include ActionController::UrlFor
-#     include Rails.application.routes.url_helpers
-#
-#     delegate :env, :request, :to => :controller
-#
-#     def initialize(controller)
-#       @controller = controller
-#       @url        = root_path # named route from the application.
-#     end
-#   end
-# 
 module ActionController
+  # Includes +url_for+ into the host class. The class has to provide a +RouteSet+ by implementing
+  # the <tt>_routes</tt> method. Otherwise, an exception will be raised.
+  #
+  # In addition to <tt>AbstractController::UrlFor</tt>, this module accesses the HTTP layer to define
+  # url options like the +host+. In order to do so, this module requires the host class
+  # to implement +env+ and +request+, which need to be a Rack-compatible.
+  #
+  #   class RootUrl
+  #     include ActionController::UrlFor
+  #     include Rails.application.routes.url_helpers
+  #
+  #     delegate :env, :request, to: :controller
+  #
+  #     def initialize(controller)
+  #       @controller = controller
+  #       @url        = root_path # named route from the application.
+  #     end
+  #   end
   module UrlFor
     extend ActiveSupport::Concern
 
     include AbstractController::UrlFor
 
     def url_options
-      @_url_options ||= super.reverse_merge(
+      @_url_options ||= {
         :host => request.host,
         :port => request.optional_port,
         :protocol => request.protocol,
-        :_path_segments => request.symbolized_path_parameters
-      ).freeze
+        :_recall => request.path_parameters
+      }.merge!(super).freeze
 
-      if _routes.equal?(env["action_dispatch.routes"])
-        @_url_options.dup.tap do |options|
-          options[:script_name] = request.script_name.dup
-          options.freeze
+      if (same_origin = _routes.equal?(env["action_dispatch.routes".freeze])) ||
+         (script_name = env["ROUTES_#{_routes.object_id}_SCRIPT_NAME"]) ||
+         (original_script_name = env['ORIGINAL_SCRIPT_NAME'.freeze])
+
+        options = @_url_options.dup
+        if original_script_name
+          options[:original_script_name] = original_script_name
+        else
+          options[:script_name] = same_origin ? request.script_name.dup : script_name
         end
+        options.freeze
       else
         @_url_options
       end
     end
-
   end
 end

data/lib/action_controller/metal.rb

@@ -1,5 +1,4 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/array/extract_options'
 require 'action_dispatch/middleware/stack'
 
 module ActionController
@@ -7,7 +6,7 @@ module ActionController
   # allowing the following syntax in controllers:
   #
   #   class PostsController < ApplicationController
-  #     use AuthenticationMiddleware, :except => [:index, :show]
+  #     use AuthenticationMiddleware, except: [:index, :show]
   #   end
   #
   class MiddlewareStack < ActionDispatch::MiddlewareStack #:nodoc:
@@ -31,14 +30,11 @@ module ActionController
       end
     end
 
-    def build(action, app=nil, &block)
-      app  ||= block
+    def build(action, app = Proc.new)
       action = action.to_s
-      raise "MiddlewareStack#build requires an app" unless app
 
       middlewares.reverse.inject(app) do |a, middleware|
-        middleware.valid?(action) ?
-          middleware.build(a) : a
+        middleware.valid?(action) ? middleware.build(a) : a
       end
     end
   end
@@ -58,7 +54,7 @@ module ActionController
   # And then to route requests to your metal controller, you would add
   # something like this to <tt>config/routes.rb</tt>:
   #
-  #   match 'hello', :to => HelloController.action(:index)
+  #   get 'hello', to: HelloController.action(:index)
   #
   # The +action+ method returns a valid Rack application for the \Rails
   # router to dispatch to.
@@ -72,7 +68,8 @@ module ActionController
   # can do the following:
   #
   #   class HelloController < ActionController::Metal
-  #     include ActionController::Rendering
+  #     include AbstractController::Rendering
+  #     include ActionView::Layouts
   #     append_view_path "#{Rails.root}/app/views"
   #
   #     def index
@@ -114,7 +111,7 @@ module ActionController
     # ==== Returns
     # * <tt>string</tt>
     def self.controller_name
-      @controller_name ||= self.name.demodulize.sub(/Controller$/, '').underscore
+      @controller_name ||= name.demodulize.sub(/Controller$/, '').underscore
     end
 
     # Delegates to the class' <tt>controller_name</tt>
@@ -168,7 +165,7 @@ module ActionController
       headers["Location"] = url
     end
 
-    # basic url_for that can be overridden for more robust functionality
+    # Basic url_for that can be overridden for more robust functionality
     def url_for(string)
       string
     end
@@ -176,24 +173,20 @@ module ActionController
     def status
       @_status
     end
+    alias :response_code :status # :nodoc:
 
     def status=(status)
       @_status = Rack::Utils.status_code(status)
     end
 
-    def response_body=(val)
-      body = if val.is_a?(String)
-        [val]
-      elsif val.nil? || val.respond_to?(:each)
-        val
-      else
-        [val]
-      end
-      super body
+    def response_body=(body)
+      body = [body] unless body.nil? || body.respond_to?(:each)
+      super
     end
 
+    # Tests if render or redirect has already happened.
     def performed?
-      response_body
+      response_body || (response && response.committed?)
     end
 
     def dispatch(name, request) #:nodoc:
@@ -211,39 +204,37 @@ module ActionController
     class_attribute :middleware_stack
     self.middleware_stack = ActionController::MiddlewareStack.new
 
-    def self.inherited(base) #nodoc:
-      base.middleware_stack = self.middleware_stack.dup
+    def self.inherited(base) # :nodoc:
+      base.middleware_stack = middleware_stack.dup
       super
     end
 
-    # Adds given middleware class and its args to bottom of middleware_stack
+    # Pushes the given Rack middleware and its arguments to the bottom of the
+    # middleware stack.
     def self.use(*args, &block)
       middleware_stack.use(*args, &block)
     end
 
-    # Alias for middleware_stack
+    # Alias for +middleware_stack+.
     def self.middleware
       middleware_stack
     end
 
-    # Makes the controller a rack endpoint that points to the action in
-    # the given env's action_dispatch.request.path_parameters key.
+    # Makes the controller a Rack endpoint that runs the action in the given
+    # +env+'s +action_dispatch.request.path_parameters+ key.
     def self.call(env)
-      action(env['action_dispatch.request.path_parameters'][:action]).call(env)
+      req = ActionDispatch::Request.new env
+      action(req.path_parameters[:action]).call(env)
     end
 
-    # Return a rack endpoint for the given action. Memoize the endpoint, so
-    # multiple calls into MyController.action will return the same object
-    # for the same action.
-    #
-    # ==== Parameters
-    # * <tt>action</tt> - An action name
-    #
-    # ==== Returns
-    # * <tt>proc</tt> - A rack application
+    # Returns a Rack endpoint for the given action name.
     def self.action(name, klass = ActionDispatch::Request)
-      middleware_stack.build(name.to_s) do |env|
-        new.dispatch(name, klass.new(env))
+      if middleware_stack.any?
+        middleware_stack.build(name) do |env|
+          new.dispatch(name, klass.new(env))
+        end
+      else
+        lambda { |env| new.dispatch(name, klass.new(env)) }
       end
     end
   end

data/lib/action_controller/model_naming.rb

@@ -0,0 +1,12 @@
+module ActionController
+  module ModelNaming
+    # Converts the given object to an ActiveModel compliant one.
+    def convert_to_model(object)
+      object.respond_to?(:to_model) ? object.to_model : object
+    end
+
+    def model_name_from_record_or_class(record_or_class)
+      convert_to_model(record_or_class).model_name
+    end
+  end
+end

data/lib/action_controller/railtie.rb

@@ -1,44 +1,64 @@
 require "rails"
 require "action_controller"
 require "action_dispatch/railtie"
-require "action_view/railtie"
 require "abstract_controller/railties/routes_helpers"
-require "action_controller/railties/paths"
+require "action_controller/railties/helpers"
+require "action_view/railtie"
 
 module ActionController
-  class Railtie < Rails::Railtie
+  class Railtie < Rails::Railtie #:nodoc:
     config.action_controller = ActiveSupport::OrderedOptions.new
 
-    initializer "action_controller.logger" do
-      ActiveSupport.on_load(:action_controller) { self.logger ||= Rails.logger }
+    config.eager_load_namespaces << ActionController
+
+    initializer "action_controller.assets_config", :group => :all do |app|
+      app.config.action_controller.assets_dir ||= app.config.paths["public"].first
     end
 
-    initializer "action_controller.initialize_framework_caches" do
-      ActiveSupport.on_load(:action_controller) { self.cache_store ||= RAILS_CACHE }
+    initializer "action_controller.set_helpers_path" do |app|
+      ActionController::Helpers.helpers_path = app.helpers_paths
     end
 
-    initializer "action_controller.assets_config", :group => :all do |app|
-      app.config.action_controller.assets_dir ||= app.config.paths["public"].first
+    initializer "action_controller.parameters_config" do |app|
+      options = app.config.action_controller
+
+      ActionController::Parameters.permit_all_parameters = options.delete(:permit_all_parameters) { false }
+      if app.config.action_controller[:always_permitted_parameters]
+        ActionController::Parameters.always_permitted_parameters =
+          app.config.action_controller.delete(:always_permitted_parameters)
+      end
+      ActionController::Parameters.action_on_unpermitted_parameters = options.delete(:action_on_unpermitted_parameters) do
+        (Rails.env.test? || Rails.env.development?) ? :log : false
+      end
     end
 
     initializer "action_controller.set_configs" do |app|
       paths   = app.config.paths
       options = app.config.action_controller
 
-      options.javascripts_dir      ||= paths["public/javascripts"].first
-      options.stylesheets_dir      ||= paths["public/stylesheets"].first
-      options.page_cache_directory ||= paths["public"].first
+      options.logger      ||= Rails.logger
+      options.cache_store ||= Rails.cache
+
+      options.javascripts_dir ||= paths["public/javascripts"].first
+      options.stylesheets_dir ||= paths["public/stylesheets"].first
 
-      # make sure readers methods get compiled
-      options.asset_path           ||= app.config.asset_path
-      options.asset_host           ||= app.config.asset_host
-      options.relative_url_root    ||= app.config.relative_url_root
+      # Ensure readers methods get compiled
+      options.asset_host        ||= app.config.asset_host
+      options.relative_url_root ||= app.config.relative_url_root
 
       ActiveSupport.on_load(:action_controller) do
         include app.routes.mounted_helpers
         extend ::AbstractController::Railties::RoutesHelpers.with(app.routes)
-        extend ::ActionController::Railties::Paths.with(app)
-        options.each { |k,v| send("#{k}=", v) }
+        extend ::ActionController::Railties::Helpers
+
+        options.each do |k,v|
+          k = "#{k}="
+          if respond_to?(k)
+            send(k, v)
+          elsif !Base.respond_to?(k)
+            raise "Invalid option key: #{k}"
+          end
+        end
       end
     end
 

data/lib/action_controller/railties/helpers.rb

@@ -0,0 +1,22 @@
+module ActionController
+  module Railties
+    module Helpers
+      def inherited(klass)
+        super
+        return unless klass.respond_to?(:helpers_path=)
+
+        if namespace = klass.parents.detect { |m| m.respond_to?(:railtie_helpers_paths) }
+          paths = namespace.railtie_helpers_paths
+        else
+          paths = ActionController::Helpers.helpers_path
+        end
+
+        klass.helpers_path = paths
+
+        if klass.superclass == ActionController::Base && ActionController::Base.include_all_helpers
+          klass.helper :all
+        end
+      end
+    end
+  end
+end