@herb-tools/node 0.8.10 → 0.9.0

package/extension/libherb/parser_match_tags.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.10/templates/src/parser_match_tags.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/src/parser_match_tags.c.erb
 
 #include "include/parser.h"
 #include "include/ast_nodes.h"
@@ -7,118 +7,161 @@
 #include "include/visitor.h"
 
 bool match_tags_visitor(const AST_NODE_T* node, void* data) {
-  hb_array_T* errors = (hb_array_T*) data;
+  match_tags_context_T* context = (match_tags_context_T*) data;
 
   if (node == NULL) { return false; }
 
   switch (node->type) {
 
+
     case AST_DOCUMENT_NODE: {
       const AST_DOCUMENT_NODE_T* document_node = (const AST_DOCUMENT_NODE_T*) node;
 
       if (document_node->children != NULL) {
-        match_tags_in_node_array(document_node->children, errors);
+        match_tags_in_node_array(document_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
 
+
+
     case AST_HTML_OPEN_TAG_NODE: {
       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) {
-        match_tags_in_node_array(html_open_tag_node->children, errors);
+        match_tags_in_node_array(html_open_tag_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
+
+
     case AST_HTML_CLOSE_TAG_NODE: {
       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) {
-        match_tags_in_node_array(html_close_tag_node->children, errors);
+        match_tags_in_node_array(html_close_tag_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
+
+
+
+
     case AST_HTML_ELEMENT_NODE: {
       const AST_HTML_ELEMENT_NODE_T* html_element_node = (const AST_HTML_ELEMENT_NODE_T*) node;
 
       if (html_element_node->body != NULL) {
-        match_tags_in_node_array(html_element_node->body, errors);
+        match_tags_in_node_array(html_element_node->body, context->errors, context->options, context->allocator);
       }
       if (html_element_node->open_tag != NULL) {
-        herb_visit_node((AST_NODE_T*) html_element_node->open_tag, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) html_element_node->open_tag, match_tags_visitor, context);
       }
       if (html_element_node->close_tag != NULL) {
-        herb_visit_node((AST_NODE_T*) html_element_node->close_tag, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) html_element_node->close_tag, match_tags_visitor, context);
       }
     } break;
 
 
+
+    case AST_HTML_CONDITIONAL_ELEMENT_NODE: {
+      const AST_HTML_CONDITIONAL_ELEMENT_NODE_T* html_conditional_element_node = (const AST_HTML_CONDITIONAL_ELEMENT_NODE_T*) node;
+
+      if (html_conditional_element_node->body != NULL) {
+        match_tags_in_node_array(html_conditional_element_node->body, context->errors, context->options, context->allocator);
+      }
+    } break;
+
+
+
     case AST_HTML_ATTRIBUTE_VALUE_NODE: {
       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) {
-        match_tags_in_node_array(html_attribute_value_node->children, errors);
+        match_tags_in_node_array(html_attribute_value_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_HTML_ATTRIBUTE_NAME_NODE: {
       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) {
-        match_tags_in_node_array(html_attribute_name_node->children, errors);
+        match_tags_in_node_array(html_attribute_name_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_HTML_ATTRIBUTE_NODE: {
       const AST_HTML_ATTRIBUTE_NODE_T* html_attribute_node = (const AST_HTML_ATTRIBUTE_NODE_T*) node;
 
       if (html_attribute_node->name != NULL) {
-        herb_visit_node((AST_NODE_T*) html_attribute_node->name, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) html_attribute_node->name, match_tags_visitor, context);
       }
       if (html_attribute_node->value != NULL) {
-        herb_visit_node((AST_NODE_T*) html_attribute_node->value, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) html_attribute_node->value, match_tags_visitor, context);
       }
     } break;
 
 
 
+
+
+
+
+    case AST_ERB_OPEN_TAG_NODE: {
+      const AST_ERB_OPEN_TAG_NODE_T* erb_open_tag_node = (const AST_ERB_OPEN_TAG_NODE_T*) node;
+
+      if (erb_open_tag_node->children != NULL) {
+        match_tags_in_node_array(erb_open_tag_node->children, context->errors, context->options, context->allocator);
+      }
+    } break;
+
+
+
+
+
     case AST_HTML_COMMENT_NODE: {
       const AST_HTML_COMMENT_NODE_T* html_comment_node = (const AST_HTML_COMMENT_NODE_T*) node;
 
       if (html_comment_node->children != NULL) {
-        match_tags_in_node_array(html_comment_node->children, errors);
+        match_tags_in_node_array(html_comment_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_HTML_DOCTYPE_NODE: {
       const AST_HTML_DOCTYPE_NODE_T* html_doctype_node = (const AST_HTML_DOCTYPE_NODE_T*) node;
 
       if (html_doctype_node->children != NULL) {
-        match_tags_in_node_array(html_doctype_node->children, errors);
+        match_tags_in_node_array(html_doctype_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_XML_DECLARATION_NODE: {
       const AST_XML_DECLARATION_NODE_T* xml_declaration_node = (const AST_XML_DECLARATION_NODE_T*) node;
 
       if (xml_declaration_node->children != NULL) {
-        match_tags_in_node_array(xml_declaration_node->children, errors);
+        match_tags_in_node_array(xml_declaration_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_CDATA_NODE: {
       const AST_CDATA_NODE_T* cdata_node = (const AST_CDATA_NODE_T*) node;
 
       if (cdata_node->children != NULL) {
-        match_tags_in_node_array(cdata_node->children, errors);
+        match_tags_in_node_array(cdata_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
@@ -126,186 +169,204 @@ bool match_tags_visitor(const AST_NODE_T* node, void* data) {
 
 
 
+
+
+
+
     case AST_ERB_ELSE_NODE: {
       const AST_ERB_ELSE_NODE_T* erb_else_node = (const AST_ERB_ELSE_NODE_T*) node;
 
       if (erb_else_node->statements != NULL) {
-        match_tags_in_node_array(erb_else_node->statements, errors);
+        match_tags_in_node_array(erb_else_node->statements, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_ERB_IF_NODE: {
       const AST_ERB_IF_NODE_T* erb_if_node = (const AST_ERB_IF_NODE_T*) node;
 
       if (erb_if_node->statements != NULL) {
-        match_tags_in_node_array(erb_if_node->statements, errors);
+        match_tags_in_node_array(erb_if_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_if_node->subsequent != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_if_node->subsequent, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_if_node->subsequent, match_tags_visitor, context);
       }
       if (erb_if_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_if_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_if_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_BLOCK_NODE: {
       const AST_ERB_BLOCK_NODE_T* erb_block_node = (const AST_ERB_BLOCK_NODE_T*) node;
 
       if (erb_block_node->body != NULL) {
-        match_tags_in_node_array(erb_block_node->body, errors);
+        match_tags_in_node_array(erb_block_node->body, context->errors, context->options, context->allocator);
       }
       if (erb_block_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_block_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_block_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_WHEN_NODE: {
       const AST_ERB_WHEN_NODE_T* erb_when_node = (const AST_ERB_WHEN_NODE_T*) node;
 
       if (erb_when_node->statements != NULL) {
-        match_tags_in_node_array(erb_when_node->statements, errors);
+        match_tags_in_node_array(erb_when_node->statements, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_ERB_CASE_NODE: {
       const AST_ERB_CASE_NODE_T* erb_case_node = (const AST_ERB_CASE_NODE_T*) node;
 
       if (erb_case_node->children != NULL) {
-        match_tags_in_node_array(erb_case_node->children, errors);
+        match_tags_in_node_array(erb_case_node->children, context->errors, context->options, context->allocator);
       }
       if (erb_case_node->conditions != NULL) {
-        match_tags_in_node_array(erb_case_node->conditions, errors);
+        match_tags_in_node_array(erb_case_node->conditions, context->errors, context->options, context->allocator);
       }
       if (erb_case_node->else_clause != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_case_node->else_clause, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_case_node->else_clause, match_tags_visitor, context);
       }
       if (erb_case_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_case_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_case_node->end_node, match_tags_visitor, context);
       }
     } 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) {
-        match_tags_in_node_array(erb_case_match_node->children, errors);
+        match_tags_in_node_array(erb_case_match_node->children, context->errors, context->options, context->allocator);
       }
       if (erb_case_match_node->conditions != NULL) {
-        match_tags_in_node_array(erb_case_match_node->conditions, errors);
+        match_tags_in_node_array(erb_case_match_node->conditions, context->errors, context->options, context->allocator);
       }
       if (erb_case_match_node->else_clause != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_case_match_node->else_clause, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_case_match_node->else_clause, match_tags_visitor, context);
       }
       if (erb_case_match_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_case_match_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_case_match_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_WHILE_NODE: {
       const AST_ERB_WHILE_NODE_T* erb_while_node = (const AST_ERB_WHILE_NODE_T*) node;
 
       if (erb_while_node->statements != NULL) {
-        match_tags_in_node_array(erb_while_node->statements, errors);
+        match_tags_in_node_array(erb_while_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_while_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_while_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_while_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_UNTIL_NODE: {
       const AST_ERB_UNTIL_NODE_T* erb_until_node = (const AST_ERB_UNTIL_NODE_T*) node;
 
       if (erb_until_node->statements != NULL) {
-        match_tags_in_node_array(erb_until_node->statements, errors);
+        match_tags_in_node_array(erb_until_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_until_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_until_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_until_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_FOR_NODE: {
       const AST_ERB_FOR_NODE_T* erb_for_node = (const AST_ERB_FOR_NODE_T*) node;
 
       if (erb_for_node->statements != NULL) {
-        match_tags_in_node_array(erb_for_node->statements, errors);
+        match_tags_in_node_array(erb_for_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_for_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_for_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_for_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_RESCUE_NODE: {
       const AST_ERB_RESCUE_NODE_T* erb_rescue_node = (const AST_ERB_RESCUE_NODE_T*) node;
 
       if (erb_rescue_node->statements != NULL) {
-        match_tags_in_node_array(erb_rescue_node->statements, errors);
+        match_tags_in_node_array(erb_rescue_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_rescue_node->subsequent != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_rescue_node->subsequent, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_rescue_node->subsequent, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_ENSURE_NODE: {
       const AST_ERB_ENSURE_NODE_T* erb_ensure_node = (const AST_ERB_ENSURE_NODE_T*) node;
 
       if (erb_ensure_node->statements != NULL) {
-        match_tags_in_node_array(erb_ensure_node->statements, errors);
+        match_tags_in_node_array(erb_ensure_node->statements, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_ERB_BEGIN_NODE: {
       const AST_ERB_BEGIN_NODE_T* erb_begin_node = (const AST_ERB_BEGIN_NODE_T*) node;
 
       if (erb_begin_node->statements != NULL) {
-        match_tags_in_node_array(erb_begin_node->statements, errors);
+        match_tags_in_node_array(erb_begin_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_begin_node->rescue_clause != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_begin_node->rescue_clause, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_begin_node->rescue_clause, match_tags_visitor, context);
       }
       if (erb_begin_node->else_clause != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_begin_node->else_clause, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_begin_node->else_clause, match_tags_visitor, context);
       }
       if (erb_begin_node->ensure_clause != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_begin_node->ensure_clause, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_begin_node->ensure_clause, match_tags_visitor, context);
       }
       if (erb_begin_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_begin_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_begin_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_UNLESS_NODE: {
       const AST_ERB_UNLESS_NODE_T* erb_unless_node = (const AST_ERB_UNLESS_NODE_T*) node;
 
       if (erb_unless_node->statements != NULL) {
-        match_tags_in_node_array(erb_unless_node->statements, errors);
+        match_tags_in_node_array(erb_unless_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_unless_node->else_clause != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_unless_node->else_clause, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_unless_node->else_clause, match_tags_visitor, context);
       }
       if (erb_unless_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_unless_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_unless_node->end_node, match_tags_visitor, context);
       }
     } 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) {
-        match_tags_in_node_array(erb_in_node->statements, errors);
+        match_tags_in_node_array(erb_in_node->statements, context->errors, context->options, context->allocator);
       }
     } break;
 

package/extension/libherb/pretty_print.c

@@ -1,17 +1,20 @@
-#include "include/pretty_print.h"
-#include "include/analyzed_ruby.h"
-#include "include/ast_node.h"
-#include "include/ast_nodes.h"
-#include "include/ast_pretty_print.h"
-#include "include/errors.h"
-#include "include/token_struct.h"
-#include "include/util.h"
-#include "include/util/hb_buffer.h"
-#include "include/util/hb_string.h"
-
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
+#ifdef HERB_EXCLUDE_PRETTYPRINT
+// Pretty print support excluded
+#else
+
+#  include "include/pretty_print.h"
+#  include "include/ast_nodes.h"
+#  include "include/ast_pretty_print.h"
+#  include "include/errors.h"
+#  include "include/token_struct.h"
+#  include "include/util.h"
+#  include "include/util/hb_allocator.h"
+#  include "include/util/hb_buffer.h"
+#  include "include/util/hb_string.h"
+
+#  include <stdbool.h>
+#  include <stdio.h>
+#  include <stdlib.h>
 
 void pretty_print_indent(hb_buffer_T* buffer, const size_t indent) {
   for (size_t i = 0; i < indent; i++) {
@@ -53,9 +56,9 @@ void pretty_print_quoted_property(
   const bool last_property,
   hb_buffer_T* buffer
 ) {
-  hb_string_T quoted = quoted_string(value);
+  hb_string_T quoted = quoted_string(buffer->allocator, value);
   pretty_print_property(name, quoted, indent, relative_indent, last_property, buffer);
-  free(quoted.data);
+  hb_allocator_dealloc(buffer->allocator, quoted.data);
 }
 
 void pretty_print_boolean_property(
@@ -212,10 +215,10 @@ void pretty_print_token_property(
 ) {
   pretty_print_label(name, indent, relative_indent, last_property, buffer);
 
-  if (token != NULL && token->value != NULL) {
-    hb_string_T quoted = quoted_string(hb_string(token->value));
+  if (token != NULL && !hb_string_is_empty(token->value)) {
+    hb_string_T quoted = quoted_string(buffer->allocator, token->value);
     hb_buffer_append_string(buffer, quoted);
-    free(quoted.data);
+    hb_allocator_dealloc(buffer->allocator, quoted.data);
 
     hb_buffer_append(buffer, " ");
     pretty_print_location(token->location, buffer);
@@ -235,19 +238,21 @@ void pretty_print_string_property(
   hb_buffer_T* buffer
 ) {
   hb_string_T value = hb_string("∅");
-  hb_string_T escaped = { .data = NULL, .length = 0 };
+  hb_string_T escaped = HB_STRING_NULL;
   hb_string_T quoted;
 
   if (!hb_string_is_empty(string)) {
-    escaped = escape_newlines(string);
-    quoted = quoted_string(escaped);
+    escaped = escape_newlines(buffer->allocator, string);
+    quoted = quoted_string(buffer->allocator, escaped);
     value = quoted;
   }
 
   pretty_print_property(name, value, indent, relative_indent, last_property, buffer);
 
   if (!hb_string_is_empty(string)) {
-    if (!hb_string_is_empty(escaped)) { free(escaped.data); }
-    if (!hb_string_is_empty(quoted)) { free(quoted.data); }
+    if (!hb_string_is_empty(escaped)) { hb_allocator_dealloc(buffer->allocator, escaped.data); }
+    if (!hb_string_is_empty(quoted)) { hb_allocator_dealloc(buffer->allocator, quoted.data); }
   }
 }
+
+#endif

package/extension/libherb/pretty_print.h

@@ -1,12 +1,16 @@
 #ifndef HERB_PRETTY_PRINT_H
 #define HERB_PRETTY_PRINT_H
 
-#include "analyzed_ruby.h"
-#include "ast_nodes.h"
-#include "location.h"
-#include "util/hb_buffer.h"
+#ifdef HERB_EXCLUDE_PRETTYPRINT
+// Pretty print support excluded
+#else
 
-#include <stdbool.h>
+#  include "analyze/analyzed_ruby.h"
+#  include "ast_nodes.h"
+#  include "location.h"
+#  include "util/hb_buffer.h"
+
+#  include <stdbool.h>
 
 void pretty_print_indent(hb_buffer_T* buffer, size_t indent);
 void pretty_print_newline(size_t indent, size_t relative_indent, hb_buffer_T* buffer);
@@ -101,3 +105,4 @@ void pretty_print_errors(
 );
 
 #endif
+#endif

package/extension/libherb/prism_context.h

@@ -0,0 +1,45 @@
+#ifndef HERB_PRISM_CONTEXT_H
+#define HERB_PRISM_CONTEXT_H
+
+#include "util/hb_allocator.h"
+#include "util/hb_buffer.h"
+#include <prism.h>
+#include <stdbool.h>
+
+typedef struct {
+  pm_parser_t parser;
+  pm_options_t pm_opts;
+  pm_node_t* root;
+  hb_buffer_T ruby_buf;
+
+  bool has_structural;
+  pm_parser_t structural_parser;
+  pm_options_t structural_pm_opts;
+  pm_node_t* structural_root;
+  hb_buffer_T structural_buf;
+
+  hb_allocator_T* allocator;
+} herb_prism_context_T;
+
+static inline void herb_prism_context_free(herb_prism_context_T* context) {
+  if (!context) { return; }
+
+  if (context->root) { pm_node_destroy(&context->parser, context->root); }
+
+  pm_parser_free(&context->parser);
+  pm_options_free(&context->pm_opts);
+  hb_buffer_free(&context->ruby_buf);
+
+  if (context->has_structural) {
+    if (context->structural_root) { pm_node_destroy(&context->structural_parser, context->structural_root); }
+
+    pm_parser_free(&context->structural_parser);
+    pm_options_free(&context->structural_pm_opts);
+
+    if (context->structural_buf.value) { hb_buffer_free(&context->structural_buf); }
+  }
+
+  hb_allocator_dealloc(context->allocator, context);
+}
+
+#endif