actionpack 3.2.19 → 4.0.0

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:
@@ -37,8 +36,7 @@ module ActionController
       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 +56,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.
@@ -114,7 +112,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>
@@ -181,19 +179,13 @@ module ActionController
       @_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
 
     def performed?
-      response_body
+      response_body || (response && response.committed?)
     end
 
     def dispatch(name, request) #:nodoc:
@@ -211,36 +203,29 @@ 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)
     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))

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)
+      (record_or_class.is_a?(Class) ? record_or_class : convert_to_model(record_or_class).class).model_name
+    end
+  end
+end

data/lib/action_controller/railtie.rb

@@ -3,42 +3,58 @@ 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"
 
 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 }
+      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
 
-      # 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
+      options.javascripts_dir ||= paths["public/javascripts"].first
+      options.stylesheets_dir ||= paths["public/stylesheets"].first
+
+      # 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

data/lib/action_controller/record_identifier.rb

@@ -1,85 +1,31 @@
-require 'active_support/core_ext/module'
+require 'action_view/record_identifier'
 
 module ActionController
-  # The record identifier encapsulates a number of naming conventions for dealing with records, like Active Records or
-  # Active Resources or pretty much any other model type that has an id. These patterns are then used to try elevate
-  # the view actions to a higher logical level. Example:
-  #
-  #   # routes
-  #   resources :posts
-  #
-  #   # view
-  #   <%= div_for(post) do %>    <div id="post_45" class="post">
-  #     <%= post.body %>           What a wonderful world!
-  #   <% end %>                  </div>
-  #
-  #   # controller
-  #   def update
-  #     post = Post.find(params[:id])
-  #     post.update_attributes(params[:post])
-  #
-  #     redirect_to(post) # Calls polymorphic_url(post) which in turn calls post_url(post)
-  #   end
-  #
-  # As the example above shows, you can stop caring to a large extent what the actual id of the post is.
-  # You just know that one is being assigned and that the subsequent calls in redirect_to expect that
-  # same naming convention and allows you to write less code if you follow it.
   module RecordIdentifier
-    extend self
+    MODULE_MESSAGE = 'Calling ActionController::RecordIdentifier.%s is deprecated and ' \
+      'will be removed in Rails 4.1, please call using ActionView::RecordIdentifier instead.'
+    INSTANCE_MESSAGE = '%s method will no longer be included by default in controllers ' \
+      'since Rails 4.1. If you would like to use it in controllers, please include ' \
+      'ActionView::RecordIdentifier module.'
 
-    JOIN = '_'.freeze
-    NEW = 'new'.freeze
-
-    # The DOM class convention is to use the singular form of an object or class. Examples:
-    #
-    #   dom_class(post)   # => "post"
-    #   dom_class(Person) # => "person"
-    #
-    # If you need to address multiple instances of the same class in the same view, you can prefix the dom_class:
-    #
-    #   dom_class(post, :edit)   # => "edit_post"
-    #   dom_class(Person, :edit) # => "edit_person"
-    def dom_class(record_or_class, prefix = nil)
-      singular = ActiveModel::Naming.param_key(record_or_class)
-      prefix ? "#{prefix}#{JOIN}#{singular}" : singular
-    end
-
-    # The DOM id convention is to use the singular form of an object or class with the id following an underscore.
-    # If no id is found, prefix with "new_" instead. Examples:
-    #
-    #   dom_id(Post.find(45))       # => "post_45"
-    #   dom_id(Post.new)            # => "new_post"
-    #
-    # If you need to address multiple instances of the same class in the same view, you can prefix the dom_id:
-    #
-    #   dom_id(Post.find(45), :edit) # => "edit_post_45"
     def dom_id(record, prefix = nil)
-      if record_id = record_key_for_dom_id(record)
-        "#{dom_class(record, prefix)}#{JOIN}#{record_id}"
-      else
-        dom_class(record, prefix || NEW)
-      end
+      ActiveSupport::Deprecation.warn(INSTANCE_MESSAGE % 'dom_id')
+      ActionView::RecordIdentifier.dom_id(record, prefix)
     end
 
-  protected
+    def dom_class(record, prefix = nil)
+      ActiveSupport::Deprecation.warn(INSTANCE_MESSAGE % 'dom_class')
+      ActionView::RecordIdentifier.dom_class(record, prefix)
+    end
 
-    # Returns a string representation of the key attribute(s) that is suitable for use in an HTML DOM id.
-    # This can be overwritten to customize the default generated string representation if desired.
-    # If you need to read back a key from a dom_id in order to query for the underlying database record,
-    # you should write a helper like 'person_record_from_dom_id' that will extract the key either based
-    # on the default implementation (which just joins all key attributes with '_') or on your own
-    # overwritten version of the method. By default, this implementation passes the key string through a
-    # method that replaces all characters that are invalid inside DOM ids, with valid ones. You need to
-    # make sure yourself that your dom ids are valid, in case you overwrite this method.
-    def record_key_for_dom_id(record)
-      record = record.to_model if record.respond_to?(:to_model)
-      key = record.to_key
-      key ? sanitize_dom_id(key.join('_')) : key
+    def self.dom_id(record, prefix = nil)
+      ActiveSupport::Deprecation.warn(MODULE_MESSAGE % 'dom_id')
+      ActionView::RecordIdentifier.dom_id(record, prefix)
     end
 
-    # Replaces characters that are invalid in HTML DOM ids with valid ones.
-    def sanitize_dom_id(candidate_id)
-      candidate_id # TODO implement conversion to valid DOM id values
+    def self.dom_class(record, prefix = nil)
+      ActiveSupport::Deprecation.warn(MODULE_MESSAGE % 'dom_class')
+      ActionView::RecordIdentifier.dom_class(record, prefix)
     end
   end
 end