herb 0.1.1 → 0.2.0

data/src/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);
 }

data/src/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;
   }
 }

data/src/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;
+
   }
 }

data/src/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;

data/src/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) {

data/src/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;
 

data/src/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

data/src/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);