actionpack 3.0.0.beta → 3.0.0.beta2

data/lib/action_dispatch/testing/performance_test.rb

@@ -1,7 +1,7 @@
 require 'active_support/testing/performance'
 require 'active_support/testing/default'
 
-if defined?(ActiveSupport::Testing::Performance)
+begin
   module ActionDispatch
     # An integration test that runs a code profiler on your test methods.
     # Profiling output for combinations of each test method, measurement, and
@@ -14,4 +14,6 @@ if defined?(ActiveSupport::Testing::Performance)
       include ActiveSupport::Testing::Default
     end
   end
+rescue NameError
+  $stderr.puts "Specify ruby-prof as application's dependency in Gemfile to run benchmarks."
 end

data/lib/action_dispatch/testing/test_process.rb

@@ -1,3 +1,5 @@
+require 'action_dispatch/middleware/flash'
+
 module ActionDispatch
   module TestProcess
     def assigns(key = nil)

data/lib/action_dispatch/testing/test_request.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/blank'
+
 module ActionDispatch
   class TestRequest < Request
     DEFAULT_ENV = Rack::MockRequest.env_for('/')

data/lib/action_pack/version.rb

@@ -1,9 +1,10 @@
-module ActionPack #:nodoc:
+module ActionPack
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 0
-    TINY  = "0.beta"
+    TINY  = 0
+    BUILD = "beta2"
 
-    STRING = [MAJOR, MINOR, TINY].join('.')
+    STRING = [MAJOR, MINOR, TINY, BUILD].join('.')
   end
 end

data/lib/action_view.rb

@@ -37,17 +37,22 @@ module ActionView
     autoload :Helpers
 
     autoload_under "render" do
+      autoload :Layouts
       autoload :Partials
       autoload :Rendering
     end
 
-    autoload :MissingTemplate,   'action_view/base'
-    autoload :Resolver,          'action_view/template/resolver'
-    autoload :PathResolver,      'action_view/template/resolver'
-    autoload :PathSet,           'action_view/paths'
-    autoload :FileSystemResolverWithFallback, 'action_view/template/resolver'
+    autoload :Base
+    autoload :LookupContext
+    autoload :Resolver,           'action_view/template/resolver'
+    autoload :PathResolver,       'action_view/template/resolver'
+    autoload :FileSystemResolver, 'action_view/template/resolver'
+    autoload :PathSet,            'action_view/paths'
 
+    autoload :MissingTemplate,    'action_view/template/error'
+    autoload :ActionViewError,    'action_view/template/error'
     autoload :TemplateError,     'action_view/template/error'
+
     autoload :TemplateHandler,   'action_view/template'
     autoload :TemplateHandlers,  'action_view/template'
   end
@@ -55,7 +60,7 @@ module ActionView
   autoload :TestCase, 'action_view/test_case'
 end
 
+require 'active_support/i18n'
 require 'active_support/core_ext/string/output_safety'
-require 'action_view/base'
 
 I18n.load_path << "#{File.dirname(__FILE__)}/action_view/locale/en.yml"

data/lib/action_view/base.rb

@@ -1,27 +1,10 @@
 require 'active_support/core_ext/module/attr_internal'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/array/wrap'
 
 module ActionView #:nodoc:
-  class ActionViewError < StandardError #:nodoc:
-  end
-
-  class MissingTemplate < ActionViewError #:nodoc:
-    attr_reader :path
-
-    def initialize(paths, path, details, partial)
-      @path = path
-      display_paths = paths.compact.join(":")
-      template_type = if partial
-        "partial"
-      elsif path =~ /layouts/i
-        'layout'
-      else
-        'template'
-      end
-
-      super("Missing #{template_type} #{path} with #{details.inspect} in view path #{display_paths}")
-    end
+  class NonConcattingString < ActiveSupport::SafeBuffer
   end
 
   # Action View templates can be written in three ways. If the template file has a <tt>.erb</tt> (or <tt>.rhtml</tt>) extension then it uses a mixture of ERb
@@ -173,128 +156,66 @@ module ActionView #:nodoc:
     module Subclasses
     end
 
-    include Helpers, Rendering, Partials, ::ERB::Util
-
-    def config
-      self.config = DEFAULT_CONFIG unless @config
-      @config
-    end
+    include Helpers, Rendering, Partials, Layouts, ::ERB::Util, Context
+    extend  ActiveSupport::Memoizable
 
-    def config=(config)
-      @config = ActiveSupport::OrderedOptions.new.merge(config)
-    end
-
-    extend ActiveSupport::Memoizable
-
-    attr_accessor :base_path, :assigns, :template_extension, :formats
-    attr_internal :captures
-
-    def reset_formats(formats)
-      @formats = formats
-
-      if defined?(AbstractController::HashKey)
-        # This is expensive, but we need to reset this when the format is updated,
-        # which currently only happens
-        Thread.current[:format_locale_key] =
-          AbstractController::HashKey.get(self.class, formats, I18n.locale)
-      end
-    end
-
-    class << self
-      delegate :erb_trim_mode=, :to => 'ActionView::Template::Handlers::ERB'
-      delegate :logger, :to => 'ActionController::Base', :allow_nil => true
-    end
-
-    @@debug_rjs = false
-    ##
-    # :singleton-method:
     # Specify whether RJS responses should be wrapped in a try/catch block
     # that alert()s the caught exception (and then re-raises it).
     cattr_accessor :debug_rjs
+    @@debug_rjs = false
 
-    # Specify whether templates should be cached. Otherwise the file we be read everytime it is accessed.
-    # Automatically reloading templates are not thread safe and should only be used in development mode.
-    @@cache_template_loading = nil
-    cattr_accessor :cache_template_loading
+    class_attribute :helpers
+    remove_method :helpers
+    attr_reader :helpers
 
-    # :nodoc:
-    def self.xss_safe?
-      true
+    class << self
+      delegate :erb_trim_mode=, :to => 'ActionView::Template::Handlers::ERB'
+      delegate :logger, :to => 'ActionController::Base', :allow_nil => true
     end
 
-    def self.cache_template_loading?
-      ActionController::Base.allow_concurrency || (cache_template_loading.nil? ? !ActiveSupport::Dependencies.load? : cache_template_loading)
-    end
+    ActiveSupport.run_load_hooks(:action_view, self)
 
-    attr_internal :request, :layout
+    attr_accessor :base_path, :assigns, :template_extension, :lookup_context
+    attr_internal :captures, :request, :controller, :template, :config
 
-    def controller_path
-      @controller_path ||= controller && controller.controller_path
-    end
+    delegate :find_template, :template_exists?, :formats, :formats=, :locale, :locale=,
+             :view_paths, :view_paths=, :with_fallbacks, :update_details, :to => :lookup_context
 
     delegate :request_forgery_protection_token, :template, :params, :session, :cookies, :response, :headers,
              :flash, :action_name, :controller_name, :to => :controller
 
     delegate :logger, :to => :controller, :allow_nil => true
 
-    delegate :find, :to => :view_paths
-
-    include Context
-
-    def self.process_view_paths(value)
-      ActionView::PathSet.new(Array(value))
+    # TODO: HACK FOR RJS
+    def view_context
+      self
     end
 
-    class_attribute :helpers
-    attr_reader :helpers
-
-    def self.for_controller(controller)
-      @views ||= {}
-
-      # TODO: Decouple this so helpers are a separate concern in AV just like
-      # they are in AC.
-      if controller.class.respond_to?(:_helper_serial)
-        klass = @views[controller.class._helper_serial] ||= Class.new(self) do
-          # Try to make stack traces clearer
-          class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
-            def self.name
-              "ActionView for #{controller.class}"
-            end
-
-            def inspect
-              "#<#{self.class.name}>"
-            end
-          ruby_eval
-
-          if controller.respond_to?(:_helpers)
-            include controller._helpers
-            self.helpers = controller._helpers
-          end
-        end
-      else
-        klass = self
-      end
+    def self.xss_safe? #:nodoc:
+      true
+    end
 
-      klass.new(controller.class.view_paths, {}, controller)
+    def self.process_view_paths(value)
+      ActionView::PathSet.new(Array.wrap(value))
     end
 
-    def initialize(view_paths = [], assigns_for_first_render = {}, controller = nil, formats = nil)#:nodoc:
+    def initialize(lookup_context = nil, assigns_for_first_render = {}, controller = nil, formats = nil) #:nodoc:
       @config = nil
-      @formats = formats
       @assigns = assigns_for_first_render.each { |key, value| instance_variable_set("@#{key}", value) }
       @helpers = self.class.helpers || Module.new
 
       @_controller   = controller
-      @_content_for  = Hash.new {|h,k| h[k] = ActiveSupport::SafeBuffer.new }
+      @_config       = ActiveSupport::InheritableOptions.new(controller.config) if controller && controller.respond_to?(:config)
+      @_content_for  = Hash.new { |h,k| h[k] = ActiveSupport::SafeBuffer.new }
       @_virtual_path = nil
-      self.view_paths = view_paths
-    end
 
-    attr_internal :controller, :template
-    attr_reader :view_paths
+      @lookup_context = lookup_context.is_a?(ActionView::LookupContext) ?
+        lookup_context : ActionView::LookupContext.new(lookup_context)
+      @lookup_context.formats = formats if formats
+    end
 
-    def view_paths=(paths)
-      @view_paths = self.class.process_view_paths(paths)
+    def controller_path
+      @controller_path ||= controller && controller.controller_path
     end
 
     def punctuate_body!(part)
@@ -302,14 +223,5 @@ module ActionView #:nodoc:
       response.body_parts << part
       nil
     end
-
-    # Evaluates the local assigns and controller ivars, pushes them to the view.
-    def _evaluate_assigns_and_ivars #:nodoc:
-      if controller
-        variables = controller.instance_variable_names
-        variables -= controller.protected_instance_variables if controller.respond_to?(:protected_instance_variables)
-        variables.each { |name| instance_variable_set(name, controller.instance_variable_get(name)) }
-      end
-    end
   end
 end

data/lib/action_view/context.rb

@@ -10,8 +10,6 @@ module ActionView
   # In order to work with ActionController, a Context
   # must implement:
   #
-  # Context.for_controller[controller] Create a new ActionView instance for a
-  #   controller
   # Context#render_partial[options]
   #   - responsible for setting options[:_template]
   #   - Returns String with the rendered partial

data/lib/action_view/helpers.rb

@@ -2,29 +2,32 @@ require 'active_support/benchmarkable'
 
 module ActionView #:nodoc:
   module Helpers #:nodoc:
-    autoload :ActiveModelHelper, 'action_view/helpers/active_model_helper'
-    autoload :AssetTagHelper, 'action_view/helpers/asset_tag_helper'
-    autoload :AtomFeedHelper, 'action_view/helpers/atom_feed_helper'
-    autoload :CacheHelper, 'action_view/helpers/cache_helper'
-    autoload :CaptureHelper, 'action_view/helpers/capture_helper'
-    autoload :CsrfHelper, 'action_view/helpers/csrf_helper'
-    autoload :DateHelper, 'action_view/helpers/date_helper'
-    autoload :DebugHelper, 'action_view/helpers/debug_helper'
-    autoload :FormHelper, 'action_view/helpers/form_helper'
-    autoload :FormOptionsHelper, 'action_view/helpers/form_options_helper'
-    autoload :FormTagHelper, 'action_view/helpers/form_tag_helper'
-    autoload :JavaScriptHelper, 'action_view/helpers/javascript_helper'
-    autoload :NumberHelper, 'action_view/helpers/number_helper'
-    autoload :PrototypeHelper, 'action_view/helpers/prototype_helper'
-    autoload :RawOutputHelper, 'action_view/helpers/raw_output_helper'
-    autoload :RecordIdentificationHelper, 'action_view/helpers/record_identification_helper'
-    autoload :RecordTagHelper, 'action_view/helpers/record_tag_helper'
-    autoload :SanitizeHelper, 'action_view/helpers/sanitize_helper'
-    autoload :ScriptaculousHelper, 'action_view/helpers/scriptaculous_helper'
-    autoload :TagHelper, 'action_view/helpers/tag_helper'
-    autoload :TextHelper, 'action_view/helpers/text_helper'
-    autoload :TranslationHelper, 'action_view/helpers/translation_helper'
-    autoload :UrlHelper, 'action_view/helpers/url_helper'
+    extend ActiveSupport::Autoload
+
+    autoload :ActiveModelHelper
+    autoload :AssetTagHelper
+    autoload :AtomFeedHelper
+    autoload :CacheHelper
+    autoload :CaptureHelper
+    autoload :CsrfHelper
+    autoload :DateHelper
+    autoload :DebugHelper
+    autoload :DeprecatedBlockHelpers
+    autoload :FormHelper
+    autoload :FormOptionsHelper
+    autoload :FormTagHelper
+    autoload :JavaScriptHelper, "action_view/helpers/javascript_helper"
+    autoload :NumberHelper
+    autoload :PrototypeHelper
+    autoload :RawOutputHelper
+    autoload :RecordIdentificationHelper
+    autoload :RecordTagHelper
+    autoload :SanitizeHelper
+    autoload :ScriptaculousHelper
+    autoload :TagHelper
+    autoload :TextHelper
+    autoload :TranslationHelper
+    autoload :UrlHelper
 
     def self.included(base)
       base.extend(ClassMethods)

data/lib/action_view/helpers/active_model_helper.rb

@@ -3,11 +3,14 @@ require 'action_view/helpers/form_helper'
 require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/object/blank'
 
 module ActionView
-  class Base
-    @@field_error_proc = Proc.new{ |html_tag, instance| "<div class=\"fieldWithErrors\">#{html_tag}</div>".html_safe }
-    cattr_accessor :field_error_proc
+  ActiveSupport.on_load(:action_view) do
+    class ActionView::Base
+      @@field_error_proc = Proc.new{ |html_tag, instance| "<div class=\"fieldWithErrors\">#{html_tag}</div>".html_safe }
+      cattr_accessor :field_error_proc
+    end
   end
 
   module Helpers
@@ -80,13 +83,13 @@ module ActionView
         record = convert_to_model(record)
 
         options = options.symbolize_keys
-        options[:action] ||= record.new_record? ? "create" : "update"
+        options[:action] ||= record.persisted? ? "update" : "create"
         action = url_for(:action => options[:action], :id => record)
 
         submit_value = options[:submit_value] || options[:action].gsub(/[^\w]/, '').capitalize
 
         contents = form_tag({:action => action}, :method =>(options[:method] || 'post'), :enctype => options[:multipart] ? 'multipart/form-data': nil)
-        contents.safe_concat hidden_field(record_name, :id) unless record.new_record?
+        contents.safe_concat hidden_field(record_name, :id) if record.persisted?
         contents.safe_concat all_input_tags(record, record_name, options)
         yield contents if block_given?
         contents.safe_concat submit_tag(submit_value)
@@ -94,10 +97,10 @@ module ActionView
       end
 
       # Returns a string containing the error message attached to the +method+ on the +object+ if one exists.
-      # This error message is wrapped in a <tt>DIV</tt> tag, which can be extended to include a <tt>:prepend_text</tt>
-      # and/or <tt>:append_text</tt> (to properly explain the error), and a <tt>:css_class</tt> to style it
-      # accordingly. +object+ should either be the name of an instance variable or the actual object. The method can be
-      # passed in either as a string or a symbol.
+      # This error message is wrapped in a <tt>DIV</tt> tag by default or with <tt>:html_tag</tt> if specified,
+      # which can be extended to include a <tt>:prepend_text</tt> and/or <tt>:append_text</tt> (to properly explain
+      # the error), and a <tt>:css_class</tt> to style it accordingly. +object+ should either be the name of an
+      # instance variable or the actual object. The method can be passed in either as a string or a symbol.
       # As an example, let's say you have a model <tt>@post</tt> that has an error message on the +title+ attribute:
       #
       #   <%= error_message_on "post", "title" %>
@@ -109,25 +112,28 @@ module ActionView
       #   <%= error_message_on "post", "title",
       #       :prepend_text => "Title simply ",
       #       :append_text => " (or it won't work).",
+      #       :html_tag => "span",
       #       :css_class => "inputError" %>
+      #   # => <span class="inputError">Title simply can't be empty (or it won't work).</span>
       def error_message_on(object, method, *args)
         options = args.extract_options!
         unless args.empty?
           ActiveSupport::Deprecation.warn('error_message_on takes an option hash instead of separate ' +
-            'prepend_text, append_text, and css_class arguments', caller)
+            'prepend_text, append_text, html_tag, and css_class arguments', caller)
 
           options[:prepend_text] = args[0] || ''
           options[:append_text] = args[1] || ''
-          options[:css_class] = args[2] || 'formError'
+          options[:html_tag] = args[2] || 'div'
+          options[:css_class] = args[3] || 'formError'
         end
-        options.reverse_merge!(:prepend_text => '', :append_text => '', :css_class => 'formError')
+        options.reverse_merge!(:prepend_text => '', :append_text => '', :html_tag => 'div', :css_class => 'formError')
 
         object = convert_to_model(object)
 
         if (obj = (object.respond_to?(:errors) ? object : instance_variable_get("@#{object}"))) &&
-          (errors = obj.errors[method])
-          content_tag("div",
-            "#{options[:prepend_text]}#{ERB::Util.html_escape(errors.first)}#{options[:append_text]}",
+          (errors = obj.errors[method]).presence
+          content_tag(options[:html_tag],
+            (options[:prepend_text].html_safe << errors.first).safe_concat(options[:append_text]),
             :class => options[:css_class]
           )
         else
@@ -226,16 +232,16 @@ module ActionView
 
             error_messages = objects.sum do |object|
               object.errors.full_messages.map do |msg|
-                content_tag(:li, ERB::Util.html_escape(msg))
+                content_tag(:li, msg)
               end
-            end.join
+            end.join.html_safe
 
             contents = ''
             contents << content_tag(options[:header_tag] || :h2, header_message) unless header_message.blank?
             contents << content_tag(:p, message) unless message.blank?
             contents << content_tag(:ul, error_messages)
 
-            content_tag(:div, contents, html)
+            content_tag(:div, contents.html_safe, html)
           end
         else
           ''
@@ -293,6 +299,10 @@ module ActionView
         end
       end
 
+      def error_message
+        object.errors[@method_name]
+      end
+
       def column_type
         object.send(:column_for_attribute, @method_name).type
       end