herb 0.9.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a1a61c49f642abaffb189b7ff947009cc5c2e808d4eaa5e8103f0086b6b6b78
-  data.tar.gz: d26cdc1d962413d92cc6a2800f4c183777e690aa95c7ab918b5ef4f6591e9278
+  metadata.gz: a490ad868e9fa08be317c7343a0553a8bf07234decbb95046d235d64256ed743
+  data.tar.gz: 2f1312897b63fe33263bf35f023b6d2377bfb9e806d5f640837d9de57b2878bb
 SHA512:
-  metadata.gz: df024e2b48dadab5af063c54e614948dc46efed4aed24f813476ca491164db7b863692a6617f580bf2e9523701a2f76a8c392935a6fb40cb4b269eece5fb1737
-  data.tar.gz: cfb04158d09179dc2a5d08b96a3300b1748ba1ec66afb71c5004e1eaabf1c4cfcfc8b1296d0fb613152eafd0927c400df43622463d5850b341ddfcb6aa03fae4
+  metadata.gz: f820a5463221a38d26c92a3a388f137bb2295125641dd7de7102290c85036adfa5c0bdafd3331e049fff6fc218a8c53b094fd5037277276c67121a64e99b7535
+  data.tar.gz: 6bee2c356c1e18c5670ce9ffcd8193100f0be4dc8d2aba74faaadc6409fe0d534390c34796dcd5aa8c1bfa4c55209cf07b856898a6a66cf654e871d14a869003

data/README.md

@@ -56,6 +56,7 @@ The Herb ecosystem offers multiple tools that integrate seamlessly into editors,
 | [Herb Parser](https://herb-tools.dev/projects/parser) | Fast, portable, HTML-aware ERB parser written in C. |
 | [Herb Linter](https://herb-tools.dev/projects/linter) | Static analysis to enforce best practices and identify common mistakes. |
 | [Herb Formatter](https://herb-tools.dev/projects/formatter) | Automatic, consistent formatting for HTML+ERB files. *(experimental)* |
+| [Herb Language Service](https://herb-tools.dev/projects/language-service) | HTML+ERB language service with ActionView tag helper support. |
 | [Herb Language Server](https://herb-tools.dev/projects/language-server) | Rich editor integration for VS Code, Zed, Neovim, and more. |
 | [Herb Engine](https://herb-tools.dev/projects/engine) | HTML-aware ERB rendering engine, API-compatible with Erubi. |
 | [Herb Dev Tools](https://herb-tools.dev/projects/dev-tools) | In-browser dev tools for inspecting and debugging templates, shipped with ReActionView. |
@@ -157,6 +158,7 @@ While Herb brings a fresh approach to HTML+ERB tooling, it builds upon and learn
 - [**erb_lint**](https://github.com/Shopify/erb_lint)
 - [**erb-formatter**](https://github.com/nebulab/erb-formatter)
 - [**erb-formatter-vscode**](https://github.com/nebulab/erb-formatter-vscode)
+- [**erblint-github**](https://github.com/github/erblint-github)
 - [**deface**](https://github.com/spree/deface)
 - [**html_press**](https://github.com/stereobooster/html_press)
 - [**htmlbeautifier**](https://github.com/threedaymonk/htmlbeautifier)

data/config.yml

@@ -410,6 +410,82 @@ errors:
         - name: layout
           type: string
 
+    - name: StrictLocalsPositionalArgumentError
+      message:
+        template: "Strict locals only support keyword arguments. Positional argument `%s` is not allowed. Use keyword argument format: `%s:`."
+        arguments:
+          - name
+          - name
+
+      fields:
+        - name: name
+          type: string
+
+    - name: StrictLocalsBlockArgumentError
+      message:
+        template: "Strict locals only support keyword arguments. Block argument `&%s` is not allowed."
+        arguments:
+          - name
+
+      fields:
+        - name: name
+          type: string
+
+    - name: StrictLocalsSplatArgumentError
+      message:
+        template: "Strict locals only support keyword arguments. Splat argument `*%s` is not allowed."
+        arguments:
+          - name
+
+      fields:
+        - name: name
+          type: string
+
+    - name: StrictLocalsMissingParenthesisError
+      message:
+        template: "Strict locals declaration requires parentheses. Expected `locals: (...)` but got `locals: %s`."
+        arguments:
+          - rest
+
+      fields:
+        - name: rest
+          type: string
+
+    - name: StrictLocalsDuplicateDeclarationError
+      message:
+        template: "Duplicate strict locals declaration. Only the first `<%# locals: (...) %>` declaration is used by Rails."
+        arguments: []
+
+      fields: []
+
+    - name: VoidElementContentError
+      message:
+        template: "Void element `%s` cannot have content. `%s` does not accept %s for content."
+        arguments:
+          - tag_name->value
+          - helper_name
+          - content_type
+
+      fields:
+        - name: tag_name
+          type: token
+
+        - name: helper_name
+          type: string
+
+        - name: content_type
+          type: string
+
+    - name: DotNotationCasingError
+      message:
+        template: "Dot-notation component tags require the first segment to start with an uppercase letter. `%s` does not start with an uppercase letter."
+        arguments:
+          - segment->value
+
+      fields:
+        - name: segment
+          type: token
+
 warnings:
   fields: []
   types: []
@@ -810,6 +886,18 @@ nodes:
           type: array
           kind: Node
 
+        - name: rescue_clause
+          type: node
+          kind: ERBRescueNode
+
+        - name: else_clause
+          type: node
+          kind: ERBElseNode
+
+        - name: ensure_clause
+          type: node
+          kind: ERBEnsureNode
+
         - name: end_node
           type: node
           kind: ERBEndNode
@@ -1169,6 +1257,43 @@ nodes:
           kind:
             - RubyRenderLocalNode
 
+    - name: RubyStrictLocalNode
+      fields:
+        - name: name
+          type: token
+
+        - name: default_value
+          type: node
+          kind: RubyLiteralNode
+
+        - name: required
+          type: boolean
+
+        - name: double_splat
+          type: boolean
+
+    - name: ERBStrictLocalsNode
+      fields:
+        - name: tag_opening
+          type: token
+
+        - name: content
+          type: token
+
+        - name: tag_closing
+          type: token
+
+        - name: analyzed_ruby
+          type: analyzed_ruby
+
+        - name: prism_node
+          type: prism_node
+
+        - name: locals
+          type: array
+          kind:
+            - RubyStrictLocalNode
+
     - name: ERBYieldNode
       fields:
         - name: tag_opening

data/ext/herb/error_helpers.c

@@ -9,8 +9,8 @@
 
 #include "../../src/include/errors.h"
 #include "../../src/include/herb.h"
-#include "../../src/include/token.h"
-#include "../../src/include/util/hb_string.h"
+#include "../../src/include/lexer/token.h"
+#include "../../src/include/lib/hb_string.h"
 
 VALUE rb_error_from_c_struct(ERROR_T* error);
 
@@ -46,6 +46,13 @@ static VALUE cRenderConflictingPartialError;
 static VALUE cRenderInvalidAsOptionError;
 static VALUE cRenderObjectAndCollectionError;
 static VALUE cRenderLayoutWithoutBlockError;
+static VALUE cStrictLocalsPositionalArgumentError;
+static VALUE cStrictLocalsBlockArgumentError;
+static VALUE cStrictLocalsSplatArgumentError;
+static VALUE cStrictLocalsMissingParenthesisError;
+static VALUE cStrictLocalsDuplicateDeclarationError;
+static VALUE cVoidElementContentError;
+static VALUE cDotNotationCasingError;
 
 void rb_init_error_classes(void) {
   mErrors = rb_define_module_under(mHerb, "Errors");
@@ -80,6 +87,13 @@ void rb_init_error_classes(void) {
   cRenderInvalidAsOptionError = rb_define_class_under(mErrors, "RenderInvalidAsOptionError", cError);
   cRenderObjectAndCollectionError = rb_define_class_under(mErrors, "RenderObjectAndCollectionError", cError);
   cRenderLayoutWithoutBlockError = rb_define_class_under(mErrors, "RenderLayoutWithoutBlockError", cError);
+  cStrictLocalsPositionalArgumentError = rb_define_class_under(mErrors, "StrictLocalsPositionalArgumentError", cError);
+  cStrictLocalsBlockArgumentError = rb_define_class_under(mErrors, "StrictLocalsBlockArgumentError", cError);
+  cStrictLocalsSplatArgumentError = rb_define_class_under(mErrors, "StrictLocalsSplatArgumentError", cError);
+  cStrictLocalsMissingParenthesisError = rb_define_class_under(mErrors, "StrictLocalsMissingParenthesisError", cError);
+  cStrictLocalsDuplicateDeclarationError = rb_define_class_under(mErrors, "StrictLocalsDuplicateDeclarationError", cError);
+  cVoidElementContentError = rb_define_class_under(mErrors, "VoidElementContentError", cError);
+  cDotNotationCasingError = rb_define_class_under(mErrors, "DotNotationCasingError", cError);
 }
 
 static VALUE rb_unexpected_error_from_c_struct(UNEXPECTED_ERROR_T* unexpected_error) {
@@ -743,6 +757,155 @@ static VALUE rb_render_layout_without_block_error_from_c_struct(RENDER_LAYOUT_WI
   return rb_class_new_instance(4, args, cRenderLayoutWithoutBlockError);
 };
 
+static VALUE rb_strict_locals_positional_argument_error_from_c_struct(STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR_T* strict_locals_positional_argument_error) {
+  if (strict_locals_positional_argument_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &strict_locals_positional_argument_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE strict_locals_positional_argument_error_name = rb_utf8_str_new(strict_locals_positional_argument_error->name.data, strict_locals_positional_argument_error->name.length);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    strict_locals_positional_argument_error_name
+  };
+
+  return rb_class_new_instance(4, args, cStrictLocalsPositionalArgumentError);
+};
+
+static VALUE rb_strict_locals_block_argument_error_from_c_struct(STRICT_LOCALS_BLOCK_ARGUMENT_ERROR_T* strict_locals_block_argument_error) {
+  if (strict_locals_block_argument_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &strict_locals_block_argument_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE strict_locals_block_argument_error_name = rb_utf8_str_new(strict_locals_block_argument_error->name.data, strict_locals_block_argument_error->name.length);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    strict_locals_block_argument_error_name
+  };
+
+  return rb_class_new_instance(4, args, cStrictLocalsBlockArgumentError);
+};
+
+static VALUE rb_strict_locals_splat_argument_error_from_c_struct(STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T* strict_locals_splat_argument_error) {
+  if (strict_locals_splat_argument_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &strict_locals_splat_argument_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE strict_locals_splat_argument_error_name = rb_utf8_str_new(strict_locals_splat_argument_error->name.data, strict_locals_splat_argument_error->name.length);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    strict_locals_splat_argument_error_name
+  };
+
+  return rb_class_new_instance(4, args, cStrictLocalsSplatArgumentError);
+};
+
+static VALUE rb_strict_locals_missing_parenthesis_error_from_c_struct(STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T* strict_locals_missing_parenthesis_error) {
+  if (strict_locals_missing_parenthesis_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &strict_locals_missing_parenthesis_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE strict_locals_missing_parenthesis_error_rest = rb_utf8_str_new(strict_locals_missing_parenthesis_error->rest.data, strict_locals_missing_parenthesis_error->rest.length);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    strict_locals_missing_parenthesis_error_rest
+  };
+
+  return rb_class_new_instance(4, args, cStrictLocalsMissingParenthesisError);
+};
+
+static VALUE rb_strict_locals_duplicate_declaration_error_from_c_struct(STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T* strict_locals_duplicate_declaration_error) {
+  if (strict_locals_duplicate_declaration_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &strict_locals_duplicate_declaration_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+
+  VALUE args[3] = {
+    type,
+    location,
+    message
+  };
+
+  return rb_class_new_instance(3, args, cStrictLocalsDuplicateDeclarationError);
+};
+
+static VALUE rb_void_element_content_error_from_c_struct(VOID_ELEMENT_CONTENT_ERROR_T* void_element_content_error) {
+  if (void_element_content_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &void_element_content_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE void_element_content_error_tag_name = rb_token_from_c_struct(void_element_content_error->tag_name);
+  VALUE void_element_content_error_helper_name = rb_utf8_str_new(void_element_content_error->helper_name.data, void_element_content_error->helper_name.length);
+  VALUE void_element_content_error_content_type = rb_utf8_str_new(void_element_content_error->content_type.data, void_element_content_error->content_type.length);
+
+  VALUE args[6] = {
+    type,
+    location,
+    message,
+    void_element_content_error_tag_name,
+    void_element_content_error_helper_name,
+    void_element_content_error_content_type
+  };
+
+  return rb_class_new_instance(6, args, cVoidElementContentError);
+};
+
+static VALUE rb_dot_notation_casing_error_from_c_struct(DOT_NOTATION_CASING_ERROR_T* dot_notation_casing_error) {
+  if (dot_notation_casing_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &dot_notation_casing_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE dot_notation_casing_error_segment = rb_token_from_c_struct(dot_notation_casing_error->segment);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    dot_notation_casing_error_segment
+  };
+
+  return rb_class_new_instance(4, args, cDotNotationCasingError);
+};
+
 
 VALUE rb_error_from_c_struct(ERROR_T* error) {
   if (!error) { return Qnil; }
@@ -778,6 +941,13 @@ VALUE rb_error_from_c_struct(ERROR_T* error) {
     case RENDER_INVALID_AS_OPTION_ERROR: return rb_render_invalid_as_option_error_from_c_struct((RENDER_INVALID_AS_OPTION_ERROR_T*) error); break;
     case RENDER_OBJECT_AND_COLLECTION_ERROR: return rb_render_object_and_collection_error_from_c_struct((RENDER_OBJECT_AND_COLLECTION_ERROR_T*) error); break;
     case RENDER_LAYOUT_WITHOUT_BLOCK_ERROR: return rb_render_layout_without_block_error_from_c_struct((RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T*) error); break;
+    case STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR: return rb_strict_locals_positional_argument_error_from_c_struct((STRICT_LOCALS_POSITIONAL_ARGUMENT_ERROR_T*) error); break;
+    case STRICT_LOCALS_BLOCK_ARGUMENT_ERROR: return rb_strict_locals_block_argument_error_from_c_struct((STRICT_LOCALS_BLOCK_ARGUMENT_ERROR_T*) error); break;
+    case STRICT_LOCALS_SPLAT_ARGUMENT_ERROR: return rb_strict_locals_splat_argument_error_from_c_struct((STRICT_LOCALS_SPLAT_ARGUMENT_ERROR_T*) error); break;
+    case STRICT_LOCALS_MISSING_PARENTHESIS_ERROR: return rb_strict_locals_missing_parenthesis_error_from_c_struct((STRICT_LOCALS_MISSING_PARENTHESIS_ERROR_T*) error); break;
+    case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: return rb_strict_locals_duplicate_declaration_error_from_c_struct((STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T*) error); break;
+    case VOID_ELEMENT_CONTENT_ERROR: return rb_void_element_content_error_from_c_struct((VOID_ELEMENT_CONTENT_ERROR_T*) error); break;
+    case DOT_NOTATION_CASING_ERROR: return rb_dot_notation_casing_error_from_c_struct((DOT_NOTATION_CASING_ERROR_T*) error); break;
   }
 
   return Qnil;

data/ext/herb/extconf.rb

@@ -46,6 +46,12 @@ prism_include_path = "#{prism_path}/include"
 $VPATH << "$(srcdir)/../../src"
 $VPATH << "$(srcdir)/../../src/analyze"
 $VPATH << "$(srcdir)/../../src/analyze/action_view"
+$VPATH << "$(srcdir)/../../src/ast"
+$VPATH << "$(srcdir)/../../src/lexer"
+$VPATH << "$(srcdir)/../../src/location"
+$VPATH << "$(srcdir)/../../src/parser"
+$VPATH << "$(srcdir)/../../src/prism"
+$VPATH << "$(srcdir)/../../src/lib"
 $VPATH << "$(srcdir)/../../src/util"
 $VPATH << prism_src_path
 $VPATH << "#{prism_src_path}/util"

data/ext/herb/extension.c

@@ -1,7 +1,7 @@
 #include <ruby.h>
 
-#include "../../src/include/util/hb_allocator.h"
-#include "../../src/include/util/hb_arena_debug.h"
+#include "../../src/include/lib/hb_allocator.h"
+#include "../../src/include/lib/hb_arena_debug.h"
 
 #include "error_helpers.h"
 #include "extension.h"
@@ -136,10 +136,20 @@ static VALUE Herb_parse(int argc, VALUE* argv, VALUE self) {
     }
     if (!NIL_P(action_view_helpers) && RTEST(action_view_helpers)) { parser_options.action_view_helpers = true; }
 
+    VALUE dot_notation_tags = rb_hash_lookup(options, rb_utf8_str_new_cstr("dot_notation_tags"));
+    if (NIL_P(dot_notation_tags)) {
+      dot_notation_tags = rb_hash_lookup(options, ID2SYM(rb_intern("dot_notation_tags")));
+    }
+    if (!NIL_P(dot_notation_tags) && RTEST(dot_notation_tags)) { parser_options.dot_notation_tags = true; }
+
     VALUE render_nodes = rb_hash_lookup(options, rb_utf8_str_new_cstr("render_nodes"));
     if (NIL_P(render_nodes)) { render_nodes = rb_hash_lookup(options, ID2SYM(rb_intern("render_nodes"))); }
     if (!NIL_P(render_nodes) && RTEST(render_nodes)) { parser_options.render_nodes = true; }
 
+    VALUE strict_locals = rb_hash_lookup(options, rb_utf8_str_new_cstr("strict_locals"));
+    if (NIL_P(strict_locals)) { strict_locals = rb_hash_lookup(options, ID2SYM(rb_intern("strict_locals"))); }
+    if (!NIL_P(strict_locals) && RTEST(strict_locals)) { parser_options.strict_locals = true; }
+
     VALUE prism_nodes = rb_hash_lookup(options, rb_utf8_str_new_cstr("prism_nodes"));
     if (NIL_P(prism_nodes)) { prism_nodes = rb_hash_lookup(options, ID2SYM(rb_intern("prism_nodes"))); }
     if (!NIL_P(prism_nodes) && RTEST(prism_nodes)) { parser_options.prism_nodes = true; }
@@ -152,6 +162,10 @@ static VALUE Herb_parse(int argc, VALUE* argv, VALUE self) {
     if (NIL_P(prism_program)) { prism_program = rb_hash_lookup(options, ID2SYM(rb_intern("prism_program"))); }
     if (!NIL_P(prism_program) && RTEST(prism_program)) { parser_options.prism_program = true; }
 
+    VALUE html = rb_hash_lookup(options, rb_utf8_str_new_cstr("html"));
+    if (NIL_P(html)) { html = rb_hash_lookup(options, ID2SYM(rb_intern("html"))); }
+    if (!NIL_P(html) && !RTEST(html)) { parser_options.html = false; }
+
     VALUE arena_stats = rb_hash_lookup(options, rb_utf8_str_new_cstr("arena_stats"));
     if (NIL_P(arena_stats)) { arena_stats = rb_hash_lookup(options, ID2SYM(rb_intern("arena_stats"))); }
     if (!NIL_P(arena_stats) && RTEST(arena_stats)) { print_arena_stats = true; }

data/ext/herb/extension_helpers.c

@@ -5,11 +5,11 @@
 #include "nodes.h"
 
 #include "../../src/include/herb.h"
-#include "../../src/include/location.h"
-#include "../../src/include/position.h"
-#include "../../src/include/token.h"
-#include "../../src/include/util/hb_allocator.h"
-#include "../../src/include/util/hb_string.h"
+#include "../../src/include/lexer/token.h"
+#include "../../src/include/lib/hb_allocator.h"
+#include "../../src/include/lib/hb_string.h"
+#include "../../src/include/location/location.h"
+#include "../../src/include/location/position.h"
 
 const char* check_string(VALUE value) {
   if (NIL_P(value)) { return NULL; }
@@ -90,6 +90,7 @@ VALUE create_parse_result(AST_DOCUMENT_NODE_T* root, VALUE source, const parser_
   rb_hash_aset(kwargs, ID2SYM(rb_intern("analyze")), options->analyze ? Qtrue : Qfalse);
   rb_hash_aset(kwargs, ID2SYM(rb_intern("action_view_helpers")), options->action_view_helpers ? Qtrue : Qfalse);
   rb_hash_aset(kwargs, ID2SYM(rb_intern("render_nodes")), options->render_nodes ? Qtrue : Qfalse);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("strict_locals")), options->strict_locals ? Qtrue : Qfalse);
   rb_hash_aset(kwargs, ID2SYM(rb_intern("prism_nodes")), options->prism_nodes ? Qtrue : Qfalse);
   rb_hash_aset(kwargs, ID2SYM(rb_intern("prism_nodes_deep")), options->prism_nodes_deep ? Qtrue : Qfalse);
   rb_hash_aset(kwargs, ID2SYM(rb_intern("prism_program")), options->prism_program ? Qtrue : Qfalse);

data/ext/herb/extension_helpers.h

@@ -4,10 +4,10 @@
 #include <ruby.h>
 
 #include "../../src/include/herb.h"
-#include "../../src/include/location.h"
-#include "../../src/include/position.h"
-#include "../../src/include/range.h"
-#include "../../src/include/token.h"
+#include "../../src/include/lexer/token.h"
+#include "../../src/include/location/location.h"
+#include "../../src/include/location/position.h"
+#include "../../src/include/location/range.h"
 
 const char* check_string(VALUE value);
 VALUE rb_string_from_hb_string(hb_string_T string);

data/ext/herb/nodes.c

@@ -10,7 +10,7 @@
 #include "nodes.h"
 
 #include "../../src/include/herb.h"
-#include "../../src/include/token.h"
+#include "../../src/include/lexer/token.h"
 
 VALUE rb_node_from_c_struct(AST_NODE_T* node);
 static VALUE rb_nodes_array_from_c_array(hb_array_T* array);
@@ -55,6 +55,8 @@ static VALUE cERBBeginNode;
 static VALUE cERBUnlessNode;
 static VALUE cRubyRenderLocalNode;
 static VALUE cERBRenderNode;
+static VALUE cRubyStrictLocalNode;
+static VALUE cERBStrictLocalsNode;
 static VALUE cERBYieldNode;
 static VALUE cERBInNode;
 
@@ -99,6 +101,8 @@ void rb_init_node_classes(void) {
   cERBUnlessNode = rb_define_class_under(mAST, "ERBUnlessNode", cNode);
   cRubyRenderLocalNode = rb_define_class_under(mAST, "RubyRenderLocalNode", cNode);
   cERBRenderNode = rb_define_class_under(mAST, "ERBRenderNode", cNode);
+  cRubyStrictLocalNode = rb_define_class_under(mAST, "RubyStrictLocalNode", cNode);
+  cERBStrictLocalsNode = rb_define_class_under(mAST, "ERBStrictLocalsNode", cNode);
   cERBYieldNode = rb_define_class_under(mAST, "ERBYieldNode", cNode);
   cERBInNode = rb_define_class_under(mAST, "ERBInNode", cNode);
 }
@@ -822,9 +826,12 @@ static VALUE rb_erb_block_node_from_c_struct(AST_ERB_BLOCK_NODE_T* erb_block_nod
     erb_block_node_prism_node = Qnil;
   }
   VALUE erb_block_node_body = rb_nodes_array_from_c_array(erb_block_node->body);
+  VALUE erb_block_node_rescue_clause = rb_node_from_c_struct((AST_NODE_T*) erb_block_node->rescue_clause);
+  VALUE erb_block_node_else_clause = rb_node_from_c_struct((AST_NODE_T*) erb_block_node->else_clause);
+  VALUE erb_block_node_ensure_clause = rb_node_from_c_struct((AST_NODE_T*) erb_block_node->ensure_clause);
   VALUE erb_block_node_end_node = rb_node_from_c_struct((AST_NODE_T*) erb_block_node->end_node);
 
-  VALUE args[9] = {
+  VALUE args[12] = {
     type,
     location,
     errors,
@@ -833,10 +840,13 @@ static VALUE rb_erb_block_node_from_c_struct(AST_ERB_BLOCK_NODE_T* erb_block_nod
     erb_block_node_tag_closing,
     erb_block_node_prism_node,
     erb_block_node_body,
+    erb_block_node_rescue_clause,
+    erb_block_node_else_clause,
+    erb_block_node_ensure_clause,
     erb_block_node_end_node
   };
 
-  return rb_class_new_instance(9, args, cERBBlockNode);
+  return rb_class_new_instance(12, args, cERBBlockNode);
 };
 
 static VALUE rb_erb_when_node_from_c_struct(AST_ERB_WHEN_NODE_T* erb_when_node) {
@@ -1368,6 +1378,80 @@ static VALUE rb_erb_render_node_from_c_struct(AST_ERB_RENDER_NODE_T* erb_render_
   return rb_class_new_instance(26, args, cERBRenderNode);
 };
 
+static VALUE rb_ruby_strict_local_node_from_c_struct(AST_RUBY_STRICT_LOCAL_NODE_T* ruby_strict_local_node) {
+  if (ruby_strict_local_node == NULL) { return Qnil; }
+
+  AST_NODE_T* node = &ruby_strict_local_node->base;
+
+  VALUE type = rb_string_from_hb_string(ast_node_type_to_string(node));
+  VALUE location = rb_location_from_c_struct(node->location);
+  VALUE errors = rb_errors_array_from_c_array(node->errors);
+
+  VALUE ruby_strict_local_node_name = rb_token_from_c_struct(ruby_strict_local_node->name);
+  VALUE ruby_strict_local_node_default_value = rb_node_from_c_struct((AST_NODE_T*) ruby_strict_local_node->default_value);
+  VALUE ruby_strict_local_node_required = (ruby_strict_local_node->required) ? Qtrue : Qfalse;
+  VALUE ruby_strict_local_node_double_splat = (ruby_strict_local_node->double_splat) ? Qtrue : Qfalse;
+
+  VALUE args[7] = {
+    type,
+    location,
+    errors,
+    ruby_strict_local_node_name,
+    ruby_strict_local_node_default_value,
+    ruby_strict_local_node_required,
+    ruby_strict_local_node_double_splat
+  };
+
+  return rb_class_new_instance(7, args, cRubyStrictLocalNode);
+};
+
+static VALUE rb_erb_strict_locals_node_from_c_struct(AST_ERB_STRICT_LOCALS_NODE_T* erb_strict_locals_node) {
+  if (erb_strict_locals_node == NULL) { return Qnil; }
+
+  AST_NODE_T* node = &erb_strict_locals_node->base;
+
+  VALUE type = rb_string_from_hb_string(ast_node_type_to_string(node));
+  VALUE location = rb_location_from_c_struct(node->location);
+  VALUE errors = rb_errors_array_from_c_array(node->errors);
+
+  VALUE erb_strict_locals_node_tag_opening = rb_token_from_c_struct(erb_strict_locals_node->tag_opening);
+  VALUE erb_strict_locals_node_content = rb_token_from_c_struct(erb_strict_locals_node->content);
+  VALUE erb_strict_locals_node_tag_closing = rb_token_from_c_struct(erb_strict_locals_node->tag_closing);
+  /* analyzed_ruby is internal parser state, not exposed to Ruby */
+  VALUE erb_strict_locals_node_analyzed_ruby = Qnil;
+  VALUE erb_strict_locals_node_prism_node;
+  if (erb_strict_locals_node->prism_node.node != NULL && erb_strict_locals_node->prism_node.parser != NULL) {
+    pm_buffer_t pm_buffer = { 0 };
+    pm_serialize(erb_strict_locals_node->prism_node.parser, erb_strict_locals_node->prism_node.node, &pm_buffer);
+
+    if (pm_buffer.length > 0) {
+      erb_strict_locals_node_prism_node = rb_str_new(pm_buffer.value, pm_buffer.length);
+      rb_enc_associate(erb_strict_locals_node_prism_node, rb_ascii8bit_encoding());
+      OBJ_FREEZE(erb_strict_locals_node_prism_node);
+    } else {
+      erb_strict_locals_node_prism_node = Qnil;
+    }
+    pm_buffer_free(&pm_buffer);
+  } else {
+    erb_strict_locals_node_prism_node = Qnil;
+  }
+  VALUE erb_strict_locals_node_locals = rb_nodes_array_from_c_array(erb_strict_locals_node->locals);
+
+  VALUE args[9] = {
+    type,
+    location,
+    errors,
+    erb_strict_locals_node_tag_opening,
+    erb_strict_locals_node_content,
+    erb_strict_locals_node_tag_closing,
+    erb_strict_locals_node_analyzed_ruby,
+    erb_strict_locals_node_prism_node,
+    erb_strict_locals_node_locals
+  };
+
+  return rb_class_new_instance(9, args, cERBStrictLocalsNode);
+};
+
 static VALUE rb_erb_yield_node_from_c_struct(AST_ERB_YIELD_NODE_T* erb_yield_node) {
   if (erb_yield_node == NULL) { return Qnil; }
 
@@ -1465,6 +1549,8 @@ VALUE rb_node_from_c_struct(AST_NODE_T* node) {
     case AST_ERB_UNLESS_NODE: return rb_erb_unless_node_from_c_struct((AST_ERB_UNLESS_NODE_T*) node); break;
     case AST_RUBY_RENDER_LOCAL_NODE: return rb_ruby_render_local_node_from_c_struct((AST_RUBY_RENDER_LOCAL_NODE_T*) node); break;
     case AST_ERB_RENDER_NODE: return rb_erb_render_node_from_c_struct((AST_ERB_RENDER_NODE_T*) node); break;
+    case AST_RUBY_STRICT_LOCAL_NODE: return rb_ruby_strict_local_node_from_c_struct((AST_RUBY_STRICT_LOCAL_NODE_T*) node); break;
+    case AST_ERB_STRICT_LOCALS_NODE: return rb_erb_strict_locals_node_from_c_struct((AST_ERB_STRICT_LOCALS_NODE_T*) node); break;
     case AST_ERB_YIELD_NODE: return rb_erb_yield_node_from_c_struct((AST_ERB_YIELD_NODE_T*) node); break;
     case AST_ERB_IN_NODE: return rb_erb_in_node_from_c_struct((AST_ERB_IN_NODE_T*) node); break;
   }

data/lib/herb/ast/erb_content_node.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+# typed: true
+
+module Herb
+  module AST
+    class ERBContentNode < Node
+      #: () -> Prism::node?
+      def parsed_prism_node
+        erb_content = @content&.value&.strip
+        return nil unless erb_content
+
+        begin
+          require "prism"
+        rescue LoadError
+          return nil
+        end
+
+        prism_result = Prism.parse(erb_content)
+        return nil unless prism_result.success?
+
+        prism_result.value.statements.body.first
+      end
+
+      #: () -> Prism::node?
+      def prism
+        return @prism if defined?(@prism)
+
+        @prism = deserialized_prism_node || parsed_prism_node
+      end
+    end
+  end
+end