actionview 4.2.11.3 → 5.2.7.1

data/lib/action_view/railtie.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 require "action_view"
 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 +19,29 @@ 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)
+        ActionView::Helpers::FormHelper.form_with_generates_remote_forms = form_with_generates_remote_forms
+      end
+    end
+
+    initializer "action_view.form_with_generates_ids" do |app|
+      ActiveSupport.on_load(:action_view) do
+        form_with_generates_ids = app.config.action_view.delete(:form_with_generates_ids)
+        unless form_with_generates_ids.nil?
+          ActionView::Helpers::FormHelper.form_with_generates_ids = form_with_generates_ids
+        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 +55,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,66 @@
-require 'active_support/core_ext/module'
-require 'action_view/model_naming'
+# frozen_string_literal: true
+
+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:
   #
-  # 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.
+  #   dom_id(Post.new)         # => "new_post"
+  #   dom_class(Post.new)      # => "post"
+  #   dom_id(Post.find 42)     # => "post_42"
+  #   dom_class(Post.find 42)  # => "post"
+  #
+  # 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 +94,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 +104,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   # This class defines the interface for a renderer. Each class that
   # subclasses +AbstractRenderer+ is used by the base +Renderer+ class to
@@ -15,7 +17,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 +27,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
 
-    def prepend_formats(formats)
-      formats = Array(formats)
-      return if formats.empty? || @lookup_context.html_fallback_for_js
+        ActiveSupport::Notifications.instrument("render_#{name}.action_view", options) do |payload|
+          yield payload
+        end
+      end
 
-      @lookup_context.formats = formats | @lookup_context.formats
-    end
+      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
   end
 end

data/lib/action_view/renderer/partial_renderer/collection_caching.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActionView
+  module CollectionCaching # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      # Fallback cache store if Action View is used without Rails.
+      # Otherwise overridden in Railtie to use Rails.cache.
+      mattr_accessor :collection_cache, default: ActiveSupport::Cache::MemoryStore.new
+    end
+
+    private
+      def cache_collection_render(instrumentation_payload)
+        return yield unless @options[:cached]
+
+        keyed_collection = collection_by_cache_keys
+        cached_partials  = collection_cache.read_multi(*keyed_collection.keys)
+        instrumentation_payload[:cache_hits] = cached_partials.size
+
+        @collection = keyed_collection.reject { |key, _| cached_partials.key?(key) }.values
+        rendered_partials = @collection.empty? ? [] : yield
+
+        index = 0
+        fetch_or_cache_partial(cached_partials, order_by: keyed_collection.each_key) do
+          rendered_partials[index].tap { index += 1 }
+        end
+      end
+
+      def callable_cache_key?
+        @options[:cached].respond_to?(:call)
+      end
+
+      def collection_by_cache_keys
+        seed = callable_cache_key? ? @options[:cached] : ->(i) { i }
+
+        @collection.each_with_object({}) do |item, hash|
+          hash[expanded_cache_key(seed.call(item))] = item
+        end
+      end
+
+      def expanded_cache_key(key)
+        key = @view.combined_fragment_cache_key(@view.cache_fragment_name(key, virtual_path: @template.virtual_path))
+        key.frozen? ? key.dup : key # #read_multi & #write may require mutability, Dalli 2.6.0.
+      end
+
+      def fetch_or_cache_partial(cached_partials, order_by:)
+        order_by.map do |cache_key|
+          cached_partials.fetch(cache_key) do
+            yield.tap do |rendered_partial|
+              collection_cache.write(cache_key, rendered_partial)
+            end
+          end
+        end
+      end
+  end
+end