actionview 4.2.10 → 5.1.0

data/lib/action_view/log_subscriber.rb

@@ -1,4 +1,4 @@
-require 'active_support/log_subscriber'
+require "active_support/log_subscriber"
 
 module ActionView
   # = Action View Log Subscriber
@@ -19,25 +19,74 @@ module ActionView
         message << " (#{event.duration.round(1)}ms)"
       end
     end
-    alias :render_partial :render_template
-    alias :render_collection :render_template
+
+    def render_partial(event)
+      info do
+        message = "  Rendered #{from_rails_root(event.payload[:identifier])}"
+        message << " within #{from_rails_root(event.payload[:layout])}" if event.payload[:layout]
+        message << " (#{event.duration.round(1)}ms)"
+        message << " #{cache_message(event.payload)}" if event.payload.key?(:cache_hit)
+        message
+      end
+    end
+
+    def render_collection(event)
+      identifier = event.payload[:identifier] || "templates"
+
+      info do
+        "  Rendered collection of #{from_rails_root(identifier)}" \
+        " #{render_count(event.payload)} (#{event.duration.round(1)}ms)"
+      end
+    end
+
+    def start(name, id, payload)
+      if name == "render_template.action_view"
+        log_rendering_start(payload)
+      end
+
+      super
+    end
 
     def logger
       ActionView::Base.logger
     end
 
-  protected
+  private
 
-    EMPTY = ''
-    def from_rails_root(string)
+    EMPTY = ""
+    def from_rails_root(string) # :doc:
       string = string.sub(rails_root, EMPTY)
       string.sub!(VIEWS_PATTERN, EMPTY)
       string
     end
 
-    def rails_root
+    def rails_root # :doc:
       @root ||= "#{Rails.root}/"
     end
+
+    def render_count(payload) # :doc:
+      if payload[:cache_hits]
+        "[#{payload[:cache_hits]} / #{payload[:count]} cache hits]"
+      else
+        "[#{payload[:count]} times]"
+      end
+    end
+
+    def cache_message(payload) # :doc:
+      if payload[:cache_hit]
+        "[cache hit]"
+      else
+        "[cache miss]"
+      end
+    end
+
+    def log_rendering_start(payload)
+      info do
+        message = "  Rendering #{from_rails_root(payload[:identifier])}"
+        message << " within #{from_rails_root(payload[:layout])}" if payload[:layout]
+        message
+      end
+    end
   end
 end
 

data/lib/action_view/lookup_context.rb

@@ -1,15 +1,16 @@
-require 'thread_safe'
-require 'active_support/core_ext/module/remove_method'
-require 'active_support/core_ext/module/attribute_accessors'
-require 'action_view/template/resolver'
+require "concurrent/map"
+require "active_support/core_ext/module/remove_method"
+require "active_support/core_ext/module/attribute_accessors"
+require "action_view/template/resolver"
 
 module ActionView
   # = Action View Lookup Context
   #
-  # LookupContext is the object responsible to hold all information required to lookup
-  # templates, i.e. view paths and details. The LookupContext is also responsible to
-  # generate a key, given to view paths, used in the resolver cache lookup. Since
-  # this key is generated just once during the request, it speeds up all cache accesses.
+  # <tt>LookupContext</tt> is the object responsible for holding all information
+  # required for looking up templates, i.e. view paths and details.
+  # <tt>LookupContext</tt> is also responsible for generating a key, given to
+  # view paths, used in the resolver cache lookup. Since this key is generated
+  # only once during the request, it speeds up all cache accesses.
   class LookupContext #:nodoc:
     attr_accessor :prefixes, :rendered_format
 
@@ -19,9 +20,9 @@ module ActionView
     mattr_accessor :registered_details
     self.registered_details = []
 
-    def self.register_detail(name, options = {}, &block)
-      self.registered_details << name
-      initialize = registered_details.map { |n| "@details[:#{n}] = details[:#{n}] || default_#{n}" }
+    def self.register_detail(name, &block)
+      registered_details << name
+      Accessors::DEFAULT_PROCS[name] = block
 
       Accessors.send :define_method, :"default_#{name}", &block
       Accessors.module_eval <<-METHOD, __FILE__, __LINE__ + 1
@@ -33,16 +34,12 @@ module ActionView
           value = value.present? ? Array(value) : default_#{name}
           _set_detail(:#{name}, value) if value != @details[:#{name}]
         end
-
-        remove_possible_method :initialize_details
-        def initialize_details(details)
-          #{initialize.join("\n")}
-        end
       METHOD
     end
 
     # Holds accessors for the registered details.
     module Accessors #:nodoc:
+      DEFAULT_PROCS = {}
     end
 
     register_detail(:locale) do
@@ -54,29 +51,27 @@ module ActionView
     end
     register_detail(:formats) { ActionView::Base.default_formats || [:html, :text, :js, :css,  :xml, :json] }
     register_detail(:variants) { [] }
-    register_detail(:handlers){ Template::Handlers.extensions }
+    register_detail(:handlers) { Template::Handlers.extensions }
 
     class DetailsKey #:nodoc:
       alias :eql? :equal?
-      alias :object_hash :hash
 
-      attr_reader :hash
-      @details_keys = ThreadSafe::Cache.new
+      @details_keys = Concurrent::Map.new
 
       def self.get(details)
         if details[:formats]
           details = details.dup
-          details[:formats] &= Mime::SET.symbols
+          details[:formats] &= Template::Types.symbols
         end
-        @details_keys[details] ||= new
+        @details_keys[details] ||= Concurrent::Map.new
       end
 
       def self.clear
         @details_keys.clear
       end
 
-      def initialize
-        @hash = object_hash
+      def self.digest_caches
+        @details_keys.values
       end
     end
 
@@ -98,9 +93,9 @@ module ActionView
         @cache = old_value
       end
 
-    protected
+    private
 
-      def _set_detail(key, value)
+      def _set_detail(key, value) # :doc:
         @details = @details.dup if @details_key
         @details_key = nil
         @details[key] = value
@@ -130,11 +125,16 @@ module ActionView
         @view_paths.find_all(*args_for_lookup(name, prefixes, partial, keys, options))
       end
 
-      def exists?(name, prefixes = [], partial = false, keys = [], options = {})
+      def exists?(name, prefixes = [], partial = false, keys = [], **options)
         @view_paths.exists?(*args_for_lookup(name, prefixes, partial, keys, options))
       end
       alias :template_exists? :exists?
 
+      def any?(name, prefixes = [], partial = false)
+        @view_paths.exists?(*args_for_any(name, prefixes, partial))
+      end
+      alias :any_templates? :any?
+
       # Adds fallbacks to the view paths. Useful in cases when you are rendering
       # a :file.
       def with_fallbacks
@@ -149,16 +149,16 @@ module ActionView
         added_resolvers.times { view_paths.pop }
       end
 
-    protected
+    private
 
-      def args_for_lookup(name, prefixes, partial, keys, details_options) #:nodoc:
+      def args_for_lookup(name, prefixes, partial, keys, details_options)
         name, prefixes = normalize_name(name, prefixes)
         details, details_key = detail_args_for(details_options)
         [name, prefixes, partial || false, details, details_key, keys]
       end
 
       # Compute details hash and key according to user options (e.g. passed from #render).
-      def detail_args_for(options)
+      def detail_args_for(options) # :doc:
         return @details, details_key if options.empty? # most common path.
         user_details = @details.merge(options)
 
@@ -171,18 +171,44 @@ module ActionView
         [user_details, details_key]
       end
 
+      def args_for_any(name, prefixes, partial)
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for_any
+        [name, prefixes, partial || false, details, details_key]
+      end
+
+      def detail_args_for_any
+        @detail_args_for_any ||= begin
+          details = {}
+
+          registered_details.each do |k|
+            if k == :variants
+              details[k] = :any
+            else
+              details[k] = Accessors::DEFAULT_PROCS[k].call
+            end
+          end
+
+          if @cache
+            [details, DetailsKey.get(details)]
+          else
+            [details, nil]
+          end
+        end
+      end
+
       # Support legacy foo.erb names even though we now ignore .erb
       # as well as incorrectly putting part of the path in the template
       # name instead of the prefix.
-      def normalize_name(name, prefixes) #:nodoc:
+      def normalize_name(name, prefixes)
         prefixes = prefixes.presence
-        parts    = name.to_s.split('/')
+        parts    = name.to_s.split("/".freeze)
         parts.shift if parts.first.empty?
-        name     = parts.pop
+        name = parts.pop
 
         return name, prefixes || [""] if parts.empty?
 
-        parts    = parts.join('/')
+        parts    = parts.join("/".freeze)
         prefixes = prefixes ? prefixes.map { |p| "#{p}/#{parts}" } : [parts]
 
         return name, prefixes
@@ -194,21 +220,32 @@ module ActionView
     include ViewPaths
 
     def initialize(view_paths, details = {}, prefixes = [])
-      @details, @details_key = {}, nil
-      @skip_default_locale = false
+      @details_key = nil
       @cache = true
       @prefixes = prefixes
       @rendered_format = nil
 
+      @details = initialize_details({}, details)
       self.view_paths = view_paths
-      initialize_details(details)
     end
 
+    def digest_cache
+      details_key
+    end
+
+    def initialize_details(target, details)
+      registered_details.each do |k|
+        target[k] = details[k] || Accessors::DEFAULT_PROCS[k].call
+      end
+      target
+    end
+    private :initialize_details
+
     # Override formats= to expand ["*/*"] values and automatically
     # add :html as fallback to :js.
     def formats=(values)
       if values
-        values.concat(default_formats) if values.delete "*/*"
+        values.concat(default_formats) if values.delete "*/*".freeze
         if values == [:js]
           values << :html
           @html_fallback_for_js = true
@@ -217,12 +254,6 @@ module ActionView
       super(values)
     end
 
-    # Do not use the default locale on template lookup.
-    def skip_default_locale!
-      @skip_default_locale = true
-      self.locale = nil
-    end
-
     # Override locale to return a symbol instead of array.
     def locale
       @details[:locale].first
@@ -237,23 +268,7 @@ module ActionView
         config.locale = value
       end
 
-      super(@skip_default_locale ? I18n.locale : default_locale)
-    end
-
-    # Uses the first format in the formats array for layout lookup.
-    def with_layout_format
-      if formats.size == 1
-        yield
-      else
-        old_formats = formats
-        _set_detail(:formats, formats[0,1])
-
-        begin
-          yield
-        ensure
-          _set_detail(:formats, old_formats)
-        end
-      end
+      super(default_locale)
     end
   end
 end

data/lib/action_view/model_naming.rb

@@ -1,5 +1,5 @@
 module ActionView
-  module ModelNaming
+  module ModelNaming #:nodoc:
     # Converts the given object to an ActiveModel compliant one.
     def convert_to_model(object)
       object.respond_to?(:to_model) ? object.to_model : object

data/lib/action_view/path_set.rb

@@ -58,32 +58,41 @@ module ActionView #:nodoc:
       find_all(path, prefixes, *args).any?
     end
 
+    def find_all_with_query(query) # :nodoc:
+      paths.each do |resolver|
+        templates = resolver.find_all_with_query(query)
+        return templates unless templates.empty?
+      end
+
+      []
+    end
+
     private
 
-    def _find_all(path, prefixes, args, outside_app)
-      prefixes = [prefixes] if String === prefixes
-      prefixes.each do |prefix|
-        paths.each do |resolver|
-          if outside_app
-            templates = resolver.find_all_anywhere(path, prefix, *args)
-          else
-            templates = resolver.find_all(path, prefix, *args)
+      def _find_all(path, prefixes, args, outside_app)
+        prefixes = [prefixes] if String === prefixes
+        prefixes.each do |prefix|
+          paths.each do |resolver|
+            if outside_app
+              templates = resolver.find_all_anywhere(path, prefix, *args)
+            else
+              templates = resolver.find_all(path, prefix, *args)
+            end
+            return templates unless templates.empty?
           end
-          return templates unless templates.empty?
         end
+        []
       end
-      []
-    end
 
-    def typecast(paths)
-      paths.map do |path|
-        case path
-        when Pathname, String
-          OptimizedFileSystemResolver.new path.to_s
-        else
-          path
+      def typecast(paths)
+        paths.map do |path|
+          case path
+          when Pathname, String
+            OptimizedFileSystemResolver.new path.to_s
+          else
+            path
+          end
         end
       end
-    end
   end
 end

data/lib/action_view/railtie.rb

@@ -3,9 +3,10 @@ require "rails"
 
 module ActionView
   # = Action View Railtie
-  class Railtie < Rails::Railtie # :nodoc:
+  class Railtie < Rails::Engine # :nodoc:
     config.action_view = ActiveSupport::OrderedOptions.new
-    config.action_view.embed_authenticity_token_in_remote_forms = false
+    config.action_view.embed_authenticity_token_in_remote_forms = nil
+    config.action_view.debug_missing_translation = true
 
     config.eager_load_namespaces << ActionView
 
@@ -16,13 +17,22 @@ module ActionView
       end
     end
 
+    initializer "action_view.form_with_generates_remote_forms" do |app|
+      ActiveSupport.on_load(:action_view) do
+        form_with_generates_remote_forms = app.config.action_view.delete(:form_with_generates_remote_forms)
+        unless form_with_generates_remote_forms.nil?
+          ActionView::Helpers::FormHelper.form_with_generates_remote_forms = form_with_generates_remote_forms
+        end
+      end
+    end
+
     initializer "action_view.logger" do
       ActiveSupport.on_load(:action_view) { self.logger ||= Rails.logger }
     end
 
     initializer "action_view.set_configs" do |app|
       ActiveSupport.on_load(:action_view) do
-        app.config.action_view.each do |k,v|
+        app.config.action_view.each do |k, v|
           send "#{k}=", v
         end
       end
@@ -36,14 +46,28 @@ module ActionView
       end
     end
 
+    initializer "action_view.per_request_digest_cache" do |app|
+      ActiveSupport.on_load(:action_view) do
+        unless ActionView::Resolver.caching?
+          app.executor.to_run ActionView::Digestor::PerExecutionDigestCacheExpiry
+        end
+      end
+    end
+
     initializer "action_view.setup_action_pack" do |app|
       ActiveSupport.on_load(:action_controller) do
-        ActionView::RoutingUrlFor.send(:include, ActionDispatch::Routing::UrlFor)
+        ActionView::RoutingUrlFor.include(ActionDispatch::Routing::UrlFor)
       end
     end
 
-    rake_tasks do
-      load "action_view/tasks/dependencies.rake"
+    initializer "action_view.collection_caching", after: "action_controller.set_configs" do |app|
+      PartialRenderer.collection_cache = app.config.action_controller.cache_store
+    end
+
+    rake_tasks do |app|
+      unless app.config.api_only
+        load "action_view/tasks/cache_digests.rake"
+      end
     end
   end
 end

data/lib/action_view/record_identifier.rb

@@ -1,38 +1,64 @@
-require 'active_support/core_ext/module'
-require 'action_view/model_naming'
+require "active_support/core_ext/module"
+require "action_view/model_naming"
 
 module ActionView
-  # The record identifier encapsulates a number of naming conventions for dealing with records, like Active Records 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.
+  # RecordIdentifier encapsulates methods used by various ActionView helpers
+  # to associate records with DOM elements.
   #
-  #   # routes
-  #   resources :posts
+  # Consider for example the following code that form of post:
   #
-  #   # view
-  #   <%= div_for(post) do %>    <div id="post_45" class="post">
-  #     <%= post.body %>           What a wonderful world!
-  #   <% end %>                  </div>
+  #   <%= form_for(post) do |f| %>
+  #     <%= f.text_field :body %>
+  #   <% end %>
   #
-  #   # controller
-  #   def update
-  #     post = Post.find(params[:id])
-  #     post.update(params[:post])
+  # When +post+ is a new, unsaved ActiveRecord::Base instance, the resulting HTML
+  # is:
   #
-  #     redirect_to(post) # Calls polymorphic_url(post) which in turn calls post_url(post)
-  #   end
+  #    <form class="new_post" id="new_post" action="/posts" accept-charset="UTF-8" method="post">
+  #      <input type="text" name="post[body]" id="post_body" />
+  #    </form>
+  #
+  # When +post+ is a persisted ActiveRecord::Base instance, the resulting HTML
+  # is:
+  #
+  #   <form class="edit_post" id="edit_post_42" action="/posts/42" accept-charset="UTF-8" method="post">
+  #     <input type="text" value="What a wonderful world!" name="post[body]" id="post_body" />
+  #   </form>
+  #
+  # In both cases, the +id+ and +class+ of the wrapping DOM element are
+  # automatically generated, following naming conventions encapsulated by the
+  # RecordIdentifier methods #dom_id and #dom_class:
+  #
+  #   dom_id(Post.new)         # => "new_post"
+  #   dom_class(Post.new)      # => "post"
+  #   dom_id(Post.find 42)     # => "post_42"
+  #   dom_class(Post.find 42)  # => "post"
   #
-  # 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.
+  # Note that these methods do not strictly require +Post+ to be a subclass of
+  # ActiveRecord::Base.
+  # Any +Post+ class will work as long as its instances respond to +to_key+
+  # and +model_name+, given that +model_name+ responds to +param_key+.
+  # For instance:
+  #
+  #   class Post
+  #     attr_accessor :to_key
+  #
+  #     def model_name
+  #       OpenStruct.new param_key: 'post'
+  #     end
+  #
+  #     def self.find(id)
+  #       new.tap { |post| post.to_key = [id] }
+  #     end
+  #   end
   module RecordIdentifier
     extend self
     extend ModelNaming
 
     include ModelNaming
 
-    JOIN = '_'.freeze
-    NEW = 'new'.freeze
+    JOIN = "_".freeze
+    NEW = "new".freeze
 
     # The DOM class convention is to use the singular form of an object or class.
     #
@@ -66,7 +92,7 @@ module ActionView
       end
     end
 
-  protected
+  private
 
     # 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.
@@ -76,9 +102,9 @@ module ActionView
     # 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)
+    def record_key_for_dom_id(record) # :doc:
       key = convert_to_model(record).to_key
-      key ? key.join('_') : key
+      key ? key.join(JOIN) : key
     end
   end
 end

data/lib/action_view/renderer/abstract_renderer.rb

@@ -15,7 +15,7 @@ module ActionView
   # that new object is called in turn. This abstracts the setup and rendering
   # into a separate classes for partials and templates.
   class AbstractRenderer #:nodoc:
-    delegate :find_template, :find_file, :template_exists?, :with_fallbacks, :with_layout_format, :formats, :to => :@lookup_context
+    delegate :find_template, :find_file, :template_exists?, :any_templates?, :with_fallbacks, :with_layout_format, :formats, to: :@lookup_context
 
     def initialize(lookup_context)
       @lookup_context = lookup_context
@@ -25,25 +25,29 @@ module ActionView
       raise NotImplementedError
     end
 
-    protected
+    private
 
-    def extract_details(options)
-      @lookup_context.registered_details.each_with_object({}) do |key, details|
-        value = options[key]
+      def extract_details(options) # :doc:
+        @lookup_context.registered_details.each_with_object({}) do |key, details|
+          value = options[key]
 
-        details[key] = Array(value) if value
+          details[key] = Array(value) if value
+        end
       end
-    end
 
-    def instrument(name, options={})
-      ActiveSupport::Notifications.instrument("render_#{name}.action_view", options){ yield }
-    end
+      def instrument(name, **options) # :doc:
+        options[:identifier] ||= (@template && @template.identifier) || @path
+
+        ActiveSupport::Notifications.instrument("render_#{name}.action_view", options) do |payload|
+          yield payload
+        end
+      end
 
-    def prepend_formats(formats)
-      formats = Array(formats)
-      return if formats.empty? || @lookup_context.html_fallback_for_js
+      def prepend_formats(formats) # :doc:
+        formats = Array(formats)
+        return if formats.empty? || @lookup_context.html_fallback_for_js
 
-      @lookup_context.formats = formats | @lookup_context.formats
-    end
+        @lookup_context.formats = formats | @lookup_context.formats
+      end
   end
 end