herb 0.11.0-aarch64-linux-gnu → 0.11.2-aarch64-linux-gnu

data/lib/herb/engine/slots/visitor.rb

@@ -66,6 +66,7 @@ module Herb
         COVERED = "@_herb_covered" #: String
         OCCURRENCES = "@_herb_region_occurrences" #: String
         OCCURRENCE = "_herb_occurrence" #: String
+        POSITION = "__herb_position" #: String
         NAME_ATTRIBUTE = "data-herb-name" #: String
         KEY_ATTRIBUTE = "herb-key" #: String
 
@@ -109,6 +110,15 @@ module Herb
 
           #: () -> bool
           def interpolated? = Types.interpolated?(type)
+
+          #: () -> bool
+          def positional? = type == :collection && key_expression.nil?
+
+          #: () -> String
+          def position_variable = "#{POSITION}#{index}"
+
+          #: () -> String?
+          def item_key = positional? ? "#{position_variable} += 1" : key_expression
         end
 
         #: (String) -> bool
@@ -1202,6 +1212,11 @@ module Herb
           )
         end
 
+        #: (Array[untyped], Integer) -> String
+        def attribute_spacing(children, position)
+          position.positive? && children[position - 1].is_a?(Herb::AST::WhitespaceNode) ? "" : " "
+        end
+
         private
 
         def visit_children_with_paths(children)
@@ -1212,6 +1227,7 @@ module Herb
             @states.check_state_assignment(child)
 
             @path.push(index)
+            record_slot(child, :child) if child.is_a?(Herb::AST::RubyLiteralNode)
             visit(child)
             @path.pop
           end
@@ -1521,7 +1537,7 @@ module Herb
         def convert_helper_boolean_attribute(node)
           open_tag = @current_open_tag
 
-          return nil unless @in_open_tag && open_tag.is_a?(Herb::AST::ERBOpenTagNode)
+          return nil unless @in_open_tag && (open_tag.is_a?(Herb::AST::ERBOpenTagNode) || open_tag.is_a?(Herb::AST::HTMLOpenTagNode))
           return nil if continuation?(node)
           return nil unless node.respond_to?(:subsequent) && node.subsequent.nil?
 
@@ -1540,7 +1556,7 @@ module Herb
           return nil unless name && Herb::HTML::Util.boolean_attribute?(name)
 
           condition = @states.condition_expression(node)
-          replacement = erb_output_node(%[(" #{name}" if #{condition})])
+          replacement = erb_output_node(%[("#{attribute_spacing(children, position)}#{name}" if #{condition})])
 
           children[position] = replacement
           record_slot(replacement, :attribute)
@@ -1864,23 +1880,27 @@ module Herb
           outputs.fetch(0).content&.value&.strip
         end
 
-        def insert_markers(node)
+        #: (untyped, ?Symbol) -> untyped
+        def insert_markers(node, namespace = :html)
           anchored = content_anchor_index(node)
+          namespace = Markers.namespace_within(namespace, node.tag_name&.value&.downcase.to_s) if node.is_a?(Herb::AST::HTMLElementNode)
 
-          each_child_array(node) do |array|
+          each_child_array(node, namespace) do |array|
             index = 0
 
             while index < array.size
               child = array[index]
               slot_index = @standing[child]&.survivor&.index
 
-              insert_markers(child)
-              wrap_items(child, slot_index)
-              mark_branches(child, slot_index)
+              insert_markers(child, namespace)
+              wrap_items(child, slot_index, namespace)
+              mark_branches(child, slot_index, namespace)
+
+              index += insert_position_counter(array, index, slot_index)
 
               if slot_index && slot_index != anchored
                 if @slots[slot_index].type == :keyed
-                  park_keyed(slot_index, child)
+                  park_keyed(slot_index, child, namespace)
 
                   array.insert(
                     index,
@@ -1921,27 +1941,29 @@ module Herb
           annotation.index
         end
 
-        #: (untyped, Integer?) -> void
-        def mark_branches(node, slot_index)
+        #: (untyped, Integer?, ?Symbol) -> void
+        def mark_branches(node, slot_index, namespace = :html)
           return unless slot_index
           return unless @slots[slot_index].type == :conditional
 
           branch_bodies(node).each_with_index do |body, branch_index|
-            body.unshift(text_node(@markers.branch(slot_index, branch_index)))
+            marker = @markers.branch(slot_index, branch_index)
+
+            park_branch(@markers.statics_key(slot_index, branch_index), marker, body, namespace)
 
-            park_branch(@markers.statics_key(slot_index, branch_index), body)
+            body.unshift(text_node(marker))
           end
         end
 
-        #: (String, Array[untyped]) -> void
-        def park_branch(key, body)
+        #: (String, String, Array[untyped], Symbol) -> void
+        def park_branch(key, marker, body, namespace)
           statics = @statics
           return unless statics
 
           markup = Statics.new(@standing).markup(body)
           return unless markup
 
-          statics[key] = markup
+          statics[key] = "#{marker}#{@markers.foreign(markup, namespace)}"
         end
 
         #: (Herb::AST::DocumentNode) -> void
@@ -2062,12 +2084,23 @@ module Herb
           bodies
         end
 
-        #: (Herb::AST::Node, Integer?) -> void
-        def wrap_items(node, slot_index)
+        #: (Array[untyped], Integer, Integer?) -> Integer
+        def insert_position_counter(array, index, slot_index)
+          slot = slot_index ? @slots[slot_index] : nil
+
+          return 0 unless slot&.positional?
+
+          array.insert(index, erb_code_node("#{slot.position_variable} = -1"))
+
+          1
+        end
+
+        #: (Herb::AST::Node, Integer?, ?Symbol) -> void
+        def wrap_items(node, slot_index, namespace = :html)
           return unless slot_index
 
           slot = @slots[slot_index]
-          return unless slot.type == :collection && slot.key_expression
+          return unless slot.type == :collection
 
           BRANCH_BODY_PROPERTIES.each do |property|
             next unless node.respond_to?(property)
@@ -2076,17 +2109,22 @@ module Herb
             next unless body.is_a?(Array) && !body.empty?
 
             key = @markers.item_statics_key(slot_index)
-            parked = park_item(key, body)
+            parked = park_item(key, body, namespace)
 
             body.unshift(
               text_node(@markers.item_open_prefix(slot_index)),
-              erb_code_node("#{@bufvar} << ::Herb::Engine.raw((#{slot.key_expression}).to_s)"),
-              text_node(@markers.item_open_suffix)
+              erb_code_node("#{@bufvar} << ::Herb::Engine.raw((#{slot.item_key}).to_s)"),
+              text_node(@markers.item_open_suffix),
+              erb_code_node("begin")
             )
 
             body.insert(3, erb_code_node(%(#{COVERED}[#{covered_key(key).inspect}] = true))) if parked && client?
 
-            body.push(text_node(@markers.item_close(slot_index)))
+            body.push(
+              erb_code_node("ensure"),
+              text_node(@markers.item_close(slot_index)),
+              erb_code_node("end")
+            )
           end
         end
 
@@ -2112,19 +2150,19 @@ module Herb
           segments.size > 1 ? segments : nil
         end
 
-        #: (Integer, untyped) -> void
-        def park_keyed(slot_index, element)
+        #: (Integer, untyped, Symbol) -> void
+        def park_keyed(slot_index, element, namespace)
           statics = @statics
           return unless statics
 
           markup = Statics.new(@standing).markup([element.open_tag, *element.body, element.close_tag].compact)
           return unless markup
 
-          statics[@markers.item_statics_key(slot_index)] = "#{@markers.branch(slot_index, Markers::ITEM_STATICS)}#{markup}"
+          statics[@markers.item_statics_key(slot_index)] = "#{@markers.branch(slot_index, Markers::ITEM_STATICS)}#{@markers.foreign(markup, namespace)}"
         end
 
-        #: (untyped, untyped) -> Array[untyped]?
-        def park_item(key, body)
+        #: (untyped, untyped, Symbol) -> Array[untyped]?
+        def park_item(key, body, namespace)
           statics = @statics
           return unless statics
 
@@ -2132,13 +2170,14 @@ module Herb
           markup = Statics.new(@standing).markup(body)
           return unless markup
 
-          statics[key] = [
-            @markers.branch(slot_index, Markers::ITEM_STATICS),
+          item = [
             @markers.item_open_prefix(slot_index),
             @markers.item_open_suffix,
             markup,
             @markers.item_close(slot_index)
           ].join
+
+          statics[key] = "#{@markers.branch(slot_index, Markers::ITEM_STATICS)}#{@markers.foreign(item, namespace)}"
         end
 
         def anchor_attributes(node, content_index = nil)
@@ -2173,8 +2212,8 @@ module Herb
           name
         end
 
-        #: (Herb::AST::Node) { (Array[untyped]) -> void } -> void
-        def each_child_array(node)
+        #: (Herb::AST::Node, ?Symbol) { (Array[untyped]) -> void } -> void
+        def each_child_array(node, namespace = :html)
           BRANCH_BODY_PROPERTIES.each do |property|
             next unless node.respond_to?(property)
 
@@ -2186,7 +2225,7 @@ module Herb
             next unless node.respond_to?(property)
 
             child = node.send(property)
-            insert_markers(child) if child
+            insert_markers(child, namespace) if child
           end
         end
 

data/lib/herb/engine/visitors/instrumentation_visitor.rb

@@ -140,6 +140,8 @@ module Herb
 
         instrument(node)
 
+        return [node] if literal?(node)
+
         if framed?(node)
           [enter_node(node), node, leave_node(node)]
         elsif erb_outputs?(node)
@@ -158,6 +160,12 @@ module Herb
         replacement
       end
 
+      def literal?(node)
+        return false unless node.respond_to?(:tag_opening) && node.tag_opening
+
+        erb_escaped?(node.tag_opening.value)
+      end
+
       def framed?(node)
         return true if node.is_a?(Herb::AST::ERBRenderNode)
 
@@ -197,9 +205,9 @@ module Herb
         body = code(node)
         call = captured?(node) ? "output" : "at"
 
-        return erb_node(node, "<%=", "#{SESSION}.#{call}(#{position(node)}) {\n#{body}\n}") if spans_lines?(body)
+        return rewrapped(node, "#{SESSION}.#{call}(#{position(node)}) {\n#{body}\n}") if spans_lines?(body)
 
-        erb_node(node, "<%=", "#{SESSION}.#{call}(#{position(node)}) { #{body} }")
+        rewrapped(node, "#{SESSION}.#{call}(#{position(node)}) { #{body} }")
       end
 
       def captured?(node)
@@ -221,10 +229,10 @@ module Herb
         body = code(node)
 
         if spans_lines?(body)
-          return erb_node(node, "<%", "#{SESSION}.enter(#{position(node)}); begin\n#{body}\nensure; #{SESSION}.leave; end")
+          return rewrapped(node, "#{SESSION}.enter(#{position(node)}); begin\n#{body}\nensure; #{SESSION}.leave; end")
         end
 
-        erb_node(node, "<%", "#{SESSION}.enter(#{position(node)}); begin; #{body}; ensure; #{SESSION}.leave; end")
+        rewrapped(node, "#{SESSION}.enter(#{position(node)}); begin; #{body}; ensure; #{SESSION}.leave; end")
       end
 
       #: (String) -> bool
@@ -276,11 +284,15 @@ module Herb
         node.content&.value.to_s.strip
       end
 
-      def erb_node(node, opening, code)
+      def rewrapped(node, code)
+        erb_node(node, node.tag_opening.value, code, closing: node.tag_closing&.value || "%>")
+      end
+
+      def erb_node(node, opening, code, closing: "%>")
         Herb::AST::ERBContentNode.build(
           tag_opening: Herb::Token.from("TOKEN_ERB_START", opening),
           content: Herb::Token.from("TOKEN_ERB_CONTENT", " #{code} "),
-          tag_closing: Herb::Token.from("TOKEN_ERB_END", "%>"),
+          tag_closing: Herb::Token.from("TOKEN_ERB_END", closing),
           valid: true,
           location: node.location
         )

data/lib/herb/engine.rb

@@ -220,8 +220,6 @@ module Herb
         @src << "\n" << code
         @src << "\n" unless code.end_with?("\n")
       else
-        @src.chomp! if @src.end_with?("\n") && code.start_with?(" ") && !code.end_with?("\n")
-
         @src << " " unless code.match?(/\A\n+\z/)
         @src << code
 

data/lib/herb/parser_options.rb

@@ -19,6 +19,7 @@ module Herb
     attr_reader :prism_nodes_deep #: bool
     attr_reader :prism_program #: bool
     attr_reader :render_nodes #: bool
+    attr_reader :ruby_version #: String?
     attr_reader :strict #: bool
     attr_reader :strict_locals #: bool
     attr_reader :timeout #: Numeric
@@ -45,8 +46,8 @@ module Herb
     DEFAULT_TRACK_WHITESPACE = false #: bool
     DEFAULT_TRANSFORM_CONDITIONALS = false #: bool
 
-    #: (?action_view_helpers: bool, ?analyze: bool, ?arena_stats: bool, ?dot_notation_tags: bool, ?erb_openers: Array[String], ?herb_directives: bool, ?html: bool, ?iteration_nodes: bool, ?max_errors: Integer?, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?render_nodes: bool, ?strict: bool, ?strict_locals: bool, ?timeout: Numeric, ?track_locations: bool, ?track_whitespace: bool, ?transform_conditionals: bool) -> void
-    def initialize(action_view_helpers: DEFAULT_ACTION_VIEW_HELPERS, analyze: DEFAULT_ANALYZE, arena_stats: DEFAULT_CAPTURE_ARENA_STATS, dot_notation_tags: DEFAULT_DOT_NOTATION_TAGS, erb_openers: [], herb_directives: DEFAULT_HERB_DIRECTIVES, html: DEFAULT_HTML, iteration_nodes: DEFAULT_ITERATION_NODES, max_errors: DEFAULT_MAX_ERRORS, prism_nodes: DEFAULT_PRISM_NODES, prism_nodes_deep: DEFAULT_PRISM_NODES_DEEP, prism_program: DEFAULT_PRISM_PROGRAM, render_nodes: DEFAULT_RENDER_NODES, strict: DEFAULT_STRICT, strict_locals: DEFAULT_STRICT_LOCALS, timeout: DEFAULT_TIMEOUT, track_locations: DEFAULT_TRACK_LOCATIONS, track_whitespace: DEFAULT_TRACK_WHITESPACE, transform_conditionals: DEFAULT_TRANSFORM_CONDITIONALS)
+    #: (?action_view_helpers: bool, ?analyze: bool, ?arena_stats: bool, ?dot_notation_tags: bool, ?erb_openers: Array[String], ?herb_directives: bool, ?html: bool, ?iteration_nodes: bool, ?max_errors: Integer?, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?render_nodes: bool, ?ruby_version: String?, ?strict: bool, ?strict_locals: bool, ?timeout: Numeric, ?track_locations: bool, ?track_whitespace: bool, ?transform_conditionals: bool) -> void
+    def initialize(action_view_helpers: DEFAULT_ACTION_VIEW_HELPERS, analyze: DEFAULT_ANALYZE, arena_stats: DEFAULT_CAPTURE_ARENA_STATS, dot_notation_tags: DEFAULT_DOT_NOTATION_TAGS, erb_openers: [], herb_directives: DEFAULT_HERB_DIRECTIVES, html: DEFAULT_HTML, iteration_nodes: DEFAULT_ITERATION_NODES, max_errors: DEFAULT_MAX_ERRORS, prism_nodes: DEFAULT_PRISM_NODES, prism_nodes_deep: DEFAULT_PRISM_NODES_DEEP, prism_program: DEFAULT_PRISM_PROGRAM, render_nodes: DEFAULT_RENDER_NODES, ruby_version: "4.0", strict: DEFAULT_STRICT, strict_locals: DEFAULT_STRICT_LOCALS, timeout: DEFAULT_TIMEOUT, track_locations: DEFAULT_TRACK_LOCATIONS, track_whitespace: DEFAULT_TRACK_WHITESPACE, transform_conditionals: DEFAULT_TRANSFORM_CONDITIONALS)
       @action_view_helpers = action_view_helpers
       @analyze = analyze
       @arena_stats = arena_stats
@@ -60,6 +61,7 @@ module Herb
       @prism_nodes_deep = prism_nodes_deep
       @prism_program = prism_program
       @render_nodes = render_nodes
+      @ruby_version = ruby_version
       @strict = strict
       @strict_locals = strict_locals
       @timeout = timeout
@@ -68,7 +70,7 @@ module Herb
       @transform_conditionals = transform_conditionals
     end
 
-    #: () -> Hash[Symbol, (bool | Numeric | Array[String] | nil)]
+    #: () -> Hash[Symbol, (bool | Numeric | String | Array[String] | nil)]
     def to_h
       {
         action_view_helpers: @action_view_helpers,
@@ -84,6 +86,7 @@ module Herb
         prism_nodes_deep: @prism_nodes_deep,
         prism_program: @prism_program,
         render_nodes: @render_nodes,
+        ruby_version: @ruby_version,
         strict: @strict,
         strict_locals: @strict_locals,
         timeout: @timeout,

data/lib/herb/project.rb

@@ -332,7 +332,7 @@ module Herb
       return unless issue_type[:key] == :invalid_ruby && file_content
 
       begin
-        engine = Herb::Engine.new(file_content, filename: file_path, escape: true, visitors: [])
+        engine = Herb::Engine.new(file_content, filename: file_path, escape: true, parser_options: engine_parser_options, visitors: [])
         puts ""
         puts "**Compiled Ruby:**"
         puts "```ruby"
@@ -345,6 +345,16 @@ module Herb
 
     private
 
+    #: () -> Hash[Symbol, untyped]
+    def parser_options
+      @parser_options ||= configuration.parser_options
+    end
+
+    #: () -> Hash[Symbol, untyped]
+    def engine_parser_options
+      @engine_parser_options ||= configuration.engine_option("parser_options", {}).transform_keys(&:to_sym).merge(parser_options)
+    end
+
     def process_file(file_path)
       isolate ? process_file_isolated(file_path) : process_file_direct(file_path)
     end
@@ -362,7 +372,7 @@ module Herb
       end
 
       Timeout.timeout(file_timeout) do
-        parse_result = Herb.parse(file_content)
+        parse_result = Herb.parse(file_content, **parser_options)
 
         if parse_result.failed?
           result[:file_content] = file_content
@@ -401,7 +411,7 @@ module Herb
           $stderr.reopen(stderr_file.path, "w")
 
           begin
-            parse_result = Herb.parse(file_content)
+            parse_result = Herb.parse(file_content, **parser_options)
             exit!(parse_result.failed? ? 2 : 0)
           rescue StandardError => e
             warn "Ruby exception: #{e.class}: #{e.message}"
@@ -457,7 +467,7 @@ module Herb
     end
 
     def classify_parse_errors(file_path, file_content)
-      default_result = Herb.parse(file_content)
+      default_result = Herb.parse(file_content, **parser_options)
 
       diagnostics = if default_result.respond_to?(:errors) && default_result.errors.any?
                       default_result.errors.map do |error|
@@ -470,8 +480,8 @@ module Herb
                       end
                     end
 
-      no_strict_result = Herb.parse(file_content, strict: false)
-      no_analyze_result = Herb.parse(file_content, analyze: false)
+      no_strict_result = Herb.parse(file_content, **parser_options, strict: false)
+      no_analyze_result = Herb.parse(file_content, **parser_options, analyze: false)
 
       if no_strict_result.success?
         { status: :strict_parse_error, diagnostics: diagnostics,
@@ -496,6 +506,7 @@ module Herb
         file_content,
         filename: file_path,
         escape: true,
+        parser_options: engine_parser_options,
         validate_ruby: validate_ruby,
         visitors: Herb::Engine::Validators.all
       )
@@ -514,7 +525,7 @@ module Herb
 
       # Retry without validators
       begin
-        Herb::Engine.new(file_content, filename: file_path, escape: true, visitors: [], validate_ruby: validate_ruby)
+        Herb::Engine.new(file_content, filename: file_path, escape: true, parser_options: engine_parser_options, visitors: [], validate_ruby: validate_ruby)
         error_name = e.is_a?(Herb::Engine::SecurityError) ? "SecurityError" : "ValidationError"
         return { status: :validation_error, file_content: file_content,
                  compilation_error: compilation_error,
@@ -526,7 +537,7 @@ module Herb
 
       # Retry without strict mode
       begin
-        Herb::Engine.new(file_content, filename: file_path, escape: true, strict: false, validate_ruby: validate_ruby)
+        Herb::Engine.new(file_content, filename: file_path, escape: true, parser_options: engine_parser_options, strict: false, validate_ruby: validate_ruby)
         return { status: :strict_compilation_failed, file_content: file_content,
                  compilation_error: compilation_error,
                  diagnostics: [{ name: "CompilationError", message: "#{e.message} (strict mode)" }],

data/lib/herb/version.rb

@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.11.0"
+  VERSION = "0.11.2"
 end

data/lib/herb.rb

@@ -67,7 +67,7 @@ rescue LoadError => e
 end
 
 module Herb
-  #: (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
+  #: (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], ?ruby_version: String?, ?arena_stats: bool) -> ParseResult
   def self.parse(...)
     Backend.parse(...)
   end

data/sig/herb/analysis/partial_resolution.rbs

@@ -5,6 +5,8 @@ module Herb
     module PartialResolution
       PARTIAL_PREFIX: String
 
+      VARIANT_SEPARATOR: String
+
       EXTENSIONS: Array[String]
 
       EXTENSION_ALTERNATIVES: String
@@ -41,6 +43,12 @@ module Herb
       # : (Array[String]) -> Array[String]
       def self.by_precedence: (Array[String]) -> Array[String]
 
+      # : (String?) -> String?
+      def self.template_variant: (String?) -> String?
+
+      # : (Array[String], String?) -> String?
+      def self.preferred_for: (Array[String], String?) -> String?
+
       # : (String, String | Pathname) -> String?
       def self.template_name_for: (String, String | Pathname) -> String?
 

data/sig/herb/ast/nodes.rbs

@@ -2133,6 +2133,7 @@ module Herb
     # |  tag_opening: Herb::Token?,
     # |  content: Herb::Token?,
     # |  tag_closing: Herb::Token?,
+    # |  prism_node: String?,
     # | }
     class ERBYieldNode < Node
       include Colors
@@ -2143,14 +2144,19 @@ module Herb
 
       attr_reader tag_closing: Herb::Token?
 
-      # : (String, Location, Array[Herb::Errors::Error], Herb::Token?, Herb::Token?, Herb::Token?) -> void
-      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token?, Herb::Token?, Herb::Token?) -> void
+      attr_reader prism_node: String?
+
+      # : (String, Location, Array[Herb::Errors::Error], Herb::Token?, Herb::Token?, Herb::Token?, String?) -> void
+      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token?, Herb::Token?, Herb::Token?, String?) -> void
 
       # : () -> String
       def self.type: () -> String
 
-      # : (?tag_opening: Herb::Token?, ?content: Herb::Token?, ?tag_closing: Herb::Token?, ?location: Location, ?errors: Array[Herb::Errors::Error]) -> ERBYieldNode
-      def self.build: (?tag_opening: Herb::Token?, ?content: Herb::Token?, ?tag_closing: Herb::Token?, ?location: Location, ?errors: Array[Herb::Errors::Error]) -> ERBYieldNode
+      # : (?tag_opening: Herb::Token?, ?content: Herb::Token?, ?tag_closing: Herb::Token?, ?prism_node: String?, ?location: Location, ?errors: Array[Herb::Errors::Error]) -> ERBYieldNode
+      def self.build: (?tag_opening: Herb::Token?, ?content: Herb::Token?, ?tag_closing: Herb::Token?, ?prism_node: String?, ?location: Location, ?errors: Array[Herb::Errors::Error]) -> ERBYieldNode
+
+      # : () -> Prism::node?
+      def deserialized_prism_node: () -> Prism::node?
 
       # : () -> serialized_erb_yield_node
       def to_hash: () -> serialized_erb_yield_node

data/sig/herb/bootstrap.rbs

@@ -26,6 +26,8 @@ module Herb
 
     def self.find_prism_as_bundler_sibling: () -> untyped
 
+    def self.prism_source?: (untyped path) -> untyped
+
     def self.find_prism_from_gem_spec: () -> untyped
   end
 end

data/sig/herb/configuration.rbs

@@ -57,6 +57,9 @@ module Herb
     # : () -> Array[String]
     def erb_openers: () -> Array[String]
 
+    # : () -> String?
+    def ruby_version: () -> String?
+
     # : () -> Hash[Symbol, untyped]
     def parser_options: () -> Hash[Symbol, untyped]
 

data/sig/herb/dev/runner.rbs

@@ -36,6 +36,9 @@ module Herb
       # : () -> bool
       def interactive?: () -> bool
 
+      # : () -> bool
+      def process_manager?: () -> bool
+
       # : (String) -> void
       def terminal: (String) -> void
 

data/sig/herb/engine/compiler.rbs

@@ -65,6 +65,8 @@ module Herb
 
       def visit_erb_comment_node: (untyped node) -> untyped
 
+      def visit_erb_strict_locals_node: (untyped node) -> untyped
+
       def visit_erb_control_node: (untyped node) ?{ (?) -> untyped } -> untyped
 
       def visit_erb_if_node: (untyped node) -> untyped
@@ -105,9 +107,9 @@ module Herb
 
       def visit_erb_block_end_node: (untyped node, ?escaped: untyped) -> untyped
 
-      def case_parts: (untyped node) -> untyped
+      def visit_erb_case_parts: (untyped node) -> untyped
 
-      def visit_erb_control_with_parts: (untyped node, *untyped parts) -> untyped
+      def visit_erb_control_with_parts: (untyped node, *untyped parts) ?{ (?) -> untyped } -> untyped
 
       private
 
@@ -188,7 +190,7 @@ module Herb
 
       def leading_space_follows_newline?: () -> untyped
 
-      def preceding_text_ends_with_newline?: () -> untyped
+      def preceding_token_value_ends_with_newline?: () -> untyped
 
       def extract_and_remove_leading_space!: () -> untyped
 
@@ -205,6 +207,15 @@ module Herb
       # : (bool) -> void
       def settle_pending_trim_newline!: (bool) -> void
 
+      # : (Array[untyped]) -> void
+      def skip_case_children: (Array[untyped]) -> void
+
+      # : (untyped) -> bool
+      def follows_trimmed_statement_tag?: (untyped) -> bool
+
+      # : () -> void
+      def drop_pending_trim_newline!: () -> void
+
       def save_pending_leading_whitespace!: (untyped whitespace) -> untyped
 
       def restore_pending_leading_whitespace!: () -> untyped