@herb-tools/node 0.8.10 → 0.9.0

package/extension/libherb/parser.h

@@ -3,6 +3,7 @@
 
 #include "ast_node.h"
 #include "lexer.h"
+#include "util/hb_allocator.h"
 #include "util/hb_array.h"
 
 typedef enum {
@@ -17,17 +18,32 @@ typedef enum { PARSER_STATE_DATA, PARSER_STATE_FOREIGN_CONTENT } parser_state_T;
 
 typedef struct PARSER_OPTIONS_STRUCT {
   bool track_whitespace;
+  bool analyze;
+  bool strict;
+  bool action_view_helpers;
+  bool prism_program;
+  bool prism_nodes;
+  bool prism_nodes_deep;
 } parser_options_T;
 
+typedef struct MATCH_TAGS_CONTEXT_STRUCT {
+  hb_array_T* errors;
+  const parser_options_T* options;
+  hb_allocator_T* allocator;
+} match_tags_context_T;
+
 extern const parser_options_T HERB_DEFAULT_PARSER_OPTIONS;
 
 typedef struct PARSER_STRUCT {
+  hb_allocator_T* allocator;
   lexer_T* lexer;
   token_T* current_token;
   hb_array_T* open_tags_stack;
   parser_state_T state;
   foreign_content_type_T foreign_content_type;
   parser_options_T options;
+  size_t consecutive_error_count;
+  bool in_recovery_mode;
 } parser_T;
 
 size_t parser_sizeof(void);
@@ -36,10 +52,19 @@ void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T options
 
 AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser);
 
-void herb_parser_match_html_tags_post_analyze(AST_DOCUMENT_NODE_T* document);
+void herb_parser_match_html_tags_post_analyze(
+  AST_DOCUMENT_NODE_T* document,
+  const parser_options_T* options,
+  hb_allocator_T* allocator
+);
 void herb_parser_deinit(parser_T* parser);
 
-void match_tags_in_node_array(hb_array_T* nodes, hb_array_T* errors);
+void match_tags_in_node_array(
+  hb_array_T* nodes,
+  hb_array_T* errors,
+  const parser_options_T* options,
+  hb_allocator_T* allocator
+);
 bool match_tags_visitor(const AST_NODE_T* node, void* data);
 
 #endif

package/extension/libherb/parser_helpers.c

@@ -1,20 +1,18 @@
 #include "include/parser_helpers.h"
-#include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
-#include "include/html_util.h"
 #include "include/lexer.h"
 #include "include/parser.h"
 #include "include/token.h"
-#include "include/token_matchers.h"
 #include "include/util/hb_array.h"
 #include "include/util/hb_buffer.h"
 #include "include/util/hb_string.h"
 
+#include <stdarg.h>
 #include <stdio.h>
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name) {
-  token_T* copy = token_copy(tag_name);
+  token_T* copy = token_copy(tag_name, parser->allocator);
   hb_array_push(parser->open_tags_stack, copy);
 }
 
@@ -22,9 +20,9 @@ bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
   if (hb_array_size(parser->open_tags_stack) == 0) { return false; }
 
   token_T* top_token = hb_array_last(parser->open_tags_stack);
-  if (top_token == NULL || top_token->value == NULL) { return false; };
+  if (top_token == NULL || hb_string_is_empty(top_token->value)) { return false; };
 
-  return hb_string_equals_case_insensitive(hb_string(top_token->value), tag_name);
+  return hb_string_equals_case_insensitive(top_token->value, tag_name);
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {
@@ -47,9 +45,8 @@ bool parser_in_svg_context(const parser_T* parser) {
   for (size_t i = 0; i < stack_size; i++) {
     token_T* tag = (token_T*) hb_array_get(parser->open_tags_stack, i);
 
-    if (tag && tag->value) {
-      hb_string_T tag_value_string = hb_string(tag->value);
-      if (hb_string_equals_case_insensitive(tag_value_string, hb_string("svg"))) { return true; }
+    if (tag && !hb_string_is_empty(tag->value)) {
+      if (hb_string_equals_case_insensitive(tag->value, hb_string("svg"))) { return true; }
     }
   }
 
@@ -75,7 +72,7 @@ hb_string_T parser_get_foreign_content_closing_tag(foreign_content_type_T type)
   switch (type) {
     case FOREIGN_CONTENT_SCRIPT: return hb_string("script");
     case FOREIGN_CONTENT_STYLE: return hb_string("style");
-    default: return hb_string("");
+    default: return HB_STRING_EMPTY;
   }
 }
 
@@ -93,24 +90,53 @@ void parser_exit_foreign_content(parser_T* parser) {
   parser->foreign_content_type = FOREIGN_CONTENT_UNKNOWN;
 }
 
-void parser_append_unexpected_error(
+void parser_append_unexpected_error_impl(
   parser_T* parser,
+  hb_array_T* errors,
   const char* description,
-  const char* expected,
-  hb_array_T* errors
+  token_type_T first_token,
+  ...
+) {
+  token_T* token = parser_advance(parser);
+
+  va_list args;
+  va_start(args, first_token);
+  char* expected = token_types_to_friendly_string_valist(parser->allocator, first_token, args);
+  va_end(args);
+
+  append_unexpected_error(
+    hb_string(description),
+    hb_string(expected),
+    token_type_to_friendly_string(token->type),
+    token->location.start,
+    token->location.end,
+    parser->allocator,
+    errors
+  );
+
+  hb_allocator_dealloc(parser->allocator, expected);
+  token_free(token, parser->allocator);
+}
+
+void parser_append_unexpected_error_string(
+  parser_T* parser,
+  hb_array_T* errors,
+  const char* description,
+  const char* expected
 ) {
   token_T* token = parser_advance(parser);
 
   append_unexpected_error(
-    description,
-    expected,
-    token_type_to_string(token->type),
+    hb_string(description),
+    hb_string(expected),
+    token_type_to_friendly_string(token->type),
     token->location.start,
     token->location.end,
+    parser->allocator,
     errors
   );
 
-  token_free(token);
+  token_free(token, parser->allocator);
 }
 
 void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, hb_array_T* errors) {
@@ -119,6 +145,7 @@ void parser_append_unexpected_token_error(parser_T* parser, token_type_T expecte
     parser->current_token,
     parser->current_token->location.start,
     parser->current_token->location.end,
+    parser->allocator,
     errors
   );
 }
@@ -129,13 +156,17 @@ void parser_append_literal_node_from_buffer(
   hb_array_T* children,
   position_T start
 ) {
-  if (hb_buffer_length(buffer) == 0) { return; }
+  if (buffer->length == 0) { return; }
+
+  hb_string_T content = { .data = buffer->value, .length = (uint32_t) buffer->length };
 
   AST_LITERAL_NODE_T* literal =
-    ast_literal_node_init(hb_buffer_value(buffer), start, parser->current_token->location.start, NULL);
+    ast_literal_node_init(content, start, parser->current_token->location.start, NULL, parser->allocator);
 
   if (children != NULL) { hb_array_append(children, literal); }
-  hb_buffer_clear(buffer);
+
+  hb_buffer_free(buffer);
+  hb_buffer_init(buffer, 128, parser->allocator);
 }
 
 token_T* parser_advance(parser_T* parser) {
@@ -155,13 +186,21 @@ token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_t
   if (token == NULL) {
     token = parser_advance(parser);
 
-    append_unexpected_token_error(expected_type, token, token->location.start, token->location.end, array);
+    append_unexpected_token_error(
+      expected_type,
+      token,
+      token->location.start,
+      token->location.end,
+      parser->allocator,
+      array
+    );
   }
 
   return token;
 }
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
+  parser_T* parser,
   AST_HTML_OPEN_TAG_NODE_T* open_tag,
   hb_array_T* body,
   hb_array_T* errors
@@ -170,11 +209,12 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
     open_tag->tag_name,
     open_tag->tag_name->location.start,
     open_tag->tag_name->location.end,
+    parser->allocator,
     errors
   );
 
   return ast_html_element_node_init(
-    open_tag,
+    (AST_NODE_T*) open_tag,
     open_tag->tag_name,
     body,
     NULL,
@@ -182,7 +222,8 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
     ELEMENT_SOURCE_HTML,
     open_tag->base.location.start,
     open_tag->base.location.end,
-    errors
+    errors,
+    parser->allocator
   );
 }
 
@@ -200,6 +241,7 @@ void parser_handle_mismatched_tags(
       actual_tag,
       actual_tag->location.start,
       actual_tag->location.end,
+      parser->allocator,
       errors
     );
   } else {
@@ -207,6 +249,7 @@ void parser_handle_mismatched_tags(
       close_tag->tag_name,
       close_tag->tag_name->location.start,
       close_tag->tag_name->location.end,
+      parser->allocator,
       errors
     );
   }
@@ -219,3 +262,47 @@ bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_t
 
   return hb_string_equals_case_insensitive(expected_tag_name, tag_name);
 }
+
+void parser_synchronize(parser_T* parser, hb_array_T* errors) {
+  (void) errors;
+
+  while (parser->current_token->type != TOKEN_EOF) {
+    token_type_T type = parser->current_token->type;
+
+    if (type == TOKEN_HTML_TAG_START || type == TOKEN_HTML_TAG_START_CLOSE || type == TOKEN_ERB_START
+        || type == TOKEN_HTML_COMMENT_START || type == TOKEN_HTML_DOCTYPE) {
+      return;
+    }
+
+    token_T* skipped = parser_advance(parser);
+    token_free(skipped, parser->allocator);
+  }
+}
+
+bool parser_can_close_ancestor(const parser_T* parser, hb_string_T tag_name) {
+  size_t stack_size = hb_array_size(parser->open_tags_stack);
+
+  for (size_t i = stack_size; i > 0; i--) {
+    token_T* open = hb_array_get(parser->open_tags_stack, i - 1);
+
+    if (open && !hb_string_is_empty(open->value) && hb_string_equals_case_insensitive(open->value, tag_name)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+size_t parser_find_ancestor_depth(const parser_T* parser, hb_string_T tag_name) {
+  size_t stack_size = hb_array_size(parser->open_tags_stack);
+
+  for (size_t i = stack_size; i > 0; i--) {
+    token_T* open = hb_array_get(parser->open_tags_stack, i - 1);
+
+    if (open && !hb_string_is_empty(open->value) && hb_string_equals_case_insensitive(open->value, tag_name)) {
+      return stack_size - i;
+    }
+  }
+
+  return (size_t) -1;
+}

package/extension/libherb/parser_helpers.h

@@ -13,11 +13,21 @@ void parser_push_open_tag(const parser_T* parser, token_T* tag_name);
 bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name);
 token_T* parser_pop_open_tag(const parser_T* parser);
 
-void parser_append_unexpected_error(
+void parser_append_unexpected_error_impl(
   parser_T* parser,
+  hb_array_T* errors,
   const char* description,
-  const char* expected,
-  hb_array_T* errors
+  token_type_T first_token,
+  ...
+);
+#define parser_append_unexpected_error(parser, errors, description, ...)                                               \
+  parser_append_unexpected_error_impl(parser, errors, description, __VA_ARGS__, TOKEN_SENTINEL)
+
+void parser_append_unexpected_error_string(
+  parser_T* parser,
+  hb_array_T* errors,
+  const char* description,
+  const char* expected
 );
 void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, hb_array_T* errors);
 
@@ -44,6 +54,7 @@ token_T* parser_consume_if_present(parser_T* parser, token_type_T type);
 token_T* parser_consume_expected(parser_T* parser, token_type_T type, hb_array_T* array);
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
+  parser_T* parser,
   AST_HTML_OPEN_TAG_NODE_T* open_tag,
   hb_array_T* body,
   hb_array_T* errors
@@ -54,4 +65,9 @@ void parser_handle_mismatched_tags(
   hb_array_T* errors
 );
 
+void parser_synchronize(parser_T* parser, hb_array_T* errors);
+
+bool parser_can_close_ancestor(const parser_T* parser, hb_string_T tag_name);
+size_t parser_find_ancestor_depth(const parser_T* parser, hb_string_T tag_name);
+
 #endif