actionview 5.0.7.2 → 5.1.7

data/lib/action_view/renderer/streaming_template_renderer.rb

@@ -1,10 +1,9 @@
-require 'fiber'
+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 +26,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"
+          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
@@ -56,48 +54,48 @@ 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
+          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
+            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,4 @@
-require 'active_support/core_ext/object/try'
+require "active_support/core_ext/object/try"
 
 module ActionView
   class TemplateRenderer < AbstractRenderer #:nodoc:
@@ -16,87 +16,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, :html, :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, [formats.first])
-      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, formats)
-      resolve_layout(layout, keys, formats)
-    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, formats)
-      details = @details.dup
-      details[:formats] = formats
+      def resolve_layout(layout, keys, formats)
+        details = @details.dup
+        details[:formats] = formats
 
-      case layout
-      when String
-        begin
-          if layout =~ /^\//
-            with_fallbacks { find_template(layout, nil, false, keys, details) }
-          else
-            find_template(layout, nil, false, keys, details)
+        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(formats), keys, formats)
-      else
-        layout
       end
-    end
   end
 end

data/lib/action_view/rendering.rb

@@ -84,15 +84,14 @@ module ActionView
     end
 
     def rendered_format
-      format = lookup_context.rendered_format
-      Template::Types[format] || 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:
+      def _render_template(options)
         variant = options.delete(:variant)
         assigns = options.delete(:assigns)
         context = view_context
@@ -105,7 +104,7 @@ module ActionView
       end
 
       # Assign the rendered format to look up context.
-      def _process_format(format) #:nodoc:
+      def _process_format(format)
         super
         lookup_context.formats = [format.to_sym]
         lookup_context.rendered_format = lookup_context.formats.first
@@ -114,7 +113,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

data/lib/action_view/routing_url_for.rb

@@ -1,8 +1,7 @@
-require 'action_dispatch/routing/polymorphic_routes'
+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
@@ -123,18 +122,15 @@ module ActionView
       controller.url_options
     end
 
-    def _routes_context #:nodoc:
-      controller
-    end
-    protected :_routes_context
-
-    def optimize_routes_generation? #:nodoc:
-      controller.respond_to?(:optimize_routes_generation?, true) ?
-        controller.optimize_routes_generation? : super
-    end
-    protected :optimize_routes_generation?
-
     private
+      def _routes_context
+        controller
+      end
+
+      def optimize_routes_generation?
+        controller.respond_to?(:optimize_routes_generation?, true) ?
+          controller.optimize_routes_generation? : super
+      end
 
       def _generate_paths_by_default
         true

data/lib/action_view/tasks/cache_digests.rake

@@ -1,19 +1,19 @@
 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?
+  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?
+  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
+      ENV["TEMPLATE"].split(".", 2).first
     end
 
     def self.finder

data/lib/action_view/template/error.rb

@@ -35,10 +35,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?
@@ -62,23 +62,13 @@ module ActionView
       # Override to prevent #cause resetting during re-raise.
       attr_reader :cause
 
-      def initialize(template, original_exception = nil)
-        if original_exception
-          ActiveSupport::Deprecation.warn("Passing #original_exception is deprecated and has no effect. " \
-                                          "Exceptions will automatically capture the original exception.", caller)
-        end
-
+      def initialize(template)
         super($!.message)
         set_backtrace($!.backtrace)
         @cause = $!
         @template, @sub_templates = template, nil
       end
 
-      def original_exception
-        ActiveSupport::Deprecation.warn("#original_exception is deprecated. Use #cause instead.", caller)
-        cause
-      end
-
       def file_name
         @template.identifier
       end
@@ -130,7 +120,7 @@ module ActionView
           if line_number
             "on line ##{line_number} of "
           else
-            'in '
+            "in "
           end + file_name
         end
 

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

@@ -7,20 +7,20 @@ module ActionView
 
       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
+      private
 
-      def require_engine
-        @required ||= begin
-          require "builder"
-          true
+        def require_engine # :doc:
+          @required ||= begin
+            require "builder"
+            true
+          end
         end
-      end
     end
   end
 end

data/lib/action_view/template/handlers/erb/deprecated_erubis.rb

@@ -0,0 +1,9 @@
+::ActiveSupport::Deprecation.warn("ActionView::Template::Handlers::Erubis is deprecated and will be removed from Rails 5.2. Switch to ActionView::Template::Handlers::ERB::Erubi instead.")
+
+module ActionView
+  class Template
+    module Handlers
+      Erubis = ERB::Erubis
+    end
+  end
+end

data/lib/action_view/template/handlers/erb/erubi.rb

@@ -0,0 +1,81 @@
+require "erubi"
+
+module ActionView
+  class Template
+    module Handlers
+      class ERB
+        class Erubi < ::Erubi::Engine
+          # :nodoc: all
+          def initialize(input, properties = {})
+            @newline_pending = 0
+
+            # Dup properties so that we don't modify argument
+            properties = Hash[properties]
+            properties[:preamble]   = "@output_buffer = output_buffer || ActionView::OutputBuffer.new;"
+            properties[:postamble]  = "@output_buffer.to_s"
+            properties[:bufvar]     = "@output_buffer"
+            properties[:escapefunc] = ""
+
+            super
+          end
+
+          def evaluate(action_view_erb_handler_context)
+            pr = eval("proc { #{@src} }", binding, @filename || "(erubi)")
+            action_view_erb_handler_context.instance_eval(&pr)
+          end
+
+        private
+          def add_text(text)
+            return if text.empty?
+
+            if text == "\n"
+              @newline_pending += 1
+            else
+              src << "@output_buffer.safe_append='"
+              src << "\n" * @newline_pending if @newline_pending > 0
+              src << text.gsub(/['\\]/, '\\\\\&')
+              src << "'.freeze;"
+
+              @newline_pending = 0
+            end
+          end
+
+          BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+
+          def add_expression(indicator, code)
+            flush_newline_if_pending(src)
+
+            if (indicator == "==") || @escape
+              src << "@output_buffer.safe_expr_append="
+            else
+              src << "@output_buffer.append="
+            end
+
+            if BLOCK_EXPR.match?(code)
+              src << " " << code
+            else
+              src << "(" << code << ");"
+            end
+          end
+
+          def add_code(code)
+            flush_newline_if_pending(src)
+            super
+          end
+
+          def add_postamble(_)
+            flush_newline_if_pending(src)
+            super
+          end
+
+          def flush_newline_if_pending(src)
+            if @newline_pending > 0
+              src << "@output_buffer.safe_append='#{"\n" * @newline_pending}'.freeze;"
+              @newline_pending = 0
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_view/template/handlers/erb/erubis.rb

@@ -0,0 +1,81 @@
+gem "erubis"
+require "erubis"
+
+module ActionView
+  class Template
+    module Handlers
+      class ERB
+        class Erubis < ::Erubis::Eruby
+          # :nodoc: all
+          def add_preamble(src)
+            @newline_pending = 0
+            src << "@output_buffer = output_buffer || ActionView::OutputBuffer.new;"
+          end
+
+          def add_text(src, text)
+            return if text.empty?
+
+            if text == "\n"
+              @newline_pending += 1
+            else
+              src << "@output_buffer.safe_append='"
+              src << "\n" * @newline_pending if @newline_pending > 0
+              src << escape_text(text)
+              src << "'.freeze;"
+
+              @newline_pending = 0
+            end
+          end
+
+          # Erubis toggles <%= and <%== behavior when escaping is enabled.
+          # We override to always treat <%== as escaped.
+          def add_expr(src, code, indicator)
+            case indicator
+            when "=="
+              add_expr_escaped(src, code)
+            else
+              super
+            end
+          end
+
+          BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+
+          def add_expr_literal(src, code)
+            flush_newline_if_pending(src)
+            if BLOCK_EXPR.match?(code)
+              src << "@output_buffer.append= " << code
+            else
+              src << "@output_buffer.append=(" << code << ");"
+            end
+          end
+
+          def add_expr_escaped(src, code)
+            flush_newline_if_pending(src)
+            if BLOCK_EXPR.match?(code)
+              src << "@output_buffer.safe_expr_append= " << code
+            else
+              src << "@output_buffer.safe_expr_append=(" << code << ");"
+            end
+          end
+
+          def add_stmt(src, code)
+            flush_newline_if_pending(src)
+            super
+          end
+
+          def add_postamble(src)
+            flush_newline_if_pending(src)
+            src << "@output_buffer.to_s"
+          end
+
+          def flush_newline_if_pending(src)
+            if @newline_pending > 0
+              src << "@output_buffer.safe_append='#{"\n" * @newline_pending}'.freeze;"
+              @newline_pending = 0
+            end
+          end
+        end
+      end
+    end
+  end
+end