@herb-tools/node 0.8.9 → 0.9.0

package/extension/libherb/analyze/invalid_structures.c

@@ -0,0 +1,193 @@
+#include "../include/analyze/invalid_structures.h"
+#include "../include/analyze/analyze.h"
+#include "../include/analyze/analyzed_ruby.h"
+#include "../include/analyze/helpers.h"
+#include "../include/ast_node.h"
+#include "../include/ast_nodes.h"
+#include "../include/errors.h"
+#include "../include/token_struct.h"
+#include "../include/util/hb_array.h"
+#include "../include/util/hb_string.h"
+#include "../include/visitor.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+bool detect_invalid_erb_structures(const AST_NODE_T* node, void* data) {
+  invalid_erb_context_T* context = (invalid_erb_context_T*) data;
+
+  if (node->type == AST_HTML_ATTRIBUTE_NAME_NODE) { return false; }
+
+  bool is_begin_node = (node->type == AST_ERB_BEGIN_NODE);
+  bool is_loop_node =
+    (node->type == AST_ERB_WHILE_NODE || node->type == AST_ERB_UNTIL_NODE || node->type == AST_ERB_FOR_NODE
+     || node->type == AST_ERB_BLOCK_NODE);
+
+  if (is_loop_node) { context->loop_depth++; }
+  if (is_begin_node) { context->rescue_depth++; }
+
+  if (node->type == AST_ERB_CONTENT_NODE) {
+    const AST_ERB_CONTENT_NODE_T* content_node = (const AST_ERB_CONTENT_NODE_T*) node;
+
+    if (content_node->parsed && !content_node->valid && content_node->analyzed_ruby != NULL) {
+      analyzed_ruby_T* analyzed = content_node->analyzed_ruby;
+
+      // =begin
+      if (has_error_message(analyzed, "embedded document meets end of file")) {
+        if (is_loop_node) { context->loop_depth--; }
+        if (is_begin_node) { context->rescue_depth--; }
+
+        return true;
+      }
+
+      // =end
+      if (has_error_message(analyzed, "unexpected '=', ignoring it")
+          && has_error_message(analyzed, "unexpected 'end', ignoring it")) {
+        if (is_loop_node) { context->loop_depth--; }
+        if (is_begin_node) { context->rescue_depth--; }
+
+        return true;
+      }
+
+      hb_string_T keyword = HB_STRING_NULL;
+
+      if (context->loop_depth == 0) {
+        if (has_error_message(analyzed, "Invalid break")) {
+          keyword = hb_string("`<% break %>`");
+        } else if (has_error_message(analyzed, "Invalid next")) {
+          keyword = hb_string("`<% next %>`");
+        } else if (has_error_message(analyzed, "Invalid redo")) {
+          keyword = hb_string("`<% redo %>`");
+        }
+      } else {
+        if (has_error_message(analyzed, "Invalid redo") || has_error_message(analyzed, "Invalid break")
+            || has_error_message(analyzed, "Invalid next")) {
+
+          if (is_loop_node) { context->loop_depth--; }
+          if (is_begin_node) { context->rescue_depth--; }
+
+          return true;
+        }
+      }
+
+      if (context->rescue_depth == 0) {
+        if (has_error_message(analyzed, "Invalid retry without rescue")) { keyword = hb_string("`<% retry %>`"); }
+      } else {
+        if (has_error_message(analyzed, "Invalid retry without rescue")) {
+          if (is_loop_node) { context->loop_depth--; }
+          if (is_begin_node) { context->rescue_depth--; }
+
+          return true;
+        }
+      }
+
+      if (hb_string_is_null(keyword)) { keyword = erb_keyword_from_analyzed_ruby(analyzed); }
+
+      if (!hb_string_is_null(keyword) && !token_value_empty(content_node->tag_closing)) {
+        append_erb_control_flow_scope_error(
+          keyword,
+          node->location.start,
+          node->location.end,
+          context->allocator,
+          node->errors
+        );
+      }
+    }
+  }
+
+  if (node->type == AST_ERB_IF_NODE) {
+    const AST_ERB_IF_NODE_T* if_node = (const AST_ERB_IF_NODE_T*) node;
+
+    if (if_node->end_node == NULL) { check_erb_node_for_missing_end(node, context->allocator); }
+
+    if (if_node->statements != NULL) {
+      for (size_t i = 0; i < hb_array_size(if_node->statements); i++) {
+        AST_NODE_T* statement = (AST_NODE_T*) hb_array_get(if_node->statements, i);
+
+        if (statement != NULL) { herb_visit_node(statement, detect_invalid_erb_structures, context); }
+      }
+    }
+
+    AST_NODE_T* subsequent = if_node->subsequent;
+
+    while (subsequent != NULL) {
+      if (subsequent->type == AST_ERB_CONTENT_NODE) {
+        const AST_ERB_CONTENT_NODE_T* content_node = (const AST_ERB_CONTENT_NODE_T*) subsequent;
+
+        if (content_node->parsed && !content_node->valid && content_node->analyzed_ruby != NULL) {
+          analyzed_ruby_T* analyzed = content_node->analyzed_ruby;
+          hb_string_T keyword = erb_keyword_from_analyzed_ruby(analyzed);
+
+          if (!token_value_empty(content_node->tag_closing)) {
+            append_erb_control_flow_scope_error(
+              keyword,
+              subsequent->location.start,
+              subsequent->location.end,
+              context->allocator,
+              subsequent->errors
+            );
+          }
+        }
+      }
+
+      if (subsequent->type == AST_ERB_IF_NODE) {
+        const AST_ERB_IF_NODE_T* elsif_node = (const AST_ERB_IF_NODE_T*) subsequent;
+
+        if (elsif_node->statements != NULL) {
+          for (size_t i = 0; i < hb_array_size(elsif_node->statements); i++) {
+            AST_NODE_T* statement = (AST_NODE_T*) hb_array_get(elsif_node->statements, i);
+
+            if (statement != NULL) { herb_visit_node(statement, detect_invalid_erb_structures, context); }
+          }
+        }
+
+        subsequent = elsif_node->subsequent;
+      } else if (subsequent->type == AST_ERB_ELSE_NODE) {
+        const AST_ERB_ELSE_NODE_T* else_node = (const AST_ERB_ELSE_NODE_T*) subsequent;
+
+        if (else_node->statements != NULL) {
+          for (size_t i = 0; i < hb_array_size(else_node->statements); i++) {
+            AST_NODE_T* statement = (AST_NODE_T*) hb_array_get(else_node->statements, i);
+
+            if (statement != NULL) { herb_visit_node(statement, detect_invalid_erb_structures, context); }
+          }
+        }
+
+        break;
+      } else {
+        break;
+      }
+    }
+  }
+
+  if (node->type == AST_ERB_UNLESS_NODE || node->type == AST_ERB_WHILE_NODE || node->type == AST_ERB_UNTIL_NODE
+      || node->type == AST_ERB_FOR_NODE || node->type == AST_ERB_CASE_NODE || node->type == AST_ERB_CASE_MATCH_NODE
+      || node->type == AST_ERB_BEGIN_NODE || node->type == AST_ERB_BLOCK_NODE || node->type == AST_ERB_ELSE_NODE) {
+    herb_visit_child_nodes(node, detect_invalid_erb_structures, context);
+  }
+
+  if (node->type == AST_ERB_UNLESS_NODE || node->type == AST_ERB_WHILE_NODE || node->type == AST_ERB_UNTIL_NODE
+      || node->type == AST_ERB_FOR_NODE || node->type == AST_ERB_CASE_NODE || node->type == AST_ERB_CASE_MATCH_NODE
+      || node->type == AST_ERB_BEGIN_NODE || node->type == AST_ERB_BLOCK_NODE || node->type == AST_ERB_ELSE_NODE) {
+    check_erb_node_for_missing_end(node, context->allocator);
+
+    if (is_loop_node) { context->loop_depth--; }
+    if (is_begin_node) { context->rescue_depth--; }
+
+    return false;
+  }
+
+  if (node->type == AST_ERB_IF_NODE) {
+    if (is_loop_node) { context->loop_depth--; }
+    if (is_begin_node) { context->rescue_depth--; }
+
+    return false;
+  }
+
+  bool result = true;
+
+  if (is_loop_node) { context->loop_depth--; }
+  if (is_begin_node) { context->rescue_depth--; }
+
+  return result;
+}

package/extension/libherb/analyze/invalid_structures.h

@@ -0,0 +1,11 @@
+#ifndef HERB_ANALYZE_INVALID_STRUCTURES_H
+#define HERB_ANALYZE_INVALID_STRUCTURES_H
+
+#include "../ast_node.h"
+#include "analyze.h"
+
+#include <stdbool.h>
+
+bool detect_invalid_erb_structures(const AST_NODE_T* node, void* data);
+
+#endif

package/extension/libherb/{analyze_missing_end.c → analyze/missing_end.c}

@@ -1,20 +1,23 @@
 // 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_missing_end.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/src/analyze/missing_end.c.erb
 
-#include "include/analyze_helpers.h"
-#include "include/errors.h"
+#include "../include/analyze/helpers.h"
+#include "../include/errors.h"
+#include "../include/util/hb_allocator.h"
+#include "../include/util/hb_string.h"
 
 
-void check_erb_node_for_missing_end(const AST_NODE_T* node) {
+void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator) {
   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 " "%" ">`",
+        append_missing_erb_end_tag_error(
+          hb_string("`<" "%" " if " "%" ">`"),
           erb_if_node->tag_opening->location.start,
           erb_if_node->tag_closing->location.end,
+          allocator,
           node->errors
         );
       }
@@ -26,10 +29,11 @@ void check_erb_node_for_missing_end(const AST_NODE_T* 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",
+        append_missing_erb_end_tag_error(
+          hb_string("ERB block"),
           erb_block_node->tag_opening->location.start,
           erb_block_node->tag_closing->location.end,
+          allocator,
           node->errors
         );
       }
@@ -41,10 +45,11 @@ void check_erb_node_for_missing_end(const AST_NODE_T* 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 " "%" ">`",
+        append_missing_erb_end_tag_error(
+          hb_string("`<" "%" " case " "%" ">`"),
           erb_case_node->tag_opening->location.start,
           erb_case_node->tag_closing->location.end,
+          allocator,
           node->errors
         );
       }
@@ -56,10 +61,11 @@ void check_erb_node_for_missing_end(const AST_NODE_T* 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 " "%" ">`",
+        append_missing_erb_end_tag_error(
+          hb_string("`<" "%" " case " "%" ">`"),
           erb_case_match_node->tag_opening->location.start,
           erb_case_match_node->tag_closing->location.end,
+          allocator,
           node->errors
         );
       }
@@ -71,10 +77,11 @@ void check_erb_node_for_missing_end(const AST_NODE_T* 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 " "%" ">`",
+        append_missing_erb_end_tag_error(
+          hb_string("`<" "%" " while " "%" ">`"),
           erb_while_node->tag_opening->location.start,
           erb_while_node->tag_closing->location.end,
+          allocator,
           node->errors
         );
       }
@@ -86,10 +93,11 @@ void check_erb_node_for_missing_end(const AST_NODE_T* 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 " "%" ">`",
+        append_missing_erb_end_tag_error(
+          hb_string("`<" "%" " until " "%" ">`"),
           erb_until_node->tag_opening->location.start,
           erb_until_node->tag_closing->location.end,
+          allocator,
           node->errors
         );
       }
@@ -101,10 +109,11 @@ void check_erb_node_for_missing_end(const AST_NODE_T* 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 " "%" ">`",
+        append_missing_erb_end_tag_error(
+          hb_string("`<" "%" " for " "%" ">`"),
           erb_for_node->tag_opening->location.start,
           erb_for_node->tag_closing->location.end,
+          allocator,
           node->errors
         );
       }
@@ -116,10 +125,11 @@ void check_erb_node_for_missing_end(const AST_NODE_T* 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 " "%" ">`",
+        append_missing_erb_end_tag_error(
+          hb_string("`<" "%" " begin " "%" ">`"),
           erb_begin_node->tag_opening->location.start,
           erb_begin_node->tag_closing->location.end,
+          allocator,
           node->errors
         );
       }
@@ -131,10 +141,11 @@ void check_erb_node_for_missing_end(const AST_NODE_T* 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 " "%" ">`",
+        append_missing_erb_end_tag_error(
+          hb_string("`<" "%" " unless " "%" ">`"),
           erb_unless_node->tag_opening->location.start,
           erb_unless_node->tag_closing->location.end,
+          allocator,
           node->errors
         );
       }

package/extension/libherb/analyze/parse_errors.c

@@ -0,0 +1,84 @@
+#include "../include/analyze/analyze.h"
+#include "../include/ast_node.h"
+#include "../include/ast_nodes.h"
+#include "../include/errors.h"
+#include "../include/extract.h"
+#include "../include/prism_helpers.h"
+#include "../include/util/hb_allocator.h"
+#include "../include/util/hb_string.h"
+
+#include <prism.h>
+#include <stdlib.h>
+#include <string.h>
+
+static void parse_erb_content_errors(AST_NODE_T* erb_node, const char* source, hb_allocator_T* allocator) {
+  if (!erb_node || erb_node->type != AST_ERB_CONTENT_NODE) { return; }
+  AST_ERB_CONTENT_NODE_T* content_node = (AST_ERB_CONTENT_NODE_T*) erb_node;
+
+  if (!content_node->content || hb_string_is_empty(content_node->content->value)) { return; }
+
+  char* content = hb_string_to_c_string_using_malloc(content_node->content->value);
+  if (!content) { return; }
+
+  pm_parser_t parser;
+  pm_options_t options = { 0, .partial_script = true };
+  pm_parser_init(&parser, (const uint8_t*) content, strlen(content), &options);
+
+  pm_node_t* root = pm_parse(&parser);
+
+  const pm_diagnostic_t* error = (const pm_diagnostic_t*) parser.error_list.head;
+
+  if (error != NULL) {
+    RUBY_PARSE_ERROR_T* parse_error = ruby_parse_error_from_prism_error_with_positions(
+      error,
+      erb_node->location.start,
+      erb_node->location.end,
+      allocator
+    );
+
+    hb_array_append(erb_node->errors, parse_error);
+  }
+
+  pm_node_destroy(&parser, root);
+  pm_parser_free(&parser);
+  pm_options_free(&options);
+  free(content);
+}
+
+void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source, hb_allocator_T* allocator) {
+  char* extracted_ruby = herb_extract_ruby_with_semicolons(source, allocator);
+
+  if (!extracted_ruby) { return; }
+
+  pm_parser_t parser;
+  pm_options_t options = { 0, .partial_script = true };
+  pm_parser_init(&parser, (const uint8_t*) extracted_ruby, strlen(extracted_ruby), &options);
+
+  pm_node_t* root = pm_parse(&parser);
+
+  for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) parser.error_list.head; error != NULL;
+       error = (const pm_diagnostic_t*) error->node.next) {
+    size_t error_offset = (size_t) (error->location.start - parser.start);
+
+    if (strstr(error->message, "unexpected ';'") != NULL) {
+      if (error_offset < strlen(extracted_ruby) && extracted_ruby[error_offset] == ';') {
+        if (error_offset >= strlen(source) || source[error_offset] != ';') {
+          AST_NODE_T* erb_node = find_erb_content_at_offset(document, source, error_offset);
+
+          if (erb_node) { parse_erb_content_errors(erb_node, source, allocator); }
+
+          continue;
+        }
+      }
+    }
+
+    RUBY_PARSE_ERROR_T* parse_error =
+      ruby_parse_error_from_prism_error(error, (AST_NODE_T*) document, source, &parser, allocator);
+    hb_array_append(document->base.errors, parse_error);
+  }
+
+  pm_node_destroy(&parser, root);
+  pm_parser_free(&parser);
+  pm_options_free(&options);
+  hb_allocator_dealloc(allocator, extracted_ruby);
+}