herb 0.10.4 → 0.11.0

data/lib/herb/visitor/stack.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+# typed: true
+
+module Herb
+  class Visitor
+    # The ordered list of passes the engine runs over a template before it compiles.
+    #
+    # Order is part of the contract rather than an implementation detail. A pass that injects nodes
+    # has to run after one that assigns positions to the nodes already there, and a pass that
+    # annotates the final tree has to run last. An array expresses that only by luck, so this adds
+    # the vocabulary to say it:
+    #
+    #     stack.insert_after(Herb::Engine::Slots::Visitor, MyVisitor.new)
+    #
+    # @rbs inherits Array[untyped]
+    class Stack < Array
+      class UnknownVisitorError < ArgumentError; end
+      class OrderError < ArgumentError; end
+
+      DESCRIPTION_LIMIT = 200 #: Integer
+
+      #: (untyped) -> Stack
+      def self.build(visitors)
+        stack = new
+        stack.replace(Array(visitors))
+        stack
+      end
+
+      #: (untyped) -> Stack
+      def self.arrange(visitors)
+        build(visitors).arrange
+      end
+
+      #: () -> Stack
+      def arrange
+        remaining = to_a
+        ordered = [] #: Array[untyped]
+
+        until remaining.empty?
+          ready = remaining.find { |visitor| remaining.none? { |other| !other.equal?(visitor) && precedes?(other, visitor) } }
+
+          raise OrderError, unsatisfiable_message(remaining) unless ready
+
+          ordered << ready
+          remaining.delete_if { |visitor| visitor.equal?(ready) }
+        end
+
+        self.class.build(ordered)
+      end
+
+      #: () -> Array[String]
+      def descriptions
+        map { |visitor|
+          described = visitor.inspect
+
+          described.length > DESCRIPTION_LIMIT ? "#{described[0, DESCRIPTION_LIMIT]}…" : described
+        }
+      end
+
+      #: () -> void
+      def validate_order!
+        each_with_index do |visitor, position|
+          validate_inlining!(visitor, position)
+          validate_reading!(visitor, position)
+          validate_style_blocks!(visitor, position)
+        end
+
+        nil
+      end
+
+      private
+
+      #: (untyped, Integer) -> void
+      def validate_inlining!(visitor, position)
+        return unless answers?(visitor, :inlines_renders?)
+        return if position.zero?
+
+        earlier = self[position - 1]
+
+        raise OrderError, "#{visitor.class} brings markup from other templates into this one, so it has to run first. #{earlier.class} would otherwise never see what it brought in. Put it first in `visitors:`."
+      end
+
+      #: (untyped, Integer) -> void
+      def validate_style_blocks!(visitor, position)
+        return unless answers?(visitor, :reads_style_blocks?)
+
+        rewriter = drop(position + 1).find { |later| answers?(later, :rewrites_style_blocks?) }
+
+        return unless rewriter
+
+        raise OrderError, "#{visitor.class} reads the `<style>` blocks a template holds, so it has to run after #{rewriter.class}, which rewrites them. It would otherwise decide what to do about a block #{rewriter.class} goes on to take out. Put it later in `visitors:`."
+      end
+
+      #: (untyped, Integer) -> void
+      def validate_reading!(visitor, position)
+        return unless answers?(visitor, :reads_erb_source?)
+
+        rewriter = take(position).find { |earlier| answers?(earlier, :rewrites_erb_source?) }
+
+        return unless rewriter
+
+        raise OrderError, "#{visitor.class} reads the ERB a template was written with, so it has to run before #{rewriter.class}, which rewrites it. Put it earlier in `visitors:`."
+      end
+
+      #: (untyped, Symbol) -> bool
+      def answers?(visitor, question)
+        klass = visitor.class
+
+        klass.respond_to?(question) && klass.public_send(question)
+      end
+
+      #: (untyped, untyped) -> bool
+      def precedes?(earlier, later)
+        return true if answers?(earlier, :inlines_renders?)
+        return true if answers?(earlier, :reads_erb_source?) && answers?(later, :rewrites_erb_source?)
+
+        answers?(earlier, :rewrites_style_blocks?) && answers?(later, :reads_style_blocks?)
+      end
+
+      #: (Array[untyped]) -> String
+      def unsatisfiable_message(remaining)
+        knotted = remaining.select { |visitor| blocked?(visitor, remaining) && blocking?(visitor, remaining) }
+        names = (knotted.empty? ? remaining : knotted).map { |visitor| visitor.class.name }.uniq.join(" and ")
+
+        "#{names} each have to run before the other, so no order of the stack satisfies what they declare. Drop one of them, or change what it declares."
+      end
+
+      #: (untyped, Array[untyped]) -> bool
+      def blocked?(visitor, remaining)
+        remaining.any? { |other| !other.equal?(visitor) && precedes?(other, visitor) }
+      end
+
+      #: (untyped, Array[untyped]) -> bool
+      def blocking?(visitor, remaining)
+        remaining.any? { |other| !other.equal?(visitor) && precedes?(visitor, other) }
+      end
+
+      public
+
+      #: (untyped) -> Stack
+      def use(visitor)
+        push(visitor)
+
+        self
+      end
+
+      # Takes an index, the way `Array#insert` does, or a visitor class to place against.
+      #: ((Integer | Module), *untyped) -> Stack
+      def insert(anchor, *visitors)
+        index = position_of(anchor)
+
+        visitors.reverse_each { |visitor| super(index, visitor) }
+
+        self
+      end
+
+      alias insert_before insert
+
+      #: ((Integer | Module), *untyped) -> Stack
+      def insert_after(anchor, *visitors)
+        index = position_of(anchor) + 1
+
+        visitors.reverse_each { |visitor| insert(index, visitor) }
+
+        self
+      end
+
+      #: (Module) -> bool
+      def include_visitor?(anchor)
+        any?(anchor)
+      end
+
+      private
+
+      #: ((Integer | Module)) -> Integer
+      def position_of(anchor)
+        return anchor if anchor.is_a?(Integer)
+
+        index_of(anchor)
+      end
+
+      #: (Module) -> Integer
+      def index_of(anchor)
+        index = find_index { |visitor| visitor.is_a?(anchor) }
+
+        raise UnknownVisitorError, "no visitor in the stack is a #{anchor}" unless index
+
+        index
+      end
+    end
+  end
+end

data/lib/herb/visitor.rb

@@ -2,11 +2,17 @@
 # typed: true
 
 # NOTE: This file is generated by the templates/template.rb script and should not be
-# modified manually. See /home/runner/work/herb/herb/templates/lib/herb/visitor.rb.erb
+# modified manually. See templates/lib/herb/visitor.rb.erb
+
+require_relative "visitor/parser_option_requirements"
 
 module Herb
   class Visitor
     include AST::Helpers
+    include ParserOptionRequirements
+
+    # @rbs!
+    #   extend Herb::Visitor::ParserOptionRequirements::ClassMethods
 
     #: (Herb::AST::Node?) -> void
     def visit(node)
@@ -148,6 +154,12 @@ module Herb
       visit_child_nodes(node)
     end
 
+    #: (Herb::AST::XMLProcessingInstructionNode) -> void
+    def visit_xml_processing_instruction_node(node)
+      visit_node(node)
+      visit_child_nodes(node)
+    end
+
     #: (Herb::AST::CDATANode) -> void
     def visit_cdata_node(node)
       visit_node(node)
@@ -195,6 +207,13 @@ module Herb
       visit_child_nodes(node)
     end
 
+    #: (Herb::AST::ERBIterationBlockNode) -> void
+    def visit_erb_iteration_block_node(node)
+      visit_node(node)
+      visit_erb_node(node)
+      visit_child_nodes(node)
+    end
+
     #: (Herb::AST::ERBWhenNode) -> void
     def visit_erb_when_node(node)
       visit_node(node)
@@ -311,5 +330,32 @@ module Herb
       visit_child_nodes(node)
     end
 
+    #: (Herb::AST::HerbDirectiveNode) -> void
+    def visit_herb_directive_node(node)
+      visit_node(node)
+      visit_erb_node(node)
+      visit_child_nodes(node)
+    end
+
+    #: (Herb::AST::HerbStateDeclarationNode) -> void
+    def visit_herb_state_declaration_node(node)
+      visit_node(node)
+      visit_child_nodes(node)
+    end
+
+    #: (Herb::AST::HerbStateDirectiveNode) -> void
+    def visit_herb_state_directive_node(node)
+      visit_node(node)
+      visit_erb_node(node)
+      visit_child_nodes(node)
+    end
+
+    #: (Herb::AST::ERBCommentNode) -> void
+    def visit_erb_comment_node(node)
+      visit_node(node)
+      visit_erb_node(node)
+      visit_child_nodes(node)
+    end
+
   end
 end

data/lib/herb/warnings.rb

@@ -44,5 +44,30 @@ module Herb
         to_hash.to_json(state)
       end
     end
+
+    # TODO: move to `config.yml` so they are in line with the way errors are defined and generated.
+    class UnkeyedCollectionWarning < Warning
+      attr_reader :expression #: String?
+      attr_reader :tag_name #: String?
+
+      #: (Location, ?String?, ?tag_name: String?) -> void
+      def initialize(location, expression = nil, tag_name: nil)
+        @expression = expression
+        @tag_name = tag_name
+
+        remediation =
+          if tag_name
+            "Add a `herb-key` or `id` attribute to `<#{tag_name}>`"
+          else
+            "Add a `<%# herb:key ... %>` directive to this collection, or wrap each row in a single element with a `herb-key` or `id` attribute,"
+          end
+
+        super(
+          "unkeyed_collection",
+          location,
+          "#{remediation} so rows can be matched across updates. Without a key, inserting or reordering the collection re-renders every following row and discards its focus, scroll, and input state."
+        )
+      end
+    end
   end
 end

data/lib/herb.rb

@@ -1,15 +1,8 @@
 # frozen_string_literal: true
 # typed: false
 
-module Herb
-  PARTIAL_EXTENSIONS = [
-    ".html.erb", ".html.herb", ".erb", ".herb", ".turbo_stream.erb", ".turbo_stream.herb"
-  ].freeze
-
-  PARTIAL_GLOB_PATTERN = "_*.{html.erb,html.herb,erb,herb,turbo_stream.erb,turbo_stream.herb}"
-end
-
 require_relative "herb/colors"
+require_relative "herb/fingerprint"
 require_relative "herb/range"
 require_relative "herb/position"
 require_relative "herb/location"
@@ -21,39 +14,34 @@ require_relative "herb/result"
 require_relative "herb/lex_result"
 require_relative "herb/parser_options"
 require_relative "herb/parse_result"
-require_relative "herb/diff_operation"
-require_relative "herb/diff_result"
+require_relative "herb/diff"
+require_relative "herb/backend"
 
-require_relative "herb/ast"
 require_relative "herb/ast/node"
 require_relative "herb/ast/nodes"
 require_relative "herb/ast/erb_content_node"
 require_relative "herb/ast/helpers"
 require_relative "herb/ast/erb_render_node"
+require_relative "herb/ast/herb_directive_node"
 
 require_relative "herb/errors"
 require_relative "herb/warnings"
-
-require_relative "herb/cli"
-require_relative "herb/project"
-require_relative "herb/configuration"
+require_relative "herb/diagnostic"
 
 require_relative "herb/version"
-
-require_relative "herb/html/util"
+require_relative "herb/ensure_installed"
 require_relative "herb/visitor"
-require_relative "herb/engine"
 
 begin
   major, minor, _patch = RUBY_VERSION.split(".") #: [String, String, String]
 
   if RUBY_PATCHLEVEL == -1
-    require "herb/herb"
+    require_relative "herb/herb"
   else
     begin
-      require "herb/#{major}.#{minor}/herb"
+      require_relative "herb/#{major}.#{minor}/herb"
     rescue LoadError
-      require "herb/herb"
+      require_relative "herb/herb"
     end
   end
 rescue LoadError => e
@@ -79,58 +67,81 @@ rescue LoadError => e
 end
 
 module Herb
-  class << self
-    #: (String path, ?arena_stats: bool) -> LexResult
-    def lex_file(path, **)
-      lex(File.read(path), **)
-    end
+  #: (String input, ?track_whitespace: bool, ?track_locations: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?dot_notation_tags: bool, ?render_nodes: bool, ?strict_locals: bool, ?herb_directives: bool, ?iteration_nodes: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?html: bool, ?erb_openers: Array[String], ?arena_stats: bool) -> ParseResult
+  def self.parse(...)
+    Backend.parse(...)
+  end
 
-    #: (String path, ?track_whitespace: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?arena_stats: bool) -> ParseResult
-    def parse_file(path, **)
-      parse(File.read(path), **)
-    end
+  #: (String input, ?erb_openers: Array[String], ?arena_stats: bool) -> LexResult
+  def self.lex(...)
+    Backend.lex(...)
+  end
 
-    #: (String source) -> Prism::ParseResult
-    def parse_ruby(source)
-      require "prism"
+  #: (String source, ?semicolons: bool, ?comments: bool, ?preserve_positions: bool, ?custom_tags: bool, ?erb_openers: Array[String]) -> String
+  def self.extract_ruby(...)
+    Backend.extract_ruby(...)
+  end
 
-      Prism.parse(source)
-    end
+  #: (String source) -> String
+  def self.extract_html(...)
+    Backend.extract_html(...)
+  end
 
-    def configuration(project_path = nil)
-      @configuration ||= Configuration.load(project_path)
-    end
+  #: (String old_source, String new_source, ?track_whitespace_changes: bool) -> Herb::Diff::Result
+  def self.diff(...)
+    Backend.diff(...)
+  end
 
-    def configure(project_path = nil)
-      @configuration = Configuration.load(project_path)
-    end
+  #: (?arena_stats: bool) -> untyped
+  def self.arena_stats(...)
+    Backend.arena_stats(...)
+  end
 
-    def reset_configuration!
-      @configuration = nil
-    end
+  #: (String source) -> untyped
+  def self.leak_check(...)
+    Backend.leak_check(...)
+  end
 
-    def dev_server_port(project_path = nil)
-      require_relative "herb/dev/server_entry"
+  #: () -> String
+  def self.version
+    Backend.version
+  end
 
-      project_path ||= Dir.pwd
-      entry = Dev::ServerEntry.find_by_project(project_path)
-      entry&.port
-    rescue StandardError
-      nil
-    end
+  #: (String path, ?arena_stats: bool) -> LexResult
+  def self.lex_file(path, arena_stats: ParserOptions::DEFAULT_CAPTURE_ARENA_STATS)
+    lex(File.read(path), arena_stats: arena_stats)
+  end
 
-    def ensure_installed(&block)
-      require "bundler/inline"
+  #: (String path, ?track_whitespace: bool, ?track_locations: bool, ?analyze: bool, ?strict: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?strict_locals: bool, ?herb_directives: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?arena_stats: bool) -> ParseResult
+  def self.parse_file(path, track_locations: ParserOptions::DEFAULT_TRACK_LOCATIONS, track_whitespace: ParserOptions::DEFAULT_TRACK_WHITESPACE, analyze: ParserOptions::DEFAULT_ANALYZE, strict: ParserOptions::DEFAULT_STRICT, action_view_helpers: ParserOptions::DEFAULT_ACTION_VIEW_HELPERS, transform_conditionals: ParserOptions::DEFAULT_TRANSFORM_CONDITIONALS, strict_locals: ParserOptions::DEFAULT_STRICT_LOCALS, herb_directives: ParserOptions::DEFAULT_HERB_DIRECTIVES, prism_nodes: ParserOptions::DEFAULT_PRISM_NODES, prism_nodes_deep: ParserOptions::DEFAULT_PRISM_NODES_DEEP, prism_program: ParserOptions::DEFAULT_PRISM_PROGRAM, arena_stats: ParserOptions::DEFAULT_CAPTURE_ARENA_STATS)
+    parse(File.read(path), track_locations: track_locations, track_whitespace: track_whitespace, analyze: analyze, strict: strict, action_view_helpers: action_view_helpers, transform_conditionals: transform_conditionals, strict_locals: strict_locals, herb_directives: herb_directives, prism_nodes: prism_nodes, prism_nodes_deep: prism_nodes_deep, prism_program: prism_program, arena_stats: arena_stats)
+  end
 
-      verbose = $VERBOSE
-      $VERBOSE = nil
+  #: (String source) -> Prism::ParseResult
+  def self.parse_ruby(source)
+    require "prism"
 
-      gemfile(true, quiet: true) do # steep:ignore
-        source "https://rubygems.org" # steep:ignore
-        instance_eval(&block) # steep:ignore
-      end
-    ensure
-      $VERBOSE = verbose
-    end
+    Prism.parse(source)
+  end
+
+  #: () -> Array[String]
+  def self.default_erb_openings
+    @default_erb_openings ||= Backend.default_erb_openings.freeze
+  end
+
+  def self.configuration(project_path = nil)
+    require_relative "herb/configuration"
+
+    @configuration ||= Configuration.load(project_path)
+  end
+
+  def self.configure(project_path = nil)
+    require_relative "herb/configuration"
+
+    @configuration = Configuration.load(project_path)
+  end
+
+  def self.reset_configuration!
+    @configuration = nil
   end
 end

data/sig/herb/action_view/helper_registry.rbs

@@ -201,10 +201,12 @@ module Herb
 
       DEBUG: ::Symbol
 
-      APPLY_FORM_FOR_OPTIONS_BANG: ::Symbol
-
       BUTTON: ::Symbol
 
+      SUBMIT: ::Symbol
+
+      APPLY_FORM_FOR_OPTIONS_BANG: ::Symbol
+
       CHECKBOX: ::Symbol
 
       COLOR_FIELD: ::Symbol
@@ -251,8 +253,6 @@ module Herb
 
       SEARCH_FIELD: ::Symbol
 
-      SUBMIT: ::Symbol
-
       TELEPHONE_FIELD: ::Symbol
 
       TEXT_FIELD: ::Symbol
@@ -459,6 +459,16 @@ module Herb
 
       URL_FOR: ::Symbol
 
+      JAVASCRIPT_IMPORT_MODULE_TAG: ::Symbol
+
+      JAVASCRIPT_IMPORTMAP_MODULE_PRELOAD_TAGS: ::Symbol
+
+      JAVASCRIPT_IMPORTMAP_TAGS: ::Symbol
+
+      JAVASCRIPT_INLINE_IMPORTMAP_TAG: ::Symbol
+
+      JAVASCRIPT_MODULE_PRELOAD_TAG: ::Symbol
+
       TURBO_EXEMPTS_PAGE_FROM_CACHE: ::Symbol
 
       TURBO_EXEMPTS_PAGE_FROM_CACHE_TAG: ::Symbol
@@ -532,6 +542,22 @@ module Herb
       def maps_to_aria_attribute?: () -> bool
     end
 
+    class HelperBlockArgument
+      attr_reader name: String
+
+      attr_reader position: Integer
+
+      attr_reader type: String
+
+      attr_reader description: String
+
+      # : (String, Integer, String, bool, String) -> void
+      def initialize: (String, Integer, String, bool, String) -> void
+
+      # : () -> bool
+      def optional?: () -> bool
+    end
+
     class HelperImplicitAttribute
       attr_reader name: String
 
@@ -547,6 +573,33 @@ module Herb
       def initialize: (String, String, String?, String, Array[String]) -> void
     end
 
+    class HelperContent
+      attr_reader source: Symbol
+
+      attr_reader arg_position: Integer?
+
+      attr_reader skip_if_hash: bool
+
+      attr_reader to_s_suffix_when_single: bool
+
+      attr_reader positional_arguments_with_block: Integer?
+
+      # : (Symbol, Integer?, bool, bool, Integer?) -> void
+      def initialize: (Symbol, Integer?, bool, bool, Integer?) -> void
+
+      # : () -> bool
+      def first_arg?: () -> bool
+
+      # : () -> bool
+      def block_or_arg?: () -> bool
+
+      # : () -> bool
+      def skip_if_hash?: () -> bool
+
+      # : () -> bool
+      def to_s_suffix_when_single?: () -> bool
+    end
+
     class HelperEntry
       attr_reader name: String
 
@@ -560,6 +613,8 @@ module Herb
 
       attr_reader visibility: String
 
+      attr_reader receiver: String
+
       attr_reader tag_name: String?
 
       attr_reader detect_style: Symbol
@@ -572,16 +627,20 @@ module Herb
 
       attr_reader implicit_attribute: HelperImplicitAttribute?
 
+      attr_reader content: HelperContent?
+
       attr_reader arguments: Array[HelperArgument]
 
       attr_reader options: Array[HelperOption]
 
+      attr_reader block_arguments: Array[HelperBlockArgument]
+
       attr_reader special_behaviors: Array[Symbol]
 
       attr_reader aliases: Array[String]
 
-      # : (name: String, type: Symbol, source: String, gem: String, output: Symbol, visibility: String, tag_name: String?, is_void: bool, supports_block: bool, preferred_for_tag: bool, supported: bool, detect_style: Symbol, description: String, signature: String, documentation_url: String, implicit_attribute: HelperImplicitAttribute?, arguments: Array[HelperArgument], options: Array[HelperOption], special_behaviors: Array[Symbol], aliases: Array[String]) -> void
-      def initialize: (name: String, type: Symbol, source: String, gem: String, output: Symbol, visibility: String, tag_name: String?, is_void: bool, supports_block: bool, preferred_for_tag: bool, supported: bool, detect_style: Symbol, description: String, signature: String, documentation_url: String, implicit_attribute: HelperImplicitAttribute?, arguments: Array[HelperArgument], options: Array[HelperOption], special_behaviors: Array[Symbol], aliases: Array[String]) -> void
+      # : (name: String, type: Symbol, source: String, gem: String, output: Symbol, visibility: String, receiver: String, tag_name: String?, is_void: bool, supports_block: bool, preferred_for_tag: bool, supported: bool, detect_style: Symbol, description: String, signature: String, documentation_url: String, implicit_attribute: HelperImplicitAttribute?, content: HelperContent?, arguments: Array[HelperArgument], options: Array[HelperOption], block_arguments: Array[HelperBlockArgument], special_behaviors: Array[Symbol], aliases: Array[String]) -> void
+      def initialize: (name: String, type: Symbol, source: String, gem: String, output: Symbol, visibility: String, receiver: String, tag_name: String?, is_void: bool, supports_block: bool, preferred_for_tag: bool, supported: bool, detect_style: Symbol, description: String, signature: String, documentation_url: String, implicit_attribute: HelperImplicitAttribute?, content: HelperContent?, arguments: Array[HelperArgument], options: Array[HelperOption], block_arguments: Array[HelperBlockArgument], special_behaviors: Array[Symbol], aliases: Array[String]) -> void
 
       # : () -> bool
       def void?: () -> bool
@@ -601,6 +660,9 @@ module Herb
       # : () -> bool
       def implicit_attribute?: () -> bool
 
+      # : () -> bool
+      def content?: () -> bool
+
       # : () -> bool
       def call_name_detect?: () -> bool
 
@@ -807,10 +869,12 @@ module Herb
 
       DEBUG: HelperEntry
 
-      APPLY_FORM_FOR_OPTIONS_BANG: HelperEntry
-
       BUTTON: HelperEntry
 
+      SUBMIT: HelperEntry
+
+      APPLY_FORM_FOR_OPTIONS_BANG: HelperEntry
+
       CHECKBOX: HelperEntry
 
       COLOR_FIELD: HelperEntry
@@ -857,8 +921,6 @@ module Herb
 
       SEARCH_FIELD: HelperEntry
 
-      SUBMIT: HelperEntry
-
       TELEPHONE_FIELD: HelperEntry
 
       TEXT_FIELD: HelperEntry
@@ -1065,6 +1127,16 @@ module Herb
 
       URL_FOR: HelperEntry
 
+      JAVASCRIPT_IMPORT_MODULE_TAG: HelperEntry
+
+      JAVASCRIPT_IMPORTMAP_MODULE_PRELOAD_TAGS: HelperEntry
+
+      JAVASCRIPT_IMPORTMAP_TAGS: HelperEntry
+
+      JAVASCRIPT_INLINE_IMPORTMAP_TAG: HelperEntry
+
+      JAVASCRIPT_MODULE_PRELOAD_TAG: HelperEntry
+
       TURBO_EXEMPTS_PAGE_FROM_CACHE: HelperEntry
 
       TURBO_EXEMPTS_PAGE_FROM_CACHE_TAG: HelperEntry