omg-actionview 8.0.0.alpha1

data/lib/action_view/template/error.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+require "active_support/syntax_error_proxy"
+
+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, :paths, :prefixes, :partial
+
+    def initialize(paths, path, prefixes, partial, details, *)
+      if partial && path.present?
+        path = path.sub(%r{([^/]+)$}, "_\\1")
+      end
+
+      @path = path
+      @paths = paths
+      @prefixes = Array(prefixes)
+      @partial = partial
+      template_type = if partial
+        "partial"
+      elsif /layouts/i.match?(path)
+        "layout"
+      else
+        "template"
+      end
+
+      searched_paths = @prefixes.map { |prefix| [prefix, path].join("/") }
+
+      out  = "Missing #{template_type} #{searched_paths.join(", ")} with #{details.inspect}.\n\nSearched in:\n"
+      out += paths.compact.map { |p| "  * #{p.to_s.inspect}\n" }.join
+      super out
+    end
+
+    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::Jaro)
+      include DidYouMean::Correctable
+
+      class Results # :nodoc:
+        Result = Struct.new(:path, :score)
+
+        def initialize(size)
+          @size = size
+          @results = []
+        end
+
+        def to_a
+          @results.map(&:path)
+        end
+
+        def should_record?(score)
+          if @results.size < @size
+            true
+          else
+            score < @results.last.score
+          end
+        end
+
+        def add(path, score)
+          if should_record?(score)
+            @results << Result.new(path, score)
+            @results.sort_by!(&:score)
+            @results.pop if @results.size > @size
+          end
+        end
+      end
+
+      # Apps may have thousands of candidate templates so we attempt to
+      # generate the suggestions as efficiently as possible.
+      # First we split templates into prefixes and basenames, so that those can
+      # be matched separately.
+      def corrections
+        candidates = paths.flat_map(&:all_template_paths).uniq
+
+        if partial
+          candidates.select!(&:partial?)
+        else
+          candidates.reject!(&:partial?)
+        end
+
+        # Group by possible prefixes
+        files_by_dir = candidates.group_by(&:prefix)
+        files_by_dir.transform_values! do |files|
+          files.map do |file|
+            # Remove prefix
+            File.basename(file.to_s)
+          end
+        end
+
+        # No suggestions if there's an exact match, but wrong details
+        if prefixes.any? { |prefix| files_by_dir[prefix]&.include?(path) }
+          return []
+        end
+
+        cached_distance = Hash.new do |h, args|
+          h[args] = -DidYouMean::Jaro.distance(*args)
+        end
+
+        results = Results.new(6)
+
+        files_by_dir.keys.index_with do |dirname|
+          prefixes.map do |prefix|
+            cached_distance[[prefix, dirname]]
+          end.min
+        end.sort_by(&:last).each do |dirname, dirweight|
+          # If our directory's score makes it impossible to find a better match
+          # we can prune this search branch.
+          next unless results.should_record?(dirweight - 1.0)
+
+          files = files_by_dir[dirname]
+
+          files.each do |file|
+            fileweight = cached_distance[[path, file]]
+            score = dirweight + fileweight
+
+            results.add(File.join(dirname, file), score)
+          end
+        end
+
+        if partial
+          results.to_a.map { |res| res.sub(%r{_([^/]+)\z}, "\\1") }
+        else
+          results.to_a
+        end
+      end
+    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
+
+      attr_reader :template
+
+      def initialize(template)
+        super($!.message)
+        @cause = $!
+        if @cause.is_a?(SyntaxError)
+          @cause = ActiveSupport::SyntaxErrorProxy.new(@cause)
+        end
+        @template, @sub_templates = template, nil
+      end
+
+      def backtrace
+        @cause.backtrace
+      end
+
+      def backtrace_locations
+        @cause.backtrace_locations
+      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)
+        return [] unless num = line_number
+        num = num.to_i
+
+        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]
+
+        formatted_code_for(source_code, start_on_line, indent)
+      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)
+          indent_template = "%#{indent}s: %s"
+          source_code.map do |line|
+            line_counter += 1
+            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

@@ -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
+        # the double assignment is to silence "assigned but unused variable" warnings
+        "xml = xml = ::Builder::XmlMarkup.new(indent: 2, target: output_buffer.raw);" \
+          "#{source};" \
+          "output_buffer.to_s"
+      end
+
+      private
+        def require_engine # :doc:
+          @required ||= begin
+            require "builder"
+            true
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# 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]}"
+
+            # Tell Eruby that whether template will be compiled with `frozen_string_literal: true`
+            properties[:freeze_template_literals] = !Template.frozen_string_literal
+
+            properties[:escapefunc] = ""
+
+            super
+          end
+
+        private
+          def add_text(text)
+            return if text.empty?
+
+            if text == "\n"
+              @newline_pending += 1
+            else
+              with_buffer do
+                src << ".safe_append='"
+                src << "\n" * @newline_pending if @newline_pending > 0
+                src << text.gsub(/['\\]/, '\\\\\&') << @text_end
+              end
+              @newline_pending = 0
+            end
+          end
+
+          BLOCK_EXPR = /((\s|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+
+          def add_expression(indicator, code)
+            flush_newline_if_pending(src)
+
+            with_buffer do
+              if (indicator == "==") || @escape
+                src << ".safe_expr_append="
+              else
+                src << ".append="
+              end
+
+              if BLOCK_EXPR.match?(code)
+                src << " " << code
+              else
+                src << "(" << code << ")"
+              end
+            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
+              with_buffer { src << ".safe_append='#{"\n" * @newline_pending}" << @text_end }
+              @newline_pending = 0
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "strscan"
+require "active_support/core_ext/erb/util"
+
+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"]
+
+        # Strip trailing newlines from rendered output
+        class_attribute :strip_trailing_newlines, default: false
+
+        ENCODING_TAG = Regexp.new("\\A(<%#{ENCODING_FLAG}-?%>)[ \\t]*")
+
+        LocationParsingError = Class.new(StandardError) # :nodoc:
+
+        def self.call(template, source)
+          new.call(template, source)
+        end
+
+        def supports_streaming?
+          true
+        end
+
+        def handles_encoding?
+          true
+        end
+
+        # Translate an error location returned by ErrorHighlight to the correct
+        # source location inside the template.
+        def translate_location(spot, backtrace_location, source)
+          # Tokenize the source line
+          tokens = ::ERB::Util.tokenize(source.lines[backtrace_location.lineno - 1])
+          new_first_column = find_offset(spot[:snippet], tokens, spot[:first_column])
+          lineno_delta = spot[:first_lineno] - backtrace_location.lineno
+          spot[:first_lineno] -= lineno_delta
+          spot[:last_lineno] -= lineno_delta
+
+          column_delta = spot[:first_column] - new_first_column
+          spot[:first_column] -= column_delta
+          spot[:last_column] -= column_delta
+          spot[:script_lines] = source.lines
+
+          spot
+        rescue NotImplementedError, LocationParsingError
+          nil
+        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.b
+
+          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!
+
+          # Strip trailing newlines from the template if enabled
+          erb.chomp! if strip_trailing_newlines
+
+          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"
+          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
+          # 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
+
+        def find_offset(compiled, source_tokens, error_column)
+          compiled = StringScanner.new(compiled)
+
+          passed_tokens = []
+
+          while tok = source_tokens.shift
+            tok_name, str = *tok
+            case tok_name
+            when :TEXT
+              loop do
+                break if compiled.match?(str)
+                compiled.getch
+              end
+              raise LocationParsingError unless compiled.scan(str)
+            when :CODE
+              if compiled.pos > error_column
+                raise LocationParsingError, "We went too far"
+              end
+
+              if compiled.pos + str.bytesize >= error_column
+                offset = error_column - compiled.pos
+                return passed_tokens.map(&:last).join.bytesize + offset
+              else
+                unless compiled.scan(str)
+                  raise LocationParsingError, "Couldn't find code snippet"
+                end
+              end
+            when :OPEN
+              next_tok = source_tokens.first.last
+              loop do
+                break if compiled.match?(next_tok)
+                compiled.getch
+              end
+            when :CLOSE
+              next_tok = source_tokens.first.last
+              loop do
+                break if compiled.match?(next_tok)
+                compiled.getch
+              end
+            else
+              raise LocationParsingError, "Not implemented: #{tok.first}"
+            end
+
+            passed_tokens << tok
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActionView
+  module Template::Handlers
+    class Raw
+      def call(template, source)
+        "#{source.inspect}.html_safe;"
+      end
+    end
+  end
+end

data/lib/action_view/template/handlers.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActionView # :nodoc:
+  class Template # :nodoc:
+    # = Action View Template Handlers
+    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
+
+      # 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)
+        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/html.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActionView # :nodoc:
+  class Template # :nodoc:
+    # = Action View HTML Template
+    class HTML # :nodoc:
+      attr_reader :type
+
+      def initialize(string, type)
+        @string = string.to_s
+        @type   = type
+      end
+
+      def identifier
+        "html template"
+      end
+
+      alias_method :inspect, :identifier
+
+      def to_str
+        ERB::Util.h(@string)
+      end
+
+      def render(*args)
+        to_str
+      end
+
+      def format
+        @type
+      end
+    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:
+  class Template # :nodoc:
+    # = Action View RawFile Template
+    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