@herb-tools/node 0.8.6 → 0.8.8

package/extension/libherb/prism_helpers.c

@@ -1,10 +1,14 @@
 #include "include/prism_helpers.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
+#include "include/location.h"
 #include "include/position.h"
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
 
 #include <prism.h>
+#include <stdlib.h>
+#include <string.h>
 
 const char* pm_error_level_to_string(pm_error_level_t level) {
   switch (level) {
@@ -50,3 +54,187 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error_with_positions(
     end
   );
 }
+
+typedef struct {
+  pm_location_t then_keyword_loc;
+  bool found;
+} then_keyword_search_context_T;
+
+static bool has_pm_location(pm_location_t location) {
+  return location.start != NULL && location.end != NULL && (location.end - location.start) > 0;
+}
+
+static bool search_then_keyword_location(const pm_node_t* node, void* data) {
+  then_keyword_search_context_T* context = (then_keyword_search_context_T*) data;
+
+  if (context->found) { return false; }
+
+  switch (node->type) {
+    case PM_IF_NODE: {
+      const pm_if_node_t* if_node = (const pm_if_node_t*) node;
+      if (has_pm_location(if_node->then_keyword_loc)) {
+        context->then_keyword_loc = if_node->then_keyword_loc;
+        context->found = true;
+        return false;
+      }
+      break;
+    }
+
+    case PM_UNLESS_NODE: {
+      const pm_unless_node_t* unless_node = (const pm_unless_node_t*) node;
+      if (has_pm_location(unless_node->then_keyword_loc)) {
+        context->then_keyword_loc = unless_node->then_keyword_loc;
+        context->found = true;
+        return false;
+      }
+      break;
+    }
+
+    case PM_WHEN_NODE: {
+      const pm_when_node_t* when_node = (const pm_when_node_t*) node;
+      if (has_pm_location(when_node->then_keyword_loc)) {
+        context->then_keyword_loc = when_node->then_keyword_loc;
+        context->found = true;
+        return false;
+      }
+      break;
+    }
+
+    case PM_IN_NODE: {
+      const pm_in_node_t* in_node = (const pm_in_node_t*) node;
+      if (has_pm_location(in_node->then_loc)) {
+        context->then_keyword_loc = in_node->then_loc;
+        context->found = true;
+        return false;
+      }
+      break;
+    }
+
+    default: break;
+  }
+
+  pm_visit_child_nodes(node, search_then_keyword_location, context);
+
+  return false;
+}
+
+location_T* get_then_keyword_location(analyzed_ruby_T* analyzed, const char* source) {
+  if (analyzed == NULL || analyzed->root == NULL || source == NULL) { return NULL; }
+
+  then_keyword_search_context_T context = { .then_keyword_loc = { .start = NULL, .end = NULL }, .found = false };
+
+  pm_visit_child_nodes(analyzed->root, search_then_keyword_location, &context);
+
+  if (!context.found) { return NULL; }
+
+  size_t start_offset = (size_t) (context.then_keyword_loc.start - analyzed->parser.start);
+  size_t end_offset = (size_t) (context.then_keyword_loc.end - analyzed->parser.start);
+
+  position_T start_position = position_from_source_with_offset(source, start_offset);
+  position_T end_position = position_from_source_with_offset(source, end_offset);
+
+  return location_create(start_position, end_position);
+}
+
+static location_T* parse_wrapped_and_find_then_keyword(
+  hb_buffer_T* buffer,
+  const char* source,
+  size_t source_length,
+  size_t prefix_length,
+  size_t adjustment_threshold,
+  size_t adjustment_amount
+) {
+  pm_parser_t parser;
+  pm_parser_init(&parser, (const uint8_t*) hb_buffer_value(buffer), hb_buffer_length(buffer), NULL);
+  pm_node_t* root = pm_parse(&parser);
+
+  if (root == NULL) {
+    pm_parser_free(&parser);
+
+    return NULL;
+  }
+
+  then_keyword_search_context_T context = { .then_keyword_loc = { .start = NULL, .end = NULL }, .found = false };
+
+  pm_visit_child_nodes(root, search_then_keyword_location, &context);
+
+  location_T* location = NULL;
+
+  if (context.found) {
+    size_t start_offset = (size_t) (context.then_keyword_loc.start - parser.start);
+    size_t end_offset = (size_t) (context.then_keyword_loc.end - parser.start);
+
+    if (start_offset >= prefix_length && end_offset >= prefix_length) {
+      start_offset -= prefix_length;
+      end_offset -= prefix_length;
+
+      if (start_offset > adjustment_threshold) {
+        start_offset += adjustment_amount;
+        end_offset += adjustment_amount;
+      }
+
+      if (start_offset <= source_length && end_offset <= source_length) {
+        position_T start_position = position_from_source_with_offset(source, start_offset);
+        position_T end_position = position_from_source_with_offset(source, end_offset);
+
+        location = location_create(start_position, end_position);
+      }
+    }
+  }
+
+  pm_node_destroy(&parser, root);
+  pm_parser_free(&parser);
+
+  return location;
+}
+
+location_T* get_then_keyword_location_wrapped(const char* source, bool is_in_clause) {
+  if (source == NULL) { return NULL; }
+
+  size_t source_length = strlen(source);
+
+  hb_buffer_T buffer;
+
+  if (!hb_buffer_init(&buffer, source_length + 16)) { return NULL; }
+
+  hb_buffer_append(&buffer, "case x\n");
+  size_t prefix_length = hb_buffer_length(&buffer);
+  hb_buffer_append(&buffer, source);
+  hb_buffer_append(&buffer, "\nend");
+
+  location_T* location =
+    parse_wrapped_and_find_then_keyword(&buffer, source, source_length, prefix_length, SIZE_MAX, 0);
+
+  free(buffer.value);
+
+  return location;
+}
+
+location_T* get_then_keyword_location_elsif_wrapped(const char* source) {
+  if (source == NULL) { return NULL; }
+
+  const char* elsif_position = strstr(source, "elsif");
+
+  if (elsif_position == NULL) { return NULL; }
+
+  size_t source_length = strlen(source);
+  size_t elsif_offset = (size_t) (elsif_position - source);
+  size_t replacement_diff = strlen("elsif") - strlen("if");
+
+  hb_buffer_T buffer;
+
+  if (!hb_buffer_init(&buffer, source_length + 8)) { return NULL; }
+
+  hb_buffer_append_with_length(&buffer, source, elsif_offset);
+  hb_buffer_append(&buffer, "if");
+  size_t if_end_offset = hb_buffer_length(&buffer);
+  hb_buffer_append(&buffer, source + elsif_offset + strlen("elsif"));
+  hb_buffer_append(&buffer, "\nend");
+
+  location_T* location =
+    parse_wrapped_and_find_then_keyword(&buffer, source, source_length, 0, if_end_offset, replacement_diff);
+
+  free(buffer.value);
+
+  return location;
+}

package/extension/libherb/prism_helpers.h

@@ -1,8 +1,10 @@
 #ifndef HERB_PRISM_HELPERS_H
 #define HERB_PRISM_HELPERS_H
 
+#include "analyzed_ruby.h"
 #include "ast_nodes.h"
 #include "errors.h"
+#include "location.h"
 #include "position.h"
 
 #include <prism.h>
@@ -22,4 +24,8 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error_with_positions(
   position_T end
 );
 
+location_T* get_then_keyword_location(analyzed_ruby_T* analyzed, const char* source);
+location_T* get_then_keyword_location_wrapped(const char* source, bool is_in_clause);
+location_T* get_then_keyword_location_elsif_wrapped(const char* source);
+
 #endif

package/extension/libherb/util/hb_array.c

@@ -116,6 +116,7 @@ void* hb_array_pop(hb_array_T* array) {
   return last_item;
 }
 
+// TODO: Remove this function once we fully migrate to hb_narray
 size_t hb_array_size(const hb_array_T* array) {
   if (array == NULL) { return 0; }
 

package/extension/libherb/util/hb_narray.c

@@ -73,3 +73,9 @@ void hb_narray_deinit(hb_narray_T* array) {
   array->size = 0;
   free(array->items);
 }
+
+size_t hb_narray_size(const hb_narray_T* array) {
+  if (array == NULL) { return 0; }
+
+  return array->size;
+}

package/extension/libherb/util/hb_narray.h

@@ -18,6 +18,7 @@ void hb_narray_init(hb_narray_T* array, size_t item_size, size_t initial_capacit
 void* hb_narray_get(const hb_narray_T* array, size_t index);
 void* hb_narray_first(hb_narray_T* array);
 void* hb_narray_last(hb_narray_T* array);
+size_t hb_narray_size(const hb_narray_T* array);
 
 void hb_narray_append(hb_narray_T* array, void* item);
 void hb_narray_remove(hb_narray_T* array, size_t index);

package/extension/libherb/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.6"
+#define HERB_VERSION "0.8.8"
 
 #endif

package/extension/libherb/visitor.c

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.6/templates/src/visitor.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.8/templates/src/visitor.c.erb
 
 #include <stdio.h>
 
@@ -24,7 +24,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_DOCUMENT_NODE_T* document_node = ((const AST_DOCUMENT_NODE_T *) node);
 
       if (document_node->children != NULL) {
-        for (size_t index = 0; index < document_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(document_node->children); index++) {
           herb_visit_node(hb_array_get(document_node->children, index), visitor, data);
         }
       }
@@ -35,7 +35,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_OPEN_TAG_NODE_T* html_open_tag_node = ((const AST_HTML_OPEN_TAG_NODE_T *) node);
 
       if (html_open_tag_node->children != NULL) {
-        for (size_t index = 0; index < html_open_tag_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_open_tag_node->children); index++) {
           herb_visit_node(hb_array_get(html_open_tag_node->children, index), visitor, data);
         }
       }
@@ -46,7 +46,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = ((const AST_HTML_CLOSE_TAG_NODE_T *) node);
 
       if (html_close_tag_node->children != NULL) {
-        for (size_t index = 0; index < html_close_tag_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_close_tag_node->children); index++) {
           herb_visit_node(hb_array_get(html_close_tag_node->children, index), visitor, data);
         }
       }
@@ -61,7 +61,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       }
 
       if (html_element_node->body != NULL) {
-        for (size_t index = 0; index < html_element_node->body->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_element_node->body); index++) {
           herb_visit_node(hb_array_get(html_element_node->body, index), visitor, data);
         }
       }
@@ -76,7 +76,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = ((const AST_HTML_ATTRIBUTE_VALUE_NODE_T *) node);
 
       if (html_attribute_value_node->children != NULL) {
-        for (size_t index = 0; index < html_attribute_value_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_attribute_value_node->children); index++) {
           herb_visit_node(hb_array_get(html_attribute_value_node->children, index), visitor, data);
         }
       }
@@ -87,7 +87,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_ATTRIBUTE_NAME_NODE_T* html_attribute_name_node = ((const AST_HTML_ATTRIBUTE_NAME_NODE_T *) node);
 
       if (html_attribute_name_node->children != NULL) {
-        for (size_t index = 0; index < html_attribute_name_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_attribute_name_node->children); index++) {
           herb_visit_node(hb_array_get(html_attribute_name_node->children, index), visitor, data);
         }
       }
@@ -111,7 +111,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_COMMENT_NODE_T* html_comment_node = ((const AST_HTML_COMMENT_NODE_T *) node);
 
       if (html_comment_node->children != NULL) {
-        for (size_t index = 0; index < html_comment_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_comment_node->children); index++) {
           herb_visit_node(hb_array_get(html_comment_node->children, index), visitor, data);
         }
       }
@@ -122,7 +122,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_DOCTYPE_NODE_T* html_doctype_node = ((const AST_HTML_DOCTYPE_NODE_T *) node);
 
       if (html_doctype_node->children != NULL) {
-        for (size_t index = 0; index < html_doctype_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(html_doctype_node->children); index++) {
           herb_visit_node(hb_array_get(html_doctype_node->children, index), visitor, data);
         }
       }
@@ -133,7 +133,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_XML_DECLARATION_NODE_T* xml_declaration_node = ((const AST_XML_DECLARATION_NODE_T *) node);
 
       if (xml_declaration_node->children != NULL) {
-        for (size_t index = 0; index < xml_declaration_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(xml_declaration_node->children); index++) {
           herb_visit_node(hb_array_get(xml_declaration_node->children, index), visitor, data);
         }
       }
@@ -144,7 +144,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_CDATA_NODE_T* cdata_node = ((const AST_CDATA_NODE_T *) node);
 
       if (cdata_node->children != NULL) {
-        for (size_t index = 0; index < cdata_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(cdata_node->children); index++) {
           herb_visit_node(hb_array_get(cdata_node->children, index), visitor, data);
         }
       }
@@ -155,7 +155,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_ELSE_NODE_T* erb_else_node = ((const AST_ERB_ELSE_NODE_T *) node);
 
       if (erb_else_node->statements != NULL) {
-        for (size_t index = 0; index < erb_else_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_else_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_else_node->statements, index), visitor, data);
         }
       }
@@ -166,7 +166,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_IF_NODE_T* erb_if_node = ((const AST_ERB_IF_NODE_T *) node);
 
       if (erb_if_node->statements != NULL) {
-        for (size_t index = 0; index < erb_if_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_if_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_if_node->statements, index), visitor, data);
         }
       }
@@ -185,7 +185,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_BLOCK_NODE_T* erb_block_node = ((const AST_ERB_BLOCK_NODE_T *) node);
 
       if (erb_block_node->body != NULL) {
-        for (size_t index = 0; index < erb_block_node->body->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_block_node->body); index++) {
           herb_visit_node(hb_array_get(erb_block_node->body, index), visitor, data);
         }
       }
@@ -200,7 +200,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_WHEN_NODE_T* erb_when_node = ((const AST_ERB_WHEN_NODE_T *) node);
 
       if (erb_when_node->statements != NULL) {
-        for (size_t index = 0; index < erb_when_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_when_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_when_node->statements, index), visitor, data);
         }
       }
@@ -211,13 +211,13 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_CASE_NODE_T* erb_case_node = ((const AST_ERB_CASE_NODE_T *) node);
 
       if (erb_case_node->children != NULL) {
-        for (size_t index = 0; index < erb_case_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_case_node->children); index++) {
           herb_visit_node(hb_array_get(erb_case_node->children, index), visitor, data);
         }
       }
 
       if (erb_case_node->conditions != NULL) {
-        for (size_t index = 0; index < erb_case_node->conditions->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_case_node->conditions); index++) {
           herb_visit_node(hb_array_get(erb_case_node->conditions, index), visitor, data);
         }
       }
@@ -236,13 +236,13 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       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 < erb_case_match_node->children->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_case_match_node->children); index++) {
           herb_visit_node(hb_array_get(erb_case_match_node->children, index), visitor, data);
         }
       }
 
       if (erb_case_match_node->conditions != NULL) {
-        for (size_t index = 0; index < erb_case_match_node->conditions->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_case_match_node->conditions); index++) {
           herb_visit_node(hb_array_get(erb_case_match_node->conditions, index), visitor, data);
         }
       }
@@ -261,7 +261,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_WHILE_NODE_T* erb_while_node = ((const AST_ERB_WHILE_NODE_T *) node);
 
       if (erb_while_node->statements != NULL) {
-        for (size_t index = 0; index < erb_while_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_while_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_while_node->statements, index), visitor, data);
         }
       }
@@ -276,7 +276,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_UNTIL_NODE_T* erb_until_node = ((const AST_ERB_UNTIL_NODE_T *) node);
 
       if (erb_until_node->statements != NULL) {
-        for (size_t index = 0; index < erb_until_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_until_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_until_node->statements, index), visitor, data);
         }
       }
@@ -291,7 +291,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_FOR_NODE_T* erb_for_node = ((const AST_ERB_FOR_NODE_T *) node);
 
       if (erb_for_node->statements != NULL) {
-        for (size_t index = 0; index < erb_for_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_for_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_for_node->statements, index), visitor, data);
         }
       }
@@ -306,7 +306,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_RESCUE_NODE_T* erb_rescue_node = ((const AST_ERB_RESCUE_NODE_T *) node);
 
       if (erb_rescue_node->statements != NULL) {
-        for (size_t index = 0; index < erb_rescue_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_rescue_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_rescue_node->statements, index), visitor, data);
         }
       }
@@ -321,7 +321,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_ENSURE_NODE_T* erb_ensure_node = ((const AST_ERB_ENSURE_NODE_T *) node);
 
       if (erb_ensure_node->statements != NULL) {
-        for (size_t index = 0; index < erb_ensure_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_ensure_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_ensure_node->statements, index), visitor, data);
         }
       }
@@ -332,7 +332,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_BEGIN_NODE_T* erb_begin_node = ((const AST_ERB_BEGIN_NODE_T *) node);
 
       if (erb_begin_node->statements != NULL) {
-        for (size_t index = 0; index < erb_begin_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_begin_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_begin_node->statements, index), visitor, data);
         }
       }
@@ -359,7 +359,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_UNLESS_NODE_T* erb_unless_node = ((const AST_ERB_UNLESS_NODE_T *) node);
 
       if (erb_unless_node->statements != NULL) {
-        for (size_t index = 0; index < erb_unless_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_unless_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_unless_node->statements, index), visitor, data);
         }
       }
@@ -378,7 +378,7 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       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 < erb_in_node->statements->size; index++) {
+        for (size_t index = 0; index < hb_array_size(erb_in_node->statements); index++) {
           herb_visit_node(hb_array_get(erb_in_node->statements, index), visitor, data);
         }
       }

package/extension/nodes.cpp

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.6/templates/javascript/packages/node/extension/nodes.cpp.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.8/templates/javascript/packages/node/extension/nodes.cpp.erb
 
 #include <node_api.h>
 #include "error_helpers.h"
@@ -581,6 +581,14 @@ napi_value erb_if_nodeNodeFromCStruct(napi_env env, AST_ERB_IF_NODE_T* erb_if_no
   napi_value tag_closing = CreateToken(env, erb_if_node->tag_closing);
   napi_set_named_property(env, result, "tag_closing", tag_closing);
 
+  napi_value then_keyword;
+  if (erb_if_node->then_keyword != NULL) {
+    then_keyword = CreateLocation(env, *erb_if_node->then_keyword);
+  } else {
+    napi_get_null(env, &then_keyword);
+  }
+  napi_set_named_property(env, result, "then_keyword", then_keyword);
+
   napi_value statements = NodesArrayFromCArray(env, erb_if_node->statements);
   napi_set_named_property(env, result, "statements", statements);
 
@@ -658,6 +666,14 @@ napi_value erb_when_nodeNodeFromCStruct(napi_env env, AST_ERB_WHEN_NODE_T* erb_w
   napi_value tag_closing = CreateToken(env, erb_when_node->tag_closing);
   napi_set_named_property(env, result, "tag_closing", tag_closing);
 
+  napi_value then_keyword;
+  if (erb_when_node->then_keyword != NULL) {
+    then_keyword = CreateLocation(env, *erb_when_node->then_keyword);
+  } else {
+    napi_get_null(env, &then_keyword);
+  }
+  napi_set_named_property(env, result, "then_keyword", then_keyword);
+
   napi_value statements = NodesArrayFromCArray(env, erb_when_node->statements);
   napi_set_named_property(env, result, "statements", statements);
 
@@ -1006,6 +1022,14 @@ napi_value erb_unless_nodeNodeFromCStruct(napi_env env, AST_ERB_UNLESS_NODE_T* e
   napi_value tag_closing = CreateToken(env, erb_unless_node->tag_closing);
   napi_set_named_property(env, result, "tag_closing", tag_closing);
 
+  napi_value then_keyword;
+  if (erb_unless_node->then_keyword != NULL) {
+    then_keyword = CreateLocation(env, *erb_unless_node->then_keyword);
+  } else {
+    napi_get_null(env, &then_keyword);
+  }
+  napi_set_named_property(env, result, "then_keyword", then_keyword);
+
   napi_value statements = NodesArrayFromCArray(env, erb_unless_node->statements);
   napi_set_named_property(env, result, "statements", statements);
 
@@ -1077,6 +1101,14 @@ napi_value erb_in_nodeNodeFromCStruct(napi_env env, AST_ERB_IN_NODE_T* erb_in_no
   napi_value tag_closing = CreateToken(env, erb_in_node->tag_closing);
   napi_set_named_property(env, result, "tag_closing", tag_closing);
 
+  napi_value then_keyword;
+  if (erb_in_node->then_keyword != NULL) {
+    then_keyword = CreateLocation(env, *erb_in_node->then_keyword);
+  } else {
+    napi_get_null(env, &then_keyword);
+  }
+  napi_set_named_property(env, result, "then_keyword", then_keyword);
+
   napi_value statements = NodesArrayFromCArray(env, erb_in_node->statements);
   napi_set_named_property(env, result, "statements", statements);
 
@@ -1089,7 +1121,7 @@ napi_value NodesArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_create_array(env, &result);
 
   if (array) {
-    for (size_t i = 0; i < array->size; i++) {
+    for (size_t i = 0; i < hb_array_size(array); i++) {
       AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
       if (child_node) {
         napi_value js_child = NodeFromCStruct(env, child_node);

package/extension/nodes.h

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.6/templates/javascript/packages/node/extension/nodes.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.8/templates/javascript/packages/node/extension/nodes.h.erb
 
 #ifndef HERB_EXTENSION_NODES_H
 #define HERB_EXTENSION_NODES_H

package/extension/prism/include/prism/version.h

@@ -14,7 +14,7 @@
 /**
  * The minor version of the Prism library as an int.
  */
-#define PRISM_VERSION_MINOR 7
+#define PRISM_VERSION_MINOR 8
 
 /**
  * The patch version of the Prism library as an int.
@@ -24,6 +24,6 @@
 /**
  * The version of the Prism library as a constant string.
  */
-#define PRISM_VERSION "1.7.0"
+#define PRISM_VERSION "1.8.0"
 
 #endif