@herb-tools/node 0.8.9 → 0.9.0

package/extension/libherb/analyze/prism_annotate.c

@@ -0,0 +1,397 @@
+#include "../include/analyze/prism_annotate.h"
+#include "../include/ast_node.h"
+#include "../include/ast_nodes.h"
+#include "../include/extract.h"
+#include "../include/herb_prism_node.h"
+#include "../include/prism_context.h"
+#include "../include/util/hb_allocator.h"
+#include "../include/util/hb_buffer.h"
+#include "../include/util/hb_narray.h"
+#include "../include/visitor.h"
+
+#include <prism.h>
+#include <string.h>
+
+typedef struct {
+  uint32_t from;
+  uint32_t to;
+} content_range_T;
+
+typedef struct {
+  pm_parser_t* parser;
+  pm_parser_t* structural_parser;
+  hb_narray_T* node_list;
+  hb_narray_T* structural_node_list;
+  bool prism_nodes_deep;
+} prism_annotate_context_T;
+
+static void collect_prism_nodes(pm_node_t* node, hb_narray_T* list);
+
+static void collect_from_statements(pm_statements_node_t* statements, hb_narray_T* list) {
+  if (!statements) { return; }
+
+  for (size_t i = 0; i < statements->body.size; i++) {
+    hb_narray_push(list, &statements->body.nodes[i]);
+    collect_prism_nodes(statements->body.nodes[i], list);
+  }
+}
+
+static void collect_prism_nodes(pm_node_t* node, hb_narray_T* list) {
+  if (!node) { return; }
+
+  switch (PM_NODE_TYPE(node)) {
+    case PM_PROGRAM_NODE: {
+      collect_from_statements(((pm_program_node_t*) node)->statements, list);
+      break;
+    }
+
+    case PM_IF_NODE: {
+      pm_if_node_t* if_node = (pm_if_node_t*) node;
+      collect_from_statements(if_node->statements, list);
+      if (if_node->subsequent) { collect_prism_nodes(if_node->subsequent, list); }
+      break;
+    }
+
+    case PM_UNLESS_NODE: {
+      pm_unless_node_t* unless_node = (pm_unless_node_t*) node;
+      collect_from_statements(unless_node->statements, list);
+      if (unless_node->else_clause) { collect_prism_nodes((pm_node_t*) unless_node->else_clause, list); }
+      break;
+    }
+
+    case PM_ELSE_NODE: {
+      collect_from_statements(((pm_else_node_t*) node)->statements, list);
+      break;
+    }
+
+    case PM_WHILE_NODE: {
+      collect_from_statements(((pm_while_node_t*) node)->statements, list);
+      break;
+    }
+
+    case PM_UNTIL_NODE: {
+      collect_from_statements(((pm_until_node_t*) node)->statements, list);
+      break;
+    }
+
+    case PM_FOR_NODE: {
+      collect_from_statements(((pm_for_node_t*) node)->statements, list);
+      break;
+    }
+
+    case PM_CASE_NODE: {
+      pm_case_node_t* case_node = (pm_case_node_t*) node;
+
+      for (size_t i = 0; i < case_node->conditions.size; i++) {
+        collect_prism_nodes(case_node->conditions.nodes[i], list);
+      }
+
+      if (case_node->else_clause) { collect_prism_nodes((pm_node_t*) case_node->else_clause, list); }
+      break;
+    }
+
+    case PM_CASE_MATCH_NODE: {
+      pm_case_match_node_t* case_match_node = (pm_case_match_node_t*) node;
+
+      for (size_t i = 0; i < case_match_node->conditions.size; i++) {
+        collect_prism_nodes(case_match_node->conditions.nodes[i], list);
+      }
+
+      if (case_match_node->else_clause) { collect_prism_nodes((pm_node_t*) case_match_node->else_clause, list); }
+      break;
+    }
+
+    case PM_WHEN_NODE: {
+      collect_from_statements(((pm_when_node_t*) node)->statements, list);
+      break;
+    }
+
+    case PM_IN_NODE: {
+      collect_from_statements(((pm_in_node_t*) node)->statements, list);
+      break;
+    }
+
+    case PM_BEGIN_NODE: {
+      pm_begin_node_t* begin_node = (pm_begin_node_t*) node;
+
+      collect_from_statements(begin_node->statements, list);
+
+      if (begin_node->rescue_clause) { collect_prism_nodes((pm_node_t*) begin_node->rescue_clause, list); }
+      if (begin_node->else_clause) { collect_prism_nodes((pm_node_t*) begin_node->else_clause, list); }
+      if (begin_node->ensure_clause) { collect_prism_nodes((pm_node_t*) begin_node->ensure_clause, list); }
+
+      break;
+    }
+
+    case PM_RESCUE_NODE: {
+      pm_rescue_node_t* rescue_node = (pm_rescue_node_t*) node;
+
+      collect_from_statements(rescue_node->statements, list);
+
+      if (rescue_node->subsequent) { collect_prism_nodes((pm_node_t*) rescue_node->subsequent, list); }
+      break;
+    }
+
+    case PM_ENSURE_NODE: {
+      collect_from_statements(((pm_ensure_node_t*) node)->statements, list);
+      break;
+    }
+
+    case PM_CALL_NODE: {
+      pm_call_node_t* call_node = (pm_call_node_t*) node;
+
+      if (call_node->block && PM_NODE_TYPE(call_node->block) == PM_BLOCK_NODE) {
+        pm_block_node_t* block = (pm_block_node_t*) call_node->block;
+
+        if (block->body && PM_NODE_TYPE(block->body) == PM_STATEMENTS_NODE) {
+          collect_from_statements((pm_statements_node_t*) block->body, list);
+        }
+      }
+
+      break;
+    }
+
+    case PM_LAMBDA_NODE: {
+      pm_lambda_node_t* lambda_node = (pm_lambda_node_t*) node;
+
+      if (lambda_node->body && PM_NODE_TYPE(lambda_node->body) == PM_STATEMENTS_NODE) {
+        collect_from_statements((pm_statements_node_t*) lambda_node->body, list);
+      }
+
+      break;
+    }
+
+    default: break;
+  }
+}
+
+static token_T* get_content_token(const AST_NODE_T* node) {
+  switch (node->type) {
+    case AST_ERB_CONTENT_NODE: return ((AST_ERB_CONTENT_NODE_T*) node)->content;
+    case AST_ERB_IF_NODE: return ((AST_ERB_IF_NODE_T*) node)->content;
+    case AST_ERB_BLOCK_NODE: return ((AST_ERB_BLOCK_NODE_T*) node)->content;
+    case AST_ERB_CASE_NODE: return ((AST_ERB_CASE_NODE_T*) node)->content;
+    case AST_ERB_CASE_MATCH_NODE: return ((AST_ERB_CASE_MATCH_NODE_T*) node)->content;
+    case AST_ERB_WHILE_NODE: return ((AST_ERB_WHILE_NODE_T*) node)->content;
+    case AST_ERB_UNTIL_NODE: return ((AST_ERB_UNTIL_NODE_T*) node)->content;
+    case AST_ERB_FOR_NODE: return ((AST_ERB_FOR_NODE_T*) node)->content;
+    case AST_ERB_BEGIN_NODE: return ((AST_ERB_BEGIN_NODE_T*) node)->content;
+    case AST_ERB_UNLESS_NODE: return ((AST_ERB_UNLESS_NODE_T*) node)->content;
+    default: return NULL;
+  }
+}
+
+static void set_prism_node(AST_NODE_T* node, herb_prism_node_T prism_ref) {
+  switch (node->type) {
+    case AST_ERB_CONTENT_NODE: ((AST_ERB_CONTENT_NODE_T*) node)->prism_node = prism_ref; break;
+    case AST_ERB_IF_NODE: ((AST_ERB_IF_NODE_T*) node)->prism_node = prism_ref; break;
+    case AST_ERB_BLOCK_NODE: ((AST_ERB_BLOCK_NODE_T*) node)->prism_node = prism_ref; break;
+    case AST_ERB_CASE_NODE: ((AST_ERB_CASE_NODE_T*) node)->prism_node = prism_ref; break;
+    case AST_ERB_CASE_MATCH_NODE: ((AST_ERB_CASE_MATCH_NODE_T*) node)->prism_node = prism_ref; break;
+    case AST_ERB_WHILE_NODE: ((AST_ERB_WHILE_NODE_T*) node)->prism_node = prism_ref; break;
+    case AST_ERB_UNTIL_NODE: ((AST_ERB_UNTIL_NODE_T*) node)->prism_node = prism_ref; break;
+    case AST_ERB_FOR_NODE: ((AST_ERB_FOR_NODE_T*) node)->prism_node = prism_ref; break;
+    case AST_ERB_BEGIN_NODE: ((AST_ERB_BEGIN_NODE_T*) node)->prism_node = prism_ref; break;
+    case AST_ERB_UNLESS_NODE: ((AST_ERB_UNLESS_NODE_T*) node)->prism_node = prism_ref; break;
+    default: break;
+  }
+}
+
+static herb_prism_node_T find_prism_node_for_herb_node(
+  pm_parser_t* parser,
+  hb_narray_T* node_list,
+  const AST_NODE_T* node
+) {
+  herb_prism_node_T result = HERB_PRISM_NODE_EMPTY;
+
+  token_T* content = get_content_token(node);
+  if (!content || hb_string_is_empty(content->value)) { return result; }
+
+  uint32_t content_from = content->range.from;
+  uint32_t content_to = content->range.to;
+
+  for (size_t i = 0; i < hb_narray_size(node_list); i++) {
+    pm_node_t* prism_node = *(pm_node_t**) hb_narray_get(node_list, i);
+    size_t prism_start = (size_t) (prism_node->location.start - parser->start);
+
+    if (prism_start >= content_from && prism_start < content_to) {
+      result.node = prism_node;
+      result.parser = parser;
+      break;
+    }
+  }
+
+  return result;
+}
+
+static bool annotate_visitor(const AST_NODE_T* node, void* data) {
+  prism_annotate_context_T* context = (prism_annotate_context_T*) data;
+
+  if (!get_content_token(node)) { return true; }
+
+  pm_parser_t* parser;
+  hb_narray_T* node_list;
+
+  if (node->type == AST_ERB_CONTENT_NODE || context->prism_nodes_deep) {
+    parser = context->parser;
+    node_list = context->node_list;
+  } else {
+    parser = context->structural_parser;
+    node_list = context->structural_node_list;
+  }
+
+  herb_prism_node_T prism_ref = find_prism_node_for_herb_node(parser, node_list, node);
+
+  if (prism_ref.node) { set_prism_node((AST_NODE_T*) node, prism_ref); }
+
+  return true;
+}
+
+static bool collect_content_ranges_visitor(const AST_NODE_T* node, void* data) {
+  if (node->type != AST_ERB_CONTENT_NODE) { return true; }
+
+  hb_narray_T* ranges = (hb_narray_T*) data;
+  token_T* content = get_content_token(node);
+
+  if (!content || hb_string_is_empty(content->value)) { return true; }
+
+  content_range_T range = { .from = content->range.from, .to = content->range.to };
+  hb_narray_push(ranges, &range);
+
+  return true;
+}
+
+void herb_annotate_prism_nodes(
+  AST_DOCUMENT_NODE_T* document,
+  const char* source,
+  bool prism_nodes,
+  bool prism_nodes_deep,
+  bool prism_program,
+  hb_allocator_T* allocator
+) {
+  if (!document || !source) { return; }
+
+  size_t source_len = strlen(source);
+
+  herb_prism_context_T* context = hb_allocator_alloc(allocator, sizeof(herb_prism_context_T));
+  if (!context) { return; }
+
+  memset(context, 0, sizeof(herb_prism_context_T));
+
+  context->allocator = allocator;
+  context->has_structural = false;
+
+  if (!hb_buffer_init(&context->ruby_buf, source_len, allocator)) {
+    hb_allocator_dealloc(allocator, context);
+    return;
+  }
+
+  herb_extract_ruby_options_T extract_options = {
+    .semicolons = true,
+    .comments = false,
+    .preserve_positions = true,
+  };
+
+  herb_extract_ruby_to_buffer_with_options(source, &context->ruby_buf, &extract_options, allocator);
+
+  if (!context->ruby_buf.value || context->ruby_buf.length == 0) {
+    hb_buffer_free(&context->ruby_buf);
+    hb_allocator_dealloc(allocator, context);
+    return;
+  }
+
+  memset(&context->pm_opts, 0, sizeof(pm_options_t));
+  pm_options_partial_script_set(&context->pm_opts, true);
+  pm_parser_init(
+    &context->parser,
+    (const uint8_t*) context->ruby_buf.value,
+    context->ruby_buf.length,
+    &context->pm_opts
+  );
+  context->root = pm_parse(&context->parser);
+
+  if (!context->root || context->root->type != PM_PROGRAM_NODE) {
+    pm_node_destroy(&context->parser, context->root);
+    context->root = NULL;
+
+    pm_parser_free(&context->parser);
+    pm_options_free(&context->pm_opts);
+
+    hb_buffer_free(&context->ruby_buf);
+    hb_allocator_dealloc(allocator, context);
+
+    return;
+  }
+
+  document->prism_context = context;
+
+  if (prism_program) {
+    herb_prism_node_T program_ref = {
+      .node = context->root,
+      .parser = &context->parser,
+    };
+
+    document->prism_node = program_ref;
+  }
+
+  hb_narray_T node_list;
+  hb_narray_pointer_init(&node_list, 32, allocator);
+
+  hb_narray_T structural_node_list;
+  hb_narray_pointer_init(&structural_node_list, 32, allocator);
+
+  if (prism_nodes) {
+    collect_prism_nodes(context->root, &node_list);
+
+    if (!prism_nodes_deep) {
+      hb_narray_T content_ranges;
+      hb_narray_init(&content_ranges, sizeof(content_range_T), 32, allocator);
+      herb_visit_node((AST_NODE_T*) document, collect_content_ranges_visitor, &content_ranges);
+
+      if (hb_buffer_init(&context->structural_buf, context->ruby_buf.length, allocator)) {
+        memcpy(context->structural_buf.value, context->ruby_buf.value, context->ruby_buf.length);
+        context->structural_buf.length = context->ruby_buf.length;
+
+        for (size_t i = 0; i < hb_narray_size(&content_ranges); i++) {
+          content_range_T* range = (content_range_T*) hb_narray_get(&content_ranges, i);
+
+          for (uint32_t j = range->from; j < range->to && j < context->structural_buf.length; j++) {
+            context->structural_buf.value[j] = ' ';
+          }
+        }
+
+        memset(&context->structural_pm_opts, 0, sizeof(pm_options_t));
+        pm_options_partial_script_set(&context->structural_pm_opts, true);
+
+        pm_parser_init(
+          &context->structural_parser,
+          (const uint8_t*) context->structural_buf.value,
+          context->structural_buf.length,
+          &context->structural_pm_opts
+        );
+
+        context->structural_root = pm_parse(&context->structural_parser);
+        context->has_structural = true;
+
+        if (context->structural_root && context->structural_root->type == PM_PROGRAM_NODE) {
+          collect_prism_nodes(context->structural_root, &structural_node_list);
+        }
+      }
+
+      hb_narray_deinit(&content_ranges);
+    }
+
+    prism_annotate_context_T annotate_context = {
+      .parser = &context->parser,
+      .structural_parser = prism_nodes_deep ? &context->parser : &context->structural_parser,
+      .node_list = &node_list,
+      .structural_node_list = prism_nodes_deep ? &node_list : &structural_node_list,
+      .prism_nodes_deep = prism_nodes_deep,
+    };
+
+    herb_visit_node((AST_NODE_T*) document, annotate_visitor, &annotate_context);
+  }
+
+  hb_narray_deinit(&node_list);
+  hb_narray_deinit(&structural_node_list);
+}

package/extension/libherb/analyze/prism_annotate.h

@@ -0,0 +1,16 @@
+#ifndef HERB_PRISM_ANNOTATE_H
+#define HERB_PRISM_ANNOTATE_H
+
+#include "../ast_nodes.h"
+#include "../util/hb_allocator.h"
+
+void herb_annotate_prism_nodes(
+  AST_DOCUMENT_NODE_T* document,
+  const char* source,
+  bool prism_nodes,
+  bool prism_nodes_deep,
+  bool prism_program,
+  hb_allocator_T* allocator
+);
+
+#endif

package/extension/libherb/{analyze_transform.c → analyze/transform.c}

@@ -1,8 +1,8 @@
 // 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.9/templates/src/analyze_transform.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/src/analyze/transform.c.erb
 
-#include "include/analyze.h"
-#include "include/visitor.h"
+#include "../include/analyze/analyze.h"
+#include "../include/visitor.h"
 
 bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
   analyze_ruby_context_T* context = (analyze_ruby_context_T*) data;
@@ -36,6 +36,13 @@ bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
     hb_array_free(&old_array);
   }
 
+  if (node->type == AST_HTML_CONDITIONAL_ELEMENT_NODE) {
+    AST_HTML_CONDITIONAL_ELEMENT_NODE_T* html_conditional_element_node = (AST_HTML_CONDITIONAL_ELEMENT_NODE_T*) node;
+    hb_array_T* old_array = html_conditional_element_node->body;
+    html_conditional_element_node->body = rewrite_node_array((AST_NODE_T*) node, html_conditional_element_node->body, context);
+    hb_array_free(&old_array);
+  }
+
   if (node->type == AST_HTML_ATTRIBUTE_VALUE_NODE) {
     AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = (AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node;
     hb_array_T* old_array = html_attribute_value_node->children;
@@ -50,6 +57,13 @@ bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
     hb_array_free(&old_array);
   }
 
+  if (node->type == AST_ERB_OPEN_TAG_NODE) {
+    AST_ERB_OPEN_TAG_NODE_T* erb_open_tag_node = (AST_ERB_OPEN_TAG_NODE_T*) node;
+    hb_array_T* old_array = erb_open_tag_node->children;
+    erb_open_tag_node->children = rewrite_node_array((AST_NODE_T*) node, erb_open_tag_node->children, context);
+    hb_array_free(&old_array);
+  }
+
   if (node->type == AST_HTML_COMMENT_NODE) {
     AST_HTML_COMMENT_NODE_T* html_comment_node = (AST_HTML_COMMENT_NODE_T*) node;
     hb_array_T* old_array = html_comment_node->children;

package/extension/libherb/ast_node.c

@@ -2,8 +2,9 @@
 #include "include/ast_nodes.h"
 #include "include/errors.h"
 #include "include/position.h"
-#include "include/token.h"
 #include "include/util.h"
+#include "include/util/hb_allocator.h"
+#include "include/util/hb_string.h"
 #include "include/visitor.h"
 
 #include <prism.h>
@@ -14,7 +15,14 @@ size_t ast_node_sizeof(void) {
   return sizeof(struct AST_NODE_STRUCT);
 }
 
-void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T start, position_T end, hb_array_T* errors) {
+void ast_node_init(
+  AST_NODE_T* node,
+  const ast_node_type_T type,
+  position_T start,
+  position_T end,
+  hb_array_T* errors,
+  hb_allocator_T* allocator
+) {
   if (!node) { return; }
 
   node->type = type;
@@ -22,18 +30,20 @@ void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T star
   node->location.end = end;
 
   if (errors == NULL) {
-    node->errors = hb_array_init(8);
+    node->errors = hb_array_init(0, allocator);
   } else {
     node->errors = errors;
   }
 }
 
-AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token) {
-  AST_LITERAL_NODE_T* literal = malloc(sizeof(AST_LITERAL_NODE_T));
+AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token, hb_allocator_T* allocator) {
+  AST_LITERAL_NODE_T* literal = hb_allocator_alloc(allocator, sizeof(AST_LITERAL_NODE_T));
 
-  ast_node_init(&literal->base, AST_LITERAL_NODE, token->location.start, token->location.end, NULL);
+  if (!literal) { return NULL; }
 
-  literal->content = herb_strdup(token->value);
+  ast_node_init(&literal->base, AST_LITERAL_NODE, token->location.start, token->location.end, NULL, allocator);
+
+  literal->content = hb_string_copy(token->value, allocator);
 
   return literal;
 }

package/extension/libherb/ast_node.h

@@ -5,19 +5,25 @@
 #include "errors.h"
 #include "position.h"
 #include "token_struct.h"
+#include "util/hb_allocator.h"
 
-void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T start, position_T end, hb_array_T* errors);
-void ast_node_free(AST_NODE_T* node);
+void ast_node_init(
+  AST_NODE_T* node,
+  ast_node_type_T type,
+  position_T start,
+  position_T end,
+  hb_array_T* errors,
+  hb_allocator_T* allocator
+);
+void ast_node_free(AST_NODE_T* node, hb_allocator_T* allocator);
 
-AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token);
+AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token, hb_allocator_T* allocator);
 
 size_t ast_node_sizeof(void);
 size_t ast_node_child_count(AST_NODE_T* node);
 
 ast_node_type_T ast_node_type(const AST_NODE_T* node);
 
-char* ast_node_name(AST_NODE_T* node);
-
 void ast_node_set_start(AST_NODE_T* node, position_T position);
 void ast_node_set_end(AST_NODE_T* node, position_T position);