herb 0.7.4-aarch64-linux-gnu → 0.8.0-aarch64-linux-gnu

data/src/analyze_helpers.c

@@ -238,6 +238,11 @@ bool search_else_nodes(analyzed_ruby_T* analyzed) {
 
 bool search_end_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'end', ignoring it")) {
+    if (has_error_message(analyzed, "unexpected '=', ignoring it")) {
+      // `=end`
+      return false;
+    }
+
     analyzed->has_end = true;
     return true;
   }

data/src/analyze_missing_end.c

@@ -0,0 +1,147 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /home/runner/work/herb/herb/templates/src/analyze_missing_end.c.erb
+
+#include "include/analyze_helpers.h"
+#include "include/errors.h"
+
+
+void check_erb_node_for_missing_end(const AST_NODE_T* node) {
+  switch (node->type) {
+    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->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " if " "%" ">`",
+          erb_if_node->tag_opening->location.start,
+          erb_if_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      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->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "ERB block",
+          erb_block_node->tag_opening->location.start,
+          erb_block_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      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->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " case " "%" ">`",
+          erb_case_node->tag_opening->location.start,
+          erb_case_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      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->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " case " "%" ">`",
+          erb_case_match_node->tag_opening->location.start,
+          erb_case_match_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      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->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " while " "%" ">`",
+          erb_while_node->tag_opening->location.start,
+          erb_while_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      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->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " until " "%" ">`",
+          erb_until_node->tag_opening->location.start,
+          erb_until_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      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->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " for " "%" ">`",
+          erb_for_node->tag_opening->location.start,
+          erb_for_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      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->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " begin " "%" ">`",
+          erb_begin_node->tag_opening->location.start,
+          erb_begin_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      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->end_node == NULL) {
+        append_missingerb_end_tag_error(
+          "`<" "%" " unless " "%" ">`",
+          erb_unless_node->tag_opening->location.start,
+          erb_unless_node->tag_closing->location.end,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
+    default: break;
+  }
+}

data/src/analyze_transform.c

@@ -0,0 +1,196 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /home/runner/work/herb/herb/templates/src/analyze_transform.c.erb
+
+#include "include/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;
+  context->parent = (AST_NODE_T*) node;
+
+  if (node->type == AST_DOCUMENT_NODE) {
+    AST_DOCUMENT_NODE_T* document_node = (AST_DOCUMENT_NODE_T*) node;
+    hb_array_T* old_array = document_node->children;
+    document_node->children = rewrite_node_array((AST_NODE_T*) node, document_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_HTML_OPEN_TAG_NODE) {
+    AST_HTML_OPEN_TAG_NODE_T* html_open_tag_node = (AST_HTML_OPEN_TAG_NODE_T*) node;
+    hb_array_T* old_array = html_open_tag_node->children;
+    html_open_tag_node->children = rewrite_node_array((AST_NODE_T*) node, html_open_tag_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_HTML_CLOSE_TAG_NODE) {
+    AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = (AST_HTML_CLOSE_TAG_NODE_T*) node;
+    hb_array_T* old_array = html_close_tag_node->children;
+    html_close_tag_node->children = rewrite_node_array((AST_NODE_T*) node, html_close_tag_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_HTML_ELEMENT_NODE) {
+    AST_HTML_ELEMENT_NODE_T* html_element_node = (AST_HTML_ELEMENT_NODE_T*) node;
+    hb_array_T* old_array = html_element_node->body;
+    html_element_node->body = rewrite_node_array((AST_NODE_T*) node, html_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;
+    html_attribute_value_node->children = rewrite_node_array((AST_NODE_T*) node, html_attribute_value_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_HTML_ATTRIBUTE_NAME_NODE) {
+    AST_HTML_ATTRIBUTE_NAME_NODE_T* html_attribute_name_node = (AST_HTML_ATTRIBUTE_NAME_NODE_T*) node;
+    hb_array_T* old_array = html_attribute_name_node->children;
+    html_attribute_name_node->children = rewrite_node_array((AST_NODE_T*) node, html_attribute_name_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;
+    html_comment_node->children = rewrite_node_array((AST_NODE_T*) node, html_comment_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_HTML_DOCTYPE_NODE) {
+    AST_HTML_DOCTYPE_NODE_T* html_doctype_node = (AST_HTML_DOCTYPE_NODE_T*) node;
+    hb_array_T* old_array = html_doctype_node->children;
+    html_doctype_node->children = rewrite_node_array((AST_NODE_T*) node, html_doctype_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_XML_DECLARATION_NODE) {
+    AST_XML_DECLARATION_NODE_T* xml_declaration_node = (AST_XML_DECLARATION_NODE_T*) node;
+    hb_array_T* old_array = xml_declaration_node->children;
+    xml_declaration_node->children = rewrite_node_array((AST_NODE_T*) node, xml_declaration_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_CDATA_NODE) {
+    AST_CDATA_NODE_T* cdata_node = (AST_CDATA_NODE_T*) node;
+    hb_array_T* old_array = cdata_node->children;
+    cdata_node->children = rewrite_node_array((AST_NODE_T*) node, cdata_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_ELSE_NODE) {
+    AST_ERB_ELSE_NODE_T* erb_else_node = (AST_ERB_ELSE_NODE_T*) node;
+    hb_array_T* old_array = erb_else_node->statements;
+    erb_else_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_else_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_IF_NODE) {
+    AST_ERB_IF_NODE_T* erb_if_node = (AST_ERB_IF_NODE_T*) node;
+    hb_array_T* old_array = erb_if_node->statements;
+    erb_if_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_if_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_BLOCK_NODE) {
+    AST_ERB_BLOCK_NODE_T* erb_block_node = (AST_ERB_BLOCK_NODE_T*) node;
+    hb_array_T* old_array = erb_block_node->body;
+    erb_block_node->body = rewrite_node_array((AST_NODE_T*) node, erb_block_node->body, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_WHEN_NODE) {
+    AST_ERB_WHEN_NODE_T* erb_when_node = (AST_ERB_WHEN_NODE_T*) node;
+    hb_array_T* old_array = erb_when_node->statements;
+    erb_when_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_when_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_CASE_NODE) {
+    AST_ERB_CASE_NODE_T* erb_case_node = (AST_ERB_CASE_NODE_T*) node;
+    hb_array_T* old_array = erb_case_node->children;
+    erb_case_node->children = rewrite_node_array((AST_NODE_T*) node, erb_case_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_CASE_NODE) {
+    AST_ERB_CASE_NODE_T* erb_case_node = (AST_ERB_CASE_NODE_T*) node;
+    hb_array_T* old_array = erb_case_node->conditions;
+    erb_case_node->conditions = rewrite_node_array((AST_NODE_T*) node, erb_case_node->conditions, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_CASE_MATCH_NODE) {
+    AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = (AST_ERB_CASE_MATCH_NODE_T*) node;
+    hb_array_T* old_array = erb_case_match_node->children;
+    erb_case_match_node->children = rewrite_node_array((AST_NODE_T*) node, erb_case_match_node->children, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_CASE_MATCH_NODE) {
+    AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = (AST_ERB_CASE_MATCH_NODE_T*) node;
+    hb_array_T* old_array = erb_case_match_node->conditions;
+    erb_case_match_node->conditions = rewrite_node_array((AST_NODE_T*) node, erb_case_match_node->conditions, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_WHILE_NODE) {
+    AST_ERB_WHILE_NODE_T* erb_while_node = (AST_ERB_WHILE_NODE_T*) node;
+    hb_array_T* old_array = erb_while_node->statements;
+    erb_while_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_while_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_UNTIL_NODE) {
+    AST_ERB_UNTIL_NODE_T* erb_until_node = (AST_ERB_UNTIL_NODE_T*) node;
+    hb_array_T* old_array = erb_until_node->statements;
+    erb_until_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_until_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_FOR_NODE) {
+    AST_ERB_FOR_NODE_T* erb_for_node = (AST_ERB_FOR_NODE_T*) node;
+    hb_array_T* old_array = erb_for_node->statements;
+    erb_for_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_for_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_RESCUE_NODE) {
+    AST_ERB_RESCUE_NODE_T* erb_rescue_node = (AST_ERB_RESCUE_NODE_T*) node;
+    hb_array_T* old_array = erb_rescue_node->statements;
+    erb_rescue_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_rescue_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_ENSURE_NODE) {
+    AST_ERB_ENSURE_NODE_T* erb_ensure_node = (AST_ERB_ENSURE_NODE_T*) node;
+    hb_array_T* old_array = erb_ensure_node->statements;
+    erb_ensure_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_ensure_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_BEGIN_NODE) {
+    AST_ERB_BEGIN_NODE_T* erb_begin_node = (AST_ERB_BEGIN_NODE_T*) node;
+    hb_array_T* old_array = erb_begin_node->statements;
+    erb_begin_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_begin_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_UNLESS_NODE) {
+    AST_ERB_UNLESS_NODE_T* erb_unless_node = (AST_ERB_UNLESS_NODE_T*) node;
+    hb_array_T* old_array = erb_unless_node->statements;
+    erb_unless_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_unless_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  if (node->type == AST_ERB_IN_NODE) {
+    AST_ERB_IN_NODE_T* erb_in_node = (AST_ERB_IN_NODE_T*) node;
+    hb_array_T* old_array = erb_in_node->statements;
+    erb_in_node->statements = rewrite_node_array((AST_NODE_T*) node, erb_in_node->statements, context);
+    hb_array_free(&old_array);
+  }
+
+  herb_visit_child_nodes(node, transform_erb_nodes, data);
+
+  return false;
+}

data/src/analyzed_ruby.c

@@ -1,12 +1,13 @@
 #include "include/analyzed_ruby.h"
+#include "include/util/hb_string.h"
 
 #include <prism.h>
 #include <string.h>
 
-analyzed_ruby_T* init_analyzed_ruby(char* source) {
+analyzed_ruby_T* init_analyzed_ruby(hb_string_T source) {
   analyzed_ruby_T* analyzed = malloc(sizeof(analyzed_ruby_T));
 
-  pm_parser_init(&analyzed->parser, (const uint8_t*) source, strlen(source), NULL);
+  pm_parser_init(&analyzed->parser, (const uint8_t*) source.data, source.length, NULL);
 
   analyzed->root = pm_parse(&analyzed->parser);
   analyzed->valid = (analyzed->parser.error_list.size == 0);
@@ -42,3 +43,23 @@ void free_analyzed_ruby(analyzed_ruby_T* analyzed) {
 
   free(analyzed);
 }
+
+const char* erb_keyword_from_analyzed_ruby(const analyzed_ruby_T* analyzed) {
+  if (analyzed->has_end) {
+    return "`<% end %>`";
+  } else if (analyzed->has_else_node) {
+    return "`<% else %>`";
+  } else if (analyzed->has_elsif_node) {
+    return "`<% elsif %>`";
+  } else if (analyzed->has_when_node) {
+    return "`<% when %>`";
+  } else if (analyzed->has_in_node) {
+    return "`<% in %>`";
+  } else if (analyzed->has_rescue_node) {
+    return "`<% rescue %>`";
+  } else if (analyzed->has_ensure_node) {
+    return "`<% ensure %>`";
+  }
+
+  return NULL;
+}

data/src/ast_node.c

@@ -12,14 +12,15 @@ 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, 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) {
   if (!node) { return; }
 
   node->type = type;
-  node->location = location_init(position_copy(start), position_copy(end));
+  node->location.start = start;
+  node->location.end = end;
 
   if (errors == NULL) {
-    node->errors = array_init(8);
+    node->errors = hb_array_init(8);
   } else {
     node->errors = errors;
   }
@@ -28,7 +29,7 @@ void ast_node_init(AST_NODE_T* node, const ast_node_type_T type, position_T* sta
 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_node_init(&literal->base, AST_LITERAL_NODE, token->location->start, token->location->end, NULL);
+  ast_node_init(&literal->base, AST_LITERAL_NODE, token->location.start, token->location.end, NULL);
 
   literal->content = herb_strdup(token->value);
 
@@ -40,35 +41,31 @@ ast_node_type_T ast_node_type(const AST_NODE_T* node) {
 }
 
 size_t ast_node_errors_count(const AST_NODE_T* node) {
-  return array_size(node->errors);
+  return hb_array_size(node->errors);
 }
 
-array_T* ast_node_errors(const AST_NODE_T* node) {
+hb_array_T* ast_node_errors(const AST_NODE_T* node) {
   return node->errors;
 }
 
 void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error) {
-  array_append(node->errors, error);
+  hb_array_append(node->errors, error);
 }
 
-void ast_node_set_start(AST_NODE_T* node, position_T* position) {
-  if (node->location->start != NULL) { position_free(node->location->start); }
-
-  node->location->start = position_copy(position);
+void ast_node_set_start(AST_NODE_T* node, position_T position) {
+  node->location.start = position;
 }
 
-void ast_node_set_end(AST_NODE_T* node, position_T* position) {
-  if (node->location->end != NULL) { position_free(node->location->end); }
-
-  node->location->end = position_copy(position);
+void ast_node_set_end(AST_NODE_T* node, position_T position) {
+  node->location.end = position;
 }
 
 void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token) {
-  ast_node_set_start(node, token->location->start);
+  ast_node_set_start(node, token->location.start);
 }
 
 void ast_node_set_end_from_token(AST_NODE_T* node, const token_T* token) {
-  ast_node_set_end(node, token->location->end);
+  ast_node_set_end(node, token->location.end);
 }
 
 void ast_node_set_positions_from_token(AST_NODE_T* node, const token_T* token) {