actionview 6.1.7.2 → 7.0.6

data/lib/action_view/template/resolver.rb

@@ -10,36 +10,18 @@ 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
+    Path = ActionView::TemplatePath
+    deprecate_constant :Path
 
     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 +40,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 +57,17 @@ 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
-
-      cached(key, [name, prefix, partial], details, locals) do
-        _find_all(name, prefix, partial, details, key, locals)
-      end
+      _find_all(name, prefix, partial, details, key, locals)
     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 +83,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 +103,37 @@ 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)
+    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 +142,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

data/lib/action_view/template/text.rb

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

data/lib/action_view/template/types.rb

@@ -3,8 +3,8 @@
 require "active_support/core_ext/module/attribute_accessors"
 
 module ActionView
-  class Template #:nodoc:
-    class Types
+  class Template # :nodoc:
+    module Types
       class Type
         SET = Struct.new(:symbols).new([ :html, :text, :js, :css, :xml, :json ])
 
@@ -37,21 +37,23 @@ module ActionView
         end
       end
 
-      cattr_accessor :type_klass
+      class << self
+        attr_accessor :type_klass
 
-      def self.delegate_to(klass)
-        self.type_klass = klass
-      end
+        def delegate_to(klass)
+          self.type_klass = klass
+        end
 
-      delegate_to Type
+        def [](type)
+          type_klass[type]
+        end
 
-      def self.[](type)
-        type_klass[type]
+        def symbols
+          type_klass::SET.symbols
+        end
       end
 
-      def self.symbols
-        type_klass::SET.symbols
-      end
+      delegate_to Type
     end
   end
 end

data/lib/action_view/template.rb

@@ -114,6 +114,9 @@ module ActionView
 
     extend Template::Handlers
 
+    singleton_class.attr_accessor :frozen_string_literal
+    @frozen_string_literal = false
+
     attr_reader :identifier, :handler
     attr_reader :variable, :format, :variant, :locals, :virtual_path
 
@@ -297,7 +300,11 @@ module ActionView
         end
 
         begin
-          mod.module_eval(source, identifier, 0)
+          if Template.frozen_string_literal
+            mod.module_eval("# frozen_string_literal: true\n#{source}", identifier, -1)
+          else
+            mod.module_eval(source, identifier, 0)
+          end
         rescue SyntaxError
           # Account for when code in the template is not syntactically valid; e.g. if we're using
           # ERB and the user writes <%= foo( %>, attempting to call a helper `foo` and interpolate
@@ -319,7 +326,16 @@ module ActionView
         # Only locals with valid variable names get set directly. Others will
         # still be available in local_assigns.
         locals = @locals - Module::RUBY_RESERVED_KEYWORDS
-        locals = locals.grep(/\A@?(?![A-Z0-9])(?:[[:alnum:]_]|[^\0-\177])+\z/)
+        deprecated_locals = locals.grep(/\A@+/)
+        if deprecated_locals.any?
+          ActiveSupport::Deprecation.warn(<<~MSG)
+            Passing instance variables to `render` is deprecated.
+            In Rails 7.1, #{deprecated_locals.to_sentence} will be ignored.
+          MSG
+          locals = locals.grep(/\A@?(?![A-Z0-9])(?:[[:alnum:]_]|[^\0-\177])+\z/)
+        else
+          locals = locals.grep(/\A(?![A-Z0-9])(?:[[:alnum:]_]|[^\0-\177])+\z/)
+        end
 
         # Assign for the same variable is to suppress unused variable warning
         locals.each_with_object(+"") { |key, code| code << "#{key} = local_assigns[:#{key}]; #{key} = #{key};" }

data/lib/action_view/template_details.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActionView
+  class TemplateDetails # :nodoc:
+    class Requested
+      attr_reader :locale, :handlers, :formats, :variants
+      attr_reader :locale_idx, :handlers_idx, :formats_idx, :variants_idx
+
+      ANY_HASH = Hash.new(1).merge(nil => 0).freeze
+
+      def initialize(locale:, handlers:, formats:, variants:)
+        @locale = locale
+        @handlers = handlers
+        @formats = formats
+        @variants = variants
+
+        @locale_idx   = build_idx_hash(locale)
+        @handlers_idx = build_idx_hash(handlers)
+        @formats_idx  = build_idx_hash(formats)
+        if variants == :any
+          @variants_idx = ANY_HASH
+        else
+          @variants_idx = build_idx_hash(variants)
+        end
+      end
+
+      private
+        def build_idx_hash(arr)
+          [*arr, nil].each_with_index.to_h.freeze
+        end
+    end
+
+    attr_reader :locale, :handler, :format, :variant
+
+    def initialize(locale, handler, format, variant)
+      @locale = locale
+      @handler = handler
+      @format = format
+      @variant = variant
+    end
+
+    def matches?(requested)
+      requested.formats_idx[@format] &&
+        requested.locale_idx[@locale] &&
+        requested.variants_idx[@variant] &&
+        requested.handlers_idx[@handler]
+    end
+
+    def sort_key_for(requested)
+      [
+        requested.formats_idx[@format],
+        requested.locale_idx[@locale],
+        requested.variants_idx[@variant],
+        requested.handlers_idx[@handler]
+      ]
+    end
+
+    def handler_class
+      Template.handler_for_extension(handler)
+    end
+
+    def format_or_default
+      format || handler_class.try(:default_format)
+    end
+  end
+end