actionview 6.1.7.2 → 7.1.3

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "strscan"
+require "active_support/core_ext/erb/util"
+
 module ActionView
   class Template
     module Handlers
@@ -16,8 +19,13 @@ module ActionView
         # 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
@@ -30,6 +38,26 @@ module ActionView
           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
@@ -45,6 +73,9 @@ module ActionView
           # 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 == "-")
@@ -52,7 +83,7 @@ module ActionView
 
           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"
+            options[:postamble] = "@output_buffer.safe_append='<!-- END #{template.short_identifier} -->';@output_buffer"
           end
 
           self.class.erb_implementation.new(erb, options).src
@@ -73,6 +104,53 @@ module ActionView
           # 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

data/lib/action_view/template/handlers.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module ActionView #:nodoc:
-  # = Action View Template Handlers
-  class Template #:nodoc:
-    module Handlers #:nodoc:
+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"

data/lib/action_view/template/html.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module ActionView #:nodoc:
-  # = Action View HTML Template
-  class Template #:nodoc:
-    class HTML #:nodoc:
+module ActionView # :nodoc:
+  class Template # :nodoc:
+    # = Action View HTML Template
+    class HTML # :nodoc:
       attr_reader :type
 
       def initialize(string, type)

data/lib/action_view/template/inline.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module ActionView #:nodoc:
-  class Template #:nodoc:
-    class Inline < Template #:nodoc:
+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:

data/lib/action_view/template/raw_file.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-module ActionView #:nodoc:
-  # = Action View RawFile Template
-  class Template #:nodoc:
-    class RawFile #:nodoc:
+module ActionView # :nodoc:
+  class Template # :nodoc:
+    # = Action View RawFile Template
+    class RawFile # :nodoc:
       attr_accessor :type, :format
 
       def initialize(filename)

data/lib/action_view/template/renderable.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module ActionView
-  # = Action View Renderable Template for objects that respond to #render_in
   class Template
+    # = Action View Renderable Template for objects that respond to #render_in
     class Renderable # :nodoc:
       def initialize(renderable)
         @renderable = renderable

data/lib/action_view/template/resolver.rb

@@ -10,36 +10,17 @@ require "concurrent/map"
 module ActionView
   # = Action View Resolver
   class Resolver
-    # Keeps all information about view path and builds virtual path.
-    class Path
-      attr_reader :name, :prefix, :partial, :virtual
-      alias_method :partial?, :partial
-
-      def self.build(name, prefix, partial)
-        virtual = +""
-        virtual << "#{prefix}/" unless prefix.empty?
-        virtual << (partial ? "_#{name}" : name)
-        new name, prefix, partial, virtual
-      end
-
-      def initialize(name, prefix, partial, virtual)
-        @name    = name
-        @prefix  = prefix
-        @partial = partial
-        @virtual = virtual
-      end
-
-      def to_str
-        @virtual
-      end
-      alias :to_s :to_str
-    end
+    include ActiveSupport::Deprecation::DeprecatedConstantAccessor
 
     class PathParser # :nodoc:
+      ParsedPath = Struct.new(:path, :details)
+
       def build_path_regex
-        handlers = Template::Handlers.extensions.map { |x| Regexp.escape(x) }.join("|")
-        formats = Template::Types.symbols.map { |x| Regexp.escape(x) }.join("|")
-        locales = "[a-z]{2}(?:-[A-Z]{2})?"
+        handlers = Regexp.union(Template::Handlers.extensions.map(&:to_s))
+        formats = Regexp.union(Template::Types.symbols.map(&:to_s))
+        available_locales = I18n.available_locales.map(&:to_s)
+        regular_locales = [/[a-z]{2}(?:[-_][A-Z]{2})?/]
+        locales = Regexp.union(available_locales + regular_locales)
         variants = "[^.]*"
 
         %r{
@@ -58,79 +39,15 @@ module ActionView
       def parse(path)
         @regex ||= build_path_regex
         match = @regex.match(path)
-        {
-          prefix: match[:prefix] || "",
-          action: match[:action],
-          partial: !!match[:partial],
-          locale: match[:locale]&.to_sym,
-          handler: match[:handler]&.to_sym,
-          format: match[:format]&.to_sym,
-          variant: match[:variant]
-        }
-      end
-    end
-
-    # Threadsafe template cache
-    class Cache #:nodoc:
-      class SmallCache < Concurrent::Map
-        def initialize(options = {})
-          super(options.merge(initial_capacity: 2))
-        end
-      end
-
-      # Preallocate all the default blocks for performance/memory consumption reasons
-      PARTIAL_BLOCK = lambda { |cache, partial| cache[partial] = SmallCache.new }
-      PREFIX_BLOCK  = lambda { |cache, prefix|  cache[prefix]  = SmallCache.new(&PARTIAL_BLOCK) }
-      NAME_BLOCK    = lambda { |cache, name|    cache[name]    = SmallCache.new(&PREFIX_BLOCK) }
-      KEY_BLOCK     = lambda { |cache, key|     cache[key]     = SmallCache.new(&NAME_BLOCK) }
-
-      # Usually a majority of template look ups return nothing, use this canonical preallocated array to save memory
-      NO_TEMPLATES = [].freeze
-
-      def initialize
-        @data = SmallCache.new(&KEY_BLOCK)
-        @query_cache = SmallCache.new
-      end
-
-      def inspect
-        "#{to_s[0..-2]} keys=#{@data.size} queries=#{@query_cache.size}>"
-      end
-
-      # Cache the templates returned by the block
-      def cache(key, name, prefix, partial, locals)
-        @data[key][name][prefix][partial][locals] ||= canonical_no_templates(yield)
-      end
-
-      def cache_query(query) # :nodoc:
-        @query_cache[query] ||= canonical_no_templates(yield)
-      end
-
-      def clear
-        @data.clear
-        @query_cache.clear
-      end
-
-      # Get the cache size. Do not call this
-      # method. This method is not guaranteed to be here ever.
-      def size # :nodoc:
-        size = 0
-        @data.each_value do |v1|
-          v1.each_value do |v2|
-            v2.each_value do |v3|
-              v3.each_value do |v4|
-                size += v4.size
-              end
-            end
-          end
-        end
-
-        size + @query_cache.size
+        path = TemplatePath.build(match[:action], match[:prefix] || "", !!match[:partial])
+        details = TemplateDetails.new(
+          match[:locale]&.to_sym,
+          match[:handler]&.to_sym,
+          match[:format]&.to_sym,
+          match[:variant]&.to_sym
+        )
+        ParsedPath.new(path, details)
       end
-
-      private
-        def canonical_no_templates(templates)
-          templates.empty? ? NO_TEMPLATES : templates
-        end
     end
 
     cattr_accessor :caching, default: true
@@ -139,25 +56,22 @@ module ActionView
       alias :caching? :caching
     end
 
-    def initialize
-      @cache = Cache.new
-    end
-
     def clear_cache
-      @cache.clear
     end
 
     # Normalizes the arguments and passes it on to find_templates.
     def find_all(name, prefix = nil, partial = false, details = {}, key = nil, locals = [])
-      locals = locals.map(&:to_s).sort!.freeze
+      _find_all(name, prefix, partial, details, key, locals)
+    end
 
-      cached(key, [name, prefix, partial], details, locals) do
-        _find_all(name, prefix, partial, details, key, locals)
-      end
+    def built_templates # :nodoc:
+      # Used for error pages
+      []
     end
 
-    def find_all_with_query(query) # :nodoc:
-      @cache.cache_query(query) { find_template_paths(File.join(@path, query)) }
+    def all_template_paths # :nodoc:
+      # Not implemented by default
+      []
     end
 
   private
@@ -173,34 +87,18 @@ module ActionView
     def find_templates(name, prefix, partial, details, locals = [])
       raise NotImplementedError, "Subclasses must implement a find_templates(name, prefix, partial, details, locals = []) method"
     end
-
-    # Handles templates caching. If a key is given and caching is on
-    # always check the cache before hitting the resolver. Otherwise,
-    # it always hits the resolver but if the key is present, check if the
-    # resolver is fresher before returning it.
-    def cached(key, path_info, details, locals)
-      name, prefix, partial = path_info
-
-      if key
-        @cache.cache(key, name, prefix, partial, locals) do
-          yield
-        end
-      else
-        yield
-      end
-    end
   end
 
-  # An abstract class that implements a Resolver with path semantics.
-  class PathResolver < Resolver #:nodoc:
-    EXTENSIONS = { locale: ".", formats: ".", variants: "+", handlers: "." }
-    DEFAULT_PATTERN = ":prefix/:action{.:locale,}{.:formats,}{+:variants,}{.:handlers,}"
+  # A resolver that loads files from the filesystem.
+  class FileSystemResolver < Resolver
+    attr_reader :path
 
-    def initialize
-      @pattern = DEFAULT_PATTERN
+    def initialize(path)
+      raise ArgumentError, "path already is a Resolver class" if path.is_a?(Resolver)
       @unbound_templates = Concurrent::Map.new
       @path_parser = PathParser.new
-      super
+      @path = File.expand_path(path)
+      super()
     end
 
     def clear_cache
@@ -209,26 +107,41 @@ module ActionView
       super
     end
 
-    private
-      def _find_all(name, prefix, partial, details, key, locals)
-        path = Path.build(name, prefix, partial)
-        query(path, details, details[:formats], locals, cache: !!key)
+    def to_s
+      @path.to_s
+    end
+    alias :to_path :to_s
+
+    def eql?(resolver)
+      self.class.equal?(resolver.class) && to_path == resolver.to_path
+    end
+    alias :== :eql?
+
+    def all_template_paths # :nodoc:
+      paths = template_glob("**/*")
+      paths.map do |filename|
+        filename.from(@path.size + 1).remove(/\.[^\/]*\z/)
+      end.uniq.map do |filename|
+        TemplatePath.parse(filename)
       end
+    end
 
-      def query(path, details, formats, locals, cache:)
-        template_paths = find_template_paths_from_details(path, details)
-        template_paths = reject_files_external_to_app(template_paths)
+    def built_templates # :nodoc:
+      @unbound_templates.values.flatten.flat_map(&:built_templates)
+    end
+
+    private
+      def _find_all(name, prefix, partial, details, key, locals)
+        requested_details = key || TemplateDetails::Requested.new(**details)
+        cache = key ? @unbound_templates : Concurrent::Map.new
 
-        template_paths.map do |template|
-          unbound_template =
-            if cache
-              @unbound_templates.compute_if_absent([template, path.virtual]) do
-                build_unbound_template(template, path.virtual)
-              end
-            else
-              build_unbound_template(template, path.virtual)
-            end
+        unbound_templates =
+          cache.compute_if_absent(TemplatePath.virtual(name, prefix, partial)) do
+            path = TemplatePath.build(name, prefix, partial)
+            unbound_templates_from_path(path)
+          end
 
+        filter_and_sort_by_details(unbound_templates, requested_details).map do |unbound_template|
           unbound_template.bind_locals(locals)
         end
       end
@@ -237,196 +150,66 @@ module ActionView
         Template::Sources::File.new(template)
       end
 
-      def build_unbound_template(template, virtual_path)
-        handler, format, variant = extract_handler_and_format_and_variant(template)
+      def build_unbound_template(template)
+        parsed = @path_parser.parse(template.from(@path.size + 1))
+        details = parsed.details
         source = source_for_template(template)
 
         UnboundTemplate.new(
           source,
           template,
-          handler,
-          virtual_path: virtual_path,
-          format: format,
-          variant: variant,
+          details: details,
+          virtual_path: parsed.path.virtual,
         )
       end
 
-      def reject_files_external_to_app(files)
-        files.reject { |filename| !inside_path?(@path, filename) }
-      end
-
-      def find_template_paths_from_details(path, details)
+      def unbound_templates_from_path(path)
         if path.name.include?(".")
-          ActiveSupport::Deprecation.warn("Rendering actions with '.' in the name is deprecated: #{path}")
-        end
-
-        query = build_query(path, details)
-        find_template_paths(query)
-      end
-
-      def find_template_paths(query)
-        Dir[query].uniq.reject do |filename|
-          File.directory?(filename) ||
-            # deals with case-insensitive file systems.
-            !File.fnmatch(query, filename, File::FNM_EXTGLOB)
-        end
-      end
-
-      def inside_path?(path, filename)
-        filename = File.expand_path(filename)
-        path = File.join(path, "")
-        filename.start_with?(path)
-      end
-
-      # Helper for building query glob string based on resolver's pattern.
-      def build_query(path, details)
-        query = @pattern.dup
-
-        prefix = path.prefix.empty? ? "" : "#{escape_entry(path.prefix)}\\1"
-        query.gsub!(/:prefix(\/)?/, prefix)
-
-        partial = escape_entry(path.partial? ? "_#{path.name}" : path.name)
-        query.gsub!(":action", partial)
-
-        details.each do |ext, candidates|
-          if ext == :variants && candidates == :any
-            query.gsub!(/:#{ext}/, "*")
-          else
-            query.gsub!(/:#{ext}/, "{#{candidates.compact.uniq.join(',')}}")
-          end
+          return []
         end
 
-        File.expand_path(query, @path)
-      end
-
-      def escape_entry(entry)
-        entry.gsub(/[*?{}\[\]]/, '\\\\\\&')
-      end
-
-      # Extract handler, formats and variant from path. If a format cannot be found neither
-      # from the path, or the handler, we should return the array of formats given
-      # to the resolver.
-      def extract_handler_and_format_and_variant(path)
-        details = @path_parser.parse(path)
-
-        handler = Template.handler_for_extension(details[:handler])
-        format = details[:format] || handler.try(:default_format)
-        variant = details[:variant]
-
-        # Template::Types[format] and handler.default_format can return nil
-        [handler, format, variant]
-      end
-  end
-
-  # A resolver that loads files from the filesystem.
-  class FileSystemResolver < PathResolver
-    attr_reader :path
-
-    def initialize(path)
-      raise ArgumentError, "path already is a Resolver class" if path.is_a?(Resolver)
-      super()
-      @path = File.expand_path(path)
-    end
-
-    def to_s
-      @path.to_s
-    end
-    alias :to_path :to_s
-
-    def eql?(resolver)
-      self.class.equal?(resolver.class) && to_path == resolver.to_path
-    end
-    alias :== :eql?
-  end
-
-  # An Optimized resolver for Rails' most common case.
-  class OptimizedFileSystemResolver < FileSystemResolver #:nodoc:
-    def initialize(path)
-      super(path)
-    end
-
-    private
-      def find_candidate_template_paths(path)
         # Instead of checking for every possible path, as our other globs would
         # do, scan the directory for files with the right prefix.
-        query = "#{escape_entry(File.join(@path, path))}*"
+        paths = template_glob("#{escape_entry(path.to_s)}*")
 
-        Dir[query].reject do |filename|
-          File.directory?(filename)
+        paths.map do |path|
+          build_unbound_template(path)
+        end.select do |template|
+          # Select for exact virtual path match, including case sensitivity
+          template.virtual_path == path.virtual
         end
       end
 
-      def find_template_paths_from_details(path, details)
-        if path.name.include?(".")
-          # Fall back to the unoptimized resolver, which will warn
-          return super
+      def filter_and_sort_by_details(templates, requested_details)
+        filtered_templates = templates.select do |template|
+          template.details.matches?(requested_details)
         end
 
-        candidates = find_candidate_template_paths(path)
-
-        regex = build_regex(path, details)
-
-        candidates.uniq.reject do |filename|
-          # This regex match does double duty of finding only files which match
-          # details (instead of just matching the prefix) and also filtering for
-          # case-insensitive file systems.
-          !regex.match?(filename) ||
-            File.directory?(filename)
-        end.sort_by do |filename|
-          # Because we scanned the directory, instead of checking for files
-          # one-by-one, they will be returned in an arbitrary order.
-          # We can use the matches found by the regex and sort by their index in
-          # details.
-          match = filename.match(regex)
-          EXTENSIONS.keys.map do |ext|
-            if ext == :variants && details[ext] == :any
-              match[ext].nil? ? 0 : 1
-            elsif match[ext].nil?
-              # No match should be last
-              details[ext].length
-            else
-              found = match[ext].to_sym
-              details[ext].index(found)
-            end
+        if filtered_templates.count > 1
+          filtered_templates.sort_by! do |template|
+            template.details.sort_key_for(requested_details)
           end
         end
-      end
 
-      def build_regex(path, details)
-        query = Regexp.escape(File.join(@path, path))
-        exts = EXTENSIONS.map do |ext, prefix|
-          match =
-            if ext == :variants && details[ext] == :any
-              ".*?"
-            else
-              arr = details[ext].compact
-              arr.uniq!
-              arr.map! { |e| Regexp.escape(e) }
-              arr.join("|")
-            end
-          prefix = Regexp.escape(prefix)
-          "(#{prefix}(?<#{ext}>#{match}))?"
-        end.join
-
-        %r{\A#{query}#{exts}\z}
+        filtered_templates
       end
-  end
 
-  # The same as FileSystemResolver but does not allow templates to store
-  # a virtual path since it is invalid for such resolvers.
-  class FallbackFileSystemResolver < FileSystemResolver #:nodoc:
-    private_class_method :new
+      # Safe glob within @path
+      def template_glob(glob)
+        query = File.join(escape_entry(@path), glob)
+        path_with_slash = File.join(@path, "")
 
-    def self.instances
-      [new(""), new("/")]
-    end
+        Dir.glob(query).filter_map do |filename|
+          filename = File.expand_path(filename)
+          next if File.directory?(filename)
+          next unless filename.start_with?(path_with_slash)
 
-    def build_unbound_template(template, _)
-      super(template, nil)
-    end
+          filename
+        end
+      end
 
-    def reject_files_external_to_app(files)
-      files
-    end
+      def escape_entry(entry)
+        entry.gsub(/[*?{}\[\]]/, '\\\\\\&')
+      end
   end
 end