actionview 6.0.0

data/lib/action_view/template/error.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+
+module ActionView
+  # = Action View Errors
+  class ActionViewError < StandardError #:nodoc:
+  end
+
+  class EncodingError < StandardError #:nodoc:
+  end
+
+  class WrongEncodingError < EncodingError #:nodoc:
+    def initialize(string, encoding)
+      @string, @encoding = string, encoding
+    end
+
+    def message
+      @string.force_encoding(Encoding::ASCII_8BIT)
+      "Your template was not saved as valid #{@encoding}. Please " \
+      "either specify #{@encoding} as the encoding for your template " \
+      "in your text editor, or mark the template with its " \
+      "encoding by inserting the following as the first line " \
+      "of the template:\n\n# encoding: <name of correct encoding>.\n\n" \
+      "The source of your template was:\n\n#{@string}"
+    end
+  end
+
+  class MissingTemplate < ActionViewError #:nodoc:
+    attr_reader :path
+
+    def initialize(paths, path, prefixes, partial, details, *)
+      @path = path
+      prefixes = Array(prefixes)
+      template_type = if partial
+        "partial"
+      elsif /layouts/i.match?(path)
+        "layout"
+      else
+        "template"
+      end
+
+      if partial && path.present?
+        path = path.sub(%r{([^/]+)$}, "_\\1")
+      end
+      searched_paths = prefixes.map { |prefix| [prefix, path].join("/") }
+
+      out  = "Missing #{template_type} #{searched_paths.join(", ")} with #{details.inspect}. Searched in:\n"
+      out += paths.compact.map { |p| "  * #{p.to_s.inspect}\n" }.join
+      super out
+    end
+  end
+
+  class Template
+    # The Template::Error exception is raised when the compilation or rendering of the template
+    # fails. This exception then gathers a bunch of intimate details and uses it to report a
+    # precise exception message.
+    class Error < ActionViewError #:nodoc:
+      SOURCE_CODE_RADIUS = 3
+
+      # Override to prevent #cause resetting during re-raise.
+      attr_reader :cause
+
+      def initialize(template)
+        super($!.message)
+        set_backtrace($!.backtrace)
+        @cause = $!
+        @template, @sub_templates = template, nil
+      end
+
+      def file_name
+        @template.identifier
+      end
+
+      def sub_template_message
+        if @sub_templates
+          "Trace of template inclusion: " +
+          @sub_templates.collect(&:inspect).join(", ")
+        else
+          ""
+        end
+      end
+
+      def source_extract(indentation = 0, output = :console)
+        return unless num = line_number
+        num = num.to_i
+
+        source_code = @template.source.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]
+
+        formatted_code_for(source_code, start_on_line, indent, output)
+      end
+
+      def sub_template_of(template_path)
+        @sub_templates ||= []
+        @sub_templates << template_path
+      end
+
+      def line_number
+        @line_number ||=
+          if file_name
+            regexp = /#{Regexp.escape File.basename(file_name)}:(\d+)/
+            $1 if message =~ regexp || backtrace.find { |line| line =~ regexp }
+          end
+      end
+
+      def annotated_source_code
+        source_extract(4)
+      end
+
+      private
+
+        def source_location
+          if line_number
+            "on line ##{line_number} of "
+          else
+            "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|
+            line_counter += 1
+            if output == :html
+              result.update(line_counter.to_s => "%#{indent}s %s\n" % ["", line])
+            else
+              result << "%#{indent}s: %s" % [line_counter, line]
+            end
+          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.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "active_support/deprecation"
+
+module ActionView #:nodoc:
+  # = Action View Template Handlers
+  class Template #:nodoc:
+    module Handlers #:nodoc:
+      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 :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 :ruby, lambda { |_, source| source }
+      end
+
+      @@template_handlers = {}
+      @@default_template_handlers = nil
+
+      def self.extensions
+        @@template_extensions ||= @@template_handlers.keys
+      end
+
+      class LegacyHandlerWrapper < SimpleDelegator # :nodoc:
+        def call(view, source)
+          __getobj__.call(ActionView::Template::LegacyTemplate.new(view, source))
+        end
+      end
+
+      # Register an object that knows how to handle template files with the given
+      # extensions. This can be used to implement new template types.
+      # The handler must respond to +:call+, which will be passed the template
+      # and should return the rendered template as a String.
+      def register_template_handler(*extensions, handler)
+        params = if handler.is_a?(Proc)
+          handler.parameters
+        else
+          handler.method(:call).parameters
+        end
+
+        unless params.find_all { |type, _| type == :req || type == :opt }.length >= 2
+          ActiveSupport::Deprecation.warn <<~eowarn
+          Single arity template handlers are deprecated. Template handlers must
+          now accept two parameters, the view object and the source for the view object.
+          Change:
+            >> #{handler}.call(#{params.map(&:last).join(", ")})
+          To:
+            >> #{handler}.call(#{params.map(&:last).join(", ")}, source)
+          eowarn
+          handler = LegacyHandlerWrapper.new(handler)
+        end
+
+        raise(ArgumentError, "Extension is required") if extensions.empty?
+        extensions.each do |extension|
+          @@template_handlers[extension.to_sym] = handler
+        end
+        @@template_extensions = nil
+      end
+
+      # Opposite to register_template_handler.
+      def unregister_template_handler(*extensions)
+        extensions.each do |extension|
+          handler = @@template_handlers.delete extension.to_sym
+          @@default_template_handlers = nil if @@default_template_handlers == handler
+        end
+        @@template_extensions = nil
+      end
+
+      def template_handler_extensions
+        @@template_handlers.keys.map(&:to_s).sort
+      end
+
+      def registered_template_handler(extension)
+        extension && @@template_handlers[extension.to_sym]
+      end
+
+      def register_default_template_handler(extension, klass)
+        register_template_handler(extension, klass)
+        @@default_template_handlers = klass
+      end
+
+      def handler_for_extension(extension)
+        registered_template_handler(extension) || @@default_template_handlers
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActionView
+  class Template
+    module Handlers
+      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, default: "-"
+
+        # Default implementation used.
+        class_attribute :erb_implementation, default: Erubi
+
+        # Do not escape templates of these mime types.
+        class_attribute :escape_ignore_list, default: ["text/plain"]
+
+        [self, singleton_class].each do |base|
+          base.alias_method :escape_whitelist, :escape_ignore_list
+          base.alias_method :escape_whitelist=, :escape_ignore_list=
+
+          base.deprecate(
+            escape_whitelist: "use #escape_ignore_list instead",
+            :escape_whitelist= => "use #escape_ignore_list= instead"
+          )
+        end
+
+        ENCODING_TAG = Regexp.new("\\A(<%#{ENCODING_FLAG}-?%>)[ \\t]*")
+
+        def self.call(template, source)
+          new.call(template, source)
+        end
+
+        def supports_streaming?
+          true
+        end
+
+        def handles_encoding?
+          true
+        end
+
+        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 = source.dup.force_encoding(Encoding::ASCII_8BIT)
+
+          erb = template_source.gsub(ENCODING_TAG, "")
+          encoding = $2
+
+          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_ignore_list.include? template.type),
+            trim: (self.class.erb_trim_mode == "-")
+          ).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
+          # where the original String was assumed to be,
+          # for instance, UTF-8, but a magic comment
+          # proved otherwise
+          string.force_encoding(encoding) if encoding
+
+          # If the String is valid, return the encoding we found
+          return string.encoding if string.valid_encoding?
+
+          # Otherwise, raise an exception
+          raise WrongEncodingError.new(string, string.encoding)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# 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[:preamble]   = ""
+            properties[:postamble]  = "@output_buffer.to_s"
+            properties[:bufvar]     = "@output_buffer"
+            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 << "@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