herb 0.9.1-aarch64-linux-gnu → 0.9.3-aarch64-linux-gnu

data/lib/herb/errors.rb

@@ -1258,5 +1258,273 @@ module Herb
       end
     end
 
+    class StrictLocalsPositionalArgumentError < Error
+      include Colors
+
+      #|  name: String?,
+      #| }
+
+      attr_reader :name #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, name)
+        super(type, location, message)
+        @name = name
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_strict_locals_positional_argument_error
+      def to_hash
+        super.merge(
+          name: name
+        ) #: Herb::serialized_strict_locals_positional_argument_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── name: #{green(name.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class StrictLocalsBlockArgumentError < Error
+      include Colors
+
+      #|  name: String?,
+      #| }
+
+      attr_reader :name #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, name)
+        super(type, location, message)
+        @name = name
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_strict_locals_block_argument_error
+      def to_hash
+        super.merge(
+          name: name
+        ) #: Herb::serialized_strict_locals_block_argument_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── name: #{green(name.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class StrictLocalsSplatArgumentError < Error
+      include Colors
+
+      #|  name: String?,
+      #| }
+
+      attr_reader :name #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, name)
+        super(type, location, message)
+        @name = name
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_strict_locals_splat_argument_error
+      def to_hash
+        super.merge(
+          name: name
+        ) #: Herb::serialized_strict_locals_splat_argument_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── name: #{green(name.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class StrictLocalsMissingParenthesisError < Error
+      include Colors
+
+      #|  rest: String?,
+      #| }
+
+      attr_reader :rest #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, rest)
+        super(type, location, message)
+        @rest = rest
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_strict_locals_missing_parenthesis_error
+      def to_hash
+        super.merge(
+          rest: rest
+        ) #: Herb::serialized_strict_locals_missing_parenthesis_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── rest: #{green(rest.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class StrictLocalsDuplicateDeclarationError < Error
+      include Colors
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("└── message: #{green(message.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class VoidElementContentError < Error
+      include Colors
+
+      #|  tag_name: Herb::Token?,
+      #|  helper_name: String?,
+      #|  content_type: String?,
+      #| }
+
+      attr_reader :tag_name #: Herb::Token?
+      attr_reader :helper_name #: String?
+      attr_reader :content_type #: String?
+
+      #: (String, Location?, String, Herb::Token, String, String) -> void
+      def initialize(type, location, message, tag_name, helper_name, content_type)
+        super(type, location, message)
+        @tag_name = tag_name
+        @helper_name = helper_name
+        @content_type = content_type
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_void_element_content_error
+      def to_hash
+        super.merge(
+          tag_name: tag_name,
+          helper_name: helper_name,
+          content_type: content_type
+        ) #: Herb::serialized_void_element_content_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("├── tag_name: ")
+        output += tag_name ? tag_name.tree_inspect : magenta("∅")
+        output += "\n"
+        output += white("├── helper_name: #{green(helper_name.inspect)}\n")
+        output += white("└── content_type: #{green(content_type.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class DotNotationCasingError < Error
+      include Colors
+
+      #|  segment: Herb::Token?,
+      #| }
+
+      attr_reader :segment #: Herb::Token?
+
+      #: (String, Location?, String, Herb::Token) -> void
+      def initialize(type, location, message, segment)
+        super(type, location, message)
+        @segment = segment
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_dot_notation_casing_error
+      def to_hash
+        super.merge(
+          segment: segment
+        ) #: Herb::serialized_dot_notation_casing_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── segment: ")
+        output += segment ? segment.tree_inspect : magenta("∅")
+        output += "\n"
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
   end
 end

data/lib/herb/parser_options.rb

@@ -7,6 +7,7 @@ module Herb
     attr_reader :analyze #: bool
     attr_reader :action_view_helpers #: bool
     attr_reader :render_nodes #: bool
+    attr_reader :strict_locals #: bool
     attr_reader :prism_program #: bool
     attr_reader :prism_nodes #: bool
     attr_reader :prism_nodes_deep #: bool
@@ -16,17 +17,19 @@ module Herb
     DEFAULT_ANALYZE = true #: bool
     DEFAULT_ACTION_VIEW_HELPERS = false #: bool
     DEFAULT_RENDER_NODES = false #: bool
+    DEFAULT_STRICT_LOCALS = false #: bool
     DEFAULT_PRISM_PROGRAM = false #: bool
     DEFAULT_PRISM_NODES = false #: bool
     DEFAULT_PRISM_NODES_DEEP = false #: bool
 
-    #: (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool) -> void
-    def initialize(strict: DEFAULT_STRICT, track_whitespace: DEFAULT_TRACK_WHITESPACE, analyze: DEFAULT_ANALYZE, action_view_helpers: DEFAULT_ACTION_VIEW_HELPERS, render_nodes: DEFAULT_RENDER_NODES, prism_nodes: DEFAULT_PRISM_NODES, prism_nodes_deep: DEFAULT_PRISM_NODES_DEEP, prism_program: DEFAULT_PRISM_PROGRAM)
+    #: (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?render_nodes: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool) -> void
+    def initialize(strict: DEFAULT_STRICT, track_whitespace: DEFAULT_TRACK_WHITESPACE, analyze: DEFAULT_ANALYZE, action_view_helpers: DEFAULT_ACTION_VIEW_HELPERS, render_nodes: DEFAULT_RENDER_NODES, strict_locals: DEFAULT_STRICT_LOCALS, prism_nodes: DEFAULT_PRISM_NODES, prism_nodes_deep: DEFAULT_PRISM_NODES_DEEP, prism_program: DEFAULT_PRISM_PROGRAM)
       @strict = strict
       @track_whitespace = track_whitespace
       @analyze = analyze
       @action_view_helpers = action_view_helpers
       @render_nodes = render_nodes
+      @strict_locals = strict_locals
       @prism_nodes = prism_nodes
       @prism_nodes_deep = prism_nodes_deep
       @prism_program = prism_program
@@ -40,6 +43,7 @@ module Herb
         analyze: @analyze,
         action_view_helpers: @action_view_helpers,
         render_nodes: @render_nodes,
+        strict_locals: @strict_locals,
         prism_nodes: @prism_nodes,
         prism_nodes_deep: @prism_nodes_deep,
         prism_program: @prism_program,
@@ -54,6 +58,7 @@ module Herb
         "analyze=#{@analyze}\n  " \
         "action_view_helpers=#{@action_view_helpers}\n  " \
         "render_nodes=#{@render_nodes}\n  " \
+        "strict_locals=#{@strict_locals}\n  " \
         "prism_nodes=#{@prism_nodes}\n  " \
         "prism_nodes_deep=#{@prism_nodes_deep}\n  " \
         "prism_program=#{@prism_program}>"

data/lib/herb/version.rb

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

data/lib/herb/visitor.rb

@@ -23,203 +23,285 @@ module Herb
       node.compact_child_nodes.each { |node| node.accept(self) }
     end
 
+    #: (Herb::AST::Node) -> void
+    def visit_node(node)
+      # Default implementation does nothing
+    end
+
+    #: (Herb::AST::Node) -> void
+    def visit_erb_node(node)
+      # Default implementation does nothing
+    end
+
     #: (Herb::AST::DocumentNode) -> void
     def visit_document_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::LiteralNode) -> void
     def visit_literal_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLOpenTagNode) -> void
     def visit_html_open_tag_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLConditionalOpenTagNode) -> void
     def visit_html_conditional_open_tag_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLCloseTagNode) -> void
     def visit_html_close_tag_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLOmittedCloseTagNode) -> void
     def visit_html_omitted_close_tag_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLVirtualCloseTagNode) -> void
     def visit_html_virtual_close_tag_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLElementNode) -> void
     def visit_html_element_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLConditionalElementNode) -> void
     def visit_html_conditional_element_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLAttributeValueNode) -> void
     def visit_html_attribute_value_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLAttributeNameNode) -> void
     def visit_html_attribute_name_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLAttributeNode) -> void
     def visit_html_attribute_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::RubyLiteralNode) -> void
     def visit_ruby_literal_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::RubyHTMLAttributesSplatNode) -> void
     def visit_ruby_html_attributes_splat_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBOpenTagNode) -> void
     def visit_erb_open_tag_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLTextNode) -> void
     def visit_html_text_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLCommentNode) -> void
     def visit_html_comment_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::HTMLDoctypeNode) -> void
     def visit_html_doctype_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::XMLDeclarationNode) -> void
     def visit_xml_declaration_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::CDATANode) -> void
     def visit_cdata_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::WhitespaceNode) -> void
     def visit_whitespace_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBContentNode) -> void
     def visit_erb_content_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBEndNode) -> void
     def visit_erb_end_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBElseNode) -> void
     def visit_erb_else_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBIfNode) -> void
     def visit_erb_if_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBBlockNode) -> void
     def visit_erb_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)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBCaseNode) -> void
     def visit_erb_case_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBCaseMatchNode) -> void
     def visit_erb_case_match_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBWhileNode) -> void
     def visit_erb_while_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBUntilNode) -> void
     def visit_erb_until_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBForNode) -> void
     def visit_erb_for_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBRescueNode) -> void
     def visit_erb_rescue_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBEnsureNode) -> void
     def visit_erb_ensure_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBBeginNode) -> void
     def visit_erb_begin_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBUnlessNode) -> void
     def visit_erb_unless_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::RubyRenderLocalNode) -> void
     def visit_ruby_render_local_node(node)
+      visit_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBRenderNode) -> void
     def visit_erb_render_node(node)
+      visit_node(node)
+      visit_erb_node(node)
+      visit_child_nodes(node)
+    end
+
+    #: (Herb::AST::RubyStrictLocalNode) -> void
+    def visit_ruby_strict_local_node(node)
+      visit_node(node)
+      visit_child_nodes(node)
+    end
+
+    #: (Herb::AST::ERBStrictLocalsNode) -> void
+    def visit_erb_strict_locals_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBYieldNode) -> void
     def visit_erb_yield_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 
     #: (Herb::AST::ERBInNode) -> void
     def visit_erb_in_node(node)
+      visit_node(node)
+      visit_erb_node(node)
       visit_child_nodes(node)
     end
 

data/lib/herb.rb

@@ -17,6 +17,7 @@ require_relative "herb/parse_result"
 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/errors"

data/sig/herb/ast/erb_content_node.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/herb/ast/erb_content_node.rb with RBS::Inline
+
+module Herb
+  module AST
+    class ERBContentNode < Node
+      # : () -> Prism::node?
+      def parsed_prism_node: () -> Prism::node?
+
+      # : () -> Prism::node?
+      def prism: () -> Prism::node?
+    end
+  end
+end