actionview 4.2.11.1 → 7.0.2.4

data/lib/action_view/lookup_context.rb

@@ -1,48 +1,43 @@
-require 'thread_safe'
-require 'active_support/core_ext/module/remove_method'
-require 'active_support/core_ext/module/attribute_accessors'
-require 'action_view/template/resolver'
+# frozen_string_literal: true
+
+require "concurrent/map"
+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.
-  class LookupContext #:nodoc:
+  # <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
 
-    mattr_accessor :fallbacks
-    @@fallbacks = FallbackFileSystemResolver.instances
-
-    mattr_accessor :registered_details
+    singleton_class.attr_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.define_method(:"default_#{name}", &block)
       Accessors.module_eval <<-METHOD, __FILE__, __LINE__ + 1
         def #{name}
-          @details.fetch(:#{name}, [])
+          @details[:#{name}] || []
         end
 
         def #{name}=(value)
           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:
+    module Accessors # :nodoc:
+      DEFAULT_PROCS = {}
     end
 
     register_detail(:locale) do
@@ -54,29 +49,44 @@ 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:
+    class DetailsKey # :nodoc:
       alias :eql? :equal?
-      alias :object_hash :hash
 
-      attr_reader :hash
-      @details_keys = ThreadSafe::Cache.new
+      @details_keys = Concurrent::Map.new
+      @digest_cache = Concurrent::Map.new
+      @view_context_mutex = Mutex.new
 
-      def self.get(details)
+      def self.digest_cache(details)
+        @digest_cache[details_cache_key(details)] ||= Concurrent::Map.new
+      end
+
+      def self.details_cache_key(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] ||= TemplateDetails::Requested.new(**details)
       end
 
       def self.clear
+        ActionView::ViewPaths.all_view_paths.each do |path_set|
+          path_set.each(&:clear_cache)
+        end
+        @view_context_class = nil
         @details_keys.clear
+        @digest_cache.clear
       end
 
-      def initialize
-        @hash = object_hash
+      def self.digest_caches
+        @digest_cache.values
+      end
+
+      def self.view_context_class(klass)
+        @view_context_mutex.synchronize do
+          @view_context_class ||= klass.with_empty_template_cache
+        end
       end
     end
 
@@ -86,8 +96,8 @@ module ActionView
 
       # Calculate the details key. Remove the handlers from calculation to improve performance
       # since the user cannot modify it explicitly.
-      def details_key #:nodoc:
-        @details_key ||= DetailsKey.get(@details) if @cache
+      def details_key # :nodoc:
+        @details_key ||= DetailsKey.details_cache_key(@details) if @cache
       end
 
       # Temporary skip passing the details_key forward.
@@ -98,10 +108,10 @@ module ActionView
         @cache = old_value
       end
 
-    protected
-
-      def _set_detail(key, value)
-        @details = @details.dup if @details_key
+    private
+      def _set_detail(key, value) # :doc:
+        @details = @details.dup if @digest_cache || @details_key
+        @digest_cache = nil
         @details_key = nil
         @details[key] = value
       end
@@ -111,59 +121,47 @@ module ActionView
     module ViewPaths
       attr_reader :view_paths, :html_fallback_for_js
 
-      # Whenever setting view paths, makes a copy so that we can manipulate them in
-      # instance objects as we wish.
-      def view_paths=(paths)
-        @view_paths = ActionView::PathSet.new(Array(paths))
-      end
-
       def find(name, prefixes = [], partial = false, keys = [], options = {})
-        @view_paths.find(*args_for_lookup(name, prefixes, partial, keys, options))
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for(options)
+        @view_paths.find(name, prefixes, partial, details, details_key, keys)
       end
       alias :find_template :find
 
-      def find_file(name, prefixes = [], partial = false, keys = [], options = {})
-        @view_paths.find_file(*args_for_lookup(name, prefixes, partial, keys, options))
-      end
-
       def find_all(name, prefixes = [], partial = false, keys = [], options = {})
-        @view_paths.find_all(*args_for_lookup(name, prefixes, partial, keys, options))
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for(options)
+        @view_paths.find_all(name, prefixes, partial, details, details_key, keys)
       end
 
-      def exists?(name, prefixes = [], partial = false, keys = [], options = {})
-        @view_paths.exists?(*args_for_lookup(name, prefixes, partial, keys, options))
+      def exists?(name, prefixes = [], partial = false, keys = [], **options)
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for(options)
+        @view_paths.exists?(name, prefixes, partial, details, details_key, keys)
       end
       alias :template_exists? :exists?
 
-      # Adds fallbacks to the view paths. Useful in cases when you are rendering
-      # a :file.
-      def with_fallbacks
-        added_resolvers = 0
-        self.class.fallbacks.each do |resolver|
-          next if view_paths.include?(resolver)
-          view_paths.push(resolver)
-          added_resolvers += 1
-        end
-        yield
-      ensure
-        added_resolvers.times { view_paths.pop }
+      def any?(name, prefixes = [], partial = false)
+        name, prefixes = normalize_name(name, prefixes)
+        details, details_key = detail_args_for_any
+        @view_paths.exists?(name, prefixes, partial, details, details_key, [])
       end
+      alias :any_templates? :any?
 
-    protected
-
-      def args_for_lookup(name, prefixes, partial, keys, details_options) #:nodoc:
-        name, prefixes = normalize_name(name, prefixes)
-        details, details_key = detail_args_for(details_options)
-        [name, prefixes, partial || false, details, details_key, keys]
+    private
+      # Whenever setting view paths, makes a copy so that we can manipulate them in
+      # instance objects as we wish.
+      def build_view_paths(paths)
+        ActionView::PathSet.new(Array(paths))
       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)
 
         if @cache
-          details_key = DetailsKey.get(user_details)
+          details_key = DetailsKey.details_cache_key(user_details)
         else
           details_key = nil
         end
@@ -171,19 +169,41 @@ module ActionView
         [user_details, details_key]
       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:
-        prefixes = prefixes.presence
-        parts    = name.to_s.split('/')
-        parts.shift if parts.first.empty?
-        name     = parts.pop
+      def detail_args_for_any
+        @detail_args_for_any ||= begin
+          details = {}
+
+          LookupContext.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.details_cache_key(details)]
+          else
+            [details, nil]
+          end
+        end
+      end
 
-        return name, prefixes || [""] if parts.empty?
+      # Fix when prefix is specified as part of the template name
+      def normalize_name(name, prefixes)
+        name = name.to_s
+        idx = name.rindex("/")
+        return name, prefixes.presence || [""] unless idx
 
-        parts    = parts.join('/')
-        prefixes = prefixes ? prefixes.map { |p| "#{p}/#{parts}" } : [parts]
+        path_prefix = name[0, idx]
+        path_prefix = path_prefix.from(1) if path_prefix.start_with?("/")
+        name = name.from(idx + 1)
+
+        if !prefixes || prefixes.empty?
+          prefixes = [path_prefix]
+        else
+          prefixes = prefixes.map { |p| "#{p}/#{path_prefix}" }
+        end
 
         return name, prefixes
       end
@@ -194,21 +214,47 @@ module ActionView
     include ViewPaths
 
     def initialize(view_paths, details = {}, prefixes = [])
-      @details, @details_key = {}, nil
-      @skip_default_locale = false
+      @details_key = nil
+      @digest_cache = nil
       @cache = true
       @prefixes = prefixes
-      @rendered_format = nil
 
-      self.view_paths = view_paths
-      initialize_details(details)
+      @details = initialize_details({}, details)
+      @view_paths = build_view_paths(view_paths)
     end
 
+    def digest_cache
+      @digest_cache ||= DetailsKey.digest_cache(@details)
+    end
+
+    def with_prepended_formats(formats)
+      details = @details.dup
+      details[:formats] = formats
+
+      self.class.new(@view_paths, details, @prefixes)
+    end
+
+    def initialize_details(target, details)
+      LookupContext.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 = values.dup
         values.concat(default_formats) if values.delete "*/*"
+        values.uniq!
+
+        invalid_values = (values - Template::Types.symbols)
+        unless invalid_values.empty?
+          raise ArgumentError, "Invalid formats: #{invalid_values.map(&:inspect).join(", ")}"
+        end
+
         if values == [:js]
           values << :html
           @html_fallback_for_js = true
@@ -217,12 +263,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 +277,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,6 +1,8 @@
+# frozen_string_literal: true
+
 module ActionView
-  module ModelNaming
-    # Converts the given object to an ActiveModel compliant one.
+  module ModelNaming # :nodoc:
+    # Converts the given object to an Active Model compliant one.
     def convert_to_model(object)
       object.respond_to?(:to_model) ? object.to_model : object
     end

data/lib/action_view/path_set.rb

@@ -1,4 +1,6 @@
-module ActionView #:nodoc:
+# frozen_string_literal: true
+
+module ActionView # :nodoc:
   # = Action View PathSet
   #
   # This class is used to store and access paths in Action View. A number of
@@ -6,7 +8,7 @@ module ActionView #:nodoc:
   # set and also perform operations on other +PathSet+ objects.
   #
   # A +LookupContext+ will use a +PathSet+ to store the paths in its context.
-  class PathSet #:nodoc:
+  class PathSet # :nodoc:
     include Enumerable
 
     attr_reader :paths
@@ -42,48 +44,42 @@ module ActionView #:nodoc:
       METHOD
     end
 
-    def find(*args)
-      find_all(*args).first || raise(MissingTemplate.new(self, *args))
-    end
-
-    def find_file(path, prefixes = [], *args)
-      _find_all(path, prefixes, args, true).first || raise(MissingTemplate.new(self, path, prefixes, *args))
+    def find(path, prefixes, partial, details, details_key, locals)
+      find_all(path, prefixes, partial, details, details_key, locals).first ||
+        raise(MissingTemplate.new(self, path, prefixes, partial, details, details_key, locals))
     end
 
-    def find_all(path, prefixes = [], *args)
-      _find_all path, prefixes, args, false
+    def find_all(path, prefixes, partial, details, details_key, locals)
+      search_combinations(prefixes) do |resolver, prefix|
+        templates = resolver.find_all(path, prefix, partial, details, details_key, locals)
+        return templates unless templates.empty?
+      end
+      []
     end
 
-    def exists?(path, prefixes, *args)
-      find_all(path, prefixes, *args).any?
+    def exists?(path, prefixes, partial, details, details_key, locals)
+      find_all(path, prefixes, partial, details, details_key, locals).any?
     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 search_combinations(prefixes)
+        prefixes = Array(prefixes)
+        prefixes.each do |prefix|
+          paths.each do |resolver|
+            yield resolver, prefix
           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
+            FileSystemResolver.new path.to_s
+          else
+            path
+          end
         end
       end
-    end
   end
 end

data/lib/action_view/railtie.rb

@@ -1,33 +1,76 @@
+# 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.action_view.default_enforce_utf8 = nil
+    config.action_view.image_loading = nil
+    config.action_view.image_decoding = nil
+    config.action_view.apply_stylesheet_media_default = true
 
     config.eager_load_namespaces << ActionView
 
-    initializer "action_view.embed_authenticity_token_in_remote_forms" do |app|
-      ActiveSupport.on_load(:action_view) do
-        ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms =
-          app.config.action_view.delete(:embed_authenticity_token_in_remote_forms)
+    config.after_initialize do |app|
+      ActionView::Helpers::FormTagHelper.embed_authenticity_token_in_remote_forms =
+        app.config.action_view.delete(:embed_authenticity_token_in_remote_forms)
+    end
+
+    config.after_initialize do |app|
+      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
+
+    config.after_initialize do |app|
+      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
 
-    initializer "action_view.logger" do
-      ActiveSupport.on_load(:action_view) { self.logger ||= Rails.logger }
+    config.after_initialize do |app|
+      default_enforce_utf8 = app.config.action_view.delete(:default_enforce_utf8)
+      unless default_enforce_utf8.nil?
+        ActionView::Helpers::FormTagHelper.default_enforce_utf8 = default_enforce_utf8
+      end
+    end
+
+    config.after_initialize do |app|
+      button_to_generates_button_tag = app.config.action_view.delete(:button_to_generates_button_tag)
+      unless button_to_generates_button_tag.nil?
+        ActionView::Helpers::UrlHelper.button_to_generates_button_tag = button_to_generates_button_tag
+      end
+    end
+
+    config.after_initialize do |app|
+      frozen_string_literal = app.config.action_view.delete(:frozen_string_literal)
+      ActionView::Template.frozen_string_literal = frozen_string_literal
     end
 
-    initializer "action_view.set_configs" do |app|
+    config.after_initialize do |app|
+      ActionView::Helpers::AssetTagHelper.image_loading = app.config.action_view.delete(:image_loading)
+      ActionView::Helpers::AssetTagHelper.image_decoding = app.config.action_view.delete(:image_decoding)
+      ActionView::Helpers::AssetTagHelper.preload_links_header = app.config.action_view.delete(:preload_links_header)
+      ActionView::Helpers::AssetTagHelper.apply_stylesheet_media_default = app.config.action_view.delete(:apply_stylesheet_media_default)
+    end
+
+    config.after_initialize 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
     end
 
+    initializer "action_view.logger" do
+      ActiveSupport.on_load(:action_view) { self.logger ||= Rails.logger }
+    end
+
     initializer "action_view.caching" do |app|
       ActiveSupport.on_load(:action_view) do
         if app.config.action_view.cache_template_loading.nil?
@@ -38,12 +81,30 @@ module ActionView
 
     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
+
+    initializer "action_view.collection_caching", after: "action_controller.set_configs" do |app|
+      PartialRenderer.collection_cache = app.config.action_controller.cache_store
+    end
+
+    config.after_initialize do |app|
+      enable_caching = if app.config.action_view.cache_template_loading.nil?
+        app.config.cache_classes
+      else
+        app.config.action_view.cache_template_loading
+      end
+
+      unless enable_caching
+        app.executor.register_hook ActionView::CacheExpiry::Executor.new(watcher: app.config.file_watcher)
       end
     end
 
-    rake_tasks do
-      load "action_view/tasks/dependencies.rake"
+    rake_tasks do |app|
+      unless app.config.api_only
+        load "action_view/tasks/cache_digests.rake"
+      end
     end
   end
 end