actionpack 3.2.22.5 → 4.0.0.beta1

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2011 David Heinemeier Hansson
+Copyright (c) 2004-2013 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -10,7 +10,7 @@ It consists of several modules:
 
 * Action Dispatch, which parses information about the web request, handles
   routing as defined by the user, and does advanced processing related to HTTP
-  such as MIME-type negotiation, decoding parameters in POST/PUT bodies,
+  such as MIME-type negotiation, decoding parameters in POST, PATCH, or PUT bodies,
   handling HTTP caching logic, cookies and sessions.
 
 * Action Controller, which provides a base controller class that can be
@@ -28,291 +28,6 @@ by default and Action View rendering is implicitly triggered by Action
 Controller. However, these modules are designed to function on their own and
 can be used outside of Rails.
 
-A short rundown of some of the major features:
-
-* Actions grouped in controller as methods instead of separate command objects
-  and can therefore share helper methods
-
-    class CustomersController < ActionController::Base
-      def show
-        @customer = find_customer
-      end
-
-      def update
-        @customer = find_customer
-        if @customer.update_attributes(params[:customer])
-          redirect_to :action => "show"
-        else
-          render :action => "edit"
-        end
-      end
-
-      private
-        def find_customer
-          Customer.find params[:id]
-        end
-    end
-
-  {Learn more}[link:classes/ActionController/Base.html]
-
-
-* ERB templates (static content mixed with dynamic output from ruby)
-
-    <% @posts.each do |post| %>
-      Title: <%= post.title %>
-    <% end %>
-
-    All post titles: <%= @posts.collect{ |p| p.title }.join(", ") %>
-
-    <% unless @person.is_client? %>
-      Not for clients to see...
-    <% end %>
-
-  {Learn more}[link:classes/ActionView.html]
-
-
-* "Builder" templates (great for XML content, like RSS)
-
-    xml.rss("version" => "2.0") do
-      xml.channel do
-        xml.title(@feed_title)
-        xml.link(@url)
-        xml.description "Basecamp: Recent items"
-        xml.language "en-us"
-        xml.ttl "40"
-
-        @recent_items.each do |item|
-          xml.item do
-            xml.title(item_title(item))
-            xml.description(item_description(item))
-            xml.pubDate(item_pubDate(item))
-            xml.guid(@recent_items.url(item))
-            xml.link(@recent_items.url(item))
-          end
-        end
-      end
-    end
-
-  {Learn more}[link:classes/ActionView/Base.html]
-
-
-* Filters for pre- and post-processing of the response
-
-    class WeblogController < ActionController::Base
-      # filters as methods
-      before_filter :authenticate, :cache, :audit
-
-      # filter as a proc
-      after_filter { |c| c.response.body = Gzip::compress(c.response.body) }
-
-      # class filter
-      after_filter LocalizeFilter
-
-      def index
-        # Before this action is run, the user will be authenticated, the cache
-        # will be examined to see if a valid copy of the results already
-        # exists, and the action will be logged for auditing.
-
-        # After this action has run, the output will first be localized then
-        # compressed to minimize bandwidth usage
-      end
-
-      private
-        def authenticate
-          # Implement the filter with full access to both request and response
-        end
-    end
-
-  {Learn more}[link:classes/ActionController/Filters/ClassMethods.html]
-
-
-* Helpers for forms, dates, action links, and text
-
-    <%= text_field_tag "post", "title", "size" => 30 %>
-    <%= link_to "New post", :controller => "post", :action => "new" %>
-    <%= truncate(post.title, :length => 25) %>
-
-  {Learn more}[link:classes/ActionView/Helpers.html]
-
-
-* Layout sharing for template reuse
-
-    class WeblogController < ActionController::Base
-      layout "weblog_layout"
-
-      def hello_world
-      end
-    end
-
-    Layout file (called weblog_layout):
-      <html><body><%= yield %></body></html>
-
-    Template for hello_world action:
-      <h1>Hello world</h1>
-
-    Result of running hello_world action:
-      <html><body><h1>Hello world</h1></body></html>
-
-  {Learn more}[link:classes/ActionController/Layout/ClassMethods.html]
-
-
-* Routing makes pretty URLs incredibly easy
-
-    match 'clients/:client_name/:project_name/:controller/:action'
-
-    Accessing "/clients/37signals/basecamp/project/index" calls ProjectController#index with
-    { "client_name" => "37signals", "project_name" => "basecamp" } in `params`
-
-    From that action, you can write the redirect in a number of ways:
-
-    redirect_to(:action => "edit") =>
-      /clients/37signals/basecamp/project/edit
-
-    redirect_to(:client_name => "nextangle", :project_name => "rails") =>
-      /clients/nextangle/rails/project/index
-
-  {Learn more}[link:classes/ActionDispatch/Routing.html]
-
-
-* Easy testing of both controller and rendered template through ActionController::TestCase
-
-    class LoginControllerTest < ActionController::TestCase
-      def test_failing_authenticate
-        process :authenticate, :user_name => "nop", :password => ""
-        assert flash.has_key?(:alert)
-        assert_redirected_to :action => "index"
-      end
-    end
-
-  {Learn more}[link:classes/ActionController/TestCase.html]
-
-
-* Automated benchmarking and integrated logging
-
-    Started GET "/weblog" for 127.0.0.1 at Fri May 28 00:41:55
-      Processing by WeblogController#index as HTML
-    Rendered weblog/index.html.erb within layouts/application (25.7ms)
-    Completed 200 OK in 29.3ms
-
-    If Active Record is used as the model, you'll have the database debugging
-    as well:
-
-    Started POST "/posts" for 127.0.0.1 at Sat Jun 19 14:04:23
-      Processing by PostsController#create as HTML
-      Parameters: {"post"=>{"title"=>"this is good"}}
-    SQL (0.6ms) INSERT INTO posts (title) VALUES('this is good')
-    Redirected to http://example.com/posts/5
-    Completed 302 Found in 221ms (Views: 215ms | ActiveRecord: 0.6ms)
-
-    You specify a logger through a class method, such as:
-
-    ActionController::Base.logger = Logger.new("Application Log")
-    ActionController::Base.logger = Log4r::Logger.new("Application Log")
-
-
-* Caching at three levels of granularity (page, action, fragment)
-
-    class WeblogController < ActionController::Base
-      caches_page :show
-      caches_action :account
-
-      def show
-        # the output of the method will be cached as
-        # ActionController::Base.page_cache_directory + "/weblog/show.html"
-        # and the web server will pick it up without even hitting Rails
-      end
-
-      def account
-        # the output of the method will be cached in the fragment store
-        # but Rails is hit to retrieve it, so filters are run
-      end
-
-      def update
-        List.update(params[:list][:id], params[:list])
-        expire_page   :action => "show", :id => params[:list][:id]
-        expire_action :action => "account"
-        redirect_to   :action => "show", :id => params[:list][:id]
-      end
-    end
-
-  {Learn more}[link:classes/ActionController/Caching.html]
-
-
-* Powerful debugging mechanism for local requests
-
-    All exceptions raised on actions performed on the request of a local user
-    will be presented with a tailored debugging screen that includes exception
-    message, stack trace, request parameters, session contents, and the
-    half-finished response.
-
-  {Learn more}[link:classes/ActionController/Rescue.html]
-
-
-== Simple example (from outside of Rails)
-
-This example will implement a simple weblog system using inline templates and
-an Active Record model. So let's build that WeblogController with just a few
-methods:
-
-  require 'action_controller'
-  require 'post'
-
-  class WeblogController < ActionController::Base
-    layout "weblog/layout"
-
-    def index
-      @posts = Post.all
-    end
-
-    def show
-      @post = Post.find(params[:id])
-    end
-
-    def new
-      @post = Post.new
-    end
-
-    def create
-      @post = Post.create(params[:post])
-      redirect_to :action => "show", :id => @post.id
-    end
-  end
-
-  WeblogController::Base.view_paths = [ File.dirname(__FILE__) ]
-  WeblogController.process_cgi if $0 == __FILE__
-
-The last two lines are responsible for telling ActionController where the
-template files are located and actually running the controller on a new
-request from the web-server (e.g., Apache).
-
-And the templates look like this:
-
-  weblog/layout.html.erb:
-    <html><body>
-    <%= yield %>
-    </body></html>
-
-  weblog/index.html.erb:
-    <% @posts.each do |post| %>
-      <p><%= link_to(post.title, :action => "show", :id => post.id) %></p>
-    <% end %>
-
-  weblog/show.html.erb:
-    <p>
-      <b><%= @post.title %></b><br/>
-      <b><%= @post.content %></b>
-    </p>
-
-  weblog/new.html.erb:
-    <%= form "post" %>
-
-This simple setup will list all the posts in the system on the index page,
-which is called by accessing /weblog/. It uses the form builder for the Active
-Record model to make the new screen, which in turn hands everything over to
-the create action (that's the default target for the form builder when given a
-new model). After creating the post, it'll redirect to the show page using
-an URL such as /weblog/5 (where 5 is the id of the post).
-
 
 == Download and installation
 
@@ -322,12 +37,14 @@ The latest version of Action Pack can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub
 
-* https://github.com/rails/rails/tree/3-2-stable/actionpack
+* https://github.com/rails/rails/tree/master/actionpack
 
 
 == License
 
-Action Pack is released under the MIT license.
+Action Pack is released under the MIT license:
+
+* http://www.opensource.org/licenses/MIT
 
 
 == Support

data/lib/abstract_controller.rb

@@ -1,13 +1,6 @@
-activesupport_path = File.expand_path('../../../activesupport/lib', __FILE__)
-$:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
-
 require 'action_pack'
-require 'active_support/concern'
-require 'active_support/ruby/shim'
-require 'active_support/dependencies/autoload'
-require 'active_support/core_ext/class/attribute'
+require 'active_support/rails'
 require 'active_support/core_ext/module/attr_internal'
-require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/module/anonymous'
 require 'active_support/i18n'
 

data/lib/abstract_controller/asset_paths.rb

@@ -1,9 +1,9 @@
 module AbstractController
-  module AssetPaths
+  module AssetPaths #:nodoc:
     extend ActiveSupport::Concern
 
     included do
-      config_accessor :asset_host, :asset_path, :assets_dir, :javascripts_dir,
+      config_accessor :asset_host, :assets_dir, :javascripts_dir,
         :stylesheets_dir, :default_asset_host_protocol, :relative_url_root
     end
   end

data/lib/abstract_controller/base.rb

@@ -1,11 +1,15 @@
 require 'erubis'
+require 'set'
 require 'active_support/configurable'
 require 'active_support/descendants_tracker'
 require 'active_support/core_ext/module/anonymous'
 
 module AbstractController
-  class Error < StandardError; end
-  class ActionNotFound < StandardError; end
+  class Error < StandardError #:nodoc:
+  end
+
+  class ActionNotFound < StandardError #:nodoc:
+  end
 
   # <tt>AbstractController::Base</tt> is a low-level API. Nobody should be
   # using it directly, and subclasses (like ActionController::Base) are
@@ -30,6 +34,15 @@ module AbstractController
         @abstract = true
       end
 
+      def inherited(klass) # :nodoc:
+        # define the abstract ivar on subclasses so that we don't get
+        # uninitialized ivar warnings
+        unless klass.instance_variable_defined?(:@abstract)
+          klass.instance_variable_set(:@abstract, false)
+        end
+        super
+      end
+
       # A list of all internal methods for a controller. This finds the first
       # abstract superclass of a controller, and gets a list of all public
       # instance methods on that abstract class. Public instance methods of
@@ -38,16 +51,17 @@ module AbstractController
       # (ActionController::Metal and ActionController::Base are defined as abstract)
       def internal_methods
         controller = self
+
         controller = controller.superclass until controller.abstract?
         controller.public_instance_methods(true)
       end
 
-      # The list of hidden actions to an empty array. Defaults to an
-      # empty array. This can be modified by other modules or subclasses
+      # The list of hidden actions. Defaults to an empty array.
+      # This can be modified by other modules or subclasses
       # to specify particular actions as hidden.
       #
       # ==== Returns
-      # * <tt>array</tt> - An array of method names that should not be considered actions.
+      # * <tt>Array</tt> - An array of method names that should not be considered actions.
       def hidden_actions
         []
       end
@@ -59,7 +73,7 @@ module AbstractController
       # itself. Finally, #hidden_actions are removed.
       #
       # ==== Returns
-      # * <tt>array</tt> - A list of all methods that should be considered actions.
+      # * <tt>Set</tt> - A set of all methods that should be considered actions.
       def action_methods
         @action_methods ||= begin
           # All public instance methods of this class, including ancestors
@@ -72,7 +86,7 @@ module AbstractController
             hidden_actions.to_a
 
           # Clear out AS callback method pollution
-          methods.reject { |method| method =~ /_one_time_conditions/ }
+          Set.new(methods.reject { |method| method =~ /_one_time_conditions/ })
         end
       end
 
@@ -85,14 +99,15 @@ module AbstractController
 
       # Returns the full controller name, underscored, without the ending Controller.
       # For instance, MyApp::MyPostsController would return "my_app/my_posts" for
-      # controller_name.
+      # controller_path.
       #
       # ==== Returns
-      # * <tt>string</tt>
+      # * <tt>String</tt>
       def controller_path
         @controller_path ||= name.sub(/Controller$/, '').underscore unless anonymous?
       end
 
+      # Refresh the cached action_methods when a new action_method is added.
       def method_added(name)
         super
         clear_action_methods!
@@ -112,7 +127,7 @@ module AbstractController
     def process(action, *args)
       @_action_name = action_name = action.to_s
 
-      unless action_name = _find_action_name(action_name)
+      unless action_name = method_for_action(action_name)
         raise ActionNotFound, "The action '#{action}' could not be found for #{self.class.name}"
       end
 
@@ -126,6 +141,7 @@ module AbstractController
       self.class.controller_path
     end
 
+    # Delegates to the class' #action_methods
     def action_methods
       self.class.action_methods
     end
@@ -135,10 +151,16 @@ module AbstractController
     #
     # Notice that <tt>action_methods.include?("foo")</tt> may return
     # false and <tt>available_action?("foo")</tt> returns true because
-    # available action consider actions that are also available
+    # this method considers actions that are also available
     # through other means, for example, implicit render ones.
+    #
+    # ==== Parameters
+    # * <tt>action_name</tt> - The name of an action to be tested
+    #
+    # ==== Returns
+    # * <tt>TrueClass</tt>, <tt>FalseClass</tt>
     def available_action?(action_name)
-      _find_action_name(action_name).present?
+      method_for_action(action_name).present?
     end
 
     private
@@ -181,23 +203,6 @@ module AbstractController
         action_missing(@_action_name, *args)
       end
 
-      # Takes an action name and returns the name of the method that will
-      # handle the action.
-      #
-      # It checks if the action name is valid and returns false otherwise.
-      #
-      # See method_for_action for more information.
-      #
-      # ==== Parameters
-      # * <tt>action_name</tt> - An action name to find a method name for
-      #
-      # ==== Returns
-      # * <tt>string</tt> - The name of the method that handles the action
-      # * false           - No valid method name could be found. Raise ActionNotFound.
-      def _find_action_name(action_name)
-        _valid_action_name?(action_name) && method_for_action(action_name)
-      end
-
       # Takes an action name and returns the name of the method that will
       # handle the action. In normal cases, this method returns the same
       # name as it receives. By default, if #method_for_action receives
@@ -220,16 +225,13 @@ module AbstractController
       #
       # ==== Returns
       # * <tt>string</tt> - The name of the method that handles the action
-      # * <tt>nil</tt>    - No method name could be found.
+      # * <tt>nil</tt>    - No method name could be found. Raise ActionNotFound.
       def method_for_action(action_name)
-        if action_method?(action_name) then action_name
-        elsif respond_to?(:action_missing, true) then "_handle_action_missing"
+        if action_method?(action_name)
+          action_name
+        elsif respond_to?(:action_missing, true)
+          "_handle_action_missing"
         end
       end
-
-      # Checks if the action name is valid and returns false otherwise.
-      def _valid_action_name?(action_name)
-        action_name.to_s !~ Regexp.new(File::SEPARATOR)
-      end
   end
 end