actionview 4.2.11.1 → 5.2.7

data/lib/action_view/renderer/streaming_template_renderer.rb

@@ -1,10 +1,11 @@
-require 'fiber'
+# frozen_string_literal: true
+
+require "fiber"
 
 module ActionView
   # == TODO
   #
   # * Support streaming from child templates, partials and so on.
-  # * Integrate exceptions with exceptron
   # * Rack::Cache needs to support streaming bodies
   class StreamingTemplateRenderer < TemplateRenderer #:nodoc:
     # A valid Rack::Body (i.e. it responds to each).
@@ -27,17 +28,16 @@ module ActionView
 
       private
 
-      # This is the same logging logic as in ShowExceptions middleware.
-      # TODO Once "exceptron" is in, refactor this piece to simply re-use exceptron.
-      def log_error(exception) #:nodoc:
-        logger = ActionView::Base.logger
-        return unless logger
+        # This is the same logging logic as in ShowExceptions middleware.
+        def log_error(exception)
+          logger = ActionView::Base.logger
+          return unless logger
 
-        message = "\n#{exception.class} (#{exception.message}):\n"
-        message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
-        message << "  " << exception.backtrace.join("\n  ")
-        logger.fatal("#{message}\n\n")
-      end
+          message = "\n#{exception.class} (#{exception.message}):\n".dup
+          message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
+          message << "  " << exception.backtrace.join("\n  ")
+          logger.fatal("#{message}\n\n")
+        end
     end
 
     # For streaming, instead of rendering a given a template, we return a Body
@@ -47,7 +47,7 @@ module ActionView
       return [super] unless layout_name && template.supports_streaming?
 
       locals ||= {}
-      layout   = layout_name && find_layout(layout_name, locals.keys)
+      layout   = layout_name && find_layout(layout_name, locals.keys, [formats.first])
 
       Body.new do |buffer|
         delayed_render(buffer, template, layout, @view, locals)
@@ -56,48 +56,50 @@ module ActionView
 
     private
 
-    def delayed_render(buffer, template, layout, view, locals)
-      # Wrap the given buffer in the StreamingBuffer and pass it to the
-      # underlying template handler. Now, every time something is concatenated
-      # to the buffer, it is not appended to an array, but streamed straight
-      # to the client.
-      output  = ActionView::StreamingBuffer.new(buffer)
-      yielder = lambda { |*name| view._layout_for(*name) }
-
-      instrument(:template, :identifier => template.identifier, :layout => layout.try(:virtual_path)) do
-        fiber = Fiber.new do
-          if layout
-            layout.render(view, locals, output, &yielder)
-          else
-            # If you don't have a layout, just render the thing
-            # and concatenate the final result. This is the same
-            # as a layout with just <%= yield %>
-            output.safe_concat view._layout_for
+      def delayed_render(buffer, template, layout, view, locals)
+        # Wrap the given buffer in the StreamingBuffer and pass it to the
+        # underlying template handler. Now, every time something is concatenated
+        # to the buffer, it is not appended to an array, but streamed straight
+        # to the client.
+        output  = ActionView::StreamingBuffer.new(buffer)
+        yielder = lambda { |*name| view._layout_for(*name) }
+
+        instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) do
+          outer_config = I18n.config
+          fiber = Fiber.new do
+            I18n.config = outer_config
+            if layout
+              layout.render(view, locals, output, &yielder)
+            else
+              # If you don't have a layout, just render the thing
+              # and concatenate the final result. This is the same
+              # as a layout with just <%= yield %>
+              output.safe_concat view._layout_for
+            end
           end
-        end
 
-        # Set the view flow to support streaming. It will be aware
-        # when to stop rendering the layout because it needs to search
-        # something in the template and vice-versa.
-        view.view_flow = StreamingFlow.new(view, fiber)
+          # Set the view flow to support streaming. It will be aware
+          # when to stop rendering the layout because it needs to search
+          # something in the template and vice-versa.
+          view.view_flow = StreamingFlow.new(view, fiber)
 
-        # Yo! Start the fiber!
-        fiber.resume
+          # Yo! Start the fiber!
+          fiber.resume
 
-        # If the fiber is still alive, it means we need something
-        # from the template, so start rendering it. If not, it means
-        # the layout exited without requiring anything from the template.
-        if fiber.alive?
-          content = template.render(view, locals, &yielder)
+          # If the fiber is still alive, it means we need something
+          # from the template, so start rendering it. If not, it means
+          # the layout exited without requiring anything from the template.
+          if fiber.alive?
+            content = template.render(view, locals, &yielder)
 
-          # Once rendering the template is done, sets its content in the :layout key.
-          view.view_flow.set(:layout, content)
+            # Once rendering the template is done, sets its content in the :layout key.
+            view.view_flow.set(:layout, content)
 
-          # In case the layout continues yielding, we need to resume
-          # the fiber until all yields are handled.
-          fiber.resume while fiber.alive?
+            # In case the layout continues yielding, we need to resume
+            # the fiber until all yields are handled.
+            fiber.resume while fiber.alive?
+          end
         end
       end
-    end
   end
 end

data/lib/action_view/renderer/template_renderer.rb

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/object/try'
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/try"
 
 module ActionView
   class TemplateRenderer < AbstractRenderer #:nodoc:
@@ -16,86 +18,85 @@ module ActionView
 
     private
 
-    # Determine the template to be rendered using the given options.
-    def determine_template(options)
-      keys = options.has_key?(:locals) ? options[:locals].keys : []
+      # Determine the template to be rendered using the given options.
+      def determine_template(options)
+        keys = options.has_key?(:locals) ? options[:locals].keys : []
 
-      if options.key?(:body)
-        Template::Text.new(options[:body])
-      elsif options.key?(:text)
-        Template::Text.new(options[:text], formats.first)
-      elsif options.key?(:plain)
-        Template::Text.new(options[:plain])
-      elsif options.key?(:html)
-        Template::HTML.new(options[:html], formats.first)
-      elsif options.key?(:file)
-        with_fallbacks { find_file(options[:file], nil, false, keys, @details) }
-      elsif options.key?(:inline)
-        handler = Template.handler_for_extension(options[:type] || "erb")
-        Template.new(options[:inline], "inline template", handler, :locals => keys)
-      elsif options.key?(:template)
-        if options[:template].respond_to?(:render)
-          options[:template]
+        if options.key?(:body)
+          Template::Text.new(options[:body])
+        elsif options.key?(:plain)
+          Template::Text.new(options[:plain])
+        elsif options.key?(:html)
+          Template::HTML.new(options[:html], formats.first)
+        elsif options.key?(:file)
+          with_fallbacks { find_file(options[:file], nil, false, keys, @details) }
+        elsif options.key?(:inline)
+          handler = Template.handler_for_extension(options[:type] || "erb")
+          Template.new(options[:inline], "inline template", handler, locals: keys)
+        elsif options.key?(:template)
+          if options[:template].respond_to?(:render)
+            options[:template]
+          else
+            find_template(options[:template], options[:prefixes], false, keys, @details)
+          end
         else
-          find_template(options[:template], options[:prefixes], false, keys, @details)
+          raise ArgumentError, "You invoked render but did not give any of :partial, :template, :inline, :file, :plain, :html or :body option."
         end
-      else
-        raise ArgumentError, "You invoked render but did not give any of :partial, :template, :inline, :file, :plain, :text or :body option."
       end
-    end
 
-    # Renders the given template. A string representing the layout can be
-    # supplied as well.
-    def render_template(template, layout_name = nil, locals = nil) #:nodoc:
-      view, locals = @view, locals || {}
+      # Renders the given template. A string representing the layout can be
+      # supplied as well.
+      def render_template(template, layout_name = nil, locals = nil)
+        view, locals = @view, locals || {}
 
-      render_with_layout(layout_name, locals) do |layout|
-        instrument(:template, :identifier => template.identifier, :layout => layout.try(:virtual_path)) do
-          template.render(view, locals) { |*name| view._layout_for(*name) }
+        render_with_layout(layout_name, locals) do |layout|
+          instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) do
+            template.render(view, locals) { |*name| view._layout_for(*name) }
+          end
         end
       end
-    end
 
-    def render_with_layout(path, locals) #:nodoc:
-      layout  = path && find_layout(path, locals.keys)
-      content = yield(layout)
+      def render_with_layout(path, locals)
+        layout  = path && find_layout(path, locals.keys, [formats.first])
+        content = yield(layout)
 
-      if layout
-        view = @view
-        view.view_flow.set(:layout, content)
-        layout.render(view, locals){ |*name| view._layout_for(*name) }
-      else
-        content
+        if layout
+          view = @view
+          view.view_flow.set(:layout, content)
+          layout.render(view, locals) { |*name| view._layout_for(*name) }
+        else
+          content
+        end
       end
-    end
 
-    # This is the method which actually finds the layout using details in the lookup
-    # context object. If no layout is found, it checks if at least a layout with
-    # the given name exists across all details before raising the error.
-    def find_layout(layout, keys)
-      with_layout_format { resolve_layout(layout, keys) }
-    end
+      # This is the method which actually finds the layout using details in the lookup
+      # context object. If no layout is found, it checks if at least a layout with
+      # the given name exists across all details before raising the error.
+      def find_layout(layout, keys, formats)
+        resolve_layout(layout, keys, formats)
+      end
 
-    def resolve_layout(layout, keys)
-      case layout
-      when String
-        begin
-          if layout =~ /^\//
-            with_fallbacks { find_template(layout, nil, false, keys, @details) }
-          else
-            find_template(layout, nil, false, keys, @details)
+      def resolve_layout(layout, keys, formats)
+        details = @details.dup
+        details[:formats] = formats
+
+        case layout
+        when String
+          begin
+            if layout.start_with?("/")
+              with_fallbacks { find_template(layout, nil, false, [], details) }
+            else
+              find_template(layout, nil, false, [], details)
+            end
+          rescue ActionView::MissingTemplate
+            all_details = @details.merge(formats: @lookup_context.default_formats)
+            raise unless template_exists?(layout, nil, false, [], all_details)
           end
-        rescue ActionView::MissingTemplate
-          all_details = @details.merge(:formats => @lookup_context.default_formats)
-          raise unless template_exists?(layout, nil, false, keys, all_details)
+        when Proc
+          resolve_layout(layout.call(formats), keys, formats)
+        else
+          layout
         end
-      when Proc
-        resolve_layout(layout.call, keys)
-      when FalseClass
-        nil
-      else
-        layout
       end
-    end
   end
 end

data/lib/action_view/rendering.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "action_view/view_paths"
 
 module ActionView
@@ -59,7 +61,7 @@ module ActionView
       @_view_context_class ||= self.class.view_context_class
     end
 
-    # An instance of a view class. The default view class is ActionView::Base
+    # An instance of a view class. The default view class is ActionView::Base.
     #
     # The view class must have the following methods:
     # View.new[lookup_context, assigns, controller]
@@ -73,8 +75,7 @@ module ActionView
     end
 
     # Returns an object that is able to render templates.
-    # :api: private
-    def view_renderer
+    def view_renderer # :nodoc:
       @_view_renderer ||= ActionView::Renderer.new(lookup_context)
     end
 
@@ -84,24 +85,26 @@ module ActionView
     end
 
     def rendered_format
-      Mime[lookup_context.rendered_format]
+      Template::Types[lookup_context.rendered_format]
     end
 
     private
 
       # Find and render a template based on the options given.
-      # :api: private
-      def _render_template(options) #:nodoc:
-        variant = options[:variant]
+      def _render_template(options)
+        variant = options.delete(:variant)
+        assigns = options.delete(:assigns)
+        context = view_context
 
+        context.assign assigns if assigns
         lookup_context.rendered_format = nil if options[:formats]
         lookup_context.variants = variant if variant
 
-        view_renderer.render(view_context, options)
+        view_renderer.render(context, options)
       end
 
-      # Assign the rendered format to lookup context.
-      def _process_format(format, options = {}) #:nodoc:
+      # Assign the rendered format to look up context.
+      def _process_format(format)
         super
         lookup_context.formats = [format.to_sym]
         lookup_context.rendered_format = lookup_context.formats.first
@@ -109,8 +112,7 @@ module ActionView
 
       # Normalize args by converting render "foo" to render :action => "foo" and
       # render "foo/bar" to render :template => "foo/bar".
-      # :api: private
-      def _normalize_args(action=nil, options={})
+      def _normalize_args(action = nil, options = {})
         options = super(action, options)
         case action
         when NilClass
@@ -121,14 +123,17 @@ module ActionView
           key = action.include?(?/) ? :template : :action
           options[key] = action
         else
-          options[:partial] = action
+          if action.respond_to?(:permitted?) && action.permitted?
+            options = action
+          else
+            options[:partial] = action
+          end
         end
 
         options
       end
 
       # Normalize options.
-      # :api: private
       def _normalize_options(options)
         options = super(options)
         if options[:partial] == true

data/lib/action_view/routing_url_for.rb

@@ -1,8 +1,9 @@
-require 'action_dispatch/routing/polymorphic_routes'
+# frozen_string_literal: true
+
+require "action_dispatch/routing/polymorphic_routes"
 
 module ActionView
   module RoutingUrlFor
-
     # Returns the URL for the set of +options+ provided. This takes the
     # same options as +url_for+ in Action Controller (see the
     # documentation for <tt>ActionController::Base#url_for</tt>). Note that by default
@@ -32,7 +33,7 @@ module ActionView
     #
     # ==== Examples
     #   <%= url_for(action: 'index') %>
-    #   # => /blog/
+    #   # => /blogs/
     #
     #   <%= url_for(action: 'find', controller: 'books') %>
     #   # => /books/find
@@ -84,11 +85,13 @@ module ActionView
       when Hash
         options = options.symbolize_keys
         unless options.key?(:only_path)
-          if options[:host].nil?
-            options[:only_path] = _generate_paths_by_default
-          else
-            options[:only_path] = false
-          end
+          options[:only_path] = only_path?(options[:host])
+        end
+
+        super(options)
+      when ActionController::Parameters
+        unless options.key?(:only_path)
+          options[:only_path] = only_path?(options[:host])
         end
 
         super(options)
@@ -121,15 +124,22 @@ module ActionView
       controller.url_options
     end
 
-    def _routes_context #:nodoc:
-      controller
-    end
-    protected :_routes_context
+    private
+      def _routes_context
+        controller
+      end
 
-    def optimize_routes_generation? #:nodoc:
-      controller.respond_to?(:optimize_routes_generation?, true) ?
-        controller.optimize_routes_generation? : super
-    end
-    protected :optimize_routes_generation?
+      def optimize_routes_generation?
+        controller.respond_to?(:optimize_routes_generation?, true) ?
+          controller.optimize_routes_generation? : super
+      end
+
+      def _generate_paths_by_default
+        true
+      end
+
+      def only_path?(host)
+        _generate_paths_by_default unless host
+      end
   end
 end

data/lib/action_view/tasks/cache_digests.rake

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+namespace :cache_digests do
+  desc "Lookup nested dependencies for TEMPLATE (like messages/show or comments/_comment.html)"
+  task nested_dependencies: :environment do
+    abort "You must provide TEMPLATE for the task to run" unless ENV["TEMPLATE"].present?
+    puts JSON.pretty_generate ActionView::Digestor.tree(CacheDigests.template_name, CacheDigests.finder).children.map(&:to_dep_map)
+  end
+
+  desc "Lookup first-level dependencies for TEMPLATE (like messages/show or comments/_comment.html)"
+  task dependencies: :environment do
+    abort "You must provide TEMPLATE for the task to run" unless ENV["TEMPLATE"].present?
+    puts JSON.pretty_generate ActionView::Digestor.tree(CacheDigests.template_name, CacheDigests.finder).children.map(&:name)
+  end
+
+  class CacheDigests
+    def self.template_name
+      ENV["TEMPLATE"].split(".", 2).first
+    end
+
+    def self.finder
+      ApplicationController.new.lookup_context
+    end
+  end
+end

data/lib/action_view/template/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/enumerable"
 
 module ActionView
@@ -8,9 +10,6 @@ module ActionView
   class EncodingError < StandardError #:nodoc:
   end
 
-  class MissingRequestError < StandardError #:nodoc:
-  end
-
   class WrongEncodingError < EncodingError #:nodoc:
     def initialize(string, encoding)
       @string, @encoding = string, encoding
@@ -35,10 +34,10 @@ module ActionView
       prefixes = Array(prefixes)
       template_type = if partial
         "partial"
-      elsif path =~ /layouts/i
-        'layout'
+      elsif /layouts/i.match?(path)
+        "layout"
       else
-        'template'
+        "template"
       end
 
       if partial && path.present?
@@ -59,13 +58,14 @@ module ActionView
     class Error < ActionViewError #:nodoc:
       SOURCE_CODE_RADIUS = 3
 
-      attr_reader :original_exception
+      # Override to prevent #cause resetting during re-raise.
+      attr_reader :cause
 
-      def initialize(template, original_exception)
-        super(original_exception.message)
-        @template, @original_exception = template, original_exception
-        @sub_templates = nil
-        set_backtrace(original_exception.backtrace)
+      def initialize(template)
+        super($!.message)
+        set_backtrace($!.backtrace)
+        @cause = $!
+        @template, @sub_templates = template, nil
       end
 
       def file_name
@@ -75,7 +75,7 @@ module ActionView
       def sub_template_message
         if @sub_templates
           "Trace of template inclusion: " +
-          @sub_templates.collect { |template| template.inspect }.join(", ")
+          @sub_templates.collect(&:inspect).join(", ")
         else
           ""
         end
@@ -119,18 +119,18 @@ module ActionView
           if line_number
             "on line ##{line_number} of "
           else
-            'in '
+            "in "
           end + file_name
         end
 
         def formatted_code_for(source_code, line_counter, indent, output)
-          start_value = (output == :html) ? {} : ""
+          start_value = (output == :html) ? {} : []
           source_code.inject(start_value) do |result, line|
             line_counter += 1
             if output == :html
               result.update(line_counter.to_s => "%#{indent}s %s\n" % ["", line])
             else
-              result << "%#{indent}s: %s\n" % [line_counter, line]
+              result << "%#{indent}s: %s" % [line_counter, line]
             end
           end
         end

data/lib/action_view/template/handlers/builder.rb

@@ -1,26 +1,25 @@
+# frozen_string_literal: true
+
 module ActionView
   module Template::Handlers
     class Builder
-      # Default format used by Builder.
-      class_attribute :default_format
-      self.default_format = :xml
+      class_attribute :default_format, default: :xml
 
       def call(template)
         require_engine
-        "xml = ::Builder::XmlMarkup.new(:indent => 2);" +
+        "xml = ::Builder::XmlMarkup.new(:indent => 2);" \
           "self.output_buffer = xml.target!;" +
           template.source +
           ";xml.target!;"
       end
 
-      protected
-
-      def require_engine
-        @required ||= begin
-          require "builder"
-          true
+      private
+        def require_engine # :doc:
+          @required ||= begin
+            require "builder"
+            true
+          end
         end
-      end
     end
   end
 end