@herb-tools/node 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.2.0 (2025-06-11)
+
+This was a version bump only for @herb-tools/node to align it with other projects, there were no code changes.
+
+## 0.1.1 (2025-04-20)
+
+This was a version bump only for @herb-tools/node to align it with other projects, there were no code changes.
+
 ## 0.1.0 (2025-04-15)
 
 This was a version bump only for @herb-tools/node to align it with other projects, there were no code changes.

package/dist/herb-node.esm.js

@@ -6,7 +6,7 @@ import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
 
 var name = "@herb-tools/node";
-var version = "0.1.0";
+var version = "0.2.0";
 var packageJSON = {
 	name: name,
 	version: version};

package/extension/extension_helpers.cpp

@@ -148,7 +148,9 @@ napi_value ReadFileToString(napi_env env, const char* file_path) {
   }
 
   napi_value result = CreateString(env, content);
+
   free(content);
+
   return result;
 }
 
@@ -176,9 +178,6 @@ napi_value CreateLexResult(napi_env env, array_T* tokens, napi_value source) {
   napi_set_named_property(env, result, "warnings", warnings_array);
   napi_set_named_property(env, result, "errors", errors_array);
 
-  // Free tokens after creating JS objects
-  herb_free_tokens(&tokens);
-
   return result;
 }
 

package/extension/herb.cpp

@@ -34,7 +34,9 @@ napi_value Herb_lex(napi_env env, napi_callback_info info) {
   array_T* tokens = herb_lex(string);
   napi_value result = CreateLexResult(env, tokens, args[0]);
 
+  herb_free_tokens(&tokens);
   free(string);
+
   return result;
 }
 
@@ -55,7 +57,9 @@ napi_value Herb_lex_file(napi_env env, napi_callback_info info) {
   napi_value source_value = ReadFileToString(env, file_path);
   napi_value result = CreateLexResult(env, tokens, source_value);
 
+  herb_free_tokens(&tokens);
   free(file_path);
+
   return result;
 }
 
@@ -76,7 +80,9 @@ napi_value Herb_parse(napi_env env, napi_callback_info info) {
   herb_analyze_parse_tree(root, string);
   napi_value result = CreateParseResult(env, root, args[0]);
 
+  ast_node_free((AST_NODE_T *) root);
   free(string);
+
   return result;
 }
 
@@ -104,8 +110,10 @@ napi_value Herb_parse_file(napi_env env, napi_callback_info info) {
   AST_DOCUMENT_NODE_T* root = herb_parse(string);
   napi_value result = CreateParseResult(env, root, source_value);
 
+  ast_node_free((AST_NODE_T *) root);
   free(file_path);
   free(string);
+
   return result;
 }
 
@@ -136,6 +144,7 @@ napi_value Herb_lex_to_json(napi_env env, napi_callback_info info) {
 
   buffer_free(&output);
   free(string);
+
   return result;
 }
 

package/extension/libherb/analyze.c

@@ -25,6 +25,7 @@ static analyzed_ruby_T* herb_analyze_ruby(char* source) {
   pm_visit_node(analyzed->root, search_if_nodes, analyzed);
   pm_visit_node(analyzed->root, search_block_nodes, analyzed);
   pm_visit_node(analyzed->root, search_case_nodes, analyzed);
+  pm_visit_node(analyzed->root, search_case_match_nodes, analyzed);
   pm_visit_node(analyzed->root, search_while_nodes, analyzed);
   pm_visit_node(analyzed->root, search_for_nodes, analyzed);
   pm_visit_node(analyzed->root, search_until_nodes, analyzed);
@@ -35,8 +36,10 @@ static analyzed_ruby_T* herb_analyze_ruby(char* source) {
   search_else_nodes(analyzed);
   search_end_nodes(analyzed);
   search_when_nodes(analyzed);
+  search_in_nodes(analyzed);
   search_rescue_nodes(analyzed);
   search_ensure_nodes(analyzed);
+  search_yield_nodes(analyzed);
   search_block_closing_nodes(analyzed);
 
   return analyzed;
@@ -84,7 +87,9 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
   if (has_else_node(ruby)) { return CONTROL_TYPE_ELSE; }
   if (has_end(ruby)) { return CONTROL_TYPE_END; }
   if (has_case_node(ruby)) { return CONTROL_TYPE_CASE; }
+  if (has_case_match_node(ruby)) { return CONTROL_TYPE_CASE_MATCH; }
   if (has_when_node(ruby)) { return CONTROL_TYPE_WHEN; }
+  if (has_in_node(ruby)) { return CONTROL_TYPE_IN; }
   if (has_begin_node(ruby)) { return CONTROL_TYPE_BEGIN; }
   if (has_rescue_node(ruby)) { return CONTROL_TYPE_RESCUE; }
   if (has_ensure_node(ruby)) { return CONTROL_TYPE_ENSURE; }
@@ -93,6 +98,7 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
   if (has_until_node(ruby)) { return CONTROL_TYPE_UNTIL; }
   if (has_for_node(ruby)) { return CONTROL_TYPE_FOR; }
   if (has_block_node(ruby)) { return CONTROL_TYPE_BLOCK; }
+  if (has_yield_node(ruby)) { return CONTROL_TYPE_YIELD; }
   if (has_block_closing(ruby)) { return CONTROL_TYPE_BLOCK_CLOSE; }
 
   return CONTROL_TYPE_UNKNOWN;
@@ -102,7 +108,8 @@ static bool is_subsequent_type(control_type_t parent_type, control_type_t child_
   switch (parent_type) {
     case CONTROL_TYPE_IF:
     case CONTROL_TYPE_ELSIF: return child_type == CONTROL_TYPE_ELSIF || child_type == CONTROL_TYPE_ELSE;
-    case CONTROL_TYPE_CASE: return child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE;
+    case CONTROL_TYPE_CASE:
+    case CONTROL_TYPE_CASE_MATCH: return child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE;
     case CONTROL_TYPE_BEGIN:
       return child_type == CONTROL_TYPE_RESCUE || child_type == CONTROL_TYPE_ELSE || child_type == CONTROL_TYPE_ENSURE;
     case CONTROL_TYPE_RESCUE: return child_type == CONTROL_TYPE_RESCUE;
@@ -117,6 +124,7 @@ static bool is_terminator_type(control_type_t parent_type, control_type_t child_
 
   switch (parent_type) {
     case CONTROL_TYPE_WHEN: return child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE;
+    case CONTROL_TYPE_IN: return child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_ELSE;
     case CONTROL_TYPE_BLOCK: return child_type == CONTROL_TYPE_BLOCK_CLOSE;
 
     default: return is_subsequent_type(parent_type, child_type);
@@ -163,27 +171,46 @@ static AST_NODE_T* create_control_node(
       return (AST_NODE_T*)
         ast_erb_else_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
 
-    case CONTROL_TYPE_CASE: {
+    case CONTROL_TYPE_CASE:
+    case CONTROL_TYPE_CASE_MATCH: {
       AST_ERB_ELSE_NODE_T* else_node = NULL;
       if (subsequent && subsequent->type == AST_ERB_ELSE_NODE) { else_node = (AST_ERB_ELSE_NODE_T*) subsequent; }
 
       array_T* when_conditions = array_init(8);
-      array_T* non_when_children = array_init(8);
+      array_T* in_conditions = array_init(8);
+      array_T* non_when_non_in_children = array_init(8);
 
       for (size_t i = 0; i < array_size(children); i++) {
         AST_NODE_T* child = array_get(children, i);
         if (child && child->type == AST_ERB_WHEN_NODE) {
           array_append(when_conditions, child);
+        } else if (child && child->type == AST_ERB_IN_NODE) {
+          array_append(in_conditions, child);
         } else {
-          array_append(non_when_children, child);
+          array_append(non_when_non_in_children, child);
         }
       }
 
+      if (array_size(in_conditions) > 0) {
+        return (AST_NODE_T*) ast_erb_case_match_node_init(
+          tag_opening,
+          content,
+          tag_closing,
+          non_when_non_in_children,
+          in_conditions,
+          else_node,
+          end_node,
+          start_position,
+          end_position,
+          errors
+        );
+      }
+
       return (AST_NODE_T*) ast_erb_case_node_init(
         tag_opening,
         content,
         tag_closing,
-        non_when_children,
+        non_when_non_in_children,
         when_conditions,
         else_node,
         end_node,
@@ -198,6 +225,11 @@ static AST_NODE_T* create_control_node(
         ast_erb_when_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
     }
 
+    case CONTROL_TYPE_IN: {
+      return (AST_NODE_T*)
+        ast_erb_in_node_init(tag_opening, content, tag_closing, children, start_position, end_position, errors);
+    }
+
     case CONTROL_TYPE_BEGIN: {
       AST_ERB_RESCUE_NODE_T* rescue_clause = NULL;
       AST_ERB_ELSE_NODE_T* else_clause = NULL;
@@ -320,6 +352,11 @@ static AST_NODE_T* create_control_node(
       );
     }
 
+    case CONTROL_TYPE_YIELD: {
+      return (AST_NODE_T*)
+        ast_erb_yield_node_init(tag_opening, content, tag_closing, start_position, end_position, errors);
+    }
+
     default: array_free(&errors); return NULL;
   }
 }
@@ -333,9 +370,10 @@ static size_t process_control_structure(
 
   index++;
 
-  if (initial_type == CONTROL_TYPE_CASE) {
+  if (initial_type == CONTROL_TYPE_CASE || initial_type == CONTROL_TYPE_CASE_MATCH) {
     array_T* when_conditions = array_init(8);
-    array_T* non_when_children = array_init(8);
+    array_T* in_conditions = array_init(8);
+    array_T* non_when_non_in_children = array_init(8);
 
     while (index < array_size(array)) {
       AST_NODE_T* next_node = array_get(array, index);
@@ -346,10 +384,10 @@ static size_t process_control_structure(
         AST_ERB_CONTENT_NODE_T* erb_content = (AST_ERB_CONTENT_NODE_T*) next_node;
         control_type_t next_type = detect_control_type(erb_content);
 
-        if (next_type == CONTROL_TYPE_WHEN) { break; }
+        if (next_type == CONTROL_TYPE_WHEN || next_type == CONTROL_TYPE_IN) { break; }
       }
 
-      array_append(non_when_children, next_node);
+      array_append(non_when_non_in_children, next_node);
       index++;
     }
 
@@ -359,7 +397,7 @@ static size_t process_control_structure(
       if (!next_node) { break; }
 
       if (next_node->type != AST_ERB_CONTENT_NODE) {
-        array_append(non_when_children, next_node);
+        array_append(non_when_non_in_children, next_node);
         index++;
         continue;
       }
@@ -380,7 +418,8 @@ static size_t process_control_structure(
             AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
             control_type_t child_type = detect_control_type(child_erb);
 
-            if (child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE || child_type == CONTROL_TYPE_END) {
+            if (child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_ELSE
+                || child_type == CONTROL_TYPE_END) {
               break;
             }
           }
@@ -401,11 +440,47 @@ static size_t process_control_structure(
 
         array_append(when_conditions, (AST_NODE_T*) when_node);
 
+        continue;
+      } else if (next_type == CONTROL_TYPE_IN) {
+        array_T* in_statements = array_init(8);
+        index++;
+
+        while (index < array_size(array)) {
+          AST_NODE_T* child = array_get(array, index);
+
+          if (!child) { break; }
+
+          if (child->type == AST_ERB_CONTENT_NODE) {
+            AST_ERB_CONTENT_NODE_T* child_erb = (AST_ERB_CONTENT_NODE_T*) child;
+            control_type_t child_type = detect_control_type(child_erb);
+
+            if (child_type == CONTROL_TYPE_IN || child_type == CONTROL_TYPE_WHEN || child_type == CONTROL_TYPE_ELSE
+                || child_type == CONTROL_TYPE_END) {
+              break;
+            }
+          }
+
+          array_append(in_statements, child);
+          index++;
+        }
+
+        AST_ERB_IN_NODE_T* in_node = ast_erb_in_node_init(
+          erb_content->tag_opening,
+          erb_content->content,
+          erb_content->tag_closing,
+          in_statements,
+          erb_content->tag_opening->location->start,
+          erb_content->tag_closing->location->end,
+          array_init(8)
+        );
+
+        array_append(in_conditions, (AST_NODE_T*) in_node);
+
         continue;
       } else if (next_type == CONTROL_TYPE_ELSE || next_type == CONTROL_TYPE_END) {
         break;
       } else {
-        array_append(non_when_children, next_node);
+        array_append(non_when_non_in_children, next_node);
         index++;
       }
     }
@@ -486,13 +561,34 @@ static size_t process_control_structure(
     } else if (array_size(when_conditions) > 0) {
       AST_NODE_T* last_when = array_get(when_conditions, array_size(when_conditions) - 1);
       end_position = last_when->location->end;
+    } else if (array_size(in_conditions) > 0) {
+      AST_NODE_T* last_in = array_get(in_conditions, array_size(in_conditions) - 1);
+      end_position = last_in->location->end;
+    }
+
+    if (array_size(in_conditions) > 0) {
+      AST_ERB_CASE_MATCH_NODE_T* case_match_node = ast_erb_case_match_node_init(
+        erb_node->tag_opening,
+        erb_node->content,
+        erb_node->tag_closing,
+        non_when_non_in_children,
+        in_conditions,
+        else_clause,
+        end_node,
+        start_position,
+        end_position,
+        array_init(8)
+      );
+
+      array_append(output_array, (AST_NODE_T*) case_match_node);
+      return index;
     }
 
     AST_ERB_CASE_NODE_T* case_node = ast_erb_case_node_init(
       erb_node->tag_opening,
       erb_node->content,
       erb_node->tag_closing,
-      non_when_children,
+      non_when_non_in_children,
       when_conditions,
       else_clause,
       end_node,
@@ -845,36 +941,15 @@ static size_t process_block_children(
 
     if (is_terminator_type(parent_type, child_type)) { break; }
 
-    if (parent_type == CONTROL_TYPE_CASE && child_type == CONTROL_TYPE_WHEN) {
-      array_T* when_statements = array_init(8);
-
-      index++;
-
-      index = process_block_children(node, array, index, when_statements, context, CONTROL_TYPE_WHEN);
-
-      AST_ERB_WHEN_NODE_T* when_node = ast_erb_when_node_init(
-        erb_content->tag_opening,
-        erb_content->content,
-        erb_content->tag_closing,
-        when_statements,
-        erb_content->tag_opening->location->start,
-        erb_content->tag_closing->location->end,
-        array_init(8)
-      );
-
-      array_append(children_array, (AST_NODE_T*) when_node);
-      continue;
-    }
-
-    if (child_type == CONTROL_TYPE_IF || child_type == CONTROL_TYPE_CASE || child_type == CONTROL_TYPE_BEGIN
-        || child_type == CONTROL_TYPE_UNLESS || child_type == CONTROL_TYPE_WHILE || child_type == CONTROL_TYPE_UNTIL
-        || child_type == CONTROL_TYPE_FOR || child_type == CONTROL_TYPE_BLOCK) {
+    if (child_type == CONTROL_TYPE_IF || child_type == CONTROL_TYPE_CASE || child_type == CONTROL_TYPE_CASE_MATCH
+        || child_type == CONTROL_TYPE_BEGIN || child_type == CONTROL_TYPE_UNLESS || child_type == CONTROL_TYPE_WHILE
+        || child_type == CONTROL_TYPE_UNTIL || child_type == CONTROL_TYPE_FOR || child_type == CONTROL_TYPE_BLOCK) {
       array_T* temp_array = array_init(1);
       size_t new_index = process_control_structure(node, array, index, temp_array, context, child_type);
 
       if (array_size(temp_array) > 0) { array_append(children_array, array_get(temp_array, 0)); }
 
-      free(temp_array);
+      array_free(&temp_array);
 
       index = new_index;
       continue;
@@ -908,12 +983,14 @@ static array_T* rewrite_node_array(AST_NODE_T* node, array_T* array, analyze_rub
     switch (type) {
       case CONTROL_TYPE_IF:
       case CONTROL_TYPE_CASE:
+      case CONTROL_TYPE_CASE_MATCH:
       case CONTROL_TYPE_BEGIN:
       case CONTROL_TYPE_UNLESS:
       case CONTROL_TYPE_WHILE:
       case CONTROL_TYPE_UNTIL:
       case CONTROL_TYPE_FOR:
       case CONTROL_TYPE_BLOCK:
+      case CONTROL_TYPE_YIELD:
         index = process_control_structure(node, array, index, new_array, context, type);
         continue;
 
@@ -933,22 +1010,30 @@ static bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
 
   if (node->type == AST_DOCUMENT_NODE) {
     AST_DOCUMENT_NODE_T* document_node = (AST_DOCUMENT_NODE_T*) node;
+    array_T* old_array = document_node->children;
     document_node->children = rewrite_node_array((AST_NODE_T*) node, document_node->children, context);
+    array_free(&old_array);
   }
 
   if (node->type == AST_HTML_ELEMENT_NODE) {
     AST_HTML_ELEMENT_NODE_T* element_node = (AST_HTML_ELEMENT_NODE_T*) node;
+    array_T* old_array = element_node->body;
     element_node->body = rewrite_node_array((AST_NODE_T*) node, element_node->body, context);
+    array_free(&old_array);
   }
 
   if (node->type == AST_HTML_OPEN_TAG_NODE) {
     AST_HTML_OPEN_TAG_NODE_T* open_tag = (AST_HTML_OPEN_TAG_NODE_T*) node;
+    array_T* old_array = open_tag->children;
     open_tag->children = rewrite_node_array((AST_NODE_T*) node, open_tag->children, context);
+    array_free(&old_array);
   }
 
   if (node->type == AST_HTML_ATTRIBUTE_VALUE_NODE) {
     AST_HTML_ATTRIBUTE_VALUE_NODE_T* value_node = (AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node;
+    array_T* old_array = value_node->children;
     value_node->children = rewrite_node_array((AST_NODE_T*) node, value_node->children, context);
+    array_free(&old_array);
   }
 
   herb_visit_child_nodes(node, transform_erb_nodes, data);
@@ -968,6 +1053,7 @@ void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source)
 
   herb_analyze_parse_errors(document, source);
 
+  array_free(&context->ruby_context_stack);
   free(context);
 }
 
@@ -977,13 +1063,22 @@ void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source
   pm_parser_t parser;
   pm_parser_init(&parser, (const uint8_t*) extracted_ruby, strlen(extracted_ruby), NULL);
 
-  pm_parse(&parser);
+  pm_node_t* root = pm_parse(&parser);
 
   for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) parser.error_list.head; error != NULL;
        error = (const pm_diagnostic_t*) error->node.next) {
-    array_append(
-      document->base.errors,
-      ruby_parse_error_from_prism_error(error, (AST_NODE_T*) document, source, &parser)
-    );
+
+    RUBY_PARSE_ERROR_T* parse_error = ruby_parse_error_from_prism_error(error, (AST_NODE_T*) document, source, &parser);
+
+    // TODO: ideally this shouldn't be hard-coded
+    if (strcmp(parse_error->diagnostic_id, "invalid_yield") == 0) {
+      error_free((ERROR_T*) parse_error);
+    } else {
+      array_append(document->base.errors, parse_error);
+    }
   }
+
+  pm_node_destroy(&parser, root);
+  pm_parser_free(&parser);
+  free(extracted_ruby);
 }

package/extension/libherb/analyze.h

@@ -0,0 +1,39 @@
+#ifndef HERB_ANALYZE_H
+#define HERB_ANALYZE_H
+
+#include "analyzed_ruby.h"
+#include "array.h"
+#include "ast_nodes.h"
+
+typedef struct ANALYZE_RUBY_CONTEXT_STRUCT {
+  AST_DOCUMENT_NODE_T* document;
+  AST_NODE_T* parent;
+  array_T* ruby_context_stack;
+} analyze_ruby_context_T;
+
+typedef enum {
+  CONTROL_TYPE_IF,
+  CONTROL_TYPE_ELSIF,
+  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,
+  CONTROL_TYPE_UNLESS,
+  CONTROL_TYPE_WHILE,
+  CONTROL_TYPE_UNTIL,
+  CONTROL_TYPE_FOR,
+  CONTROL_TYPE_BLOCK,
+  CONTROL_TYPE_BLOCK_CLOSE,
+  CONTROL_TYPE_YIELD,
+  CONTROL_TYPE_UNKNOWN
+} control_type_t;
+
+void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source);
+void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source);
+
+#endif

package/extension/libherb/analyze_helpers.c

@@ -32,10 +32,18 @@ bool has_case_node(analyzed_ruby_T* analyzed) {
   return analyzed->has_case_node;
 }
 
+bool has_case_match_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_case_match_node;
+}
+
 bool has_when_node(analyzed_ruby_T* analyzed) {
   return analyzed->has_when_node;
 }
 
+bool has_in_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_in_node;
+}
+
 bool has_for_node(analyzed_ruby_T* analyzed) {
   return analyzed->has_for_node;
 }
@@ -64,6 +72,10 @@ bool has_unless_node(analyzed_ruby_T* analyzed) {
   return analyzed->has_unless_node;
 }
 
+bool has_yield_node(analyzed_ruby_T* analyzed) {
+  return analyzed->has_yield_node;
+}
+
 bool has_error_message(analyzed_ruby_T* anlayzed, const char* message) {
   for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) anlayzed->parser.error_list.head; error != NULL;
        error = (const pm_diagnostic_t*) error->node.next) {
@@ -102,7 +114,7 @@ bool search_block_nodes(const pm_node_t* node, void* data) {
 bool search_case_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
-  if (node->type == PM_CASE_MATCH_NODE) {
+  if (node->type == PM_CASE_NODE) {
     analyzed->has_case_node = true;
     return true;
   } else {
@@ -112,6 +124,19 @@ bool search_case_nodes(const pm_node_t* node, void* data) {
   return false;
 }
 
+bool search_case_match_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_CASE_MATCH_NODE) {
+    analyzed->has_case_match_node = true;
+    return true;
+  } else {
+    pm_visit_child_nodes(node, search_case_match_nodes, analyzed);
+  }
+
+  return false;
+}
+
 bool search_while_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
@@ -222,6 +247,15 @@ bool search_when_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
+bool search_in_nodes(analyzed_ruby_T* analyzed) {
+  if (has_error_message(analyzed, "unexpected 'in', ignoring it")) {
+    analyzed->has_in_node = true;
+    return true;
+  }
+
+  return false;
+}
+
 bool search_rescue_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'rescue', ignoring it")) {
     analyzed->has_rescue_node = true;
@@ -239,3 +273,12 @@ bool search_ensure_nodes(analyzed_ruby_T* analyzed) {
 
   return false;
 }
+
+bool search_yield_nodes(analyzed_ruby_T* analyzed) {
+  if (has_error_message(analyzed, "Invalid yield")) {
+    analyzed->has_yield_node = true;
+    return true;
+  }
+
+  return false;
+}

package/extension/libherb/analyze_helpers.h

@@ -0,0 +1,49 @@
+#ifndef HERB_ANALYZE_HELPERS_H
+#define HERB_ANALYZE_HELPERS_H
+
+#include <prism.h>
+#include <stdbool.h>
+
+#include "analyzed_ruby.h"
+
+bool has_if_node(analyzed_ruby_T* analyzed);
+bool has_elsif_node(analyzed_ruby_T* analyzed);
+bool has_else_node(analyzed_ruby_T* analyzed);
+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);
+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);
+bool search_begin_nodes(const pm_node_t* node, void* data);
+bool search_unless_nodes(const pm_node_t* node, void* data);
+bool search_elsif_nodes(analyzed_ruby_T* analyzed);
+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/analyzed_ruby.c

@@ -18,7 +18,9 @@ analyzed_ruby_T* init_analyzed_ruby(char* source) {
   analyzed->has_block_node = false;
   analyzed->has_block_closing = false;
   analyzed->has_case_node = false;
+  analyzed->has_case_match_node = false;
   analyzed->has_when_node = false;
+  analyzed->has_in_node = false;
   analyzed->has_for_node = false;
   analyzed->has_while_node = false;
   analyzed->has_until_node = false;
@@ -26,10 +28,17 @@ analyzed_ruby_T* init_analyzed_ruby(char* source) {
   analyzed->has_rescue_node = false;
   analyzed->has_ensure_node = false;
   analyzed->has_unless_node = false;
+  analyzed->has_yield_node = false;
 
   return analyzed;
 }
 
 void free_analyzed_ruby(analyzed_ruby_T* analyzed) {
-  // TODO
+  if (!analyzed) { return; }
+
+  if (analyzed->parsed && analyzed->root != NULL) { pm_node_destroy(&analyzed->parser, analyzed->root); }
+
+  pm_parser_free(&analyzed->parser);
+
+  free(analyzed);
 }