@herb-tools/node 0.1.0 → 0.2.0

package/extension/libherb/ast_pretty_print.h

@@ -0,0 +1,17 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release/templates/src/include/ast_pretty_print.h.erb
+
+#ifndef HERB_AST_PRETTY_PRINT_H
+#define HERB_AST_PRETTY_PRINT_H
+
+#include "ast_nodes.h"
+#include "buffer.h"
+
+void ast_pretty_print_node(
+  AST_NODE_T* node,
+  size_t indent,
+  size_t relative_indent,
+  buffer_T* buffer
+);
+
+#endif

package/extension/libherb/buffer.c

@@ -10,7 +10,7 @@
 bool buffer_init(buffer_T* buffer) {
   buffer->capacity = 1024;
   buffer->length = 0;
-  buffer->value = nullable_safe_malloc(buffer->capacity * sizeof(char));
+  buffer->value = nullable_safe_malloc((buffer->capacity + 1) * sizeof(char));
 
   if (!buffer->value) {
     fprintf(stderr, "Error: Failed to initialize buffer with capacity of %zu.\n", buffer->capacity);
@@ -50,32 +50,39 @@ size_t buffer_sizeof(void) {
  * or null termination.
  *
  * @param buffer The buffer to increase capacity for
- * @param required_length The additional length needed beyond current buffer length
- * @return true if capacity is sufficient (either already or after reallocation),
- *         false if reallocation failed
+ * @param additional_capacity The additional length needed beyond current buffer capacity
+ * @return true if capacity was increased, false if reallocation failed
  */
-bool buffer_increase_capacity(buffer_T* buffer, const size_t required_length) {
-  if (SIZE_MAX - buffer->length < required_length) {
+bool buffer_increase_capacity(buffer_T* buffer, const size_t additional_capacity) {
+  if (additional_capacity + 1 >= SIZE_MAX) {
     fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
-    return false;
+    exit(1);
   }
 
-  const size_t required_capacity = buffer->length + required_length;
-
-  if (buffer->capacity >= required_capacity) { return true; }
+  const size_t new_capacity = buffer->capacity + additional_capacity;
 
-  size_t new_capacity;
-  if (required_capacity > SIZE_MAX / 2) {
-    new_capacity = required_capacity + 1024;
+  return buffer_resize(buffer, new_capacity);
+}
 
-    if (new_capacity < required_capacity) { new_capacity = SIZE_MAX; }
-  } else {
-    new_capacity = required_capacity * 2;
+/**
+ * Resizes the capacity of the buffer to the specified new capacity.
+ *
+ * @param buffer The buffer to resize
+ * @param new_capacity The new capacity to resize the buffer to
+ * @return true if capacity was resized, false if reallocation failed
+ */
+bool buffer_resize(buffer_T* buffer, const size_t new_capacity) {
+  if (new_capacity + 1 >= SIZE_MAX) {
+    fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
+    exit(1);
   }
 
-  char* new_value = safe_realloc(buffer->value, new_capacity);
+  char* new_value = nullable_safe_realloc(buffer->value, new_capacity + 1);
 
-  if (unlikely(new_value == NULL)) { return false; }
+  if (unlikely(new_value == NULL)) {
+    fprintf(stderr, "Error: Failed to resize buffer to %zu.\n", new_capacity);
+    exit(1);
+  }
 
   buffer->value = new_value;
   buffer->capacity = new_capacity;
@@ -83,6 +90,33 @@ bool buffer_increase_capacity(buffer_T* buffer, const size_t required_length) {
   return true;
 }
 
+/**
+ * Expands the capacity of the buffer by doubling its current capacity.
+ * This function is a convenience function that calls buffer_increase_capacity
+ * with a factor of 2.
+ *
+ * @param buffer The buffer to expand capacity for
+ * @return true if capacity was increased, false if reallocation failed
+ */
+bool buffer_expand_capacity(buffer_T* buffer) {
+  return buffer_resize(buffer, buffer->capacity * 2);
+}
+
+/**
+ * Expands the capacity of the buffer if needed to accommodate additional content.
+ * This function is a convenience function that calls buffer_has_capacity and
+ * buffer_expand_capacity.
+ *
+ * @param buffer The buffer to expand capacity for
+ * @param required_length The additional length needed beyond current buffer capacity
+ * @return true if capacity was increased, false if reallocation failed
+ */
+bool buffer_expand_if_needed(buffer_T* buffer, const size_t required_length) {
+  if (buffer_has_capacity(buffer, required_length)) { return true; }
+
+  return buffer_resize(buffer, buffer->capacity + (required_length * 2));
+}
+
 /**
  * Appends a null-terminated string to the buffer.
  * @note This function requires that 'text' is a properly null-terminated string.
@@ -99,7 +133,7 @@ void buffer_append(buffer_T* buffer, const char* text) {
 
   size_t text_length = strlen(text);
 
-  if (!buffer_increase_capacity(buffer, text_length)) { return; }
+  if (!buffer_expand_if_needed(buffer, text_length)) { return; }
 
   memcpy(buffer->value + buffer->length, text, text_length);
   buffer->length += text_length;
@@ -120,7 +154,7 @@ void buffer_append(buffer_T* buffer, const char* text) {
  */
 void buffer_append_with_length(buffer_T* buffer, const char* text, const size_t length) {
   if (!buffer || !text || length == 0) { return; }
-  if (!buffer_increase_capacity(buffer, length)) { return; }
+  if (!buffer_expand_if_needed(buffer, length)) { return; }
 
   memcpy(buffer->value + buffer->length, text, length);
 
@@ -161,7 +195,7 @@ void buffer_prepend(buffer_T* buffer, const char* text) {
 
   size_t text_length = strlen(text);
 
-  if (!buffer_increase_capacity(buffer, text_length)) { return; }
+  if (!buffer_expand_if_needed(buffer, text_length)) { return; }
 
   memmove(buffer->value + text_length, buffer->value, buffer->length + 1);
   memcpy(buffer->value, text, text_length);
@@ -171,17 +205,16 @@ void buffer_prepend(buffer_T* buffer, const char* text) {
 
 void buffer_concat(buffer_T* destination, buffer_T* source) {
   if (source->length == 0) { return; }
-  if (!buffer_increase_capacity(destination, source->length)) { return; }
+  if (!buffer_expand_if_needed(destination, source->length)) { return; }
 
   memcpy(destination->value + destination->length, source->value, source->length);
+
   destination->length += source->length;
   destination->value[destination->length] = '\0';
 }
 
-bool buffer_reserve(buffer_T* buffer, const size_t min_capacity) {
-  const size_t required_length = min_capacity - buffer->length;
-
-  return buffer_increase_capacity(buffer, required_length);
+bool buffer_has_capacity(buffer_T* buffer, const size_t required_length) {
+  return (buffer->length + required_length <= buffer->capacity);
 }
 
 void buffer_clear(buffer_T* buffer) {
@@ -192,7 +225,7 @@ void buffer_clear(buffer_T* buffer) {
 void buffer_free(buffer_T* buffer) {
   if (!buffer) { return; }
 
-  free(buffer->value);
+  if (buffer->value != NULL) { free(buffer->value); }
 
   buffer->value = NULL;
   buffer->length = buffer->capacity = 0;

package/extension/libherb/buffer.h

@@ -0,0 +1,39 @@
+#ifndef HERB_BUFFER_H
+#define HERB_BUFFER_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef struct BUFFER_STRUCT {
+  char* value;
+  size_t length;
+  size_t capacity;
+} buffer_T;
+
+bool buffer_init(buffer_T* buffer);
+buffer_T buffer_new(void);
+
+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);
+void buffer_append_char(buffer_T* buffer, char character);
+void buffer_append_repeated(buffer_T* buffer, char character, size_t length);
+void buffer_append_whitespace(buffer_T* buffer, size_t length);
+void buffer_prepend(buffer_T* buffer, const char* text);
+void buffer_concat(buffer_T* destination, buffer_T* source);
+
+char* buffer_value(const buffer_T* buffer);
+
+size_t buffer_length(const buffer_T* buffer);
+size_t buffer_capacity(const buffer_T* buffer);
+size_t buffer_sizeof(void);
+
+void buffer_clear(buffer_T* buffer);
+void buffer_free(buffer_T* buffer);
+
+#endif

package/extension/libherb/errors.h

@@ -0,0 +1,125 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release/templates/src/include/errors.h.erb
+
+#ifndef HERB_ERRORS_H
+#define HERB_ERRORS_H
+
+#include "array.h"
+#include "buffer.h"
+#include "errors.h"
+#include "location.h"
+#include "position.h"
+#include "token.h"
+
+typedef enum {
+  UNEXPECTED_ERROR,
+  UNEXPECTED_TOKEN_ERROR,
+  MISSING_OPENING_TAG_ERROR,
+  MISSING_CLOSING_TAG_ERROR,
+  TAG_NAMES_MISMATCH_ERROR,
+  QUOTES_MISMATCH_ERROR,
+  VOID_ELEMENT_CLOSING_TAG_ERROR,
+  UNCLOSED_ELEMENT_ERROR,
+  RUBY_PARSE_ERROR,
+} error_type_T;
+
+typedef struct ERROR_STRUCT {
+  error_type_T type;
+  location_T* location;
+  char* message;
+} ERROR_T;
+
+
+typedef struct {
+  ERROR_T base;
+  const char* description;
+  const char* expected;
+  const char* found;
+} UNEXPECTED_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_type_T expected_type;
+  token_T* found;
+} UNEXPECTED_TOKEN_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_T* closing_tag;
+} MISSING_OPENING_TAG_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_T* opening_tag;
+} MISSING_CLOSING_TAG_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_T* opening_tag;
+  token_T* closing_tag;
+} TAG_NAMES_MISMATCH_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_T* opening_quote;
+  token_T* closing_quote;
+} QUOTES_MISMATCH_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_T* tag_name;
+  const char* expected;
+  const char* found;
+} VOID_ELEMENT_CLOSING_TAG_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  token_T* opening_tag;
+} UNCLOSED_ELEMENT_ERROR_T;
+
+typedef struct {
+  ERROR_T base;
+  const char* error_message;
+  const char* diagnostic_id;
+  const char* level;
+} RUBY_PARSE_ERROR_T;
+
+UNEXPECTED_ERROR_T* unexpected_error_init(const char* description, const char* expected, const char* found, position_T* start, position_T* end);
+void append_unexpected_error(const char* description, const char* expected, const char* found, position_T* start, position_T* end, array_T* errors);
+UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T* start, position_T* end);
+void append_unexpected_token_error(token_type_T expected_type, token_T* found, position_T* start, position_T* end, array_T* errors);
+MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error_init(token_T* closing_tag, position_T* start, position_T* end);
+void append_missing_opening_tag_error(token_T* closing_tag, position_T* start, position_T* end, array_T* errors);
+MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error_init(token_T* opening_tag, position_T* start, position_T* end);
+void append_missing_closing_tag_error(token_T* opening_tag, position_T* start, position_T* end, array_T* errors);
+TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error_init(token_T* opening_tag, token_T* closing_tag, position_T* start, position_T* end);
+void append_tag_names_mismatch_error(token_T* opening_tag, token_T* closing_tag, position_T* start, position_T* end, array_T* errors);
+QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error_init(token_T* opening_quote, token_T* closing_quote, position_T* start, position_T* end);
+void append_quotes_mismatch_error(token_T* opening_quote, token_T* closing_quote, position_T* start, position_T* end, array_T* errors);
+VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error_init(token_T* tag_name, const char* expected, const char* found, position_T* start, position_T* end);
+void append_void_element_closing_tag_error(token_T* tag_name, const char* expected, const char* found, position_T* start, position_T* end, array_T* errors);
+UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error_init(token_T* opening_tag, position_T* start, position_T* end);
+void append_unclosed_element_error(token_T* opening_tag, position_T* start, position_T* end, array_T* errors);
+RUBY_PARSE_ERROR_T* ruby_parse_error_init(const char* error_message, const char* diagnostic_id, const char* level, position_T* start, position_T* end);
+void append_ruby_parse_error(const char* error_message, const char* diagnostic_id, const char* level, position_T* start, position_T* end, array_T* errors);
+
+void error_init(ERROR_T* error, error_type_T type, position_T* start, position_T* end);
+
+size_t error_sizeof(void);
+error_type_T error_type(ERROR_T* error);
+
+char* error_message(ERROR_T* error);
+
+const char* error_type_to_string(ERROR_T* error);
+const char* error_human_type(ERROR_T* error);
+
+void error_free(ERROR_T* error);
+
+void error_pretty_print(ERROR_T* error, size_t indent, size_t relative_indent, buffer_T* buffer);
+
+void error_pretty_print_array(
+  const char* name, array_T* array, size_t indent, size_t relative_indent, bool last_property,
+  buffer_T* buffer
+);
+
+#endif

package/extension/libherb/extract.c

@@ -7,25 +7,28 @@
 #include <stdlib.h>
 
 void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output) {
-  const array_T* tokens = herb_lex(source);
+  array_T* tokens = herb_lex(source);
+  bool skip_erb_content = false;
 
   for (size_t i = 0; i < array_size(tokens); i++) {
     const token_T* token = array_get(tokens, i);
 
     switch (token->type) {
-      case TOKEN_NEWLINE:
-      case TOKEN_ERB_CONTENT: buffer_append(output, token->value); break;
-      case TOKEN_ERB_END: {
-        buffer_append_char(output, ';');
-        buffer_append_whitespace(output, range_length(token->range) - 1);
+      case TOKEN_NEWLINE: {
+        buffer_append(output, token->value);
         break;
       }
 
       case TOKEN_ERB_START: {
-        if (strcmp(token->value, "<%#") == 0) {
-          buffer_append_char(output, ' ');
-          buffer_append_char(output, ' ');
-          buffer_append_char(output, '#');
+        if (strcmp(token->value, "<%#") == 0) { skip_erb_content = true; }
+
+        buffer_append_whitespace(output, range_length(token->range));
+        break;
+      }
+
+      case TOKEN_ERB_CONTENT: {
+        if (skip_erb_content == false) {
+          buffer_append(output, token->value);
         } else {
           buffer_append_whitespace(output, range_length(token->range));
         }
@@ -33,25 +36,46 @@ void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* o
         break;
       }
 
-      default: buffer_append_whitespace(output, range_length(token->range));
+      case TOKEN_ERB_END: {
+        skip_erb_content = false;
+
+        buffer_append_char(output, ';');
+        buffer_append_whitespace(output, range_length(token->range) - 1);
+        break;
+      }
+
+      default: {
+        buffer_append_whitespace(output, range_length(token->range));
+      }
     }
   }
+
+  herb_free_tokens(&tokens);
 }
 
 void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
-  const array_T* tokens = herb_lex(source);
+  array_T* tokens = herb_lex(source);
+  bool skip_erb_content = false;
 
   for (size_t i = 0; i < array_size(tokens); i++) {
     const token_T* token = array_get(tokens, i);
 
     switch (token->type) {
-      case TOKEN_NEWLINE:
-      case TOKEN_ERB_CONTENT: buffer_append(output, token->value); break;
+      case TOKEN_NEWLINE: {
+        buffer_append(output, token->value);
+        break;
+      }
+
       case TOKEN_ERB_START: {
-        if (strcmp(token->value, "<%#") == 0) {
-          buffer_append_char(output, ' ');
-          buffer_append_char(output, ' ');
-          buffer_append_char(output, '#');
+        if (strcmp(token->value, "<%#") == 0) { skip_erb_content = true; }
+
+        buffer_append_whitespace(output, range_length(token->range));
+        break;
+      }
+
+      case TOKEN_ERB_CONTENT: {
+        if (skip_erb_content == false) {
+          buffer_append(output, token->value);
         } else {
           buffer_append_whitespace(output, range_length(token->range));
         }
@@ -59,13 +83,24 @@ void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
         break;
       }
 
-      default: buffer_append_whitespace(output, range_length(token->range));
+      case TOKEN_ERB_END: {
+        skip_erb_content = false;
+
+        buffer_append_whitespace(output, range_length(token->range));
+        break;
+      }
+
+      default: {
+        buffer_append_whitespace(output, range_length(token->range));
+      }
     }
   }
+
+  herb_free_tokens(&tokens);
 }
 
 void herb_extract_html_to_buffer(const char* source, buffer_T* output) {
-  const array_T* tokens = herb_lex(source);
+  array_T* tokens = herb_lex(source);
 
   for (size_t i = 0; i < array_size(tokens); i++) {
     const token_T* token = array_get(tokens, i);
@@ -77,6 +112,8 @@ void herb_extract_html_to_buffer(const char* source, buffer_T* output) {
       default: buffer_append(output, token->value);
     }
   }
+
+  herb_free_tokens(&tokens);
 }
 
 char* herb_extract_ruby_with_semicolons(const char* source) {

package/extension/libherb/extract.h

@@ -0,0 +1,20 @@
+#ifndef HERB_EXTRACT_H
+#define HERB_EXTRACT_H
+
+#include "buffer.h"
+
+typedef enum {
+  HERB_EXTRACT_LANGUAGE_RUBY,
+  HERB_EXTRACT_LANGUAGE_HTML,
+} herb_extract_language_T;
+
+void herb_extract_ruby_to_buffer(const char* source, buffer_T* output);
+void herb_extract_html_to_buffer(const char* source, buffer_T* output);
+
+char* herb_extract_ruby_with_semicolons(const char* source);
+void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output);
+
+char* herb_extract(const char* source, herb_extract_language_T language);
+char* herb_extract_from_file(const char* path, herb_extract_language_T language);
+
+#endif

package/extension/libherb/herb.h

@@ -0,0 +1,32 @@
+#ifndef HERB_H
+#define HERB_H
+
+#include "array.h"
+#include "ast_node.h"
+#include "buffer.h"
+#include "extract.h"
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void herb_lex_to_buffer(const char* source, buffer_T* output);
+void herb_lex_json_to_buffer(const char* source, buffer_T* output);
+
+array_T* herb_lex(const char* source);
+array_T* herb_lex_file(const char* path);
+
+AST_DOCUMENT_NODE_T* herb_parse(const char* source);
+
+const char* herb_version(void);
+const char* herb_prism_version(void);
+
+void herb_free_tokens(array_T** tokens);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/extension/libherb/html_util.h

@@ -0,0 +1,13 @@
+#ifndef HERB_HTML_UTIL_H
+#define HERB_HTML_UTIL_H
+
+#include <stdbool.h>
+
+bool is_void_element(const char* tag_name);
+bool is_html4_void_element(const char* tag_name);
+
+char* html_opening_tag_string(const char* tag_name);
+char* html_closing_tag_string(const char* tag_name);
+char* html_self_closing_tag_string(const char* tag_name);
+
+#endif

package/extension/libherb/include/analyze.h

@@ -17,7 +17,9 @@ typedef enum {
   CONTROL_TYPE_ELSE,
   CONTROL_TYPE_END,
   CONTROL_TYPE_CASE,
+  CONTROL_TYPE_CASE_MATCH,
   CONTROL_TYPE_WHEN,
+  CONTROL_TYPE_IN,
   CONTROL_TYPE_BEGIN,
   CONTROL_TYPE_RESCUE,
   CONTROL_TYPE_ENSURE,
@@ -27,6 +29,7 @@ typedef enum {
   CONTROL_TYPE_FOR,
   CONTROL_TYPE_BLOCK,
   CONTROL_TYPE_BLOCK_CLOSE,
+  CONTROL_TYPE_YIELD,
   CONTROL_TYPE_UNKNOWN
 } control_type_t;
 

package/extension/libherb/include/analyze_helpers.h

@@ -13,7 +13,9 @@ bool has_end(analyzed_ruby_T* analyzed);
 bool has_block_node(analyzed_ruby_T* analyzed);
 bool has_block_closing(analyzed_ruby_T* analyzed);
 bool has_case_node(analyzed_ruby_T* analyzed);
+bool has_case_match_node(analyzed_ruby_T* analyzed);
 bool has_when_node(analyzed_ruby_T* analyzed);
+bool has_in_node(analyzed_ruby_T* analyzed);
 bool has_for_node(analyzed_ruby_T* analyzed);
 bool has_while_node(analyzed_ruby_T* analyzed);
 bool has_until_node(analyzed_ruby_T* analyzed);
@@ -21,12 +23,14 @@ bool has_begin_node(analyzed_ruby_T* analyzed);
 bool has_rescue_node(analyzed_ruby_T* analyzed);
 bool has_ensure_node(analyzed_ruby_T* analyzed);
 bool has_unless_node(analyzed_ruby_T* analyzed);
+bool has_yield_node(analyzed_ruby_T* analyzed);
 
 bool has_error_message(analyzed_ruby_T* anlayzed, const char* message);
 
 bool search_if_nodes(const pm_node_t* node, void* data);
 bool search_block_nodes(const pm_node_t* node, void* data);
 bool search_case_nodes(const pm_node_t* node, void* data);
+bool search_case_match_nodes(const pm_node_t* node, void* data);
 bool search_while_nodes(const pm_node_t* node, void* data);
 bool search_for_nodes(const pm_node_t* node, void* data);
 bool search_until_nodes(const pm_node_t* node, void* data);
@@ -37,7 +41,9 @@ bool search_else_nodes(analyzed_ruby_T* analyzed);
 bool search_end_nodes(analyzed_ruby_T* analyzed);
 bool search_block_closing_nodes(analyzed_ruby_T* analyzed);
 bool search_when_nodes(analyzed_ruby_T* analyzed);
+bool search_in_nodes(analyzed_ruby_T* analyzed);
 bool search_rescue_nodes(analyzed_ruby_T* analyzed);
 bool search_ensure_nodes(analyzed_ruby_T* analyzed);
+bool search_yield_nodes(analyzed_ruby_T* analyzed);
 
 #endif

package/extension/libherb/include/analyzed_ruby.h

@@ -17,7 +17,9 @@ typedef struct ANALYZED_RUBY_STRUCT {
   bool has_block_closing;
   bool has_block_node;
   bool has_case_node;
+  bool has_case_match_node;
   bool has_when_node;
+  bool has_in_node;
   bool has_for_node;
   bool has_while_node;
   bool has_until_node;
@@ -25,6 +27,7 @@ typedef struct ANALYZED_RUBY_STRUCT {
   bool has_rescue_node;
   bool has_ensure_node;
   bool has_unless_node;
+  bool has_yield_node;
 } analyzed_ruby_T;
 
 analyzed_ruby_T* init_analyzed_ruby(char* source);

package/extension/libherb/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);