herb 0.1.1-x86_64-linux-gnu → 0.2.0-x86_64-linux-gnu

data/src/include/ast_nodes.h

@@ -35,6 +35,7 @@ typedef enum {
   AST_ERB_BLOCK_NODE,
   AST_ERB_WHEN_NODE,
   AST_ERB_CASE_NODE,
+  AST_ERB_CASE_MATCH_NODE,
   AST_ERB_WHILE_NODE,
   AST_ERB_UNTIL_NODE,
   AST_ERB_FOR_NODE,
@@ -42,6 +43,8 @@ typedef enum {
   AST_ERB_ENSURE_NODE,
   AST_ERB_BEGIN_NODE,
   AST_ERB_UNLESS_NODE,
+  AST_ERB_YIELD_NODE,
+  AST_ERB_IN_NODE,
 } ast_node_type_T;
 
 typedef struct AST_NODE_STRUCT {
@@ -203,6 +206,17 @@ typedef struct AST_ERB_CASE_NODE_STRUCT {
   struct AST_ERB_END_NODE_STRUCT* end_node;
 } AST_ERB_CASE_NODE_T;
 
+typedef struct AST_ERB_CASE_MATCH_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* children;
+  array_T* conditions;
+  struct AST_ERB_ELSE_NODE_STRUCT* else_clause;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_CASE_MATCH_NODE_T;
+
 typedef struct AST_ERB_WHILE_NODE_STRUCT {
   AST_NODE_T base;
   token_T* tag_opening;
@@ -269,6 +283,21 @@ typedef struct AST_ERB_UNLESS_NODE_STRUCT {
   struct AST_ERB_END_NODE_STRUCT* end_node;
 } AST_ERB_UNLESS_NODE_T;
 
+typedef struct AST_ERB_YIELD_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+} AST_ERB_YIELD_NODE_T;
+
+typedef struct AST_ERB_IN_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+} AST_ERB_IN_NODE_T;
+
 AST_DOCUMENT_NODE_T* ast_document_node_init(array_T* children, position_T* start_position, position_T* end_position, array_T* errors);
 AST_LITERAL_NODE_T* ast_literal_node_init(const char* content, position_T* start_position, position_T* end_position, array_T* errors);
 AST_HTML_OPEN_TAG_NODE_T* ast_html_open_tag_node_init(token_T* tag_opening, token_T* tag_name, token_T* tag_closing, array_T* children, bool is_void, position_T* start_position, position_T* end_position, array_T* errors);
@@ -289,6 +318,7 @@ AST_ERB_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content,
 AST_ERB_BLOCK_NODE_T* ast_erb_block_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* body, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_WHEN_NODE_T* ast_erb_when_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_CASE_NODE_T* ast_erb_case_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* children, array_T* conditions, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_CASE_MATCH_NODE_T* ast_erb_case_match_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* children, array_T* conditions, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_WHILE_NODE_T* ast_erb_while_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_UNTIL_NODE_T* ast_erb_until_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_FOR_NODE_T* ast_erb_for_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
@@ -296,6 +326,8 @@ AST_ERB_RESCUE_NODE_T* ast_erb_rescue_node_init(token_T* tag_opening, token_T* c
 AST_ERB_ENSURE_NODE_T* ast_erb_ensure_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_BEGIN_NODE_T* ast_erb_begin_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_RESCUE_NODE_STRUCT* rescue_clause, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_ENSURE_NODE_STRUCT* ensure_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
 AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_ELSE_NODE_STRUCT* else_clause, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_YIELD_NODE_T* ast_erb_yield_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_IN_NODE_T* ast_erb_in_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, position_T* start_position, position_T* end_position, array_T* errors);
 
 const char* ast_node_type_to_string(AST_NODE_T* node);
 const char* ast_node_human_type(AST_NODE_T* node);

data/src/include/buffer.h

@@ -13,8 +13,11 @@ typedef struct BUFFER_STRUCT {
 bool buffer_init(buffer_T* buffer);
 buffer_T buffer_new(void);
 
-bool buffer_increase_capacity(buffer_T* buffer, size_t required_length);
-bool buffer_reserve(buffer_T* buffer, size_t min_capacity);
+bool buffer_increase_capacity(buffer_T* buffer, size_t additional_capacity);
+bool buffer_has_capacity(buffer_T* buffer, size_t required_length);
+bool buffer_expand_capacity(buffer_T* buffer);
+bool buffer_expand_if_needed(buffer_T* buffer, size_t required_length);
+bool buffer_resize(buffer_T* buffer, size_t new_capacity);
 
 void buffer_append(buffer_T* buffer, const char* text);
 void buffer_append_with_length(buffer_T* buffer, const char* text, size_t length);

data/src/include/lexer_peek_helpers.h

@@ -1,5 +1,5 @@
-#ifndef HERB_LEXER_PEEK_H
-#define HERB_LEXER_PEEK_H
+#ifndef HERB_LEXER_PEEK_HELPERS_H
+#define HERB_LEXER_PEEK_HELPERS_H
 
 #include "lexer_struct.h"
 

data/src/include/macros.h

@@ -1,9 +1,9 @@
 #ifndef HERB_MACROS_H
 #define HERB_MACROS_H
 
-#define MAX(a, b) (a) > (b) ? (a) : (b)
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
 
-#define MIN(a, b) (a) < (b) ? (a) : (b)
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
 
 #define unlikely(x) __builtin_expect(!!(x), 0)
 

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.1.1"
+#define HERB_VERSION "0.2.0"
 
 #endif

data/src/lexer.c

@@ -72,7 +72,7 @@ token_T* lexer_error(lexer_T* lexer, const char* message) {
     lexer->current_column
   );
 
-  return token_init(herb_strdup(error_message), TOKEN_ERROR, lexer);
+  return token_init(error_message, TOKEN_ERROR, lexer);
 }
 
 static void lexer_advance(lexer_T* lexer) {

data/src/parser.c

@@ -124,10 +124,9 @@ static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
   return doctype;
 }
 
-static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser) {
+static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T* document_errors) {
   position_T* start = position_copy(parser->current_token->location->start);
 
-  array_T* errors = array_init(8);
   buffer_T content = buffer_new();
 
   while (token_is_none_of(
@@ -142,16 +141,18 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser) {
     if (token_is(parser, TOKEN_ERROR)) {
       buffer_free(&content);
 
-      token_T* token = parser_consume_expected(parser, TOKEN_ERROR, errors);
+      token_T* token = parser_consume_expected(parser, TOKEN_ERROR, document_errors);
       append_unexpected_error(
         "Token Error",
         "not TOKEN_ERROR",
         token->value,
         token->location->start,
         token->location->end,
-        errors
+        document_errors
       );
+
       token_free(token);
+      position_free(start);
 
       return NULL;
     }
@@ -161,6 +162,8 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser) {
     token_free(token);
   }
 
+  array_T* errors = array_init(8);
+
   if (buffer_length(&content) > 0) {
     AST_HTML_TEXT_NODE_T* text_node =
       ast_html_text_node_init(buffer_value(&content), start, parser->current_token->location->start, errors);
@@ -265,7 +268,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
       false,
       erb_node->base.location->start,
       erb_node->base.location->end,
-      NULL
+      errors
     );
   }
 
@@ -284,7 +287,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
       false,
       literal->base.location->start,
       literal->base.location->end,
-      NULL
+      errors
     );
   }
 
@@ -400,6 +403,9 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
       token_free(tag_start);
       token_free(tag_name);
 
+      array_free(&children);
+      array_free(&errors);
+
       return NULL;
     }
 
@@ -617,7 +623,7 @@ static void parser_parse_in_data_state(parser_T* parser, array_T* children, arra
           TOKEN_UNDERSCORE,
           TOKEN_WHITESPACE
         )) {
-      array_append(children, parser_parse_text_content(parser));
+      array_append(children, parser_parse_text_content(parser, errors));
       continue;
     }
 
@@ -650,6 +656,10 @@ static void parser_parse_stray_closing_tags(parser_T* parser, array_T* children,
   while (token_is_not(parser, TOKEN_EOF)) {
     if (token_is_not(parser, TOKEN_HTML_TAG_START_CLOSE)) {
       parser_append_unexpected_token_error(parser, TOKEN_HTML_TAG_START_CLOSE, errors);
+
+      token_T* unexpected = parser_advance(parser);
+      token_free(unexpected);
+
       continue;
     }
 

data/src/token.c

@@ -72,7 +72,7 @@ const char* token_type_to_string(const token_type_T type) {
     case TOKEN_EOF: return "TOKEN_EOF";
   }
 
-  return "Unkown token_type_T";
+  return "Unknown token_type_T";
 }
 
 char* token_to_string(const token_T* token) {

data/src/util.c

@@ -43,13 +43,15 @@ int count_newlines(const char* string) {
 }
 
 char* replace_char(char* string, const char find, const char replace) {
+  char* original_string = string;
+
   while (*string != '\0') {
     if (*string == find) { *string = replace; }
 
     string++;
   }
 
-  return string;
+  return original_string;
 }
 
 char* escape_newlines(const char* input) {

data/src/visitor.c

@@ -199,6 +199,31 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_ERB_CASE_MATCH_NODE: {
+      const AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = ((const AST_ERB_CASE_MATCH_NODE_T *) node);
+
+      if (erb_case_match_node->children != NULL) {
+        for (size_t index = 0; index < array_size(erb_case_match_node->children); index++) {
+          herb_visit_node(array_get(erb_case_match_node->children, index), visitor, data);
+        }
+      }
+
+      if (erb_case_match_node->conditions != NULL) {
+        for (size_t index = 0; index < array_size(erb_case_match_node->conditions); index++) {
+          herb_visit_node(array_get(erb_case_match_node->conditions, index), visitor, data);
+        }
+      }
+
+      if (erb_case_match_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_case_match_node->else_clause, visitor, data);
+      }
+
+      if (erb_case_match_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_case_match_node->end_node, visitor, data);
+      }
+
+    } break;
+
     case AST_ERB_WHILE_NODE: {
       const AST_ERB_WHILE_NODE_T* erb_while_node = ((const AST_ERB_WHILE_NODE_T *) node);
 
@@ -316,6 +341,17 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_ERB_IN_NODE: {
+      const AST_ERB_IN_NODE_T* erb_in_node = ((const AST_ERB_IN_NODE_T *) node);
+
+      if (erb_in_node->statements != NULL) {
+        for (size_t index = 0; index < array_size(erb_in_node->statements); index++) {
+          herb_visit_node(array_get(erb_in_node->statements, index), visitor, data);
+        }
+      }
+
+    } break;
+
     default: break;
   }
 }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: x86_64-linux-gnu
 authors:
 - Marco Roth
 bindir: exe
 cert_chain: []
-date: 2025-04-20 00:00:00.000000000 Z
+date: 2025-06-12 00:00:00.000000000 Z
 dependencies: []
 description: Powerful and seamless HTML-aware ERB parsing and tooling.
 email:
@@ -17,7 +17,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- License.txt
+- LICENSE.txt
 - Makefile
 - README.md
 - Rakefile
@@ -62,6 +62,27 @@ files:
 - lib/herb/token.rb
 - lib/herb/token_list.rb
 - lib/herb/version.rb
+- lib/herb/visitor.rb
+- lib/herb/warnings.rb
+- sig/herb.rbs
+- sig/herb/ast.rbs
+- sig/herb/ast/node.rbs
+- sig/herb/ast/nodes.rbs
+- sig/herb/errors.rbs
+- sig/herb/lex_result.rbs
+- sig/herb/location.rbs
+- sig/herb/parse_result.rbs
+- sig/herb/position.rbs
+- sig/herb/range.rbs
+- sig/herb/result.rbs
+- sig/herb/token.rbs
+- sig/herb/token_list.rbs
+- sig/herb/version.rbs
+- sig/herb/visitor.rbs
+- sig/herb/warnings.rbs
+- sig/serialized.rbs
+- sig/serialized_ast_errors.rbs
+- sig/serialized_ast_nodes.rbs
 - src/analyze.c
 - src/analyze_helpers.c
 - src/analyzed_ruby.c