@herb-tools/node 0.1.0 → 0.2.0

package/extension/libherb/analyzed_ruby.h

@@ -0,0 +1,36 @@
+#ifndef HERB_ANALYZED_RUBY_H
+#define HERB_ANALYZED_RUBY_H
+
+#include "array.h"
+
+#include <prism.h>
+
+typedef struct ANALYZED_RUBY_STRUCT {
+  pm_parser_t parser;
+  pm_node_t* root;
+  bool valid;
+  bool parsed;
+  bool has_if_node;
+  bool has_elsif_node;
+  bool has_else_node;
+  bool has_end;
+  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;
+  bool has_begin_node;
+  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);
+void free_analyzed_ruby(analyzed_ruby_T* analyzed);
+
+#endif

package/extension/libherb/array.h

@@ -0,0 +1,33 @@
+#ifndef HERB_ARRAY_H
+#define HERB_ARRAY_H
+
+#include <stdlib.h>
+
+typedef struct ARRAY_STRUCT {
+  void** items;
+  size_t size;
+  size_t capacity;
+} array_T;
+
+array_T* array_init(size_t capacity);
+
+void* array_get(const array_T* array, size_t index);
+void* array_first(array_T* array);
+void* array_last(array_T* array);
+
+void array_append(array_T* array, void* item);
+void array_set(const array_T* array, size_t index, void* item);
+void array_free(array_T** array);
+void array_remove(array_T* array, size_t index);
+
+size_t array_index_of(array_T* array, void* item);
+void array_remove_item(array_T* array, void* item);
+
+void array_push(array_T* array, void* item);
+void* array_pop(array_T* array);
+
+size_t array_capacity(const array_T* array);
+size_t array_size(const array_T* array);
+size_t array_sizeof(void);
+
+#endif

package/extension/libherb/ast_node.h

@@ -0,0 +1,35 @@
+#ifndef HERB_AST_H
+#define HERB_AST_H
+
+#include "ast_nodes.h"
+#include "errors.h"
+#include "position.h"
+#include "token_struct.h"
+
+void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T* start, position_T* end, array_T* errors);
+void ast_node_free(AST_NODE_T* node);
+
+AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token);
+
+size_t ast_node_sizeof(void);
+size_t ast_node_child_count(AST_NODE_T* node);
+
+ast_node_type_T ast_node_type(const AST_NODE_T* node);
+
+char* ast_node_name(AST_NODE_T* node);
+
+void ast_node_set_start(AST_NODE_T* node, position_T* position);
+void ast_node_set_end(AST_NODE_T* node, position_T* position);
+
+size_t ast_node_errors_count(const AST_NODE_T* node);
+array_T* ast_node_errors(const AST_NODE_T* node);
+void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error);
+
+void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token);
+void ast_node_set_end_from_token(AST_NODE_T* node, const token_T* token);
+
+void ast_node_set_positions_from_token(AST_NODE_T* node, const token_T* token);
+
+bool ast_node_is(const AST_NODE_T* node, ast_node_type_T type);
+
+#endif

package/extension/libherb/ast_nodes.c

@@ -266,6 +266,22 @@ AST_ERB_CASE_NODE_T* ast_erb_case_node_init(token_T* tag_opening, token_T* conte
   return erb_case_node;
 }
 
+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_CASE_MATCH_NODE_T* erb_case_match_node = malloc(sizeof(AST_ERB_CASE_MATCH_NODE_T));
+
+  ast_node_init(&erb_case_match_node->base, AST_ERB_CASE_MATCH_NODE, start_position, end_position, errors);
+
+  erb_case_match_node->tag_opening = token_copy(tag_opening);
+  erb_case_match_node->content = token_copy(content);
+  erb_case_match_node->tag_closing = token_copy(tag_closing);
+  erb_case_match_node->children = children;
+  erb_case_match_node->conditions = conditions;
+  erb_case_match_node->else_clause = else_clause;
+  erb_case_match_node->end_node = end_node;
+
+  return erb_case_match_node;
+}
+
 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_WHILE_NODE_T* erb_while_node = malloc(sizeof(AST_ERB_WHILE_NODE_T));
 
@@ -367,6 +383,31 @@ AST_ERB_UNLESS_NODE_T* ast_erb_unless_node_init(token_T* tag_opening, token_T* c
   return erb_unless_node;
 }
 
+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_YIELD_NODE_T* erb_yield_node = malloc(sizeof(AST_ERB_YIELD_NODE_T));
+
+  ast_node_init(&erb_yield_node->base, AST_ERB_YIELD_NODE, start_position, end_position, errors);
+
+  erb_yield_node->tag_opening = token_copy(tag_opening);
+  erb_yield_node->content = token_copy(content);
+  erb_yield_node->tag_closing = token_copy(tag_closing);
+
+  return erb_yield_node;
+}
+
+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) {
+  AST_ERB_IN_NODE_T* erb_in_node = malloc(sizeof(AST_ERB_IN_NODE_T));
+
+  ast_node_init(&erb_in_node->base, AST_ERB_IN_NODE, start_position, end_position, errors);
+
+  erb_in_node->tag_opening = token_copy(tag_opening);
+  erb_in_node->content = token_copy(content);
+  erb_in_node->tag_closing = token_copy(tag_closing);
+  erb_in_node->statements = statements;
+
+  return erb_in_node;
+}
+
 const char* ast_node_type_to_string(AST_NODE_T* node) {
   switch (node->type) {
     case AST_DOCUMENT_NODE: return "AST_DOCUMENT_NODE";
@@ -389,6 +430,7 @@ const char* ast_node_type_to_string(AST_NODE_T* node) {
     case AST_ERB_BLOCK_NODE: return "AST_ERB_BLOCK_NODE";
     case AST_ERB_WHEN_NODE: return "AST_ERB_WHEN_NODE";
     case AST_ERB_CASE_NODE: return "AST_ERB_CASE_NODE";
+    case AST_ERB_CASE_MATCH_NODE: return "AST_ERB_CASE_MATCH_NODE";
     case AST_ERB_WHILE_NODE: return "AST_ERB_WHILE_NODE";
     case AST_ERB_UNTIL_NODE: return "AST_ERB_UNTIL_NODE";
     case AST_ERB_FOR_NODE: return "AST_ERB_FOR_NODE";
@@ -396,6 +438,8 @@ const char* ast_node_type_to_string(AST_NODE_T* node) {
     case AST_ERB_ENSURE_NODE: return "AST_ERB_ENSURE_NODE";
     case AST_ERB_BEGIN_NODE: return "AST_ERB_BEGIN_NODE";
     case AST_ERB_UNLESS_NODE: return "AST_ERB_UNLESS_NODE";
+    case AST_ERB_YIELD_NODE: return "AST_ERB_YIELD_NODE";
+    case AST_ERB_IN_NODE: return "AST_ERB_IN_NODE";
   }
 
   return "Unknown ast_node_type_T";
@@ -423,6 +467,7 @@ const char* ast_node_human_type(AST_NODE_T* node) {
     case AST_ERB_BLOCK_NODE: return "ERBBlockNode";
     case AST_ERB_WHEN_NODE: return "ERBWhenNode";
     case AST_ERB_CASE_NODE: return "ERBCaseNode";
+    case AST_ERB_CASE_MATCH_NODE: return "ERBCaseMatchNode";
     case AST_ERB_WHILE_NODE: return "ERBWhileNode";
     case AST_ERB_UNTIL_NODE: return "ERBUntilNode";
     case AST_ERB_FOR_NODE: return "ERBForNode";
@@ -430,6 +475,8 @@ const char* ast_node_human_type(AST_NODE_T* node) {
     case AST_ERB_ENSURE_NODE: return "ERBEnsureNode";
     case AST_ERB_BEGIN_NODE: return "ERBBeginNode";
     case AST_ERB_UNLESS_NODE: return "ERBUnlessNode";
+    case AST_ERB_YIELD_NODE: return "ERBYieldNode";
+    case AST_ERB_IN_NODE: return "ERBInNode";
   }
 
   return "Unknown ast_node_type_T";
@@ -603,7 +650,9 @@ static void ast_free_erb_content_node(AST_ERB_CONTENT_NODE_T* erb_content_node)
   if (erb_content_node->tag_opening != NULL) { token_free(erb_content_node->tag_opening); }
   if (erb_content_node->content != NULL) { token_free(erb_content_node->content); }
   if (erb_content_node->tag_closing != NULL) { token_free(erb_content_node->tag_closing); }
-  // TODO: free
+  if (erb_content_node->analyzed_ruby != NULL) {
+    free_analyzed_ruby(erb_content_node->analyzed_ruby);
+  }
 
   ast_free_base_node(&erb_content_node->base);
 }
@@ -709,6 +758,32 @@ static void ast_free_erb_case_node(AST_ERB_CASE_NODE_T* erb_case_node) {
   ast_free_base_node(&erb_case_node->base);
 }
 
+static void ast_free_erb_case_match_node(AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node) {
+  if (erb_case_match_node->tag_opening != NULL) { token_free(erb_case_match_node->tag_opening); }
+  if (erb_case_match_node->content != NULL) { token_free(erb_case_match_node->content); }
+  if (erb_case_match_node->tag_closing != NULL) { token_free(erb_case_match_node->tag_closing); }
+  if (erb_case_match_node->children != NULL) {
+    for (size_t i = 0; i < array_size(erb_case_match_node->children); i++) {
+      AST_NODE_T* child = array_get(erb_case_match_node->children, i);
+      if (child) { ast_node_free(child); }
+    }
+
+    array_free(&erb_case_match_node->children);
+  }
+  if (erb_case_match_node->conditions != NULL) {
+    for (size_t i = 0; i < array_size(erb_case_match_node->conditions); i++) {
+      AST_NODE_T* child = array_get(erb_case_match_node->conditions, i);
+      if (child) { ast_node_free(child); }
+    }
+
+    array_free(&erb_case_match_node->conditions);
+  }
+  ast_node_free((AST_NODE_T*) erb_case_match_node->else_clause);
+  ast_node_free((AST_NODE_T*) erb_case_match_node->end_node);
+
+  ast_free_base_node(&erb_case_match_node->base);
+}
+
 static void ast_free_erb_while_node(AST_ERB_WHILE_NODE_T* erb_while_node) {
   if (erb_while_node->tag_opening != NULL) { token_free(erb_while_node->tag_opening); }
   if (erb_while_node->content != NULL) { token_free(erb_while_node->content); }
@@ -831,6 +906,30 @@ static void ast_free_erb_unless_node(AST_ERB_UNLESS_NODE_T* erb_unless_node) {
   ast_free_base_node(&erb_unless_node->base);
 }
 
+static void ast_free_erb_yield_node(AST_ERB_YIELD_NODE_T* erb_yield_node) {
+  if (erb_yield_node->tag_opening != NULL) { token_free(erb_yield_node->tag_opening); }
+  if (erb_yield_node->content != NULL) { token_free(erb_yield_node->content); }
+  if (erb_yield_node->tag_closing != NULL) { token_free(erb_yield_node->tag_closing); }
+
+  ast_free_base_node(&erb_yield_node->base);
+}
+
+static void ast_free_erb_in_node(AST_ERB_IN_NODE_T* erb_in_node) {
+  if (erb_in_node->tag_opening != NULL) { token_free(erb_in_node->tag_opening); }
+  if (erb_in_node->content != NULL) { token_free(erb_in_node->content); }
+  if (erb_in_node->tag_closing != NULL) { token_free(erb_in_node->tag_closing); }
+  if (erb_in_node->statements != NULL) {
+    for (size_t i = 0; i < array_size(erb_in_node->statements); i++) {
+      AST_NODE_T* child = array_get(erb_in_node->statements, i);
+      if (child) { ast_node_free(child); }
+    }
+
+    array_free(&erb_in_node->statements);
+  }
+
+  ast_free_base_node(&erb_in_node->base);
+}
+
 void ast_node_free(AST_NODE_T* node) {
   if (!node) { return; }
 
@@ -855,6 +954,7 @@ void ast_node_free(AST_NODE_T* node) {
     case AST_ERB_BLOCK_NODE: ast_free_erb_block_node((AST_ERB_BLOCK_NODE_T*) node); break;
     case AST_ERB_WHEN_NODE: ast_free_erb_when_node((AST_ERB_WHEN_NODE_T*) node); break;
     case AST_ERB_CASE_NODE: ast_free_erb_case_node((AST_ERB_CASE_NODE_T*) node); break;
+    case AST_ERB_CASE_MATCH_NODE: ast_free_erb_case_match_node((AST_ERB_CASE_MATCH_NODE_T*) node); break;
     case AST_ERB_WHILE_NODE: ast_free_erb_while_node((AST_ERB_WHILE_NODE_T*) node); break;
     case AST_ERB_UNTIL_NODE: ast_free_erb_until_node((AST_ERB_UNTIL_NODE_T*) node); break;
     case AST_ERB_FOR_NODE: ast_free_erb_for_node((AST_ERB_FOR_NODE_T*) node); break;
@@ -862,5 +962,7 @@ void ast_node_free(AST_NODE_T* node) {
     case AST_ERB_ENSURE_NODE: ast_free_erb_ensure_node((AST_ERB_ENSURE_NODE_T*) node); break;
     case AST_ERB_BEGIN_NODE: ast_free_erb_begin_node((AST_ERB_BEGIN_NODE_T*) node); break;
     case AST_ERB_UNLESS_NODE: ast_free_erb_unless_node((AST_ERB_UNLESS_NODE_T*) node); break;
+    case AST_ERB_YIELD_NODE: ast_free_erb_yield_node((AST_ERB_YIELD_NODE_T*) node); break;
+    case AST_ERB_IN_NODE: ast_free_erb_in_node((AST_ERB_IN_NODE_T*) node); break;
   }
 }

package/extension/libherb/ast_nodes.h

@@ -0,0 +1,335 @@
+// 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_nodes.h.erb
+
+#ifndef HERB_AST_NODES_H
+#define HERB_AST_NODES_H
+
+#include <stdbool.h>
+#include <prism.h>
+
+#include "array.h"
+#include "buffer.h"
+#include "position.h"
+#include "location.h"
+#include "token_struct.h"
+#include "analyzed_ruby.h"
+
+typedef enum {
+  AST_DOCUMENT_NODE,
+  AST_LITERAL_NODE,
+  AST_HTML_OPEN_TAG_NODE,
+  AST_HTML_CLOSE_TAG_NODE,
+  AST_HTML_SELF_CLOSE_TAG_NODE,
+  AST_HTML_ELEMENT_NODE,
+  AST_HTML_ATTRIBUTE_VALUE_NODE,
+  AST_HTML_ATTRIBUTE_NAME_NODE,
+  AST_HTML_ATTRIBUTE_NODE,
+  AST_HTML_TEXT_NODE,
+  AST_HTML_COMMENT_NODE,
+  AST_HTML_DOCTYPE_NODE,
+  AST_WHITESPACE_NODE,
+  AST_ERB_CONTENT_NODE,
+  AST_ERB_END_NODE,
+  AST_ERB_ELSE_NODE,
+  AST_ERB_IF_NODE,
+  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,
+  AST_ERB_RESCUE_NODE,
+  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 {
+  ast_node_type_T type;
+  location_T* location;
+  // maybe a range too?
+  array_T* errors;
+} AST_NODE_T;
+
+
+typedef struct AST_DOCUMENT_NODE_STRUCT {
+  AST_NODE_T base;
+  array_T* children;
+} AST_DOCUMENT_NODE_T;
+
+typedef struct AST_LITERAL_NODE_STRUCT {
+  AST_NODE_T base;
+  const char* content;
+} AST_LITERAL_NODE_T;
+
+typedef struct AST_HTML_OPEN_TAG_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* tag_name;
+  token_T* tag_closing;
+  array_T* children;
+  bool is_void;
+} AST_HTML_OPEN_TAG_NODE_T;
+
+typedef struct AST_HTML_CLOSE_TAG_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* tag_name;
+  token_T* tag_closing;
+} AST_HTML_CLOSE_TAG_NODE_T;
+
+typedef struct AST_HTML_SELF_CLOSE_TAG_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* tag_name;
+  array_T* attributes;
+  token_T* tag_closing;
+  bool is_void;
+} AST_HTML_SELF_CLOSE_TAG_NODE_T;
+
+typedef struct AST_HTML_ELEMENT_NODE_STRUCT {
+  AST_NODE_T base;
+  struct AST_HTML_OPEN_TAG_NODE_STRUCT* open_tag;
+  token_T* tag_name;
+  array_T* body;
+  struct AST_HTML_CLOSE_TAG_NODE_STRUCT* close_tag;
+  bool is_void;
+} AST_HTML_ELEMENT_NODE_T;
+
+typedef struct AST_HTML_ATTRIBUTE_VALUE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* open_quote;
+  array_T* children;
+  token_T* close_quote;
+  bool quoted;
+} AST_HTML_ATTRIBUTE_VALUE_NODE_T;
+
+typedef struct AST_HTML_ATTRIBUTE_NAME_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* name;
+} AST_HTML_ATTRIBUTE_NAME_NODE_T;
+
+typedef struct AST_HTML_ATTRIBUTE_NODE_STRUCT {
+  AST_NODE_T base;
+  struct AST_HTML_ATTRIBUTE_NAME_NODE_STRUCT* name;
+  token_T* equals;
+  struct AST_HTML_ATTRIBUTE_VALUE_NODE_STRUCT* value;
+} AST_HTML_ATTRIBUTE_NODE_T;
+
+typedef struct AST_HTML_TEXT_NODE_STRUCT {
+  AST_NODE_T base;
+  const char* content;
+} AST_HTML_TEXT_NODE_T;
+
+typedef struct AST_HTML_COMMENT_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* comment_start;
+  array_T* children;
+  token_T* comment_end;
+} AST_HTML_COMMENT_NODE_T;
+
+typedef struct AST_HTML_DOCTYPE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  array_T* children;
+  token_T* tag_closing;
+} AST_HTML_DOCTYPE_NODE_T;
+
+typedef struct AST_WHITESPACE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* value;
+} AST_WHITESPACE_NODE_T;
+
+typedef struct AST_ERB_CONTENT_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  analyzed_ruby_T* analyzed_ruby;
+  bool parsed;
+  bool valid;
+} AST_ERB_CONTENT_NODE_T;
+
+typedef struct AST_ERB_END_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+} AST_ERB_END_NODE_T;
+
+typedef struct AST_ERB_ELSE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+} AST_ERB_ELSE_NODE_T;
+
+typedef struct AST_ERB_IF_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+  AST_NODE_T* subsequent;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_IF_NODE_T;
+
+typedef struct AST_ERB_BLOCK_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* body;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_BLOCK_NODE_T;
+
+typedef struct AST_ERB_WHEN_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+} AST_ERB_WHEN_NODE_T;
+
+typedef struct AST_ERB_CASE_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_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;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_WHILE_NODE_T;
+
+typedef struct AST_ERB_UNTIL_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_UNTIL_NODE_T;
+
+typedef struct AST_ERB_FOR_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+  struct AST_ERB_END_NODE_STRUCT* end_node;
+} AST_ERB_FOR_NODE_T;
+
+typedef struct AST_ERB_RESCUE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+  struct AST_ERB_RESCUE_NODE_STRUCT* subsequent;
+} AST_ERB_RESCUE_NODE_T;
+
+typedef struct AST_ERB_ENSURE_NODE_STRUCT {
+  AST_NODE_T base;
+  token_T* tag_opening;
+  token_T* content;
+  token_T* tag_closing;
+  array_T* statements;
+} AST_ERB_ENSURE_NODE_T;
+
+typedef struct AST_ERB_BEGIN_NODE_STRUCT {
+  AST_NODE_T base;
+  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;
+} AST_ERB_BEGIN_NODE_T;
+
+typedef struct AST_ERB_UNLESS_NODE_STRUCT {
+  AST_NODE_T base;
+  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;
+} 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);
+AST_HTML_CLOSE_TAG_NODE_T* ast_html_close_tag_node_init(token_T* tag_opening, token_T* tag_name, token_T* tag_closing, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_SELF_CLOSE_TAG_NODE_T* ast_html_self_close_tag_node_init(token_T* tag_opening, token_T* tag_name, array_T* attributes, token_T* tag_closing, bool is_void, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_ELEMENT_NODE_T* ast_html_element_node_init(struct AST_HTML_OPEN_TAG_NODE_STRUCT* open_tag, token_T* tag_name, array_T* body, struct AST_HTML_CLOSE_TAG_NODE_STRUCT* close_tag, bool is_void, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_ATTRIBUTE_VALUE_NODE_T* ast_html_attribute_value_node_init(token_T* open_quote, array_T* children, token_T* close_quote, bool quoted, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_ATTRIBUTE_NAME_NODE_T* ast_html_attribute_name_node_init(token_T* name, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_ATTRIBUTE_NODE_T* ast_html_attribute_node_init(struct AST_HTML_ATTRIBUTE_NAME_NODE_STRUCT* name, token_T* equals, struct AST_HTML_ATTRIBUTE_VALUE_NODE_STRUCT* value, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_TEXT_NODE_T* ast_html_text_node_init(const char* content, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_COMMENT_NODE_T* ast_html_comment_node_init(token_T* comment_start, array_T* children, token_T* comment_end, position_T* start_position, position_T* end_position, array_T* errors);
+AST_HTML_DOCTYPE_NODE_T* ast_html_doctype_node_init(token_T* tag_opening, array_T* children, token_T* tag_closing, position_T* start_position, position_T* end_position, array_T* errors);
+AST_WHITESPACE_NODE_T* ast_whitespace_node_init(token_T* value, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_CONTENT_NODE_T* ast_erb_content_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, analyzed_ruby_T* analyzed_ruby, bool parsed, bool valid, position_T* start_position, position_T* end_position, array_T* errors);
+AST_ERB_END_NODE_T* ast_erb_end_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_ELSE_NODE_T* ast_erb_else_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_IF_NODE_T* ast_erb_if_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, AST_NODE_T* subsequent, struct AST_ERB_END_NODE_STRUCT* end_node, position_T* start_position, position_T* end_position, array_T* errors);
+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);
+AST_ERB_RESCUE_NODE_T* ast_erb_rescue_node_init(token_T* tag_opening, token_T* content, token_T* tag_closing, array_T* statements, struct AST_ERB_RESCUE_NODE_STRUCT* subsequent, position_T* start_position, position_T* end_position, array_T* errors);
+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);
+
+#endif

package/extension/libherb/ast_pretty_print.c

@@ -364,6 +364,47 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
 
     } break;
 
+    case AST_ERB_CASE_MATCH_NODE: {
+      const AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = (AST_ERB_CASE_MATCH_NODE_T*) node;
+
+      pretty_print_errors(node, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_case_match_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_case_match_node->content, "content", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_case_match_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
+      pretty_print_array("children", erb_case_match_node->children, indent, relative_indent, false, buffer);
+      pretty_print_array("conditions", erb_case_match_node->conditions, indent, relative_indent, false, buffer);
+
+      pretty_print_label("else_clause", indent, relative_indent, false, buffer);
+
+      if (erb_case_match_node->else_clause) {
+        buffer_append(buffer, "\n");
+        pretty_print_indent(buffer, indent);
+        pretty_print_indent(buffer, relative_indent + 1);
+
+        buffer_append(buffer, "└── ");
+        ast_pretty_print_node((AST_NODE_T*) erb_case_match_node->else_clause, indent, relative_indent + 2, buffer);
+      } else {
+        buffer_append(buffer, " ∅\n");
+      }
+      buffer_append(buffer, "\n");
+
+
+      pretty_print_label("end_node", indent, relative_indent, true, buffer);
+
+      if (erb_case_match_node->end_node) {
+        buffer_append(buffer, "\n");
+        pretty_print_indent(buffer, indent);
+        pretty_print_indent(buffer, relative_indent + 1);
+
+        buffer_append(buffer, "└── ");
+        ast_pretty_print_node((AST_NODE_T*) erb_case_match_node->end_node, indent, relative_indent + 2, buffer);
+      } else {
+        buffer_append(buffer, " ∅\n");
+      }
+      buffer_append(buffer, "\n");
+
+    } break;
+
     case AST_ERB_WHILE_NODE: {
       const AST_ERB_WHILE_NODE_T* erb_while_node = (AST_ERB_WHILE_NODE_T*) node;
 
@@ -584,5 +625,24 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
 
     } break;
 
+    case AST_ERB_YIELD_NODE: {
+      const AST_ERB_YIELD_NODE_T* erb_yield_node = (AST_ERB_YIELD_NODE_T*) node;
+
+      pretty_print_errors(node, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_yield_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_yield_node->content, "content", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_yield_node->tag_closing, "tag_closing", indent, relative_indent, true, buffer);
+    } break;
+
+    case AST_ERB_IN_NODE: {
+      const AST_ERB_IN_NODE_T* erb_in_node = (AST_ERB_IN_NODE_T*) node;
+
+      pretty_print_errors(node, indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_in_node->tag_opening, "tag_opening", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_in_node->content, "content", indent, relative_indent, false, buffer);
+      pretty_print_token_property(erb_in_node->tag_closing, "tag_closing", indent, relative_indent, false, buffer);
+      pretty_print_array("statements", erb_in_node->statements, indent, relative_indent, true, buffer);
+    } break;
+
   }
 }