actionview 4.2.11.1 → 6.1.5

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,25 +75,25 @@ 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
       end
 
-      def source_extract(indentation = 0, output = :console)
-        return unless num = line_number
+      def source_extract(indentation = 0)
+        return [] unless num = line_number
         num = num.to_i
 
-        source_code = @template.source.split("\n")
+        source_code = @template.encode!.split("\n")
 
         start_on_line = [ num - SOURCE_CODE_RADIUS - 1, 0 ].max
         end_on_line   = [ num + SOURCE_CODE_RADIUS - 1, source_code.length].min
 
         indent = end_on_line.to_s.size + indentation
-        return unless source_code = source_code[start_on_line..end_on_line]
+        return [] unless source_code = source_code[start_on_line..end_on_line]
 
-        formatted_code_for(source_code, start_on_line, indent, output)
+        formatted_code_for(source_code, start_on_line, indent)
       end
 
       def sub_template_of(template_path)
@@ -109,33 +109,48 @@ module ActionView
           end
       end
 
-      def annoted_source_code
+      def annotated_source_code
         source_extract(4)
       end
 
       private
-
         def source_location
           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) ? {} : ""
-          source_code.inject(start_value) do |result, line|
+        def formatted_code_for(source_code, line_counter, indent)
+          indent_template = "%#{indent}s: %s"
+          source_code.map do |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]
-            end
+            indent_template % [line_counter, line]
           end
         end
     end
   end
 
   TemplateError = Template::Error
+
+  class SyntaxErrorInTemplate < TemplateError #:nodoc
+    def initialize(template, offending_code_string)
+      @offending_code_string = offending_code_string
+      super(template)
+    end
+
+    def message
+      <<~MESSAGE
+        Encountered a syntax error while rendering template: check #{@offending_code_string}
+      MESSAGE
+    end
+
+    def annotated_source_code
+      @offending_code_string.split("\n").map.with_index(1) { |line, index|
+        indentation = " " * 4
+        "#{index}:#{indentation}#{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)
+      def call(template, source)
         require_engine
-        "xml = ::Builder::XmlMarkup.new(:indent => 2);" +
+        "xml = ::Builder::XmlMarkup.new(:indent => 2);" \
           "self.output_buffer = xml.target!;" +
-          template.source +
+          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

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+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[:bufvar]     ||= "@output_buffer"
+            properties[:preamble]   ||= ""
+            properties[:postamble]  ||= "#{properties[:bufvar]}.to_s"
+
+            properties[:escapefunc] = ""
+
+            super
+          end
+
+          def evaluate(action_view_erb_handler_context)
+            src = @src
+            view = Class.new(ActionView::Base) {
+              include action_view_erb_handler_context._routes.url_helpers
+              class_eval("define_method(:_template) { |local_assigns, output_buffer| #{src} }", defined?(@filename) ? @filename : "(erubi)", 0)
+            }.empty
+            view._run(:_template, nil, {}, ActionView::OutputBuffer.new)
+          end
+
+        private
+          def add_text(text)
+            return if text.empty?
+
+            if text == "\n"
+              @newline_pending += 1
+            else
+              src << bufvar << ".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 << bufvar << ".safe_expr_append="
+            else
+              src << bufvar << ".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 << bufvar << ".safe_append='#{"\n" * @newline_pending}'.freeze;"
+              @newline_pending = 0
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,96 +1,25 @@
-require 'erubis'
+# frozen_string_literal: true
 
 module ActionView
   class Template
     module Handlers
-      class Erubis < ::Erubis::Eruby
-        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 code =~ BLOCK_EXPR
-            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 code =~ BLOCK_EXPR
-            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
-
       class ERB
+        autoload :Erubi, "action_view/template/handlers/erb/erubi"
+
         # Specify trim mode for the ERB compiler. Defaults to '-'.
         # See ERB documentation for suitable values.
-        class_attribute :erb_trim_mode
-        self.erb_trim_mode = '-'
+        class_attribute :erb_trim_mode, default: "-"
 
         # Default implementation used.
-        class_attribute :erb_implementation
-        self.erb_implementation = Erubis
+        class_attribute :erb_implementation, default: Erubi
 
         # Do not escape templates of these mime types.
-        class_attribute :escape_whitelist
-        self.escape_whitelist = ["text/plain"]
+        class_attribute :escape_ignore_list, default: ["text/plain"]
 
         ENCODING_TAG = Regexp.new("\\A(<%#{ENCODING_FLAG}-?%>)[ \\t]*")
 
-        def self.call(template)
-          new.call(template)
+        def self.call(template, source)
+          new.call(template, source)
         end
 
         def supports_streaming?
@@ -101,30 +30,35 @@ module ActionView
           true
         end
 
-        def call(template)
+        def call(template, source)
           # First, convert to BINARY, so in case the encoding is
           # wrong, we can still find an encoding tag
           # (<%# encoding %>) inside the String using a regular
           # expression
-          template_source = template.source.dup.force_encoding(Encoding::ASCII_8BIT)
+          template_source = source.b
 
-          erb = template_source.gsub(ENCODING_TAG, '')
+          erb = template_source.gsub(ENCODING_TAG, "")
           encoding = $2
 
-          erb.force_encoding valid_encoding(template.source.dup, encoding)
+          erb.force_encoding valid_encoding(source.dup, encoding)
 
           # Always make sure we return a String in the default_internal
           erb.encode!
 
-          self.class.erb_implementation.new(
-            erb,
-            :escape => (self.class.escape_whitelist.include? template.type),
-            :trim => (self.class.erb_trim_mode == "-")
-          ).src
+          options = {
+            escape: (self.class.escape_ignore_list.include? template.type),
+            trim: (self.class.erb_trim_mode == "-")
+          }
+
+          if ActionView::Base.annotate_rendered_view_with_filenames && template.format == :html
+            options[:preamble] = "@output_buffer.safe_append='<!-- BEGIN #{template.short_identifier} -->';"
+            options[:postamble] = "@output_buffer.safe_append='<!-- END #{template.short_identifier} -->';@output_buffer.to_s"
+          end
+
+          self.class.erb_implementation.new(erb, options).src
         end
 
       private
-
         def valid_encoding(string, encoding)
           # If a magic encoding comment was found, tag the
           # String with this encoding. This is for a case

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Template::Handlers
+    class Html < Raw
+      def call(template, source)
+        "ActionView::OutputBuffer.new #{super}"
+      end
+    end
+  end
+end

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

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
+
 module ActionView
   module Template::Handlers
     class Raw
-      def call(template)
-        escaped = template.source.gsub(/:/, '\:')
-
-        '%q:' + escaped + ':;'
+      def call(template, source)
+        "#{source.inspect}.html_safe;"
       end
     end
   end

data/lib/action_view/template/handlers.rb

@@ -1,16 +1,20 @@
+# frozen_string_literal: true
+
 module ActionView #:nodoc:
   # = Action View Template Handlers
-  class Template
+  class Template #:nodoc:
     module Handlers #:nodoc:
-      autoload :ERB, 'action_view/template/handlers/erb'
-      autoload :Builder, 'action_view/template/handlers/builder'
-      autoload :Raw, 'action_view/template/handlers/raw'
+      autoload :Raw, "action_view/template/handlers/raw"
+      autoload :ERB, "action_view/template/handlers/erb"
+      autoload :Html, "action_view/template/handlers/html"
+      autoload :Builder, "action_view/template/handlers/builder"
 
       def self.extended(base)
-        base.register_default_template_handler :erb, ERB.new
+        base.register_default_template_handler :raw, Raw.new
+        base.register_template_handler :erb, ERB.new
+        base.register_template_handler :html, Html.new
         base.register_template_handler :builder, Builder.new
-        base.register_template_handler :raw, Raw.new
-        base.register_template_handler :ruby, :source.to_proc
+        base.register_template_handler :ruby, lambda { |_, source| source }
       end
 
       @@template_handlers = {}
@@ -42,7 +46,7 @@ module ActionView #:nodoc:
       end
 
       def template_handler_extensions
-        @@template_handlers.keys.map {|key| key.to_s }.sort
+        @@template_handlers.keys.map(&:to_s).sort
       end
 
       def registered_template_handler(extension)

data/lib/action_view/template/html.rb

@@ -1,22 +1,21 @@
+# frozen_string_literal: true
+
 module ActionView #:nodoc:
   # = Action View HTML Template
-  class Template
+  class Template #:nodoc:
     class HTML #:nodoc:
-      attr_accessor :type
+      attr_reader :type
 
-      def initialize(string, type = nil)
+      def initialize(string, type)
         @string = string.to_s
-        @type   = Types[type] || type if type
-        @type ||= Types[:html]
+        @type   = type
       end
 
       def identifier
-        'html template'
+        "html template"
       end
 
-      def inspect
-        'html template'
-      end
+      alias_method :inspect, :identifier
 
       def to_str
         ERB::Util.h(@string)
@@ -26,8 +25,8 @@ module ActionView #:nodoc:
         to_str
       end
 
-      def formats
-        [@type.respond_to?(:ref) ? @type.ref : @type.to_s]
+      def format
+        @type
       end
     end
   end

data/lib/action_view/template/inline.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActionView #:nodoc:
+  class Template #:nodoc:
+    class Inline < Template #:nodoc:
+      # This finalizer is needed (and exactly with a proc inside another proc)
+      # otherwise templates leak in development.
+      Finalizer = proc do |method_name, mod| # :nodoc:
+        proc do
+          mod.module_eval do
+            remove_possible_method method_name
+          end
+        end
+      end
+
+      def compile(mod)
+        super
+        ObjectSpace.define_finalizer(self, Finalizer[method_name, mod])
+      end
+    end
+  end
+end

data/lib/action_view/template/raw_file.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActionView #:nodoc:
+  # = Action View RawFile Template
+  class Template #:nodoc:
+    class RawFile #:nodoc:
+      attr_accessor :type, :format
+
+      def initialize(filename)
+        @filename = filename.to_s
+        extname = ::File.extname(filename).delete(".")
+        @type = Template::Types[extname] || Template::Types[:text]
+        @format = @type.symbol
+      end
+
+      def identifier
+        @filename
+      end
+
+      def render(*args)
+        ::File.read(@filename)
+      end
+    end
+  end
+end

data/lib/action_view/template/renderable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActionView
+  # = Action View Renderable Template for objects that respond to #render_in
+  class Template
+    class Renderable # :nodoc:
+      def initialize(renderable)
+        @renderable = renderable
+      end
+
+      def identifier
+        @renderable.class.name
+      end
+
+      def render(context, *args)
+        @renderable.render_in(context)
+      end
+
+      def format
+        @renderable.format
+      end
+    end
+  end
+end