actionpack 2.3.18 → 3.0.0.beta

data/lib/action_view/locale/en.yml

@@ -9,7 +9,7 @@
       delimiter: ","
       # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
       precision: 3
-      
+
     # Used in number_to_currency()
     currency:
       format:
@@ -20,15 +20,15 @@
         separator: "."
         delimiter: ","
         precision: 2
-        
+
     # Used in number_to_percentage()
     percentage:
       format:
         # These three are to override number.format and are optional
-        # separator: 
+        # separator:
         delimiter: ""
-        # precision: 
-        
+        # precision:
+
     # Used in number_to_precision()
     precision:
       format:
@@ -36,12 +36,12 @@
         # separator:
         delimiter: ""
         # precision:
-        
+
     # Used in number_to_human_size()
     human:
       format:
         # These three are to override number.format and are optional
-        # separator: 
+        # separator:
         delimiter: ""
         precision: 1
       storage_units:
@@ -63,37 +63,37 @@
       half_a_minute: "half a minute"
       less_than_x_seconds:
         one:   "less than 1 second"
-        other: "less than %{count} seconds"
+        other: "less than {{count}} seconds"
       x_seconds:
         one:   "1 second"
-        other: "%{count} seconds"
+        other: "{{count}} seconds"
       less_than_x_minutes:
         one:   "less than a minute"
-        other: "less than %{count} minutes"
+        other: "less than {{count}} minutes"
       x_minutes:
         one:   "1 minute"
-        other: "%{count} minutes"
+        other: "{{count}} minutes"
       about_x_hours:
         one:   "about 1 hour"
-        other: "about %{count} hours"
+        other: "about {{count}} hours"
       x_days:
         one:   "1 day"
-        other: "%{count} days"
+        other: "{{count}} days"
       about_x_months:
         one:   "about 1 month"
-        other: "about %{count} months"
+        other: "about {{count}} months"
       x_months:
         one:   "1 month"
-        other: "%{count} months"
+        other: "{{count}} months"
       about_x_years:
         one:   "about 1 year"
-        other: "about %{count} years"
+        other: "about {{count}} years"
       over_x_years:
         one:   "over 1 year"
-        other: "over %{count} years"
+        other: "over {{count}} years"
       almost_x_years:
         one:   "almost 1 year"
-        other: "almost %{count} years"
+        other: "almost {{count}} years"
     prompts:
       year:   "Year"
       month:  "Month"
@@ -102,16 +102,22 @@
       minute: "Minute"
       second: "Seconds"
 
-  activerecord:
-    errors:
-      template:
-        header:
-          one:    "1 error prohibited this %{model} from being saved"
-          other:  "%{count} errors prohibited this %{model} from being saved"
-        # The variable :count is also available
-        body: "There were problems with the following fields:"
+  errors:
+    template:
+      header:
+        one:    "1 error prohibited this {{model}} from being saved"
+        other:  "{{count}} errors prohibited this {{model}} from being saved"
+      # The variable :count is also available
+      body: "There were problems with the following fields:"
 
-  support:
+  helpers:
     select:
-      # default value for :prompt => true in FormOptionsHelper
+      # Default value for :prompt => true in FormOptionsHelper
       prompt: "Please select"
+
+    # Default translation keys for submit FormHelper
+    submit:
+      create: 'Create {{model}}'
+      update: 'Update {{model}}'
+      submit: 'Save {{model}}'
+

data/lib/action_view/paths.rb

@@ -1,17 +1,17 @@
 module ActionView #:nodoc:
   class PathSet < Array #:nodoc:
-    def self.type_cast(obj)
+    def self.type_cast(obj, cache = nil)
+      # TODO: Clean this up
       if obj.is_a?(String)
-        if Base.cache_template_loading?
-          Template::EagerPath.new(obj.to_s)
-        else
-          ReloadableTemplate::ReloadablePath.new(obj.to_s)
+        if cache.nil?
+          cache = !defined?(Rails.application) || Rails.application.config.cache_classes
         end
+        FileSystemResolverWithFallback.new(obj, :cache => cache)
       else
         obj
       end
     end
-    
+
     def initialize(*args)
       super(*args).map! { |obj| self.class.type_cast(obj) }
     end
@@ -35,9 +35,26 @@ module ActionView #:nodoc:
     def unshift(*objs)
       super(*objs.map { |obj| self.class.type_cast(obj) })
     end
+
+    def find(path, details = {}, prefix = nil, partial = false)
+      template_path = path
+
+      each do |load_path|
+        if template = load_path.find(template_path, details, prefix, partial)
+          return template
+        end
+      end
+      
+      raise ActionView::MissingTemplate.new(self, "#{prefix}/#{path}", details, partial)
+    end
     
-    def load!
-      each(&:load!)
+    def exists?(path, extension = nil, prefix = nil, partial = false)
+      template_path = path.sub(/^\//, '')
+
+      each do |load_path|
+        return true if template = load_path.find(template_path, extension, prefix, partial)
+      end      
+      false
     end
 
     def find_template(original_template_path, format = nil, html_fallback = true)
@@ -45,31 +62,17 @@ module ActionView #:nodoc:
       template_path = original_template_path.sub(/^\//, '')
 
       each do |load_path|
-        if format && (template = load_path["#{template_path}.#{I18n.locale}.#{format}"])
-          return template
-        # Try the default locale version if the current locale doesn't have one
-        # (i.e. you haven't translated this view to German yet, but you have the English version on hand)
-        elsif format && (template = load_path["#{template_path}.#{I18n.default_locale}.#{format}"]) 
-          return template
-        elsif format && (template = load_path["#{template_path}.#{format}"])
-          return template
-        elsif template = load_path["#{template_path}.#{I18n.locale}"]
-          return template
-        elsif template = load_path["#{template_path}.#{I18n.default_locale}"]
-          return template
-        elsif template = load_path[template_path]
+        if template = load_path.find(template_path, format)
           return template
         # Try to find html version if the format is javascript
         elsif format == :js && html_fallback && template = load_path["#{template_path}.#{I18n.locale}.html"]
           return template
-        elsif format == :js && html_fallback && template = load_path["#{template_path}.#{I18n.default_locale}.html"]
-          return template
         elsif format == :js && html_fallback && template = load_path["#{template_path}.html"]
           return template
         end
       end
 
-      return Template.new(original_template_path) if File.file?(original_template_path)
+      return Template.new(original_template_path, original_template_path.to_s =~ /\A\// ? "" : ".") if File.file?(original_template_path)
 
       raise MissingTemplate.new(self, original_template_path, format)
     end

data/lib/action_view/railtie.rb

@@ -0,0 +1,17 @@
+require "action_view"
+require "rails"
+
+module ActionView
+  class Railtie < Rails::Railtie
+    railtie_name :action_view
+
+    require "action_view/railties/subscriber"
+    subscriber ActionView::Railties::Subscriber.new
+
+    initializer "action_view.cache_asset_timestamps" do |app|
+      unless app.config.cache_classes
+        ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
+      end
+    end
+  end
+end

data/lib/action_view/railties/subscriber.rb

@@ -0,0 +1,24 @@
+module ActionView
+  module Railties
+    class Subscriber < Rails::Subscriber
+      def render_template(event)
+        message = "Rendered #{from_rails_root(event.payload[:identifier])}"
+        message << " within #{from_rails_root(event.payload[:layout])}" if event.payload[:layout]
+        message << (" (%.1fms)" % event.duration)
+        info(message)        
+      end
+      alias :render_partial :render_template
+      alias :render_collection :render_template
+
+      def logger
+        ActionController::Base.logger
+      end
+
+    protected
+
+      def from_rails_root(string)
+        string.sub("#{Rails.root}/", "").sub(/^app\/views\//, "")
+      end
+    end
+  end
+end

data/lib/action_view/{partials.rb → render/partials.rb}

@@ -170,72 +170,182 @@ module ActionView
   #     <%- end -%>
   #   <% end %>
   module Partials
-    extend ActiveSupport::Memoizable
+    extend ActiveSupport::Concern
 
-    private
-      def render_partial(options = {}) #:nodoc:
-        local_assigns = options[:locals] || {}
+    class PartialRenderer
+      PARTIAL_NAMES = Hash.new {|h,k| h[k] = {} }
+      TEMPLATES = Hash.new {|h,k| h[k] = {} }
+
+      attr_reader :template
+
+      def initialize(view_context, options, block)
+        @view           = view_context
+        @partial_names  = PARTIAL_NAMES[@view.controller.class]
+
+        key = Thread.current[:format_locale_key]
+        @templates      = TEMPLATES[key] if key
+
+        setup(options, block)
+      end
+
+      def setup(options, block)
+        partial = options[:partial]
 
-        case partial_path = options[:partial]
-        when String, Symbol, NilClass
-          if options.has_key?(:collection)
-            render_partial_collection(options)
+        @options = options
+        @locals  = options[:locals] || {}
+        @block   = block
+
+        if String === partial
+          @object     = options[:object]
+          @path       = partial
+          @collection = collection
+        else
+          @object = partial
+
+          if @collection = collection
+            paths = @collection_paths = @collection.map { |o| partial_path(o) }
+            @path = paths.uniq.size == 1 ? paths.first : nil
           else
-            _pick_partial_template(partial_path).render_partial(self, options[:object], local_assigns)
+            @path = partial_path
+          end
+        end
+      end
+
+      def render
+        identifier = ((@template = find_template) ? @template.identifier : @path)
+
+        if @collection
+          ActiveSupport::Notifications.instrument("action_view.render_collection",
+            :identifier => identifier || "collection", :count => @collection.size) do
+            render_collection
           end
-        when ActionView::Helpers::FormBuilder
-          builder_partial_path = partial_path.class.to_s.demodulize.underscore.sub(/_builder$/, '')
-          local_assigns.merge!(builder_partial_path.to_sym => partial_path)
-          render_partial(:partial => builder_partial_path, :object => options[:object], :locals => local_assigns)
         else
-          if Array === partial_path ||
-            (defined?(ActiveRecord) &&
-             (ActiveRecord::Associations::AssociationCollection === partial_path ||
-              ActiveRecord::NamedScope::Scope === partial_path))
-            render_partial_collection(options.except(:partial).merge(:collection => partial_path))
-          else
-            object = partial_path
-            render_partial(
-              :partial => ActionController::RecordIdentifier.partial_path(object, controller.class.controller_path),
-              :object => object,
-              :locals => local_assigns
-            )
+          content = ActiveSupport::Notifications.instrument("action_view.render_partial",
+            :identifier => identifier) do
+            render_partial
+          end
+
+          if !@block && (layout = @options[:layout])
+            content = @view._render_layout(find_template(layout), @locals){ content }
           end
+          content
         end
       end
 
-      def render_partial_collection(options = {}) #:nodoc:
-        return nil if options[:collection].blank?
+      def render_collection
+        return nil if @collection.blank?
 
-        partial = options[:partial]
-        spacer = options[:spacer_template] ? render(:partial => options[:spacer_template]) : ''
-        local_assigns = options[:locals] ? options[:locals].clone : {}
-        as = options[:as]
-
-        index = 0
-        options[:collection].map do |object|
-          _partial_path ||= partial ||
-            ActionController::RecordIdentifier.partial_path(object, controller.class.controller_path)
-          template = _pick_partial_template(_partial_path)
-          local_assigns[template.counter_name] = index
-          local_assigns["#{as.to_s}_counter".to_sym] = local_assigns[template.counter_name] if as
-          result = template.render_partial(self, object, local_assigns.dup, as)
-          index += 1
-          result
-        end.join(spacer).html_safe
+        if @options.key?(:spacer_template)
+          spacer = find_template(@options[:spacer_template]).render(@view, @locals)
+        end
+
+        result = @template ? collection_with_template : collection_without_template
+        result.join(spacer).html_safe
       end
 
-      def _pick_partial_template(partial_path) #:nodoc:
-        if partial_path.include?('/')
-          path = File.join(File.dirname(partial_path), "_#{File.basename(partial_path)}")
-        elsif controller
-          path = "#{controller.class.controller_path}/_#{partial_path}"
+      def collection_with_template(template = @template)
+        segments, locals, as = [], @locals, @options[:as] || template.variable_name
+
+        counter_name  = template.counter_name
+        locals[counter_name] = -1
+
+        @collection.each do |object|
+          locals[counter_name] += 1
+          locals[as] = object
+
+          segments << template.render(@view, locals)
+        end
+
+        @template = template
+        segments
+      end
+
+      def collection_without_template(collection_paths = @collection_paths)
+        segments, locals, as = [], @locals, @options[:as]
+        index, template = -1, nil
+
+        @collection.each_with_index do |object, i|
+          template = find_template(collection_paths[i])
+          locals[template.counter_name] = (index += 1)
+          locals[as || template.variable_name] = object
+
+          segments << template.render(@view, locals)
+        end
+
+        @template = template
+        segments
+      end
+
+      def render_partial(object = @object)
+        locals, view = @locals, @view
+
+        object ||= locals[template.variable_name]
+        locals[@options[:as] || template.variable_name] = object
+
+        template.render(view, locals) do |*name|
+          view._layout_for(*name, &@block)
+        end
+      end
+
+    private
+      def collection
+        if @object.respond_to?(:to_ary)
+          @object
+        elsif @options.key?(:collection)
+          @options[:collection] || []
+        end
+      end
+
+      def find_template(path = @path)
+        unless @templates
+          path && _find_template(path)
         else
-          path = "_#{partial_path}"
+          path && @templates[path] ||= _find_template(path)
         end
+      end
 
-        self.view_paths.find_template(path, self.template_format)
+      def _find_template(path)
+        if controller = @view.controller
+          prefix = controller.controller_path unless path.include?(?/)
+        end
+
+        @view.find(path, {:formats => @view.formats}, prefix, true)
+      end
+
+      def partial_path(object = @object)
+        @partial_names[object.class] ||= begin
+          object = object.to_model if object.respond_to?(:to_model)
+
+          object.class.model_name.partial_path.dup.tap do |partial|
+            path = @view.controller_path
+            partial.insert(0, "#{File.dirname(path)}/") if path.include?(?/)
+          end
+        end
       end
-      memoize :_pick_partial_template
+    end
+
+    def render_partial(options)
+      _evaluate_assigns_and_ivars
+
+      details = options[:_details]
+
+      # Is this needed
+      self.formats = details[:formats] if details
+      renderer = PartialRenderer.new(self, options, nil)
+      text = renderer.render
+      options[:_template] = renderer.template
+      text
+    end
+
+    def _render_partial(options, &block) #:nodoc:
+      if defined? @renderer
+        @renderer.setup(options, block)
+      else
+        @renderer = PartialRenderer.new(self, options, block)
+      end
+
+      @renderer.render
+    end
+
   end
 end