@herb-tools/node 0.1.1 → 0.3.0

package/extension/libherb/memory.h

@@ -0,0 +1,12 @@
+#ifndef HERB_MEMORY_H
+#define HERB_MEMORY_H
+
+#include <stddef.h>
+
+void* safe_malloc(size_t size);
+void* safe_realloc(void* pointer, size_t new_size);
+
+void* nullable_safe_malloc(size_t size);
+void* nullable_safe_realloc(void* pointer, size_t new_size);
+
+#endif

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

package/extension/libherb/parser.h

@@ -0,0 +1,22 @@
+#ifndef HERB_PARSER_H
+#define HERB_PARSER_H
+
+#include "array.h"
+#include "ast_node.h"
+#include "lexer.h"
+
+typedef struct PARSER_STRUCT {
+  lexer_T* lexer;
+  token_T* current_token;
+  array_T* open_tags_stack;
+} parser_T;
+
+parser_T* parser_init(lexer_T* lexer);
+
+AST_DOCUMENT_NODE_T* parser_parse(parser_T* parser);
+
+size_t parser_sizeof(void);
+
+void parser_free(parser_T* parser);
+
+#endif

package/extension/libherb/parser_helpers.h

@@ -0,0 +1,33 @@
+#ifndef HERB_PARSER_HELPERS_H
+#define HERB_PARSER_HELPERS_H
+
+#include "array.h"
+#include "ast_nodes.h"
+#include "buffer.h"
+#include "errors.h"
+#include "parser.h"
+#include "token.h"
+
+void parser_push_open_tag(const parser_T* parser, token_T* tag_name);
+bool parser_check_matching_tag(const parser_T* parser, const char* tag_name);
+token_T* parser_pop_open_tag(const parser_T* parser);
+
+void parser_append_unexpected_error(parser_T* parser, const char* description, const char* expected, array_T* errors);
+void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors);
+
+void parser_append_literal_node_from_buffer(
+  const parser_T* parser, buffer_T* buffer, array_T* children, position_T* start
+);
+
+bool parser_in_svg_context(const parser_T* parser);
+
+token_T* parser_advance(parser_T* parser);
+token_T* parser_consume_if_present(parser_T* parser, token_type_T type);
+token_T* parser_consume_expected(parser_T* parser, token_type_T type, array_T* array);
+
+AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
+  AST_HTML_OPEN_TAG_NODE_T* open_tag, array_T* body, array_T* errors
+);
+void parser_handle_mismatched_tags(const parser_T* parser, const AST_HTML_CLOSE_TAG_NODE_T* close_tag, array_T* errors);
+
+#endif

package/extension/libherb/position.h

@@ -0,0 +1,22 @@
+#ifndef HERB_POSITION_H
+#define HERB_POSITION_H
+
+#include <stdlib.h>
+
+typedef struct POSITION_STRUCT {
+  size_t line;
+  size_t column;
+} position_T;
+
+position_T* position_init(size_t line, size_t column);
+
+size_t position_line(const position_T* position);
+size_t position_column(const position_T* position);
+
+size_t position_sizeof(void);
+
+position_T* position_copy(position_T* position);
+
+void position_free(position_T* position);
+
+#endif

package/extension/libherb/pretty_print.h

@@ -0,0 +1,53 @@
+#ifndef HERB_PRETTY_PRINT_H
+#define HERB_PRETTY_PRINT_H
+
+#include "analyzed_ruby.h"
+#include "ast_nodes.h"
+#include "buffer.h"
+#include "location.h"
+
+#include <stdbool.h>
+
+void pretty_print_indent(buffer_T* buffer, size_t indent);
+void pretty_print_newline(size_t indent, size_t relative_indent, buffer_T* buffer);
+void pretty_print_label(const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
+
+void pretty_print_position_property(
+  position_T* position, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_location(location_T* location, buffer_T* buffer);
+
+void pretty_print_property(
+  const char* name, const char* value, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_size_t_property(
+  size_t value, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_string_property(
+  const char* string, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_quoted_property(
+  const char* name, const char* value, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_boolean_property(
+  const char* name, bool value, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_token_property(
+  token_T* token, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_array(
+  const char* name, array_T* array, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_errors(AST_NODE_T* node, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
+
+void pretty_print_analyed_ruby(analyzed_ruby_T* analyzed, const char* source);
+
+#endif

package/extension/libherb/prism_helpers.h

@@ -0,0 +1,18 @@
+#ifndef HERB_PRISM_HELPERS_H
+#define HERB_PRISM_HELPERS_H
+
+#include "ast_nodes.h"
+#include "errors.h"
+#include "position.h"
+
+#include <prism.h>
+
+const char* pm_error_level_to_string(pm_error_level_t level);
+
+RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
+  const pm_diagnostic_t* error, const AST_NODE_T* node, const char* source, pm_parser_t* parser
+);
+
+position_T* position_from_source_with_offset(const char* source, size_t offset);
+
+#endif

package/extension/libherb/range.h

@@ -0,0 +1,23 @@
+#ifndef HERB_RANGE_H
+#define HERB_RANGE_H
+
+#include <stdlib.h>
+
+typedef struct RANGE_STRUCT {
+  size_t from;
+  size_t to;
+} range_T;
+
+range_T* range_init(size_t from, size_t to);
+
+size_t range_from(const range_T* range);
+size_t range_to(const range_T* range);
+size_t range_length(range_T* range);
+
+range_T* range_copy(range_T* range);
+
+size_t range_sizeof(void);
+
+void range_free(range_T* range);
+
+#endif

package/extension/libherb/ruby_parser.h

@@ -0,0 +1,6 @@
+#ifndef HERB_RUBY_PARSER_H
+#define HERB_RUBY_PARSER_H
+
+void herb_parse_ruby_to_stdout(char* source);
+
+#endif

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

package/extension/libherb/token.h

@@ -0,0 +1,25 @@
+#ifndef HERB_TOKEN_H
+#define HERB_TOKEN_H
+
+#include "lexer_struct.h"
+#include "position.h"
+#include "token_struct.h"
+
+token_T* token_init(const char* value, token_type_T type, lexer_T* lexer);
+char* token_to_string(const token_T* token);
+char* token_to_json(const token_T* token);
+const char* token_type_to_string(token_type_T type);
+
+char* token_value(const token_T* token);
+int token_type(const token_T* token);
+
+position_T* token_start_position(token_T* token);
+position_T* token_end_position(token_T* token);
+
+size_t token_sizeof(void);
+
+token_T* token_copy(token_T* token);
+
+void token_free(token_T* token);
+
+#endif

package/extension/libherb/token_matchers.h

@@ -0,0 +1,21 @@
+#ifndef HERB_TOKEN_MATCHERS_H
+#define HERB_TOKEN_MATCHERS_H
+
+#include "parser.h"
+#include "token.h"
+
+#include <stdarg.h>
+#include <stdbool.h>
+
+// This "TOKEN" is used to terminate the va_list arguments in the token_matches_any function
+#define TOKEN_SENTINEL 99999999
+
+bool token_is(parser_T* parser, token_type_T expected_type);
+bool token_is_not(parser_T* parser, token_type_T type);
+
+bool token_matches_any(token_type_T current_token, token_type_T first_token, ...);
+
+#define token_is_any_of(parser, ...) (token_matches_any((parser)->current_token->type, __VA_ARGS__, TOKEN_SENTINEL))
+#define token_is_none_of(parser, ...) (!token_matches_any((parser)->current_token->type, __VA_ARGS__, TOKEN_SENTINEL))
+
+#endif

package/extension/libherb/token_struct.h

@@ -0,0 +1,51 @@
+#ifndef HERB_TOKEN_STRUCT_H
+#define HERB_TOKEN_STRUCT_H
+
+#include "location.h"
+#include "range.h"
+
+typedef enum {
+  TOKEN_WHITESPACE, // ' '
+  TOKEN_NBSP,       // \xC2\xA0
+  TOKEN_NEWLINE,    // \n
+  TOKEN_IDENTIFIER,
+
+  TOKEN_HTML_DOCTYPE, // <!DOCTYPE, <!doctype, <!DoCtYpE, <!dOcTyPe
+
+  TOKEN_HTML_TAG_START,       // <
+  TOKEN_HTML_TAG_START_CLOSE, // </
+  TOKEN_HTML_TAG_END,         // >
+  TOKEN_HTML_TAG_SELF_CLOSE,  // />
+
+  TOKEN_HTML_COMMENT_START, // <!--
+  TOKEN_HTML_COMMENT_END,   // -->
+
+  TOKEN_ERB_START,   // <%, <%=, <%#, <%-, <%==, <%%
+  TOKEN_ERB_CONTENT, // Ruby Code
+  TOKEN_ERB_END,     // %>, -%>, %%>
+
+  TOKEN_LT,          // <
+  TOKEN_SLASH,       // /
+  TOKEN_EQUALS,      // =
+  TOKEN_QUOTE,       // ", '
+  TOKEN_DASH,        // -
+  TOKEN_UNDERSCORE,  // _
+  TOKEN_EXCLAMATION, // !
+  TOKEN_SEMICOLON,   // ;
+  TOKEN_COLON,       // :
+  TOKEN_PERCENT,     // %
+  TOKEN_AMPERSAND,   // &
+
+  TOKEN_CHARACTER,
+  TOKEN_ERROR,
+  TOKEN_EOF,
+} token_type_T;
+
+typedef struct TOKEN_STRUCT {
+  char* value;
+  range_T* range;
+  location_T* location;
+  token_type_T type;
+} token_T;
+
+#endif

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

package/extension/libherb/util.h

@@ -0,0 +1,25 @@
+#ifndef HERB_UTIL_H
+#define HERB_UTIL_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+int is_whitespace(int character);
+int is_newline(int character);
+
+int count_in_string(const char* string, char character);
+int count_newlines(const char* string);
+
+char* replace_char(char* string, char find, char replace);
+char* escape_newlines(const char* input);
+char* quoted_string(const char* input);
+char* wrap_string(const char* input, char character);
+
+bool string_blank(const char* input);
+bool string_present(const char* input);
+
+char* herb_strdup(const char* s);
+
+char* size_t_to_string(size_t value);
+
+#endif

package/extension/libherb/version.h

@@ -0,0 +1,6 @@
+#ifndef HERB_VERSION_H
+#define HERB_VERSION_H
+
+#define HERB_VERSION "0.3.0"
+
+#endif

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

package/extension/libherb/visitor.h

@@ -0,0 +1,11 @@
+#ifndef HERB_VISITOR_H
+#define HERB_VISITOR_H
+
+#include "array.h"
+#include "ast_node.h"
+#include "ast_nodes.h"
+
+void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data);
+void herb_visit_child_nodes(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T* node, void* data), void* data);
+
+#endif

package/extension/nodes.cpp

@@ -675,6 +675,49 @@ napi_value erb_case_nodeNodeFromCStruct(napi_env env, AST_ERB_CASE_NODE_T* erb_c
   napi_set_named_property(env, result, "end_node", end_node);
 
 
+  return result;
+}
+napi_value erb_case_match_nodeNodeFromCStruct(napi_env env, AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node) {
+  if (!erb_case_match_node) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateString(env, ast_node_type_to_string(&erb_case_match_node->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value location = CreateLocation(env, erb_case_match_node->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+  napi_value errors = ErrorsArrayFromCArray(env, erb_case_match_node->base.errors);
+  napi_set_named_property(env, result, "errors", errors);
+
+  napi_value tag_opening = CreateToken(env, erb_case_match_node->tag_opening);
+  napi_set_named_property(env, result, "tag_opening", tag_opening);
+
+  napi_value content = CreateToken(env, erb_case_match_node->content);
+  napi_set_named_property(env, result, "content", content);
+
+  napi_value tag_closing = CreateToken(env, erb_case_match_node->tag_closing);
+  napi_set_named_property(env, result, "tag_closing", tag_closing);
+
+  napi_value children = NodesArrayFromCArray(env, erb_case_match_node->children);
+  napi_set_named_property(env, result, "children", children);
+
+  napi_value conditions = NodesArrayFromCArray(env, erb_case_match_node->conditions);
+  napi_set_named_property(env, result, "conditions", conditions);
+
+  napi_value else_clause = NodeFromCStruct(env, (AST_NODE_T*) erb_case_match_node->else_clause);
+  napi_set_named_property(env, result, "else_clause", else_clause);
+
+  napi_value end_node = NodeFromCStruct(env, (AST_NODE_T*) erb_case_match_node->end_node);
+  napi_set_named_property(env, result, "end_node", end_node);
+
+
   return result;
 }
 napi_value erb_while_nodeNodeFromCStruct(napi_env env, AST_ERB_WHILE_NODE_T* erb_while_node) {
@@ -943,6 +986,71 @@ napi_value erb_unless_nodeNodeFromCStruct(napi_env env, AST_ERB_UNLESS_NODE_T* e
   napi_set_named_property(env, result, "end_node", end_node);
 
 
+  return result;
+}
+napi_value erb_yield_nodeNodeFromCStruct(napi_env env, AST_ERB_YIELD_NODE_T* erb_yield_node) {
+  if (!erb_yield_node) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateString(env, ast_node_type_to_string(&erb_yield_node->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value location = CreateLocation(env, erb_yield_node->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+  napi_value errors = ErrorsArrayFromCArray(env, erb_yield_node->base.errors);
+  napi_set_named_property(env, result, "errors", errors);
+
+  napi_value tag_opening = CreateToken(env, erb_yield_node->tag_opening);
+  napi_set_named_property(env, result, "tag_opening", tag_opening);
+
+  napi_value content = CreateToken(env, erb_yield_node->content);
+  napi_set_named_property(env, result, "content", content);
+
+  napi_value tag_closing = CreateToken(env, erb_yield_node->tag_closing);
+  napi_set_named_property(env, result, "tag_closing", tag_closing);
+
+
+  return result;
+}
+napi_value erb_in_nodeNodeFromCStruct(napi_env env, AST_ERB_IN_NODE_T* erb_in_node) {
+  if (!erb_in_node) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateString(env, ast_node_type_to_string(&erb_in_node->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value location = CreateLocation(env, erb_in_node->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+  napi_value errors = ErrorsArrayFromCArray(env, erb_in_node->base.errors);
+  napi_set_named_property(env, result, "errors", errors);
+
+  napi_value tag_opening = CreateToken(env, erb_in_node->tag_opening);
+  napi_set_named_property(env, result, "tag_opening", tag_opening);
+
+  napi_value content = CreateToken(env, erb_in_node->content);
+  napi_set_named_property(env, result, "content", content);
+
+  napi_value tag_closing = CreateToken(env, erb_in_node->tag_closing);
+  napi_set_named_property(env, result, "tag_closing", tag_closing);
+
+  napi_value statements = NodesArrayFromCArray(env, erb_in_node->statements);
+  napi_set_named_property(env, result, "statements", statements);
+
+
   return result;
 }
 
@@ -1031,6 +1139,9 @@ napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node) {
     case AST_ERB_CASE_NODE:
       return erb_case_nodeNodeFromCStruct(env, (AST_ERB_CASE_NODE_T*) node);
       break;
+    case AST_ERB_CASE_MATCH_NODE:
+      return erb_case_match_nodeNodeFromCStruct(env, (AST_ERB_CASE_MATCH_NODE_T*) node);
+      break;
     case AST_ERB_WHILE_NODE:
       return erb_while_nodeNodeFromCStruct(env, (AST_ERB_WHILE_NODE_T*) node);
       break;
@@ -1052,6 +1163,12 @@ napi_value NodeFromCStruct(napi_env env, AST_NODE_T* node) {
     case AST_ERB_UNLESS_NODE:
       return erb_unless_nodeNodeFromCStruct(env, (AST_ERB_UNLESS_NODE_T*) node);
       break;
+    case AST_ERB_YIELD_NODE:
+      return erb_yield_nodeNodeFromCStruct(env, (AST_ERB_YIELD_NODE_T*) node);
+      break;
+    case AST_ERB_IN_NODE:
+      return erb_in_nodeNodeFromCStruct(env, (AST_ERB_IN_NODE_T*) node);
+      break;
     default:
       napi_value null_value;
       napi_get_null(env, &null_value);

package/extension/nodes.h

@@ -33,6 +33,7 @@ napi_value erb_if_nodeNodeFromCStruct(napi_env env, AST_ERB_IF_NODE_T* erb_if_no
 napi_value erb_block_nodeNodeFromCStruct(napi_env env, AST_ERB_BLOCK_NODE_T* erb_block_node);
 napi_value erb_when_nodeNodeFromCStruct(napi_env env, AST_ERB_WHEN_NODE_T* erb_when_node);
 napi_value erb_case_nodeNodeFromCStruct(napi_env env, AST_ERB_CASE_NODE_T* erb_case_node);
+napi_value erb_case_match_nodeNodeFromCStruct(napi_env env, AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node);
 napi_value erb_while_nodeNodeFromCStruct(napi_env env, AST_ERB_WHILE_NODE_T* erb_while_node);
 napi_value erb_until_nodeNodeFromCStruct(napi_env env, AST_ERB_UNTIL_NODE_T* erb_until_node);
 napi_value erb_for_nodeNodeFromCStruct(napi_env env, AST_ERB_FOR_NODE_T* erb_for_node);
@@ -40,5 +41,7 @@ napi_value erb_rescue_nodeNodeFromCStruct(napi_env env, AST_ERB_RESCUE_NODE_T* e
 napi_value erb_ensure_nodeNodeFromCStruct(napi_env env, AST_ERB_ENSURE_NODE_T* erb_ensure_node);
 napi_value erb_begin_nodeNodeFromCStruct(napi_env env, AST_ERB_BEGIN_NODE_T* erb_begin_node);
 napi_value erb_unless_nodeNodeFromCStruct(napi_env env, AST_ERB_UNLESS_NODE_T* erb_unless_node);
+napi_value erb_yield_nodeNodeFromCStruct(napi_env env, AST_ERB_YIELD_NODE_T* erb_yield_node);
+napi_value erb_in_nodeNodeFromCStruct(napi_env env, AST_ERB_IN_NODE_T* erb_in_node);
 
 #endif