herb 0.10.3-x86-linux-gnu → 0.11.0-x86-linux-gnu

data/sig/herb/fingerprint.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/herb/fingerprint.rb with RBS::Inline
+
+module Herb
+  # Identifies content by what it is instead of by where it lives or when it was touched.
+  #
+  #     Herb::Fingerprint.file(asset)      #=> "9f2a1c4e…"
+  #     Herb::Fingerprint.template(source) #=> "d242d277…"
+  module Fingerprint
+    BOM: String
+
+    SHORT_LENGTH: Integer
+
+    # : (String?) -> String?
+    def self.of: (String?) -> String?
+
+    # : ((String | Pathname)?) -> String?
+    def self.file: ((String | Pathname)?) -> String?
+
+    # : (String?) -> String?
+    def self.template: (String?) -> String?
+
+    # : ((String | Pathname)?) -> String?
+    def self.template_file: ((String | Pathname)?) -> String?
+
+    # : (String?) -> String?
+    def self.short: (String?) -> String?
+
+    # : () -> void
+    def self.clear_cache: () -> void
+
+    # : () -> Hash[Array[untyped], String]
+    def self.cache: () -> Hash[Array[untyped], String]
+
+    # : (String) -> String
+    def self.strip_bom: (String) -> String
+  end
+end

data/sig/herb/html/elements.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/herb/html/elements.rb with RBS::Inline
+
+module Herb
+  module HTML
+    module Elements
+      RAW_TEXT_ELEMENTS: Array[String]
+
+      RCDATA_ELEMENTS: Array[String]
+
+      VOID_ELEMENTS: Array[String]
+
+      BOOLEAN_ATTRIBUTES: Array[String]
+
+      WHITESPACE_PRESERVING_ELEMENTS: Array[String]
+
+      INLINE_ELEMENTS: Array[String]
+    end
+  end
+end

data/sig/herb/html/util.rbs

@@ -3,11 +3,25 @@
 module Herb
   module HTML
     module Util
-      # TODO: extract to shared utility for all languages in .yml
       VOID_ELEMENTS: Array[String]
 
+      RCDATA_ELEMENTS: Array[String]
+
+      RAW_TEXT_ELEMENTS: Array[String]
+
+      BOOLEAN_ATTRIBUTES: Array[String]
+
       # : (String) -> bool
       def self.void_element?: (String) -> bool
+
+      # : (String) -> bool
+      def self.rcdata_element?: (String) -> bool
+
+      # : (String) -> bool
+      def self.raw_text_element?: (String) -> bool
+
+      # : (String) -> bool
+      def self.boolean_attribute?: (String) -> bool
     end
   end
 end

data/sig/herb/lex_result.rbs

@@ -6,11 +6,5 @@ module Herb
 
     # : (Array[Herb::Token], String, Array[Herb::Warnings::Warning], Array[Herb::Errors::Error]) -> void
     def initialize: (Array[Herb::Token], String, Array[Herb::Warnings::Warning], Array[Herb::Errors::Error]) -> void
-
-    # : () -> bool
-    def success?: () -> bool
-
-    # : () -> bool
-    def failed?: () -> bool
   end
 end

data/sig/herb/locate.rbs

@@ -0,0 +1,89 @@
+# Generated from lib/herb/locate.rb with RBS::Inline
+
+module Herb
+  # Finds the most specific node at a position, and the nodes it sits inside.
+  #
+  #     result = document.locate(Herb::Position.from(2, 7))
+  #
+  #     result.node      #=> the innermost node whose location contains the position
+  #     result.ancestors #=> every node it sits inside, nearest first
+  #
+  # A node and a parse result both answer, so a walk starts from whichever one a caller already
+  # holds. `Herb::AST::Node#locate` and `Herb::ParseResult#locate` are the same walk from different
+  # starting points.
+  #
+  # Everything that reads a position back from a rendered page, an editor, or a diagnostic needs
+  # this, and every caller was writing its own descent. A finding at `2:7` is a node before it is
+  # anything a person can act on.
+  #
+  # `ancestors` reads nearest first, the way `caller` does, so the enclosing element a caller wants
+  # is the first one that answers:
+  #
+  #     result.ancestors.find { |node| node.is_a?(Herb::AST::HTMLElementNode) }
+  #
+  # A node's location contains its start and stops short of its end, so two nodes sitting next to
+  # each other never both answer for the character between them. A position past the end of the
+  # source belongs to no node, and the answer is `nil`.
+  #
+  # Columns are 0-based character offsets into their line, which is what the parser reports.
+  # `Herb::Position#to_one_based` is what turns one into what an editor shows.
+  #
+  # `Herb::Locate::Result` holds what was found, and what it was found inside.
+  #
+  #     result.node      #=> #<Herb::AST::LiteralNode>
+  #     result.ancestors #=> [#<...HTMLAttributeNameNode>, #<...HTMLAttributeNode>, ...]
+  class Locate
+    class Result
+      attr_reader node: Herb::AST::Node
+
+      attr_reader ancestors: Array[Herb::AST::Node]
+
+      # : (Herb::AST::Node, Array[Herb::AST::Node]) -> void
+      def initialize: (Herb::AST::Node, Array[Herb::AST::Node]) -> void
+
+      # : (untyped) -> Herb::AST::Node?
+      def innermost: (untyped) -> Herb::AST::Node?
+
+      # : () -> Array[Herb::AST::Node]
+      def path: () -> Array[Herb::AST::Node]
+
+      # : () -> String
+      def inspect: () -> String
+    end
+
+    # : ((Herb::AST::Node | Herb::ParseResult), Herb::Position) -> Result?
+    def self.call: (Herb::AST::Node | Herb::ParseResult, Herb::Position) -> Result?
+
+    # : ((Herb::AST::Node | Herb::ParseResult), Herb::Position) -> bool
+    def self.locatable?: (Herb::AST::Node | Herb::ParseResult, Herb::Position) -> bool
+
+    # : ((Herb::AST::Node | Herb::ParseResult)) -> Herb::AST::Node
+    def self.root: (Herb::AST::Node | Herb::ParseResult) -> Herb::AST::Node
+
+    # : (Herb::Position) -> void
+    def initialize: (Herb::Position) -> void
+
+    # : ((Herb::AST::Node | Herb::ParseResult)) -> Result?
+    def call: (Herb::AST::Node | Herb::ParseResult) -> Result?
+
+    # : ((Herb::AST::Node | Herb::ParseResult)) -> bool
+    def locatable?: (Herb::AST::Node | Herb::ParseResult) -> bool
+
+    private
+
+    # : (Herb::AST::Node, Array[Herb::AST::Node]) -> Result?
+    def descend: (Herb::AST::Node, Array[Herb::AST::Node]) -> Result?
+
+    # : (Herb::AST::Node) -> bool
+    def contains?: (Herb::AST::Node) -> bool
+
+    # : (Herb::AST::Node) -> bool
+    def within_extent?: (Herb::AST::Node) -> bool
+
+    # : (Herb::AST::Node) -> Herb::Location?
+    def extent: (Herb::AST::Node) -> Herb::Location?
+
+    # : (Herb::Location?, Herb::Location) -> Herb::Location
+    def union: (Herb::Location?, Herb::Location) -> Herb::Location
+  end
+end

data/sig/herb/location.rbs

@@ -19,6 +19,18 @@ module Herb
     # : (Integer, Integer, Integer, Integer) -> Location
     def self.[]: (Integer, Integer, Integer, Integer) -> Location
 
+    # : () -> Location
+    def self.zero: () -> Location
+
+    # : (Position) -> bool
+    def contains?: (Position) -> bool
+
+    # : (Location) -> bool
+    def covers?: (Location) -> bool
+
+    # : () -> bool
+    def empty?: () -> bool
+
     # : () -> serialized_location
     def to_hash: () -> serialized_location
 

data/sig/herb/parse_result.rbs

@@ -6,21 +6,23 @@ module Herb
 
     attr_reader options: Herb::ParserOptions
 
-    # : (Herb::AST::DocumentNode, String, Array[Herb::Warnings::Warning], Array[Herb::Errors::Error], Herb::ParserOptions) -> void
-    def initialize: (Herb::AST::DocumentNode, String, Array[Herb::Warnings::Warning], Array[Herb::Errors::Error], Herb::ParserOptions) -> void
+    attr_reader error_count: Integer?
+
+    # : (Herb::AST::DocumentNode, String, Array[Herb::Warnings::Warning], Array[Herb::Errors::Error], Herb::ParserOptions, ?Integer?) -> void
+    def initialize: (Herb::AST::DocumentNode, String, Array[Herb::Warnings::Warning], Array[Herb::Errors::Error], Herb::ParserOptions, ?Integer?) -> void
 
     # : () -> Array[Herb::Errors::Error]
     def errors: () -> Array[Herb::Errors::Error]
 
-    # : () -> bool
-    def failed?: () -> bool
-
-    # : () -> bool
-    def success?: () -> bool
-
     # : () -> String
     def pretty_errors: () -> String
 
+    # : (Herb::Position) -> Herb::Locate::Result?
+    def locate: (Herb::Position) -> Herb::Locate::Result?
+
+    # : (Herb::Position) -> bool
+    def locatable?: (Herb::Position) -> bool
+
     # : (Visitor) -> void
     def visit: (Visitor) -> void
   end

data/sig/herb/parser_options.rbs

@@ -2,59 +2,85 @@
 
 module Herb
   class ParserOptions
-    attr_reader strict: bool
-
-    attr_reader track_whitespace: bool
+    attr_reader action_view_helpers: bool
 
     attr_reader analyze: bool
 
-    attr_reader action_view_helpers: bool
+    attr_reader arena_stats: bool
 
-    attr_reader transform_conditionals: bool
+    attr_reader dot_notation_tags: bool
 
-    attr_reader render_nodes: bool
+    attr_reader erb_openers: Array[String]
 
-    attr_reader strict_locals: bool
+    attr_reader herb_directives: bool
 
-    attr_reader prism_program: bool
+    attr_reader html: bool
+
+    attr_reader iteration_nodes: bool
+
+    attr_reader max_errors: Integer?
 
     attr_reader prism_nodes: bool
 
     attr_reader prism_nodes_deep: bool
 
+    attr_reader prism_program: bool
+
+    attr_reader render_nodes: bool
+
+    attr_reader strict: bool
+
+    attr_reader strict_locals: bool
+
     attr_reader timeout: Numeric
 
-    attr_reader max_errors: Integer?
+    attr_reader track_locations: bool
 
-    DEFAULT_STRICT: bool
+    attr_reader track_whitespace: bool
 
-    DEFAULT_TRACK_WHITESPACE: bool
+    attr_reader transform_conditionals: bool
+
+    DEFAULT_ACTION_VIEW_HELPERS: bool
 
     DEFAULT_ANALYZE: bool
 
-    DEFAULT_ACTION_VIEW_HELPERS: bool
+    DEFAULT_CAPTURE_ARENA_STATS: bool
 
-    DEFAULT_TRANSFORM_CONDITIONALS: bool
+    DEFAULT_DOT_NOTATION_TAGS: bool
 
-    DEFAULT_RENDER_NODES: bool
+    DEFAULT_HERB_DIRECTIVES: bool
 
-    DEFAULT_STRICT_LOCALS: bool
+    DEFAULT_HTML: bool
 
-    DEFAULT_PRISM_PROGRAM: bool
+    DEFAULT_ITERATION_NODES: bool
+
+    DEFAULT_MAX_ERRORS: Integer
 
     DEFAULT_PRISM_NODES: bool
 
     DEFAULT_PRISM_NODES_DEEP: bool
 
+    DEFAULT_PRISM_PROGRAM: bool
+
+    DEFAULT_RENDER_NODES: bool
+
+    DEFAULT_STRICT: bool
+
+    DEFAULT_STRICT_LOCALS: bool
+
     DEFAULT_TIMEOUT: Numeric
 
-    DEFAULT_MAX_ERRORS: Integer
+    DEFAULT_TRACK_LOCATIONS: bool
+
+    DEFAULT_TRACK_WHITESPACE: bool
+
+    DEFAULT_TRANSFORM_CONDITIONALS: bool
 
-    # : (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?render_nodes: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?timeout: Numeric) -> void
-    def initialize: (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?render_nodes: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?timeout: Numeric) -> void
+    # : (?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: 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
 
-    # : () -> Hash[Symbol, (bool | Numeric | nil)]
-    def to_h: () -> Hash[Symbol, bool | Numeric | nil]
+    # : () -> Hash[Symbol, (bool | Numeric | Array[String] | nil)]
+    def to_h: () -> Hash[Symbol, bool | Numeric | Array[String] | nil]
 
     # : () -> String
     def inspect: () -> String

data/sig/herb/position.rbs

@@ -3,6 +3,8 @@
 module Herb
   # : type serialized_position = { line: Integer, column: Integer }
   class Position
+    include Comparable
+
     attr_reader line: Integer
 
     attr_reader column: Integer
@@ -16,9 +18,18 @@ module Herb
     # : (Integer, Integer) -> Position
     def self.from: (Integer, Integer) -> Position
 
+    # : () -> Position
+    def self.zero: () -> Position
+
+    # : (untyped) -> Integer?
+    def <=>: (untyped) -> Integer?
+
     # : () -> serialized_position
     def to_hash: () -> serialized_position
 
+    # : () -> serialized_position
+    def to_one_based: () -> serialized_position
+
     # : (?untyped) -> String
     def to_json: (?untyped) -> String
 

data/sig/herb/range.rbs

@@ -16,6 +16,9 @@ module Herb
     # : (Integer, Integer) -> Range
     def self.from: (Integer, Integer) -> Range
 
+    # : () -> Range
+    def self.zero: () -> Range
+
     # : () -> serialized_range
     def to_a: () -> serialized_range
 

data/sig/herb/ruby_program.rbs

@@ -0,0 +1,51 @@
+# Generated from lib/herb/ruby_program.rb with RBS::Inline
+
+module Herb
+  # Answers what Ruby a span of a template holds, out of the one Prism program the parser built
+  # for the whole document. `extract_ruby` blanks the HTML in place, so a Prism byte offset and a
+  # template byte offset are the same number, which is what lets a `Herb::Location` address Ruby.
+  #
+  #     program = Herb::RubyProgram.for(document)
+  #     program.resolve(node.content.location)&.nodes #=> [#<Prism::CallNode>]
+  #
+  # The document has to have been parsed with the `prism_program` parser option, and `for` answers
+  # `nil` when it was not. `Herb::Locate` is the same question asked of the HTML tree, and
+  # `Herb::Analysis::RubyLocalsIndex::OffsetTable` walks the other way, from a Prism offset back
+  # to a `Herb::Location`.
+  class RubyProgram
+    class Resolved < Data
+      attr_reader nodes(): Array[untyped]
+
+      attr_reader offset(): Integer
+
+      attr_reader source(): String
+
+      def self.new: (Array[untyped] nodes, Integer offset, String source) -> instance
+                  | (nodes: Array[untyped], offset: Integer, source: String) -> instance
+
+      def self.members: () -> [ :nodes, :offset, :source ]
+
+      def members: () -> [ :nodes, :offset, :source ]
+    end
+
+    # : (untyped) -> RubyProgram?
+    def self.for: (untyped) -> RubyProgram?
+
+    # : (String, untyped) -> void
+    def initialize: (String, untyped) -> void
+
+    # : (Herb::Location?) -> Resolved?
+    def resolve: (Herb::Location?) -> Resolved?
+
+    private
+
+    # : (untyped) -> Array[untyped]
+    def flatten: (untyped) -> Array[untyped]
+
+    # : (Integer, Integer) -> Array[untyped]
+    def enclosed: (Integer, Integer) -> Array[untyped]
+
+    # : (untyped) -> Integer?
+    def offset_of: (untyped) -> Integer?
+  end
+end

data/sig/herb/source_path.rbs

@@ -0,0 +1,132 @@
+# Generated from lib/herb/source_path.rb with RBS::Inline
+
+module Herb
+  # A path, and optionally where in it something is.
+  #
+  #     Herb::SourcePath.new("app/views/posts/_card.html.erb", line: 8, column: 2).to_s
+  #     #=> "app/views/posts/_card.html.erb:8:3"
+  #
+  #     Herb::SourcePath.parse("app/views/posts/_card.html.erb:8:3").position
+  #     #=> #<Herb::Position (8:2)>
+  #
+  # `path:line:column` is what an editor linkifies, what a terminal makes clickable, and what
+  # `data-herb-source` holds. Herb wrote it by hand in five places and they did not agree, because
+  # the column the parser reports is 0-based and the column an editor shows is 1-based. Everything
+  # that reads or writes one of these strings goes through here so that conversion happens once.
+  #
+  # A part that is not known is left out, so a path on its own stays a path:
+  #
+  #     Herb::SourcePath.new("index.html.erb").to_s        #=> "index.html.erb"
+  #     Herb::SourcePath.new("index.html.erb", line: 8).to_s #=> "index.html.erb:8"
+  #
+  # A scheme is optional too, and turns the same reference into something an editor opens:
+  #
+  #     Herb::SourcePath.new(path, line: 8, column: 2, scheme: "vscode").to_s
+  #     #=> "vscode://file/app/views/posts/_card.html.erb:8:3"
+  #
+  # A project turns the same reference into either form. A stamp and a diagnostic show the relative
+  # path, and an editor scheme needs the absolute one:
+  #
+  #     reference = Herb::SourcePath.at(path, position, project_path: Rails.root)
+  #
+  #     reference.relative.to_s                    #=> "app/views/posts/_card.html.erb:8:3"
+  #     reference.absolute.with_scheme("vscode").to_s
+  #     #=> "vscode://file/Users/marco/blog/app/views/posts/_card.html.erb:8:3"
+  #
+  # Neither is guessed. `to_s` writes the path it was handed, so a caller says which one it wants.
+  # An editor scheme names a file from the root, so call `absolute` before putting one on.
+  #
+  # Lines count from one and columns count from zero, which is what the parser reports and what
+  # `Herb::Position` carries. Only `to_s` and `parse` speak the 1-based column an editor shows.
+  class SourcePath
+    PATTERN: Regexp
+
+    FILE_SCHEME_SEPARATOR: String
+
+    attr_reader path: Pathname
+
+    attr_reader project_path: Pathname?
+
+    attr_reader line: Integer?
+
+    attr_reader column: Integer?
+
+    attr_reader scheme: String?
+
+    # : ((String | Pathname), ?project_path: (String | Pathname)?, ?line: Integer?, ?column: Integer?, ?scheme: String?) -> void
+    def initialize: (String | Pathname, ?project_path: (String | Pathname)?, ?line: Integer?, ?column: Integer?, ?scheme: String?) -> void
+
+    # : ((String | Pathname), Herb::Position?, ?project_path: (String | Pathname)?, ?scheme: String?) -> SourcePath
+    def self.at: (String | Pathname, Herb::Position?, ?project_path: (String | Pathname)?, ?scheme: String?) -> SourcePath
+
+    # : ((String | Pathname)) -> Pathname
+    def self.coerce: (String | Pathname) -> Pathname
+
+    # : (String, ?project_path: (String | Pathname)?) -> SourcePath?
+    def self.parse: (String, ?project_path: (String | Pathname)?) -> SourcePath?
+
+    # : (String?) -> Integer?
+    def self.reported_column: (String?) -> Integer?
+
+    # : () -> Herb::Position?
+    def position: () -> Herb::Position?
+
+    # : () -> bool
+    def position?: () -> bool
+
+    # : ((String | Pathname)) -> SourcePath
+    def with_path: (String | Pathname) -> SourcePath
+
+    # : ((String | Pathname)?) -> SourcePath
+    def with_project_path: ((String | Pathname)?) -> SourcePath
+
+    # : () -> bool
+    def absolute?: () -> bool
+
+    # : () -> Pathname
+    def absolute_path: () -> Pathname
+
+    # : () -> Pathname
+    def relative_path: () -> Pathname
+
+    # : () -> SourcePath
+    def absolute: () -> SourcePath
+
+    # : () -> SourcePath
+    def relative: () -> SourcePath
+
+    # : (Herb::Position?) -> SourcePath
+    def with_position: (Herb::Position?) -> SourcePath
+
+    # : (String?) -> SourcePath
+    def with_scheme: (String?) -> SourcePath
+
+    # : () -> String
+    def to_s: () -> String
+
+    # : () -> Pathname
+    def to_pathname: () -> Pathname
+
+    # : (untyped) -> bool
+    def ==: (untyped) -> bool
+
+    alias eql? ==
+
+    # : () -> Integer
+    def hash: () -> Integer
+
+    # : () -> String
+    def inspect: () -> String
+
+    private
+
+    # : () -> String
+    def prefix: () -> String
+
+    # : () -> String
+    def written_path: () -> String
+
+    # : () -> String
+    def suffix: () -> String
+  end
+end

data/sig/herb/token.rbs

@@ -18,6 +18,9 @@ module Herb
 
     attr_reader type: String
 
+    # : (String | Symbol, String, ?location: Location, ?range: Range) -> Token
+    def self.from: (String | Symbol, String, ?location: Location, ?range: Range) -> Token
+
     # : (String, Range, Location, String) -> void
     def initialize: (String, Range, Location, String) -> void
 
@@ -36,8 +39,8 @@ module Herb
     # : () -> String
     def colorize_range: () -> String
 
-    # : (Position) -> String
-    def colorize_position: (Position) -> String
+    # : (Position?) -> String
+    def colorize_position: (Position?) -> String
 
     # : () -> String
     def inspect: () -> String

data/sig/herb/visitor/context/origin.rbs

@@ -0,0 +1,51 @@
+# Generated from lib/herb/visitor/context/origin.rb with RBS::Inline
+
+module Herb
+  class Visitor
+    class Context
+      # Which nodes hold content that was written somewhere other than the file being compiled.
+      #
+      # A visitor that splices one template into another leaves a tree that no longer answers "where
+      # was this written" by itself, and the node it wraps the splice in is one nobody wrote at all.
+      # Both matter to anything reporting a position back to a developer, and neither is visible from
+      # the node alone.
+      #
+      #     origin.authored(wrapper, "app/views/posts/_card.html.erb", from: render_node)
+      #
+      #     origin.of(wrapper).file #=> "app/views/posts/_card.html.erb"
+      #     origin.of(wrapper).from #=> the `render` tag it replaced
+      #
+      # What is recorded is the node holding the content rather than each node of it, because what
+      # was moved is the partial and not each node of the partial. Recording the nodes themselves
+      # would leave nothing saying which of them belong together, and a partial spliced into the
+      # middle of another would split the one around it in two.
+      #
+      # Only nodes that hold content from elsewhere are recorded, so an untouched tree costs nothing.
+      # This lives on the compile rather than on a visitor, because the visitor that needs the answer
+      # is never the one that knows it.
+      class Origin
+        class Entry < Data
+          attr_reader file(): untyped
+
+          attr_reader from(): untyped
+
+          def self.new: (untyped file, untyped from) -> instance
+                      | (file: untyped, from: untyped) -> instance
+
+          def self.members: () -> [ :file, :from ]
+
+          def members: () -> [ :file, :from ]
+        end
+
+        # : () -> void
+        def initialize: () -> void
+
+        # : (Herb::AST::Node, String, ?from: Herb::AST::Node?) -> void
+        def authored: (Herb::AST::Node, String, ?from: Herb::AST::Node?) -> void
+
+        # : (Herb::AST::Node) -> Entry?
+        def of: (Herb::AST::Node) -> Entry?
+      end
+    end
+  end
+end

data/sig/herb/visitor/context/replacements.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/herb/visitor/context/replacements.rb with RBS::Inline
+
+module Herb
+  class Visitor
+    class Context
+      # Which nodes stand in the tree where another node stood when the compile began.
+      #
+      # A visitor that rewrites an ERB tag builds a fresh node for it and puts that where the old
+      # one was. Any other visitor that recorded something about the old node by identity is then
+      # holding a key nothing in the tree matches, and its `finish` walks a tree it no longer
+      # recognizes. The rewriter knows what it swapped and the recorder knows what it recorded, so
+      # the answer has to live on the compile, where both can reach it.
+      #
+      #     replacements.record(tag, wrapped)
+      #
+      #     replacements.original_of(wrapped) #=> tag
+      #
+      # A chain collapses as it is recorded, so a node replaced twice still answers with the node
+      # the compile started from. Only replaced nodes are recorded, so an untouched tree costs
+      # nothing.
+      class Replacements
+        # : () -> void
+        def initialize: () -> void
+
+        # : (Herb::AST::Node, Herb::AST::Node) -> void
+        def record: (Herb::AST::Node, Herb::AST::Node) -> void
+
+        # : (Herb::AST::Node) -> Herb::AST::Node
+        def original_of: (Herb::AST::Node) -> Herb::AST::Node
+
+        # : () -> bool
+        def any?: () -> bool
+
+        # : () { (Herb::AST::Node, Herb::AST::Node) -> void } -> void
+        def each: () { (Herb::AST::Node, Herb::AST::Node) -> void } -> void
+      end
+    end
+  end
+end