herbst 0.0.1 → 0.1.0

data/sig/herbst/cli.rbs

@@ -0,0 +1,101 @@
+# Generated from lib/herbst/cli.rb with RBS::Inline
+
+module Herbst
+  # The `herbst` command.
+  #
+  #   herbst convert app/views/posts/show.html.haml   # prints the ERB
+  #   herbst convert app/views                        # writes show.html.erb next to show.html.haml or .slim
+  #
+  # A single file is printed to stdout unless `--write` is given. Directories and multiple
+  # files are written next to their sources, replacing the `.haml` or `.slim` extension with `.erb`.
+  # Existing ERB files are skipped unless `--force` is given. A file without a format gets
+  # `html`, so `show.haml` becomes `show.html.erb`, while `welcome.text.haml` keeps its format.
+  class CLI
+    class Conversion
+      attr_reader path: String
+
+      attr_reader warnings: Array[String]
+
+      attr_reader error: String?
+
+      attr_reader difference: String?
+
+      attr_accessor erb: String?
+
+      # : (String, ?erb: String?, ?warnings: Array[String], ?error: String?, ?difference: String?) -> void
+      def initialize: (String, ?erb: String?, ?warnings: Array[String], ?error: String?, ?difference: String?) -> void
+
+      # : () -> bool
+      def failed?: () -> bool
+    end
+
+    @option_parser: OptionParser?
+
+    @version: bool
+
+    @help: bool
+
+    @default_format: String?
+
+    @force: bool
+
+    @write: bool
+
+    @verify: bool
+
+    @format: bool
+
+    @stderr: IO
+
+    @stdout: IO
+
+    @arguments: Array[String]
+
+    # : (Array[String], ?stdout: IO, ?stderr: IO) -> void
+    def initialize: (Array[String], ?stdout: IO, ?stderr: IO) -> void
+
+    # : () -> Integer
+    def run: () -> Integer
+
+    private
+
+    # : (Array[String]) -> Integer
+    def convert: (Array[String]) -> Integer
+
+    # : () -> OptionParser
+    def option_parser: () -> OptionParser
+
+    # : (?Integer, ?String?) -> Integer
+    def help: (?Integer, ?String?) -> Integer
+
+    # : () -> Integer
+    def version: () -> Integer
+
+    # : (String) -> Conversion
+    def convert_file: (String) -> Conversion
+
+    # : (String) -> Herbst::Converter
+    def converter_for: (String) -> Herbst::Converter
+
+    # : (Array[Conversion]) -> void
+    def format: (Array[Conversion]) -> void
+
+    # : (Conversion) -> Integer
+    def print_file: (Conversion) -> Integer
+
+    # : (Array[Conversion]) -> Integer
+    def write_files: (Array[Conversion]) -> Integer
+
+    # : (String) -> String
+    def target_path: (String) -> String
+
+    # : (Conversion) -> void
+    def report: (Conversion) -> void
+
+    # : (Integer, Integer, Integer, Integer) -> String
+    def summary: (Integer, Integer, Integer, Integer) -> String
+
+    # : (String) -> Integer
+    def fail_with: (String) -> Integer
+  end
+end

data/sig/herbst/converter.rbs

@@ -0,0 +1,59 @@
+# Generated from lib/herbst/converter.rb with RBS::Inline
+
+module Herbst
+  class Converter
+    include Builder
+
+    INDENT: String
+
+    type clause = [ String, String?, Array[Herb::AST::Node], Integer? ]
+
+    attr_reader warnings: Array[String]
+
+    @markup: bool
+
+    # : () -> void
+    def initialize: () -> void
+
+    # : (String) -> Herb::AST::DocumentNode
+    def convert: (String) -> Herb::AST::DocumentNode
+
+    # : (String) -> Array[Herb::AST::Node]
+    def text_nodes: (String) -> Array[Herb::AST::Node]
+
+    # : (Integer?, String) -> void
+    def warn: (Integer?, String) -> void
+
+    private
+
+    # : (Herb::AST::DocumentNode) -> Herb::AST::DocumentNode
+    def finish: (Herb::AST::DocumentNode) -> Herb::AST::DocumentNode
+
+    # : (Integer) -> String
+    def newline: (Integer) -> String
+
+    # : (String) -> String?
+    def keyword: (String) -> String?
+
+    # : (String, String?, Array[Herb::AST::Node], Array[clause], Integer, ?line: Integer?) -> Herb::AST::Node
+    def control: (String, String?, Array[Herb::AST::Node], Array[clause], Integer, ?line: Integer?) -> Herb::AST::Node
+
+    # : (String, Array[Herb::AST::Node], Array[clause]) -> Herb::AST::ERBIfNode
+    def control_if: (String, Array[Herb::AST::Node], Array[clause]) -> Herb::AST::ERBIfNode
+
+    # : (String, Array[Herb::AST::Node], Array[clause]) -> Herb::AST::ERBUnlessNode
+    def control_unless: (String, Array[Herb::AST::Node], Array[clause]) -> Herb::AST::ERBUnlessNode
+
+    # : (String, Array[Herb::AST::Node], Array[clause], Integer, Integer?) -> Herb::AST::ERBCaseNode
+    def control_case: (String, Array[Herb::AST::Node], Array[clause], Integer, Integer?) -> Herb::AST::ERBCaseNode
+
+    # : (String, Array[Herb::AST::Node], Array[clause]) -> Herb::AST::ERBBeginNode
+    def control_begin: (String, Array[Herb::AST::Node], Array[clause]) -> Herb::AST::ERBBeginNode
+
+    # : (String, Array[Herb::AST::Node], Array[clause]) -> Herb::AST::ERBBlockNode
+    def control_block: (String, Array[Herb::AST::Node], Array[clause]) -> Herb::AST::ERBBlockNode
+
+    # : (String?, String, Integer?) -> bot
+    def unsupported_clause: (String?, String, Integer?) -> bot
+  end
+end

data/sig/herbst/haml/attributes.rbs

@@ -0,0 +1,49 @@
+# Generated from lib/herbst/haml/attributes.rb with RBS::Inline
+
+module Herbst
+  module Haml
+    class Attributes
+      include Builder
+
+      @warnings: Array[String]
+
+      # : (Array[String]) -> void
+      def initialize: (Array[String]) -> void
+
+      # : (::Haml::Parser::ParseNode) -> Array[Herb::AST::Node]
+      def compile: (::Haml::Parser::ParseNode) -> Array[Herb::AST::Node]
+
+      private
+
+      # : (String, Array[[Symbol, untyped]]) -> Array[Herb::AST::Node]
+      def compile_attribute: (String, Array[[ Symbol, untyped ]]) -> Array[Herb::AST::Node]
+
+      # : (String, Array[[Symbol, untyped]], String) { (String) -> String } -> Array[Herb::AST::Node]
+      def compile_joined: (String, Array[[ Symbol, untyped ]], String) { (String) -> String } -> Array[Herb::AST::Node]
+
+      # : (String, [Symbol, untyped]) -> Array[Herb::AST::Node]
+      def compile_hash: (String, [ Symbol, untyped ]) -> Array[Herb::AST::Node]
+
+      # : (String, [Symbol, untyped]) -> Array[Herb::AST::Node]
+      def compile_single: (String, [ Symbol, untyped ]) -> Array[Herb::AST::Node]
+
+      # : (::Haml::Parser::ParseNode, Array[String]) -> Array[Herb::AST::Node]
+      def fallback: (::Haml::Parser::ParseNode, Array[String]) -> Array[Herb::AST::Node]
+
+      # : (String) -> bool
+      def literal?: (String) -> bool
+
+      # : (String) -> bool
+      def array_literal?: (String) -> bool
+
+      # : (String) -> bool
+      def boolean?: (String) -> bool
+
+      # : (String) -> String
+      def escape: (String) -> String
+
+      # : (::Haml::Parser::ParseNode, String) -> void
+      def warn: (::Haml::Parser::ParseNode, String) -> void
+    end
+  end
+end

data/sig/herbst/haml/converter.rbs

@@ -0,0 +1,78 @@
+# Generated from lib/herbst/haml/converter.rb with RBS::Inline
+
+module Herbst
+  module Haml
+    # Converts the tree produced by Haml::Parser into a Herb AST.
+    #
+    # The resulting tree prints to ERB that renders the same HTML as the Haml
+    # template (modulo insignificant whitespace).
+    class Converter < Herbst::Converter
+      MID_BLOCK_KEYWORDS: Array[String]
+
+      ESCAPED_INTERPOLATION: Regexp
+
+      type haml_clause = [ ::Haml::Parser::ParseNode, Array[::Haml::Parser::ParseNode] ]
+
+      @nuke_inner: Array[bool?]
+
+      @filters: Filters
+
+      @attributes: Attributes
+
+      @options: Hash[Symbol, untyped]
+
+      # : (?Hash[Symbol, untyped]) -> void
+      def initialize: (?Hash[Symbol, untyped]) -> void
+
+      # : (String) -> Herb::AST::DocumentNode
+      def convert: (String) -> Herb::AST::DocumentNode
+
+      # : (Array[::Haml::Parser::ParseNode], Integer) -> Array[Herb::AST::Node]
+      def join: (Array[::Haml::Parser::ParseNode], Integer) -> Array[Herb::AST::Node]
+
+      # : (Array[::Haml::Parser::ParseNode], Integer, ?nuke_edges: bool) -> Array[Herb::AST::Node]
+      def block_body: (Array[::Haml::Parser::ParseNode], Integer, ?nuke_edges: bool) -> Array[Herb::AST::Node]
+
+      # : (String, escape: bool?) -> Array[Herb::AST::Node]
+      def interpolate: (String, escape: bool?) -> Array[Herb::AST::Node]
+
+      private
+
+      # : (::Haml::Parser::ParseNode, Integer) -> (Herb::AST::Node | Array[Herb::AST::Node])
+      def convert_node: (::Haml::Parser::ParseNode, Integer) -> (Herb::AST::Node | Array[Herb::AST::Node])
+
+      # : (::Haml::Parser::ParseNode, Integer) -> (Herb::AST::Node | Array[Herb::AST::Node])
+      def convert_script: (::Haml::Parser::ParseNode, Integer) -> (Herb::AST::Node | Array[Herb::AST::Node])
+
+      # : (::Haml::Parser::ParseNode, Integer) -> Herb::AST::Node
+      def convert_silent_script: (::Haml::Parser::ParseNode, Integer) -> Herb::AST::Node
+
+      # : (::Haml::Parser::ParseNode) -> [Array[::Haml::Parser::ParseNode], Array[haml_clause]]
+      def segments: (::Haml::Parser::ParseNode) -> [ Array[::Haml::Parser::ParseNode], Array[haml_clause] ]
+
+      # : (::Haml::Parser::ParseNode) -> bool
+      def mid_block?: (::Haml::Parser::ParseNode) -> bool
+
+      # : (::Haml::Parser::ParseNode, Integer) -> (Herb::AST::HTMLElementNode | Array[Herb::AST::Node])
+      def convert_tag: (::Haml::Parser::ParseNode, Integer) -> (Herb::AST::HTMLElementNode | Array[Herb::AST::Node])
+
+      # : (::Haml::Parser::ParseNode, Integer) -> (Herb::AST::Node | Array[Herb::AST::Node])
+      def convert_comment: (::Haml::Parser::ParseNode, Integer) -> (Herb::AST::Node | Array[Herb::AST::Node])
+
+      # : (::Haml::Parser::ParseNode) -> (Herb::AST::HTMLDoctypeNode | Array[Herb::AST::Node])
+      def convert_doctype: (::Haml::Parser::ParseNode) -> (Herb::AST::HTMLDoctypeNode | Array[Herb::AST::Node])
+
+      # : (::Haml::Parser::ParseNode) -> (Herb::AST::ERBCommentNode | Array[Herb::AST::Node])
+      def convert_haml_comment: (::Haml::Parser::ParseNode) -> (Herb::AST::ERBCommentNode | Array[Herb::AST::Node])
+
+      # : (::Haml::Parser::ParseNode) -> bool
+      def nuke_whitespace?: (::Haml::Parser::ParseNode) -> bool
+
+      # : (::Haml::Parser::ParseNode, ::Haml::Parser::ParseNode) -> bool
+      def whitespace_between?: (::Haml::Parser::ParseNode, ::Haml::Parser::ParseNode) -> bool
+
+      # : [T] (bool?) { () -> T } -> T
+      def with_nuke_inner: [T] (bool?) { () -> T } -> T
+    end
+  end
+end

data/sig/herbst/haml/filters.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/herbst/haml/filters.rb with RBS::Inline
+
+module Herbst
+  module Haml
+    class Filters
+      include Builder
+
+      @converter: Converter
+
+      # : (Converter) -> void
+      def initialize: (Converter) -> void
+
+      # : (::Haml::Parser::ParseNode, Integer) -> (Herb::AST::Node | Array[Herb::AST::Node])
+      def convert: (::Haml::Parser::ParseNode, Integer) -> (Herb::AST::Node | Array[Herb::AST::Node])
+
+      private
+
+      # : (String, Integer) -> Array[Herb::AST::Node]
+      def wrapped: (String, Integer) -> Array[Herb::AST::Node]
+
+      # : (String) -> Array[Herb::AST::Node]
+      def text_nodes: (String) -> Array[Herb::AST::Node]
+    end
+  end
+end

data/sig/herbst/haml.rbs

@@ -0,0 +1,22 @@
+# Generated from lib/herbst/haml.rb with RBS::Inline
+
+module Herbst
+  # Converts Haml templates into Herb's syntax tree and ERB.
+  #
+  #   Herbst::Haml.parse("%p= greeting")   # => Herb::AST::DocumentNode
+  #   Herbst::Haml.to_erb("%p= greeting")  # => "<p><%= greeting %></p>\n"
+  #
+  # To compile Haml, compile its ERB with Herb::Engine:
+  #
+  #   Herb::Engine.new(Herbst::Haml.to_erb(source), escape: true).src
+  #
+  # Use Herbst::Haml::Converter directly to read the warnings of a conversion. The haml gem is
+  # only needed when converting Haml, so it isn't a dependency of Herbst.
+  module Haml
+    # : (String, **untyped) -> Herb::AST::DocumentNode
+    def self.parse: (String, **untyped) -> Herb::AST::DocumentNode
+
+    # : (String, ?format: bool, **untyped) -> String
+    def self.to_erb: (String, ?format: bool, **untyped) -> String
+  end
+end

data/sig/herbst/identity_printer.rbs

@@ -0,0 +1,206 @@
+# Generated from lib/herbst/identity_printer.rb with RBS::Inline
+
+module Herbst
+  class IdentityPrinter < Herb::Visitor
+    interface _ERBTag
+      def tag_opening: () -> Herb::Token?
+
+      def content: () -> Herb::Token?
+
+      def tag_closing: () -> Herb::Token?
+    end
+
+    interface _Delimited
+      def tag_opening: () -> Herb::Token?
+
+      def children: () -> Array[Herb::AST::Node]
+
+      def tag_closing: () -> Herb::Token?
+    end
+
+    @line_offsets: Array[Integer]?
+
+    @output: String
+
+    @source: String?
+
+    # : (Herb::AST::Node, ?source: String?) -> String
+    def self.print: (Herb::AST::Node, ?source: String?) -> String
+
+    # : (?source: String?) -> void
+    def initialize: (?source: String?) -> void
+
+    # : (Herb::AST::Node) -> String
+    def print: (Herb::AST::Node) -> String
+
+    # : (Herb::AST::DocumentNode) -> void
+    def visit_document_node: (Herb::AST::DocumentNode) -> void
+
+    # : (Herb::AST::LiteralNode) -> void
+    def visit_literal_node: (Herb::AST::LiteralNode) -> void
+
+    # : (Herb::AST::HTMLTextNode) -> void
+    def visit_html_text_node: (Herb::AST::HTMLTextNode) -> void
+
+    # : (Herb::AST::WhitespaceNode) -> void
+    def visit_whitespace_node: (Herb::AST::WhitespaceNode) -> void
+
+    # : (Herb::AST::HTMLOpenTagNode) -> void
+    def visit_html_open_tag_node: (Herb::AST::HTMLOpenTagNode) -> void
+
+    # : (Herb::AST::HTMLConditionalOpenTagNode) -> void
+    def visit_html_conditional_open_tag_node: (Herb::AST::HTMLConditionalOpenTagNode) -> void
+
+    # : (Herb::AST::HTMLCloseTagNode) -> void
+    def visit_html_close_tag_node: (Herb::AST::HTMLCloseTagNode) -> void
+
+    # : (Herb::AST::HTMLOmittedCloseTagNode) -> void
+    def visit_html_omitted_close_tag_node: (Herb::AST::HTMLOmittedCloseTagNode) -> void
+
+    # : (Herb::AST::HTMLVirtualCloseTagNode) -> void
+    def visit_html_virtual_close_tag_node: (Herb::AST::HTMLVirtualCloseTagNode) -> void
+
+    # : (Herb::AST::HTMLElementNode) -> void
+    def visit_html_element_node: (Herb::AST::HTMLElementNode) -> void
+
+    # : (Herb::AST::HTMLConditionalElementNode) -> void
+    def visit_html_conditional_element_node: (Herb::AST::HTMLConditionalElementNode) -> void
+
+    # : (Herb::AST::HTMLAttributeNode) -> void
+    def visit_html_attribute_node: (Herb::AST::HTMLAttributeNode) -> void
+
+    # : (Herb::AST::HTMLAttributeNameNode) -> void
+    def visit_html_attribute_name_node: (Herb::AST::HTMLAttributeNameNode) -> void
+
+    # : (Herb::AST::HTMLAttributeValueNode) -> void
+    def visit_html_attribute_value_node: (Herb::AST::HTMLAttributeValueNode) -> void
+
+    # : (Herb::AST::RubyLiteralNode) -> void
+    def visit_ruby_literal_node: (Herb::AST::RubyLiteralNode) -> void
+
+    # : (Herb::AST::RubyHTMLAttributesSplatNode) -> void
+    def visit_ruby_html_attributes_splat_node: (Herb::AST::RubyHTMLAttributesSplatNode) -> void
+
+    # : (Herb::AST::HTMLCommentNode) -> void
+    def visit_html_comment_node: (Herb::AST::HTMLCommentNode) -> void
+
+    # : (Herb::AST::HTMLDoctypeNode) -> void
+    def visit_html_doctype_node: (Herb::AST::HTMLDoctypeNode) -> void
+
+    # : (Herb::AST::XMLDeclarationNode) -> void
+    def visit_xml_declaration_node: (Herb::AST::XMLDeclarationNode) -> void
+
+    # : (Herb::AST::CDATANode) -> void
+    def visit_cdata_node: (Herb::AST::CDATANode) -> void
+
+    # : (Herb::AST::XMLProcessingInstructionNode) -> void
+    def visit_xml_processing_instruction_node: (Herb::AST::XMLProcessingInstructionNode) -> void
+
+    # : (Herb::AST::ERBOpenTagNode) -> void
+    def visit_erb_open_tag_node: (Herb::AST::ERBOpenTagNode) -> void
+
+    # : (Herb::AST::ERBContentNode) -> void
+    def visit_erb_content_node: (Herb::AST::ERBContentNode) -> void
+
+    # : (Herb::AST::ERBCommentNode) -> void
+    def visit_erb_comment_node: (Herb::AST::ERBCommentNode) -> void
+
+    # : (Herb::AST::ERBIfNode) -> void
+    def visit_erb_if_node: (Herb::AST::ERBIfNode) -> void
+
+    # : (Herb::AST::ERBElseNode) -> void
+    def visit_erb_else_node: (Herb::AST::ERBElseNode) -> void
+
+    # : (Herb::AST::ERBEndNode) -> void
+    def visit_erb_end_node: (Herb::AST::ERBEndNode) -> void
+
+    # : (Herb::AST::ERBBlockNode) -> void
+    def visit_erb_block_node: (Herb::AST::ERBBlockNode) -> void
+
+    # : (Herb::AST::ERBIterationBlockNode) -> void
+    def visit_erb_iteration_block_node: (Herb::AST::ERBIterationBlockNode) -> void
+
+    # : (Herb::AST::ERBCaseNode) -> void
+    def visit_erb_case_node: (Herb::AST::ERBCaseNode) -> void
+
+    # : (Herb::AST::ERBWhenNode) -> void
+    def visit_erb_when_node: (Herb::AST::ERBWhenNode) -> void
+
+    # : (Herb::AST::ERBWhileNode) -> void
+    def visit_erb_while_node: (Herb::AST::ERBWhileNode) -> void
+
+    # : (Herb::AST::ERBUntilNode) -> void
+    def visit_erb_until_node: (Herb::AST::ERBUntilNode) -> void
+
+    # : (Herb::AST::ERBForNode) -> void
+    def visit_erb_for_node: (Herb::AST::ERBForNode) -> void
+
+    # : (Herb::AST::ERBBeginNode) -> void
+    def visit_erb_begin_node: (Herb::AST::ERBBeginNode) -> void
+
+    # : (Herb::AST::ERBRescueNode) -> void
+    def visit_erb_rescue_node: (Herb::AST::ERBRescueNode) -> void
+
+    # : (Herb::AST::ERBEnsureNode) -> void
+    def visit_erb_ensure_node: (Herb::AST::ERBEnsureNode) -> void
+
+    # : (Herb::AST::ERBUnlessNode) -> void
+    def visit_erb_unless_node: (Herb::AST::ERBUnlessNode) -> void
+
+    # : (Herb::AST::ERBRenderNode) -> void
+    def visit_erb_render_node: (Herb::AST::ERBRenderNode) -> void
+
+    # : (Herb::AST::RubyRenderKeywordsNode) -> void
+    def visit_ruby_render_keywords_node: (Herb::AST::RubyRenderKeywordsNode) -> void
+
+    # : (Herb::AST::RubyRenderLocalNode) -> void
+    def visit_ruby_render_local_node: (Herb::AST::RubyRenderLocalNode) -> void
+
+    # : (Herb::AST::ERBStrictLocalsNode) -> void
+    def visit_erb_strict_locals_node: (Herb::AST::ERBStrictLocalsNode) -> void
+
+    # : (Herb::AST::HerbDirectiveNode) -> void
+    def visit_herb_directive_node: (Herb::AST::HerbDirectiveNode) -> void
+
+    # : (Herb::AST::HerbStateDirectiveNode) -> void
+    def visit_herb_state_directive_node: (Herb::AST::HerbStateDirectiveNode) -> void
+
+    # : (Herb::AST::HerbStateDeclarationNode) -> void
+    def visit_herb_state_declaration_node: (Herb::AST::HerbStateDeclarationNode) -> void
+
+    # : (Herb::AST::RubyParameterNode) -> void
+    def visit_ruby_parameter_node: (Herb::AST::RubyParameterNode) -> void
+
+    # : (Herb::AST::ERBYieldNode) -> void
+    def visit_erb_yield_node: (Herb::AST::ERBYieldNode) -> void
+
+    # : (Herb::AST::ERBInNode) -> void
+    def visit_erb_in_node: (Herb::AST::ERBInNode) -> void
+
+    # : (Herb::AST::ERBCaseMatchNode) -> void
+    def visit_erb_case_match_node: (Herb::AST::ERBCaseMatchNode) -> void
+
+    private
+
+    # : (String?) -> void
+    def write: (String?) -> void
+
+    # : () -> bool
+    def ends_with_whitespace?: () -> bool
+
+    # : (_ERBTag) -> void
+    def print_erb: (_ERBTag) -> void
+
+    # : (_Delimited) -> void
+    def print_delimited: (_Delimited) -> void
+
+    # : (Herb::Position, Herb::Position) -> String
+    def separator_between: (Herb::Position, Herb::Position) -> String
+
+    # : (String, Herb::Position, Herb::Position) -> String?
+    def slice_between: (String, Herb::Position, Herb::Position) -> String?
+
+    # : (String, Herb::Position) -> Integer?
+    def offset: (String, Herb::Position) -> Integer?
+  end
+end

data/sig/herbst/printer.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/herbst/printer.rb with RBS::Inline
+
+module Herbst
+  module Printer
+    FORMATTER: Array[String]
+
+    class Error < Herbst::Error
+    end
+
+    # : (Herb::AST::DocumentNode, ?format: bool) -> String
+    def self.print: (Herb::AST::DocumentNode, ?format: bool) -> String
+
+    # : (Array[Herb::AST::DocumentNode], ?format: bool) -> Array[String]
+    def self.print_all: (Array[Herb::AST::DocumentNode], ?format: bool) -> Array[String]
+
+    # : (String) -> String
+    def self.format: (String) -> String
+
+    # : (Array[String]) -> Array[String]
+    def self.format_all: (Array[String]) -> Array[String]
+
+    # : (*String, **untyped) -> String
+    def self.run: (*String, **untyped) -> String
+  end
+end

data/sig/herbst/round_trip.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/herbst/round_trip.rb with RBS::Inline
+
+module Herbst
+  # Checks that printed ERB parses back into exactly the tree it was printed from.
+  #
+  # The ERB is parsed with `track_whitespace: true`, and every node, field, token value and
+  # whitespace node is compared. Only source positions and Prism data are ignored, since a
+  # built tree doesn't have them.
+  #
+  #   Herbst::RoundTrip.difference(document, erb) # => nil, or where the trees differ
+  module RoundTrip
+    POSITIONAL_FIELDS: Array[String]
+
+    # : (Herb::AST::DocumentNode, String) -> String?
+    def self.difference: (Herb::AST::DocumentNode, String) -> String?
+
+    # : (Herb::AST::Node) -> untyped
+    def self.comparable: (Herb::AST::Node) -> untyped
+
+    # : (untyped) -> untyped
+    def self.strip_positions: (untyped) -> untyped
+
+    # : (untyped, untyped, String) -> String?
+    def self.tree_difference: (untyped, untyped, String) -> String?
+  end
+end