@herb-tools/node 0.8.10 → 0.9.1

package/extension/libherb/extract.h

@@ -1,19 +1,35 @@
 #ifndef HERB_EXTRACT_H
 #define HERB_EXTRACT_H
 
+#include "util/hb_allocator.h"
 #include "util/hb_buffer.h"
 
+#include <stdbool.h>
+
 typedef enum {
   HERB_EXTRACT_LANGUAGE_RUBY,
   HERB_EXTRACT_LANGUAGE_HTML,
 } herb_extract_language_T;
 
-void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output);
-void herb_extract_html_to_buffer(const char* source, hb_buffer_T* output);
+typedef struct {
+  bool semicolons;
+  bool comments;
+  bool preserve_positions;
+} herb_extract_ruby_options_T;
+
+extern const herb_extract_ruby_options_T HERB_EXTRACT_RUBY_DEFAULT_OPTIONS;
+
+void herb_extract_ruby_to_buffer_with_options(
+  const char* source,
+  hb_buffer_T* output,
+  const herb_extract_ruby_options_T* options,
+  hb_allocator_T* allocator
+);
+void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output, hb_allocator_T* allocator);
+void herb_extract_html_to_buffer(const char* source, hb_buffer_T* output, hb_allocator_T* allocator);
 
-char* herb_extract_ruby_with_semicolons(const char* source);
+char* herb_extract_ruby_with_semicolons(const char* source, hb_allocator_T* allocator);
 
-char* herb_extract(const char* source, herb_extract_language_T language);
-char* herb_extract_from_file(const char* path, herb_extract_language_T language);
+char* herb_extract(const char* source, herb_extract_language_T language, hb_allocator_T* allocator);
 
 #endif

package/extension/libherb/herb.c

@@ -1,21 +1,25 @@
 #include "include/herb.h"
-#include "include/io.h"
+#include "include/analyze/analyze.h"
+#include "include/analyze/prism_annotate.h"
 #include "include/lexer.h"
 #include "include/parser.h"
 #include "include/token.h"
+#include "include/util/hb_allocator.h"
 #include "include/util/hb_array.h"
-#include "include/util/hb_buffer.h"
 #include "include/version.h"
 
 #include <prism.h>
 #include <stdlib.h>
+#include <string.h>
+
+HERB_EXPORTED_FUNCTION hb_array_T* herb_lex(const char* source, hb_allocator_T* allocator) {
+  if (!source) { source = ""; }
 
-HERB_EXPORTED_FUNCTION hb_array_T* herb_lex(const char* source) {
   lexer_T lexer = { 0 };
-  lexer_init(&lexer, source);
+  lexer_init(&lexer, source, allocator);
 
   token_T* token = NULL;
-  hb_array_T* tokens = hb_array_init(128);
+  hb_array_T* tokens = hb_array_init(128, allocator);
 
   while ((token = lexer_next_token(&lexer))->type != TOKEN_EOF) {
     hb_array_append(tokens, token);
@@ -26,15 +30,18 @@ HERB_EXPORTED_FUNCTION hb_array_T* herb_lex(const char* source) {
   return tokens;
 }
 
-HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options) {
+HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(
+  const char* source,
+  const parser_options_T* options,
+  hb_allocator_T* allocator
+) {
   if (!source) { source = ""; }
 
   lexer_T lexer = { 0 };
-  lexer_init(&lexer, source);
+  lexer_init(&lexer, source, allocator);
   parser_T parser = { 0 };
 
   parser_options_T parser_options = HERB_DEFAULT_PARSER_OPTIONS;
-
   if (options != NULL) { parser_options = *options; }
 
   herb_parser_init(&parser, &lexer, parser_options);
@@ -43,40 +50,28 @@ HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(const char* source, parse
 
   herb_parser_deinit(&parser);
 
-  return document;
-}
-
-HERB_EXPORTED_FUNCTION hb_array_T* herb_lex_file(const char* path) {
-  char* source = herb_read_file(path);
-  hb_array_T* tokens = herb_lex(source);
-
-  free(source);
-
-  return tokens;
-}
-
-HERB_EXPORTED_FUNCTION void herb_lex_to_buffer(const char* source, hb_buffer_T* output) {
-  hb_array_T* tokens = herb_lex(source);
-
-  for (size_t i = 0; i < hb_array_size(tokens); i++) {
-    token_T* token = hb_array_get(tokens, i);
-
-    hb_string_T type = token_to_string(token);
-    hb_buffer_append_string(output, type);
-    free(type.data);
-
-    hb_buffer_append(output, "\n");
+  if (parser_options.analyze) { herb_analyze_parse_tree(document, source, &parser_options, allocator); }
+
+  if (parser_options.prism_nodes || parser_options.prism_program) {
+    herb_annotate_prism_nodes(
+      document,
+      source,
+      parser_options.prism_nodes,
+      parser_options.prism_nodes_deep,
+      parser_options.prism_program,
+      allocator
+    );
   }
 
-  herb_free_tokens(&tokens);
+  return document;
 }
 
-HERB_EXPORTED_FUNCTION void herb_free_tokens(hb_array_T** tokens) {
+HERB_EXPORTED_FUNCTION void herb_free_tokens(hb_array_T** tokens, hb_allocator_T* allocator) {
   if (!tokens || !*tokens) { return; }
 
   for (size_t i = 0; i < hb_array_size(*tokens); i++) {
     token_T* token = hb_array_get(*tokens, i);
-    if (token) { token_free(token); }
+    if (token) { token_free(token, allocator); }
   }
 
   hb_array_free(tokens);
@@ -89,3 +84,26 @@ HERB_EXPORTED_FUNCTION const char* herb_version(void) {
 HERB_EXPORTED_FUNCTION const char* herb_prism_version(void) {
   return PRISM_VERSION;
 }
+
+HERB_EXPORTED_FUNCTION herb_ruby_parse_result_T* herb_parse_ruby(const char* source, size_t length) {
+  if (!source) { return NULL; }
+
+  herb_ruby_parse_result_T* result = malloc(sizeof(herb_ruby_parse_result_T));
+  if (!result) { return NULL; }
+
+  memset(&result->options, 0, sizeof(pm_options_t));
+  pm_parser_init(&result->parser, (const uint8_t*) source, length, &result->options);
+  result->root = pm_parse(&result->parser);
+
+  return result;
+}
+
+HERB_EXPORTED_FUNCTION void herb_free_ruby_parse_result(herb_ruby_parse_result_T* result) {
+  if (!result) { return; }
+
+  if (result->root) { pm_node_destroy(&result->parser, result->root); }
+
+  pm_parser_free(&result->parser);
+  pm_options_free(&result->options);
+  free(result);
+}

package/extension/libherb/herb.h

@@ -5,26 +5,38 @@
 #include "extract.h"
 #include "macros.h"
 #include "parser.h"
+#include "util/hb_allocator.h"
 #include "util/hb_array.h"
 #include "util/hb_buffer.h"
 
+#include <prism.h>
+#include <stdbool.h>
 #include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-HERB_EXPORTED_FUNCTION void herb_lex_to_buffer(const char* source, hb_buffer_T* output);
+HERB_EXPORTED_FUNCTION hb_array_T* herb_lex(const char* source, hb_allocator_T* allocator);
 
-HERB_EXPORTED_FUNCTION hb_array_T* herb_lex(const char* source);
-HERB_EXPORTED_FUNCTION hb_array_T* herb_lex_file(const char* path);
-
-HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(const char* source, parser_options_T* options);
+HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(
+  const char* source,
+  const parser_options_T* options,
+  hb_allocator_T* allocator
+);
 
 HERB_EXPORTED_FUNCTION const char* herb_version(void);
 HERB_EXPORTED_FUNCTION const char* herb_prism_version(void);
 
-HERB_EXPORTED_FUNCTION void herb_free_tokens(hb_array_T** tokens);
+typedef struct {
+  pm_parser_t parser;
+  pm_node_t* root;
+  pm_options_t options;
+} herb_ruby_parse_result_T;
+
+HERB_EXPORTED_FUNCTION herb_ruby_parse_result_T* herb_parse_ruby(const char* source, size_t length);
+HERB_EXPORTED_FUNCTION void herb_free_ruby_parse_result(herb_ruby_parse_result_T* result);
+HERB_EXPORTED_FUNCTION void herb_free_tokens(hb_array_T** tokens, hb_allocator_T* allocator);
 
 #ifdef __cplusplus
 }

package/extension/libherb/herb_prism_node.h

@@ -0,0 +1,13 @@
+#ifndef HERB_PRISM_NODE_H
+#define HERB_PRISM_NODE_H
+
+#include <prism.h>
+
+typedef struct {
+  pm_node_t* node;
+  pm_parser_t* parser;
+} herb_prism_node_T;
+
+#define HERB_PRISM_NODE_EMPTY ((herb_prism_node_T) { .node = NULL, .parser = NULL })
+
+#endif

package/extension/libherb/html_util.c

@@ -1,5 +1,5 @@
 #include "include/html_util.h"
-#include "include/util.h"
+#include "include/util/hb_allocator.h"
 #include "include/util/hb_buffer.h"
 #include "include/util/hb_string.h"
 
@@ -10,22 +10,251 @@
 #include <string.h>
 
 // https://developer.mozilla.org/en-US/docs/Glossary/Void_element
+static hb_string_T void_tags[] = HB_STRING_LIST(
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+);
+
+// https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
+static hb_string_T optional_end_tags[] = HB_STRING_LIST(
+  "li",
+  "dt",
+  "dd",
+  "p",
+  "rt",
+  "rp",
+  "optgroup",
+  "option",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "td",
+  "th",
+  "colgroup"
+);
+
+static hb_string_T p_closers[] = HB_STRING_LIST(
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "details",
+  "div",
+  "dl",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "hr",
+  "main",
+  "menu",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "ul"
+);
+
+static hb_string_T p_parent_closers[] = HB_STRING_LIST(
+  "article",
+  "aside",
+  "blockquote",
+  "body",
+  "details",
+  "div",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "header",
+  "main",
+  "nav",
+  "section",
+  "td",
+  "th",
+  "li",
+  "dd",
+  "template"
+);
+
 bool is_void_element(hb_string_T tag_name) {
   if (hb_string_is_empty(tag_name)) { return false; }
 
-  hb_string_T void_tags[14] = {
-    hb_string("area"),  hb_string("base"),   hb_string("br"),    hb_string("col"),  hb_string("embed"),
-    hb_string("hr"),    hb_string("img"),    hb_string("input"), hb_string("link"), hb_string("meta"),
-    hb_string("param"), hb_string("source"), hb_string("track"), hb_string("wbr"),
-  };
-
-  for (size_t i = 0; i < 14; i++) {
+  for (size_t i = 0; i < sizeof(void_tags) / sizeof(void_tags[0]); i++) {
     if (hb_string_equals_case_insensitive(tag_name, void_tags[i])) { return true; }
   }
 
   return false;
 }
 
+bool has_optional_end_tag(hb_string_T tag_name) {
+  if (hb_string_is_empty(tag_name)) { return false; }
+
+  for (size_t i = 0; i < sizeof(optional_end_tags) / sizeof(optional_end_tags[0]); i++) {
+    if (hb_string_equals_case_insensitive(tag_name, optional_end_tags[i])) { return true; }
+  }
+
+  return false;
+}
+
+static bool tag_in_list(hb_string_T tag_name, hb_string_T* list, size_t count) {
+  for (size_t i = 0; i < count; i++) {
+    if (hb_string_equals_case_insensitive(tag_name, list[i])) { return true; }
+  }
+
+  return false;
+}
+
+bool should_implicitly_close(hb_string_T open_tag_name, hb_string_T next_tag_name) {
+  if (hb_string_is_empty(open_tag_name)) { return false; }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("li"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("li"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("dt"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("dt"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("dd"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("dd"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("dd"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("dt"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("p"))) {
+    return tag_in_list(next_tag_name, p_closers, sizeof(p_closers) / sizeof(p_closers[0]));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("rt"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("rt"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("rp"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("rp"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("rp"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("rt"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("optgroup"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("optgroup"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("option"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("option"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("optgroup"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("thead"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("tbody"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("tfoot"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("tbody"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("tbody"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("tfoot"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("tr"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("tr"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("td"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("td"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("th"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("th"))) {
+    return hb_string_equals_case_insensitive(next_tag_name, hb_string("th"))
+        || hb_string_equals_case_insensitive(next_tag_name, hb_string("td"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("colgroup"))) {
+    return !hb_string_equals_case_insensitive(next_tag_name, hb_string("col"));
+  }
+
+  return false;
+}
+
+bool parent_closes_element(hb_string_T open_tag_name, hb_string_T parent_close_tag_name) {
+  if (hb_string_is_empty(open_tag_name)) { return false; }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("li"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("ul"))
+        || hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("ol"))
+        || hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("menu"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("dt"))
+      || hb_string_equals_case_insensitive(open_tag_name, hb_string("dd"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("dl"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("p"))) {
+    return tag_in_list(parent_close_tag_name, p_parent_closers, sizeof(p_parent_closers) / sizeof(p_parent_closers[0]));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("rt"))
+      || hb_string_equals_case_insensitive(open_tag_name, hb_string("rp"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("ruby"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("optgroup"))
+      || hb_string_equals_case_insensitive(open_tag_name, hb_string("option"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("select"))
+        || hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("datalist"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("thead"))
+      || hb_string_equals_case_insensitive(open_tag_name, hb_string("tbody"))
+      || hb_string_equals_case_insensitive(open_tag_name, hb_string("tfoot"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("table"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("tr"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("thead"))
+        || hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("tbody"))
+        || hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("tfoot"))
+        || hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("table"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("td"))
+      || hb_string_equals_case_insensitive(open_tag_name, hb_string("th"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("tr"));
+  }
+
+  if (hb_string_equals_case_insensitive(open_tag_name, hb_string("colgroup"))) {
+    return hb_string_equals_case_insensitive(parent_close_tag_name, hb_string("table"));
+  }
+
+  return false;
+}
+
 /**
  * @brief Creates a closing HTML tag string like "</tag_name>"
  *
@@ -41,9 +270,9 @@ bool is_void_element(hb_string_T tag_name) {
  * free(tag.data);
  * @endcode
  */
-hb_string_T html_closing_tag_string(hb_string_T tag_name) {
+hb_string_T html_closing_tag_string(hb_string_T tag_name, struct hb_allocator* allocator) {
   hb_buffer_T buffer;
-  hb_buffer_init(&buffer, tag_name.length + 3);
+  hb_buffer_init(&buffer, tag_name.length + 3, allocator);
 
   hb_buffer_append_char(&buffer, '<');
   hb_buffer_append_char(&buffer, '/');
@@ -67,9 +296,9 @@ hb_string_T html_closing_tag_string(hb_string_T tag_name) {
  * free(tag);
  * @endcode
  */
-hb_string_T html_self_closing_tag_string(hb_string_T tag_name) {
+hb_string_T html_self_closing_tag_string(hb_string_T tag_name, struct hb_allocator* allocator) {
   hb_buffer_T buffer;
-  hb_buffer_init(&buffer, tag_name.length + 4);
+  hb_buffer_init(&buffer, tag_name.length + 4, allocator);
 
   hb_buffer_append_char(&buffer, '<');
   hb_buffer_append_string(&buffer, tag_name);

package/extension/libherb/html_util.h

@@ -4,9 +4,14 @@
 #include "util/hb_string.h"
 #include <stdbool.h>
 
+struct hb_allocator;
+
 bool is_void_element(hb_string_T tag_name);
+bool has_optional_end_tag(hb_string_T tag_name);
+bool should_implicitly_close(hb_string_T open_tag_name, hb_string_T next_tag_name);
+bool parent_closes_element(hb_string_T open_tag_name, hb_string_T parent_close_tag_name);
 
-hb_string_T html_closing_tag_string(hb_string_T tag_name);
-hb_string_T html_self_closing_tag_string(hb_string_T tag_name);
+hb_string_T html_closing_tag_string(hb_string_T tag_name, struct hb_allocator* allocator);
+hb_string_T html_self_closing_tag_string(hb_string_T tag_name, struct hb_allocator* allocator);
 
 #endif

package/extension/libherb/include/analyze/action_view/attribute_extraction_helpers.h

@@ -0,0 +1,36 @@
+#ifndef ATTRIBUTE_EXTRACTION_HELPERS_H
+#define ATTRIBUTE_EXTRACTION_HELPERS_H
+
+#include "../../util/hb_allocator.h"
+#include "tag_helper_handler.h"
+#include "tag_helpers.h"
+
+#include <prism.h>
+
+AST_HTML_ATTRIBUTE_NODE_T* extract_html_attribute_from_assoc(
+  pm_assoc_node_t* assoc,
+  const uint8_t* source,
+  const char* original_source,
+  size_t erb_content_offset,
+  hb_allocator_T* allocator
+);
+
+hb_array_T* extract_html_attributes_from_keyword_hash(
+  pm_keyword_hash_node_t* kw_hash,
+  const uint8_t* source,
+  const char* original_source,
+  size_t erb_content_offset,
+  hb_allocator_T* allocator
+);
+
+bool has_html_attributes_in_call(pm_call_node_t* call_node);
+
+hb_array_T* extract_html_attributes_from_call_node(
+  pm_call_node_t* call_node,
+  const uint8_t* source,
+  const char* original_source,
+  size_t erb_content_offset,
+  hb_allocator_T* allocator
+);
+
+#endif

package/extension/libherb/include/analyze/action_view/tag_helper_handler.h

@@ -0,0 +1,43 @@
+#ifndef TAG_HELPER_HANDLER_H
+#define TAG_HELPER_HANDLER_H
+
+#include "../../util/hb_allocator.h"
+#include "../../util/hb_array.h"
+#include "../../util/hb_string.h"
+#include <prism.h>
+#include <stdbool.h>
+
+typedef struct {
+  char* tag_name;
+  pm_call_node_t* call_node;
+  hb_array_T* attributes;
+  char* content;
+  bool content_is_ruby_expression;
+  bool has_block;
+  hb_allocator_T* allocator;
+} tag_helper_info_T;
+
+typedef struct {
+  const char* name;
+  hb_string_T source;
+  bool (*detect)(pm_call_node_t* call_node, pm_parser_t* parser);
+  char* (*extract_tag_name)(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator);
+  char* (*extract_content)(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator);
+  hb_array_T* (*extract_attributes)(
+    pm_call_node_t* call_node,
+    const uint8_t* source,
+    const char* original_source,
+    size_t erb_content_offset
+  );
+  bool (*supports_block)(void);
+} tag_helper_handler_T;
+
+tag_helper_info_T* tag_helper_info_init(hb_allocator_T* allocator);
+void tag_helper_info_free(tag_helper_info_T** info);
+
+tag_helper_handler_T* get_tag_helper_handlers(void);
+size_t get_tag_helper_handlers_count(void);
+
+char* extract_inline_block_content(pm_call_node_t* call_node, hb_allocator_T* allocator);
+
+#endif

package/extension/libherb/include/analyze/action_view/tag_helper_node_builders.h

@@ -0,0 +1,70 @@
+#ifndef HERB_ANALYZE_TAG_HELPER_NODE_BUILDERS_H
+#define HERB_ANALYZE_TAG_HELPER_NODE_BUILDERS_H
+
+#include "../../ast_nodes.h"
+#include "../../position.h"
+#include "../../token_struct.h"
+#include "../../util/hb_allocator.h"
+#include "../../util/hb_array.h"
+
+#include <prism.h>
+
+token_T* create_synthetic_token(
+  hb_allocator_T* allocator,
+  const char* value,
+  token_type_T type,
+  position_T start,
+  position_T end
+);
+
+AST_HTML_ATTRIBUTE_NAME_NODE_T* create_attribute_name_node(
+  const char* name_string,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+);
+
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_node(
+  const char* name_string,
+  const char* value_string,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+);
+
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal(
+  const char* name_string,
+  const char* ruby_content,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+);
+
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_interpolated_value(
+  const char* name_string,
+  pm_interpolated_string_node_t* interpolated_node,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+);
+
+hb_array_T* prepend_attribute(hb_array_T* attributes, AST_NODE_T* attribute, hb_allocator_T* allocator);
+
+AST_HTML_ATTRIBUTE_NODE_T* create_href_attribute(
+  const char* href,
+  bool is_ruby_expression,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+);
+
+void append_body_content_node(
+  hb_array_T* body,
+  const char* content,
+  bool is_ruby_expression,
+  position_T start,
+  position_T end,
+  hb_allocator_T* allocator
+);
+
+#endif