actionpack 3.0.0.beta → 3.0.0.beta2

data/lib/action_controller/middleware.rb

@@ -6,7 +6,8 @@ module ActionController
       end
 
       def call(env)
-        @controller.build(@app).dispatch(:index, env)
+        request = ActionDispatch::Request.new(env)
+        @controller.build(@app).dispatch(:index, request)
       end
     end
 

data/lib/action_controller/polymorphic_routes.rb

@@ -92,8 +92,7 @@ module ActionController
       inflection = if options[:action].to_s == "new"
         args.pop
         :singular
-      elsif (record.respond_to?(:new_record?) && record.new_record?) ||
-            (record.respond_to?(:destroyed?) && record.destroyed?)
+      elsif (record.respond_to?(:persisted?) && !record.persisted?)
         args.pop
         :plural
       elsif record.is_a?(Class)

data/lib/action_controller/railtie.rb

@@ -1,30 +1,83 @@
-require "action_controller"
 require "rails"
+require "action_controller"
+require "action_dispatch/railtie"
 require "action_view/railtie"
+require "active_support/core_ext/class/subclasses"
+require "active_support/deprecation/proxy_wrappers"
+require "active_support/deprecation"
+
+require "action_controller/railties/log_subscriber"
+require "action_controller/railties/url_helpers"
 
 module ActionController
   class Railtie < Rails::Railtie
-    railtie_name :action_controller
+    config.action_controller = ActiveSupport::OrderedOptions.new
+
+    ad = config.action_dispatch
+    config.action_controller.singleton_class.send(:define_method, :session) do
+      ActiveSupport::Deprecation.warn "config.action_controller.session has been " \
+        "renamed to config.action_dispatch.session.", caller
+      ad.session
+    end
 
-    require "action_controller/railties/subscriber"
-    subscriber ActionController::Railties::Subscriber.new
+    config.action_controller.singleton_class.send(:define_method, :session=) do |val|
+      ActiveSupport::Deprecation.warn "config.action_controller.session has been " \
+        "renamed to config.action_dispatch.session.", caller
+      ad.session = val
+    end
+
+    config.action_controller.singleton_class.send(:define_method, :session_store) do
+      ActiveSupport::Deprecation.warn "config.action_controller.session_store has been " \
+        "renamed to config.action_dispatch.session_store.", caller
+      ad.session_store
+    end
+
+    config.action_controller.singleton_class.send(:define_method, :session_store=) do |val|
+      ActiveSupport::Deprecation.warn "config.action_controller.session_store has been " \
+        "renamed to config.action_dispatch.session_store.", caller
+      ad.session_store = val
+    end
+
+    log_subscriber :action_controller, ActionController::Railties::LogSubscriber.new
 
     initializer "action_controller.logger" do
-      ActionController::Base.logger ||= Rails.logger
+      ActiveSupport.on_load(:action_controller) { self.logger ||= Rails.logger }
     end
 
     initializer "action_controller.set_configs" do |app|
-      app.config.action_controller.each do |k,v|
-        ActionController::Base.send "#{k}=", v
+      paths = app.config.paths
+      ac = app.config.action_controller
+
+      ac.assets_dir      = paths.public.to_a.first
+      ac.javascripts_dir = paths.public.javascripts.to_a.first
+      ac.stylesheets_dir = paths.public.stylesheets.to_a.first
+      ac.secret          = app.config.cookie_secret
+
+      ActiveSupport.on_load(:action_controller) do
+        self.config.merge!(ac)
       end
     end
 
     initializer "action_controller.initialize_framework_caches" do
-      ActionController::Base.cache_store ||= RAILS_CACHE
+      ActiveSupport.on_load(:action_controller) { self.cache_store ||= RAILS_CACHE }
     end
 
     initializer "action_controller.set_helpers_path" do |app|
-      ActionController::Base.helpers_path = app.config.paths.app.helpers.to_a
+      ActiveSupport.on_load(:action_controller) do
+        self.helpers_path = app.config.paths.app.helpers.to_a
+      end
+    end
+
+    initializer "action_controller.url_helpers" do |app|
+      ActiveSupport.on_load(:action_controller) do
+        extend ::ActionController::Railties::UrlHelpers.with(app.routes)
+      end
+
+      message = "ActionController::Routing::Routes is deprecated. " \
+                "Instead, use Rails.application.routes"
+
+      proxy = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(app.routes, message)
+      ActionController::Routing::Routes = proxy
     end
   end
-end
+end

data/lib/action_controller/railties/{subscriber.rb → log_subscriber.rb}

@@ -1,6 +1,8 @@
+require 'active_support/core_ext/object/blank'
+
 module ActionController
   module Railties
-    class Subscriber < Rails::Subscriber
+    class LogSubscriber < Rails::LogSubscriber
       INTERNAL_PARAMS = %w(controller action format _method only_path)
 
       def start_processing(event)
@@ -15,23 +17,14 @@ module ActionController
         payload   = event.payload
         additions = ActionController::Base.log_process_action(payload)
 
-        message = "Completed in %.0fms" % event.duration
+        message = "Completed #{payload[:status]} #{Rack::Utils::HTTP_STATUS_CODES[payload[:status]]} in %.0fms" % event.duration
         message << " (#{additions.join(" | ")})" unless additions.blank?
-        message << " with #{payload[:status]}"
 
         info(message)
       end
 
       def send_file(event)
-        message = if event.payload[:x_sendfile]
-          header = ActionController::Streaming::X_SENDFILE_HEADER
-          "Sent #{header} header %s"
-        elsif event.payload[:stream]
-          "Streamed file %s"
-        else
-          "Sent file %s"
-        end
-
+        message = "Sent file %s"
         message << " (%.1fms)"
         info(message % [event.payload[:path], event.duration])
       end

data/lib/action_controller/railties/url_helpers.rb

@@ -0,0 +1,14 @@
+module ActionController
+  module Railties
+    module UrlHelpers
+      def self.with(routes)
+        Module.new do
+          define_method(:inherited) do |klass|
+            super(klass)
+            klass.send(:include, routes.url_helpers)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_controller/record_identifier.rb

@@ -60,13 +60,32 @@ module ActionController
     #
     #   dom_id(Post.find(45), :edit) # => "edit_post_45"
     def dom_id(record, prefix = nil) 
-      if record_id = record.id
+      if record_id = record_key_for_dom_id(record)
         "#{dom_class(record, prefix)}#{JOIN}#{record_id}"
       else
         dom_class(record, prefix || NEW)
       end
     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
+    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
+    end
+
     # Returns the plural class name of a record or class. Examples:
     #
     #   plural_class_name(post)             # => "posts"

data/lib/action_controller/test_case.rb

@@ -1,7 +1,108 @@
 require 'rack/session/abstract/id'
-require 'action_view/test_case'
+require 'active_support/core_ext/object/blank'
 
 module ActionController
+  module TemplateAssertions
+    extend ActiveSupport::Concern
+
+    included do
+      setup :setup_subscriptions
+      teardown :teardown_subscriptions
+    end
+
+    def setup_subscriptions
+      @partials = Hash.new(0)
+      @templates = Hash.new(0)
+      @layouts = Hash.new(0)
+
+      ActiveSupport::Notifications.subscribe("action_view.render_template") do |name, start, finish, id, payload|
+        path = payload[:layout]
+        @layouts[path] += 1
+      end
+
+      ActiveSupport::Notifications.subscribe("action_view.render_template!") do |name, start, finish, id, payload|
+        path = payload[:virtual_path]
+        next unless path
+        partial = path =~ /^.*\/_[^\/]*$/
+        if partial
+          @partials[path] += 1
+          @partials[path.split("/").last] += 1
+          @templates[path] += 1
+        else
+          @templates[path] += 1
+        end
+      end
+    end
+
+    def teardown_subscriptions
+      ActiveSupport::Notifications.unsubscribe("action_view.render_template!")
+    end
+
+    # Asserts that the request was rendered with the appropriate template file or partials
+    #
+    # ==== Examples
+    #
+    #   # assert that the "new" view template was rendered
+    #   assert_template "new"
+    #
+    #   # assert that the "_customer" partial was rendered twice
+    #   assert_template :partial => '_customer', :count => 2
+    #
+    #   # assert that no partials were rendered
+    #   assert_template :partial => false
+    #
+    def assert_template(options = {}, message = nil)
+      validate_request!
+
+      case options
+      when NilClass, String
+        rendered = @templates
+        msg = build_message(message,
+                "expecting <?> but rendering with <?>",
+                options, rendered.keys.join(', '))
+        assert_block(msg) do
+          if options.nil?
+            @templates.blank?
+          else
+            rendered.any? { |t,num| t.match(options) }
+          end
+        end
+      when Hash
+        if expected_partial = options[:partial]
+          if expected_count = options[:count]
+            actual_count = @partials[expected_partial]
+            # actual_count = found.nil? ? 0 : found[1]
+            msg = build_message(message,
+                    "expecting ? to be rendered ? time(s) but rendered ? time(s)",
+                     expected_partial, expected_count, actual_count)
+            assert(actual_count == expected_count.to_i, msg)
+          elsif options.key?(:layout)
+            msg = build_message(message,
+                    "expecting layout <?> but action rendered <?>",
+                    expected_layout, @layouts.keys)
+
+            case layout = options[:layout]
+            when String
+              assert(@layouts.include?(expected_layout), msg)
+            when Regexp
+              assert(@layouts.any? {|l| l =~ layout }, msg)
+            when nil
+              assert(@layouts.empty?, msg)
+            end
+          else
+            msg = build_message(message,
+                    "expecting partial <?> but action rendered <?>",
+                    options[:partial], @partials.keys)
+            assert(@partials.include?(expected_partial), msg)
+          end
+        else
+          assert @partials.empty?,
+            "Expected no partials to be rendered"
+        end
+      end
+    end
+  end
+
   class TestRequest < ActionDispatch::TestRequest #:nodoc:
     def initialize(env = {})
       super
@@ -17,9 +118,9 @@ module ActionController
       end
     end
 
-    def assign_parameters(controller_path, action, parameters = {})
+    def assign_parameters(routes, controller_path, action, parameters = {})
       parameters = parameters.symbolize_keys.merge(:controller => controller_path, :action => action)
-      extra_keys = ActionController::Routing::Routes.extra_keys(parameters)
+      extra_keys = routes.extra_keys(parameters)
       non_path_parameters = get? ? query_parameters : request_parameters
       parameters.each do |key, value|
         if value.is_a? Fixnum
@@ -181,6 +282,7 @@ module ActionController
   #  assert_redirected_to page_url(:title => 'foo')
   class TestCase < ActiveSupport::TestCase
     include ActionDispatch::TestProcess
+    include ActionController::TemplateAssertions
 
     # Executes a request simulating GET HTTP method and set/volley the response
     def get(action, parameters = nil, session = nil, flash = nil)
@@ -220,7 +322,7 @@ module ActionController
     def process(action, parameters = nil, session = nil, flash = nil, http_method = 'GET')
       # Sanity check for required instance variables so we can give an
       # understandable error message.
-      %w(@controller @request @response).each do |iv_name|
+      %w(@routes @controller @request @response).each do |iv_name|
         if !(instance_variable_names.include?(iv_name) || instance_variable_names.include?(iv_name.to_sym)) || instance_variable_get(iv_name).nil?
           raise "#{iv_name} is nil: make sure you set it in your test's setup method."
         end
@@ -236,7 +338,7 @@ module ActionController
       @request.env['REQUEST_METHOD'] = http_method
 
       parameters ||= {}
-      @request.assign_parameters(@controller.class.name.underscore.sub(/_controller$/, ''), action.to_s, parameters)
+      @request.assign_parameters(@routes, @controller.class.name.underscore.sub(/_controller$/, ''), action.to_s, parameters)
 
       @request.session = ActionController::TestSession.new(session) unless session.nil?
       @request.session["flash"] = @request.flash.update(flash || {})
@@ -322,6 +424,8 @@ module ActionController
         @controller ||= klass.new rescue nil
       end
 
+      @request.env.delete('PATH_INFO')
+
       if @controller
         @controller.request = @request
         @controller.params = {}
@@ -335,13 +439,20 @@ module ActionController
 
     private
       def build_request_uri(action, parameters)
-        unless @request.env['REQUEST_URI']
-          options = @controller.__send__(:rewrite_options, parameters)
-          options.update(:only_path => true, :action => action)
-
-          url = ActionController::UrlRewriter.new(@request, parameters)
-          @request.request_uri = url.rewrite(options)
+        unless @request.env["PATH_INFO"]
+          options = @controller.__send__(:url_options).merge(parameters)
+          options.update(
+            :only_path => true,
+            :action => action,
+            :relative_url_root => nil,
+            :_path_segments => @request.symbolized_path_parameters)
+
+          url, query_string = @routes.url_for(options).split("?", 2)
+
+          @request.env["SCRIPT_NAME"] = @controller.config.relative_url_root
+          @request.env["PATH_INFO"] = url
+          @request.env["QUERY_STRING"] = query_string || ""
         end
       end
-  end
+    end
 end

data/lib/action_dispatch.rb

@@ -48,6 +48,7 @@ module ActionDispatch
     autoload :Flash
     autoload :Head
     autoload :ParamsParser
+    autoload :RemoteIp
     autoload :Rescue
     autoload :ShowExceptions
     autoload :Static

data/lib/action_dispatch/http/cache.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/blank'
+
 module ActionDispatch
   module Http
     module Cache
@@ -37,8 +39,21 @@ module ActionDispatch
       end
 
       module Response
-        def cache_control
-          @cache_control ||= {}
+        attr_reader :cache_control
+
+        def initialize(*)
+          status, header, body = super
+
+          @cache_control = {}
+          @etag = self["ETag"]
+
+          if cache_control = self["Cache-Control"]
+            cache_control.split(/,\s*/).each do |segment|
+              first, last = segment.split("=")
+              last ||= true
+              @cache_control[first.to_sym] = last
+            end
+          end
         end
 
         def last_modified
@@ -65,7 +80,7 @@ module ActionDispatch
 
         def etag=(etag)
           key = ActiveSupport::Cache.expand_cache_key(etag)
-          @etag = %("#{Digest::MD5.hexdigest(key)}")
+          @etag = self["ETag"] = %("#{Digest::MD5.hexdigest(key)}")
         end
 
       private
@@ -100,6 +115,8 @@ module ActionDispatch
         def set_conditional_cache_control!
           control = @cache_control
 
+          return if self["Cache-Control"].present?
+
           if control.empty?
             headers["Cache-Control"] = DEFAULT_CACHE_CONTROL
           elsif @cache_control[:no_cache]

data/lib/action_dispatch/http/filter_parameters.rb

@@ -1,5 +1,6 @@
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/object/duplicable'
 
 module ActionDispatch
   module Http
@@ -25,9 +26,15 @@ module ActionDispatch
     module FilterParameters
       extend ActiveSupport::Concern
 
+      @@compiled_parameter_filter_for = {}
+
       # Return a hash of parameters with all sensitive data replaced.
       def filtered_parameters
-        @filtered_parameters ||= process_parameter_filter(parameters)
+        @filtered_parameters ||= if filtering_parameters?
+          process_parameter_filter(parameters)
+        else
+          parameters.dup
+        end
       end
       alias :fitered_params :filtered_parameters
 
@@ -46,10 +53,18 @@ module ActionDispatch
 
     protected
 
-      def compile_parameter_filter #:nodoc:
+      def filtering_parameters? #:nodoc:
+        @env["action_dispatch.parameter_filter"].present?
+      end
+
+      def process_parameter_filter(params) #:nodoc:
+        compiled_parameter_filter_for(@env["action_dispatch.parameter_filter"]).call(params)
+      end
+
+      def compile_parameter_filter(filters) #:nodoc:
         strings, regexps, blocks = [], [], []
 
-        Array(@env["action_dispatch.parameter_filter"]).each do |item|
+        filters.each do |item|
           case item
           when NilClass
           when Proc
@@ -65,34 +80,34 @@ module ActionDispatch
         [regexps, blocks]
       end
 
-      def filtering_parameters? #:nodoc:
-        @env["action_dispatch.parameter_filter"].present?
-      end
+      def compiled_parameter_filter_for(filters) #:nodoc:
+        @@compiled_parameter_filter_for[filters] ||= begin
+          regexps, blocks = compile_parameter_filter(filters)
 
-      def process_parameter_filter(original_params) #:nodoc:
-        return original_params.dup unless filtering_parameters?
+          lambda do |original_params|
+            filtered_params = {}
 
-        filtered_params = {}
-        regexps, blocks = compile_parameter_filter
+            original_params.each do |key, value|
+              if regexps.find { |r| key =~ r }
+                value = '[FILTERED]'
+              elsif value.is_a?(Hash)
+                value = process_parameter_filter(value)
+              elsif value.is_a?(Array)
+                value = value.map { |v| v.is_a?(Hash) ? process_parameter_filter(v) : v }
+              elsif blocks.present?
+                key = key.dup
+                value = value.dup if value.duplicable?
+                blocks.each { |b| b.call(key, value) }
+              end
 
-        original_params.each do |key, value|
-          if regexps.find { |r| key =~ r }
-            value = '[FILTERED]'
-          elsif value.is_a?(Hash)
-            value = process_parameter_filter(value)
-          elsif value.is_a?(Array)
-            value = value.map { |i| process_parameter_filter(i) }
-          elsif blocks.present?
-            key = key.dup
-            value = value.dup if value.duplicable?
-            blocks.each { |b| b.call(key, value) }
-          end
+              filtered_params[key] = value
+            end
 
-          filtered_params[key] = value
+            filtered_params
+          end
         end
-
-        filtered_params
       end
+
     end
   end
 end