actionview 6.1.4.1 → 7.0.0.alpha1

data/lib/action_view/model_naming.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActionView
-  module ModelNaming #:nodoc:
+  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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module ActionView #:nodoc:
+module ActionView # :nodoc:
   # = Action View PathSet
   #
   # This class is used to store and access paths in Action View. A number of
@@ -8,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
@@ -44,44 +44,38 @@ module ActionView #:nodoc:
       METHOD
     end
 
-    def find(*args)
-      find_all(*args).first || raise(MissingTemplate.new(self, *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
-    end
-
-    def exists?(path, prefixes, *args)
-      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)
+    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, partial, details, details_key, locals)
+      find_all(path, prefixes, partial, details, details_key, locals).any?
+    end
+
     private
-      def _find_all(path, prefixes, args)
-        prefixes = [prefixes] if String === prefixes
+      def search_combinations(prefixes)
+        prefixes = Array(prefixes)
         prefixes.each do |prefix|
           paths.each do |resolver|
-            templates = resolver.find_all(path, prefix, *args)
-            return templates unless templates.empty?
+            yield resolver, prefix
           end
         end
-        []
       end
 
       def typecast(paths)
         paths.map do |path|
           case path
           when Pathname, String
-            OptimizedFileSystemResolver.new path.to_s
+            FileSystemResolver.new path.to_s
           else
             path
           end

data/lib/action_view/railtie.rb

@@ -10,6 +10,9 @@ module ActionView
     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
 
@@ -38,7 +41,17 @@ module ActionView
     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|
+      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|
@@ -46,7 +59,7 @@ module ActionView
         app.config.action_view.each do |k, v|
           if k == :raise_on_missing_translations
             ActiveSupport::Deprecation.warn \
-              "action_view.raise_on_missing_translations is deprecated and will be removed in Rails 6.2. " \
+              "action_view.raise_on_missing_translations is deprecated and will be removed in Rails 7.0. " \
               "Set i18n.raise_on_missing_translations instead. " \
               "Note that this new setting also affects how missing translations are handled in controllers."
           end
@@ -85,7 +98,7 @@ module ActionView
       end
 
       unless enable_caching
-        app.executor.to_run ActionView::CacheExpiry::Executor.new(watcher: app.config.file_watcher)
+        app.executor.register_hook ActionView::CacheExpiry::Executor.new(watcher: app.config.file_watcher)
       end
     end
 

data/lib/action_view/render_parser.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "action_view/ripper_ast_parser"
+
+module ActionView
+  class RenderParser # :nodoc:
+    def initialize(name, code)
+      @name = name
+      @code = code
+      @parser = RipperASTParser
+    end
+
+    def render_calls
+      render_nodes = @parser.parse_render_nodes(@code)
+
+      render_nodes.map do |method, nodes|
+        nodes.map { |n| send(:parse_render, n) }
+      end.flatten.compact
+    end
+
+    private
+      def directory
+        File.dirname(@name)
+      end
+
+      def resolve_path_directory(path)
+        if path.include?("/")
+          path
+        else
+          "#{directory}/#{path}"
+        end
+      end
+
+      # Convert
+      #   render("foo", ...)
+      # into either
+      #   render(template: "foo", ...)
+      # or
+      #   render(partial: "foo", ...)
+      def normalize_args(string, options_hash)
+        if options_hash
+          { partial: string, locals: options_hash }
+        else
+          { partial: string }
+        end
+      end
+
+      def parse_render(node)
+        node = node.argument_nodes
+
+        if (node.length == 1 || node.length == 2) && !node[0].hash?
+          if node.length == 1
+            options = normalize_args(node[0], nil)
+          elsif node.length == 2
+            options = normalize_args(node[0], node[1])
+          end
+
+          return nil unless options
+
+          parse_render_from_options(options)
+        elsif node.length == 1 && node[0].hash?
+          options = parse_hash_to_symbols(node[0])
+
+          return nil unless options
+
+          parse_render_from_options(options)
+        else
+          nil
+        end
+      end
+
+      def parse_hash(node)
+        node.hash? && node.to_hash
+      end
+
+      def parse_hash_to_symbols(node)
+        hash = parse_hash(node)
+
+        return unless hash
+
+        hash.transform_keys do |key_node|
+          key = parse_sym(key_node)
+
+          return unless key
+
+          key
+        end
+      end
+
+      ALL_KNOWN_KEYS = [:partial, :template, :layout, :formats, :locals, :object, :collection, :as, :status, :content_type, :location, :spacer_template]
+
+      RENDER_TYPE_KEYS =
+        [:partial, :template, :layout]
+
+      def parse_render_from_options(options_hash)
+        renders = []
+        keys = options_hash.keys
+
+        if (keys & RENDER_TYPE_KEYS).size < 1
+          # Must have at least one of render keys
+          return nil
+        end
+
+        if (keys - ALL_KNOWN_KEYS).any?
+          # de-opt in case of unknown option
+          return nil
+        end
+
+        render_type = (keys & RENDER_TYPE_KEYS)[0]
+
+        node = options_hash[render_type]
+
+        if node.string?
+          template = resolve_path_directory(node.to_string)
+        else
+          if node.variable_reference?
+            dependency = node.variable_name.sub(/\A(?:\$|@{1,2})/, "")
+          elsif node.vcall?
+            dependency = node.variable_name
+          elsif node.call?
+            dependency = node.call_method_name
+          else
+            return
+          end
+
+          object_template = true
+          template = "#{dependency.pluralize}/#{dependency.singularize}"
+        end
+
+        return unless template
+
+        if spacer_template = render_template_with_spacer?(options_hash)
+          virtual_path = partial_to_virtual_path(:partial, spacer_template)
+          renders << virtual_path
+        end
+
+        if options_hash.key?(:object) || options_hash.key?(:collection) || object_template
+          return nil if options_hash.key?(:object) && options_hash.key?(:collection)
+          return nil unless options_hash.key?(:partial)
+        end
+
+        virtual_path = partial_to_virtual_path(render_type, template)
+        renders << virtual_path
+
+        # Support for rendering multiple templates (i.e. a partial with a layout)
+        if layout_template = render_template_with_layout?(render_type, options_hash)
+          virtual_path = partial_to_virtual_path(:layout, layout_template)
+
+          renders << virtual_path
+        end
+
+        renders
+      end
+
+      def parse_str(node)
+        node.string? && node.to_string
+      end
+
+      def parse_sym(node)
+        node.symbol? && node.to_symbol
+      end
+
+      private
+        def render_template_with_layout?(render_type, options_hash)
+          if render_type != :layout && options_hash.key?(:layout)
+            parse_str(options_hash[:layout])
+          end
+        end
+
+        def render_template_with_spacer?(options_hash)
+          if options_hash.key?(:spacer_template)
+            parse_str(options_hash[:spacer_template])
+          end
+        end
+
+        def partial_to_virtual_path(render_type, partial_path)
+          if render_type == :partial || render_type == :layout
+            partial_path.gsub(%r{(/|^)([^/]*)\z}, '\1_\2')
+          else
+            partial_path
+          end
+        end
+
+        def layout_to_virtual_path(layout_path)
+          "layouts/#{layout_path}"
+        end
+  end
+end

data/lib/action_view/renderer/abstract_renderer.rb

@@ -18,7 +18,7 @@ module ActionView
   # renderer object of the correct type is created, and the +render+ method on
   # that new object is called in turn. This abstracts the set up and rendering
   # into a separate classes for partials and templates.
-  class AbstractRenderer #:nodoc:
+  class AbstractRenderer # :nodoc:
     delegate :template_exists?, :any_templates?, :formats, to: :@lookup_context
 
     def initialize(lookup_context)
@@ -158,7 +158,7 @@ module ActionView
 
       def extract_details(options) # :doc:
         details = nil
-        @lookup_context.registered_details.each do |key|
+        LookupContext.registered_details.each do |key|
           value = options[key]
 
           if value

data/lib/action_view/renderer/partial_renderer.rb

@@ -217,40 +217,6 @@ module ActionView
   #   </div>
   #
   # As you can see, the <tt>:locals</tt> hash is shared between both the partial and its layout.
-  #
-  # If you pass arguments to "yield" then this will be passed to the block. One way to use this is to pass
-  # an array to layout and treat it as an enumerable.
-  #
-  #   <%# app/views/users/_user.html.erb %>
-  #   <div class="user">
-  #     Budget: $<%= user.budget %>
-  #     <%= yield user %>
-  #   </div>
-  #
-  #   <%# app/views/users/index.html.erb %>
-  #   <%= render layout: @users do |user| %>
-  #     Title: <%= user.title %>
-  #   <% end %>
-  #
-  # This will render the layout for each user and yield to the block, passing the user, each time.
-  #
-  # You can also yield multiple times in one layout and use block arguments to differentiate the sections.
-  #
-  #   <%# app/views/users/_user.html.erb %>
-  #   <div class="user">
-  #     <%= yield user, :header %>
-  #     Budget: $<%= user.budget %>
-  #     <%= yield user, :footer %>
-  #   </div>
-  #
-  #   <%# app/views/users/index.html.erb %>
-  #   <%= render layout: @users do |user, section| %>
-  #     <%- case section when :header -%>
-  #       Title: <%= user.title %>
-  #     <%- when :footer -%>
-  #       Deadline: <%= user.deadline %>
-  #     <%- end -%>
-  #   <% end %>
   class PartialRenderer < AbstractRenderer
     include CollectionCaching
 

data/lib/action_view/renderer/renderer.rb

@@ -44,12 +44,12 @@ module ActionView
     end
 
     # Direct access to template rendering.
-    def render_template(context, options) #:nodoc:
+    def render_template(context, options) # :nodoc:
       render_template_to_object(context, options).body
     end
 
     # Direct access to partial rendering.
-    def render_partial(context, options, &block) #:nodoc:
+    def render_partial(context, options, &block) # :nodoc:
       render_partial_to_object(context, options, &block).body
     end
 
@@ -57,11 +57,11 @@ module ActionView
       @cache_hits ||= {}
     end
 
-    def render_template_to_object(context, options) #:nodoc:
+    def render_template_to_object(context, options) # :nodoc:
       TemplateRenderer.new(@lookup_context).render(context, options)
     end
 
-    def render_partial_to_object(context, options, &block) #:nodoc:
+    def render_partial_to_object(context, options, &block) # :nodoc:
       partial = options[:partial]
       if String === partial
         collection = collection_from_options(options)

data/lib/action_view/renderer/streaming_template_renderer.rb

@@ -7,11 +7,11 @@ module ActionView
   #
   # * Support streaming from child templates, partials and so on.
   # * Rack::Cache needs to support streaming bodies
-  class StreamingTemplateRenderer < TemplateRenderer #:nodoc:
+  class StreamingTemplateRenderer < TemplateRenderer # :nodoc:
     # A valid Rack::Body (i.e. it responds to each).
     # It is initialized with a block that, when called, starts
     # rendering the template.
-    class Body #:nodoc:
+    class Body # :nodoc:
       def initialize(&start)
         @start = start
       end
@@ -42,7 +42,7 @@ module ActionView
     # For streaming, instead of rendering a given a template, we return a Body
     # object that responds to each. This object is initialized with a block
     # that knows how to render the template.
-    def render_template(view, template, layout_name = nil, locals = {}) #:nodoc:
+    def render_template(view, template, layout_name = nil, locals = {}) # :nodoc:
       return [super.body] unless layout_name && template.supports_streaming?
 
       locals ||= {}

data/lib/action_view/renderer/template_renderer.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActionView
-  class TemplateRenderer < AbstractRenderer #:nodoc:
+  class TemplateRenderer < AbstractRenderer # :nodoc:
     def render(context, options)
       @details = extract_details(options)
       template = determine_template(options)
@@ -26,7 +26,11 @@ module ActionView
           if File.exist?(options[:file])
             Template::RawFile.new(options[:file])
           else
-            raise ArgumentError, "`render file:` should be given the absolute path to a file. '#{options[:file]}' was given instead"
+            if Pathname.new(options[:file]).absolute?
+              raise ArgumentError, "File #{options[:file]} does not exist"
+            else
+              raise ArgumentError, "`render file:` should be given the absolute path to a file. '#{options[:file]}' was given instead"
+            end
           end
         elsif options.key?(:inline)
           handler = Template.handler_for_extension(options[:type] || "erb")