herb 0.10.4-x86_64-linux-gnu → 0.11.1-x86_64-linux-gnu

data/src/extract.c

@@ -1,9 +1,12 @@
 #include "include/herb.h"
+#include "include/lexer/lexer.h"
+#include "include/lexer/token.h"
 #include "include/lib/hb_allocator.h"
 #include "include/lib/hb_array.h"
 #include "include/lib/hb_buffer.h"
 #include "include/lib/hb_string.h"
 #include "include/lib/string.h"
+#include "include/util/util.h"
 
 #include <assert.h>
 #include <stdlib.h>
@@ -11,188 +14,255 @@
 
 const herb_extract_ruby_options_T HERB_EXTRACT_RUBY_DEFAULT_OPTIONS = { .semicolons = true,
                                                                         .comments = false,
-                                                                        .preserve_positions = true };
-
-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
-) {
-  herb_extract_ruby_options_T extract_options = options ? *options : HERB_EXTRACT_RUBY_DEFAULT_OPTIONS;
-
-  hb_array_T* tokens = herb_lex(source, allocator);
-  bool skip_erb_content = false;
-  bool is_comment_tag = false;
-  bool is_erb_comment_tag = false;
-  bool need_newline = false;
-
-  for (size_t i = 0; i < hb_array_size(tokens); i++) {
-    const token_T* token = hb_array_get(tokens, i);
+                                                                        .preserve_positions = true,
+                                                                        .custom_tags = false,
+                                                                        .erb_openers = NULL,
+                                                                        .erb_opener_count = 0 };
+
+typedef struct {
+  herb_extract_ruby_options_T options;
+  hb_buffer_T* output;
+  bool skip_erb_content;
+  bool is_comment_tag;
+  bool is_erb_comment_tag;
+  bool need_newline;
+} extract_ruby_state_T;
+
+static void extract_ruby_data(extract_ruby_state_T* state, const char* data, uint32_t from, uint32_t to) {
+  uint32_t run_start = from;
+
+  for (uint32_t position = from; position < to; position++) {
+    if (!is_newline(data[position])) { continue; }
+
+    if (state->options.preserve_positions) { hb_buffer_append_whitespace(state->output, position - run_start); }
+
+    hb_buffer_append_char(state->output, data[position]);
+    state->need_newline = false;
+    run_start = position + 1;
+  }
 
-    switch (token->type) {
-      case TOKEN_NEWLINE: {
-        hb_buffer_append_string(output, token->value);
-        need_newline = false;
-        break;
-      }
+  if (state->options.preserve_positions) { hb_buffer_append_whitespace(state->output, to - run_start); }
+}
 
-      case TOKEN_ERB_START: {
-        is_erb_comment_tag = hb_string_equals(token->value, hb_string("<%#"));
+static void extract_ruby_token(extract_ruby_state_T* state, const token_T* token, const token_T* next) {
+  switch (token->type) {
+    case TOKEN_NEWLINE: {
+      hb_buffer_append_string(state->output, token->value);
+      state->need_newline = false;
+      break;
+    }
 
-        if (is_erb_comment_tag) {
-          if (extract_options.comments) {
-            skip_erb_content = false;
-            is_comment_tag = false;
+    case TOKEN_ERB_START: {
+      state->is_erb_comment_tag = hb_string_equals(token->value, hb_string("<%#"));
 
-            if (extract_options.preserve_positions) {
-              bool is_multiline = false;
+      if (state->is_erb_comment_tag) {
+        if (state->options.comments) {
+          state->skip_erb_content = false;
+          state->is_comment_tag = false;
 
-              if (i + 1 < hb_array_size(tokens)) {
-                const token_T* next = hb_array_get(tokens, i + 1);
+          if (state->options.preserve_positions) {
+            bool is_multiline = false;
 
-                if (next->type == TOKEN_ERB_CONTENT && !hb_string_is_null(next->value)
-                    && memchr(next->value.data, '\n', next->value.length) != NULL) {
-                  is_multiline = true;
-                }
-              }
+            if (next && next->type == TOKEN_ERB_CONTENT && !hb_string_is_null(next->value)
+                && memchr(next->value.data, '\n', next->value.length) != NULL) {
+              is_multiline = true;
+            }
 
-              if (is_multiline) {
-                hb_buffer_append_char(output, '#');
-                hb_buffer_append_whitespace(output, 2);
-              } else {
-                hb_buffer_append_whitespace(output, 2);
-                hb_buffer_append_char(output, '#');
-              }
+            if (is_multiline) {
+              hb_buffer_append_char(state->output, '#');
+              hb_buffer_append_whitespace(state->output, 2);
             } else {
-              if (need_newline) { hb_buffer_append_char(output, '\n'); }
-              hb_buffer_append_char(output, '#');
-              need_newline = true;
+              hb_buffer_append_whitespace(state->output, 2);
+              hb_buffer_append_char(state->output, '#');
             }
           } else {
-            skip_erb_content = true;
-            is_comment_tag = true;
-            if (extract_options.preserve_positions) { hb_buffer_append_whitespace(output, range_length(token->range)); }
+            if (state->need_newline) { hb_buffer_append_char(state->output, '\n'); }
+            hb_buffer_append_char(state->output, '#');
+            state->need_newline = true;
           }
-        } else if (hb_string_equals(token->value, hb_string("<%%")) || hb_string_equals(token->value, hb_string("<%%="))
-                   || hb_string_equals(token->value, hb_string("<%graphql"))) {
-          skip_erb_content = true;
-          is_comment_tag = false;
-          if (extract_options.preserve_positions) { hb_buffer_append_whitespace(output, range_length(token->range)); }
         } else {
-          skip_erb_content = false;
-          is_comment_tag = false;
-
-          if (extract_options.preserve_positions) {
-            hb_buffer_append_whitespace(output, range_length(token->range));
-          } else if (need_newline) {
-            hb_buffer_append_char(output, '\n');
-            need_newline = false;
+          state->skip_erb_content = true;
+          state->is_comment_tag = true;
+          if (state->options.preserve_positions) {
+            hb_buffer_append_whitespace(state->output, range_length(token->range));
           }
         }
-
-        break;
+      } else if (hb_string_equals(token->value, hb_string("<%%")) || hb_string_equals(token->value, hb_string("<%%="))
+                 || (erb_opening_is_custom(token->value) && !state->options.custom_tags)) {
+        state->skip_erb_content = true;
+        state->is_comment_tag = false;
+        if (state->options.preserve_positions) {
+          hb_buffer_append_whitespace(state->output, range_length(token->range));
+        }
+      } else {
+        state->skip_erb_content = false;
+        state->is_comment_tag = false;
+
+        if (state->options.preserve_positions) {
+          hb_buffer_append_whitespace(state->output, range_length(token->range));
+        } else if (state->need_newline) {
+          hb_buffer_append_char(state->output, '\n');
+          state->need_newline = false;
+        }
       }
 
-      case TOKEN_ERB_CONTENT: {
-        if (skip_erb_content == false) {
-          bool is_inline_comment = false;
+      break;
+    }
 
-          if (!extract_options.comments && !is_comment_tag && !hb_string_is_empty(token->value)) {
-            hb_string_T trimmed = hb_string_trim_start(token->value);
+    case TOKEN_ERB_CONTENT: {
+      if (state->skip_erb_content == false) {
+        bool is_inline_comment = false;
 
-            if (!hb_string_is_empty(trimmed) && trimmed.data[0] == '#'
-                && token->location.start.line == token->location.end.line) {
-              is_comment_tag = true;
-              is_inline_comment = true;
-            }
-          }
+        if (!state->options.comments && !state->is_comment_tag && !hb_string_is_empty(token->value)) {
+          hb_string_T trimmed = hb_string_trim_start(token->value);
 
-          if (is_inline_comment) {
-            if (extract_options.preserve_positions) { hb_buffer_append_whitespace(output, range_length(token->range)); }
-          } else if (is_erb_comment_tag && !hb_string_is_null(token->value)) {
-            const char* content = token->value.data;
-            size_t content_remaining = token->value.length;
+          if (!hb_string_is_empty(trimmed) && trimmed.data[0] == '#'
+              && token->location.start.line == token->location.end.line) {
+            state->is_comment_tag = true;
+            is_inline_comment = true;
+          }
+        }
 
-            while (content_remaining > 0) {
-              if (*content == '\n') {
-                hb_buffer_append_char(output, '\n');
-                content++;
-                content_remaining--;
+        if (is_inline_comment) {
+          if (state->options.preserve_positions) {
+            hb_buffer_append_whitespace(state->output, range_length(token->range));
+          }
+        } else if (state->is_erb_comment_tag && !hb_string_is_null(token->value)) {
+          const char* content = token->value.data;
+          size_t content_remaining = token->value.length;
 
-                if (content_remaining > 0 && extract_options.preserve_positions && *content == ' ') {
-                  content++;
-                  content_remaining--;
-                }
+          while (content_remaining > 0) {
+            if (*content == '\n') {
+              hb_buffer_append_char(state->output, '\n');
+              content++;
+              content_remaining--;
 
-                hb_buffer_append_char(output, '#');
-              } else {
-                hb_buffer_append_char(output, *content);
+              if (content_remaining > 0 && state->options.preserve_positions && *content == ' ') {
                 content++;
                 content_remaining--;
               }
-            }
-
-            if (!extract_options.preserve_positions) { need_newline = true; }
-          } else {
-            hb_buffer_append_string(output, token->value);
-
-            if (!extract_options.preserve_positions) { need_newline = true; }
-          }
-        } else {
-          if (is_erb_comment_tag && extract_options.preserve_positions && !hb_string_is_null(token->value)) {
-            const char* content = token->value.data;
-            size_t content_remaining = token->value.length;
-
-            while (content_remaining > 0) {
-              if (*content == '\n') {
-                hb_buffer_append_char(output, '\n');
-              } else {
-                hb_buffer_append_char(output, ' ');
-              }
 
+              hb_buffer_append_char(state->output, '#');
+            } else {
+              hb_buffer_append_char(state->output, *content);
               content++;
               content_remaining--;
             }
-          } else if (extract_options.preserve_positions) {
-            hb_buffer_append_whitespace(output, range_length(token->range));
           }
-        }
 
-        break;
-      }
+          if (!state->options.preserve_positions) { state->need_newline = true; }
+        } else {
+          hb_buffer_append_string(state->output, token->value);
 
-      case TOKEN_ERB_END: {
-        bool was_comment = is_comment_tag;
-        bool was_erb_comment = is_erb_comment_tag;
-        skip_erb_content = false;
-        is_comment_tag = false;
-        is_erb_comment_tag = false;
-
-        if (extract_options.preserve_positions) {
-          if (was_comment) {
-            hb_buffer_append_whitespace(output, range_length(token->range));
-          } else if (was_erb_comment && extract_options.comments) {
-            hb_buffer_append_whitespace(output, range_length(token->range));
-          } else if (extract_options.semicolons) {
-            hb_buffer_append_char(output, ' ');
-            hb_buffer_append_char(output, ';');
-            hb_buffer_append_whitespace(output, range_length(token->range) - 2);
-          } else {
-            hb_buffer_append_whitespace(output, range_length(token->range));
-          }
+          if (!state->options.preserve_positions) { state->need_newline = true; }
         }
+      } else {
+        if (state->is_erb_comment_tag && state->options.preserve_positions && !hb_string_is_null(token->value)) {
+          const char* content = token->value.data;
+          size_t content_remaining = token->value.length;
+
+          while (content_remaining > 0) {
+            if (*content == '\n') {
+              hb_buffer_append_char(state->output, '\n');
+            } else {
+              hb_buffer_append_char(state->output, ' ');
+            }
 
-        break;
+            content++;
+            content_remaining--;
+          }
+        } else if (state->options.preserve_positions) {
+          hb_buffer_append_whitespace(state->output, range_length(token->range));
+        }
       }
 
-      default: {
-        if (extract_options.preserve_positions) { hb_buffer_append_whitespace(output, range_length(token->range)); }
+      break;
+    }
+
+    case TOKEN_ERB_END: {
+      bool was_comment = state->is_comment_tag;
+      bool was_erb_comment = state->is_erb_comment_tag;
+      state->skip_erb_content = false;
+      state->is_comment_tag = false;
+      state->is_erb_comment_tag = false;
+
+      if (state->options.preserve_positions) {
+        if (was_comment) {
+          hb_buffer_append_whitespace(state->output, range_length(token->range));
+        } else if (was_erb_comment && state->options.comments) {
+          hb_buffer_append_whitespace(state->output, range_length(token->range));
+        } else if (state->options.semicolons) {
+          size_t length = range_length(token->range);
+
+          if (length >= 2) { hb_buffer_append_char(state->output, ' '); }
+          if (length >= 1) { hb_buffer_append_char(state->output, ';'); }
+          if (length >= 2) { hb_buffer_append_whitespace(state->output, length - 2); }
+        } else {
+          hb_buffer_append_whitespace(state->output, range_length(token->range));
+        }
       }
+
+      break;
+    }
+
+    default: {
+      if (state->options.preserve_positions) { hb_buffer_append_whitespace(state->output, range_length(token->range)); }
     }
   }
+}
 
-  herb_free_tokens(&tokens, allocator);
+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
+) {
+  extract_ruby_state_T state = {
+    .options = options ? *options : HERB_EXTRACT_RUBY_DEFAULT_OPTIONS,
+    .output = output,
+    .skip_erb_content = false,
+    .is_comment_tag = false,
+    .is_erb_comment_tag = false,
+    .need_newline = false,
+  };
+
+  parser_options_T lex_options = HERB_DEFAULT_PARSER_OPTIONS;
+  lex_options.erb_openers = state.options.erb_openers;
+  lex_options.erb_opener_count = state.options.erb_opener_count;
+
+  lexer_T lexer = { 0 };
+  lexer_init(&lexer, source ? source : "", allocator);
+  lexer_apply_erb_openers(&lexer, &lex_options);
+
+  const char* data = lexer.source.data;
+  uint32_t length = (uint32_t) lexer.source.length;
+  token_T* pending = NULL;
+
+  while (true) {
+    if (!pending && lexer.state == STATE_DATA) {
+      uint32_t position = lexer.current_position;
+
+      while (position < length && !(data[position] == '<' && data[position + 1] == '%')) {
+        position++;
+      }
+
+      extract_ruby_data(&state, data, lexer.current_position, position);
+      lexer_skip_data_to(&lexer, position);
+    }
+
+    token_T* token = pending ? pending : lexer_next_token(&lexer);
+    pending = NULL;
+
+    if (token->type == TOKEN_EOF) {
+      token_free(token, allocator);
+      break;
+    }
+
+    if (token->type == TOKEN_ERB_START) { pending = lexer_next_token(&lexer); }
+
+    extract_ruby_token(&state, token, pending);
+    token_free(token, allocator);
+  }
 }
 
 void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output, hb_allocator_T* allocator) {
@@ -216,17 +286,30 @@ void herb_extract_html_to_buffer(const char* source, hb_buffer_T* output, hb_all
   herb_free_tokens(&tokens, allocator);
 }
 
-char* herb_extract_ruby_with_semicolons(const char* source, hb_allocator_T* allocator) {
+char* herb_extract_ruby_with_semicolons_and_openers(
+  const char* source,
+  const hb_string_T* erb_openers,
+  size_t erb_opener_count,
+  hb_allocator_T* allocator
+) {
   if (!source) { return NULL; }
 
   hb_buffer_T output;
   hb_buffer_init(&output, strlen(source), allocator);
 
-  herb_extract_ruby_to_buffer(source, &output, allocator);
+  herb_extract_ruby_options_T extract_options = HERB_EXTRACT_RUBY_DEFAULT_OPTIONS;
+  extract_options.erb_openers = erb_openers;
+  extract_options.erb_opener_count = erb_opener_count;
+
+  herb_extract_ruby_to_buffer_with_options(source, &output, &extract_options, allocator);
 
   return output.value;
 }
 
+char* herb_extract_ruby_with_semicolons(const char* source, hb_allocator_T* allocator) {
+  return herb_extract_ruby_with_semicolons_and_openers(source, NULL, 0, allocator);
+}
+
 char* herb_extract(const char* source, const herb_extract_language_T language, hb_allocator_T* allocator) {
   if (!source) { return NULL; }
 

data/src/herb.c

@@ -8,16 +8,22 @@
 #include "include/lib/hb_array.h"
 #include "include/parser/parser.h"
 #include "include/version.h"
+#include "include/visitor.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) {
+HERB_EXPORTED_FUNCTION hb_array_T* herb_lex_with_options(
+  const char* source,
+  const parser_options_T* options,
+  hb_allocator_T* allocator
+) {
   if (!source) { source = ""; }
 
   lexer_T lexer = { 0 };
   lexer_init(&lexer, source, allocator);
+  lexer_apply_erb_openers(&lexer, options);
 
   token_T* token = NULL;
   hb_array_T* tokens = hb_array_init(128, allocator);
@@ -31,6 +37,18 @@ HERB_EXPORTED_FUNCTION hb_array_T* herb_lex(const char* source, hb_allocator_T*
   return tokens;
 }
 
+HERB_EXPORTED_FUNCTION hb_array_T* herb_lex(const char* source, hb_allocator_T* allocator) {
+  return herb_lex_with_options(source, NULL, allocator);
+}
+
+static bool herb_count_node_errors(const AST_NODE_T* node, void* data) {
+  if (node == NULL) { return false; }
+
+  if (node->errors != NULL) { *((uint32_t*) data) += (uint32_t) hb_array_size(node->errors); }
+
+  return true;
+}
+
 HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(
   const char* source,
   const parser_options_T* options,
@@ -46,7 +64,7 @@ HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(
   if (options != NULL) { parser_options = *options; }
 
   uint32_t error_count = 0;
-  parser_options.error_count = &error_count;
+  if (parser_options.error_count == NULL) { parser_options.error_count = &error_count; }
 
   parser_options_set_deadline(&parser_options);
 
@@ -60,6 +78,8 @@ HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(
     lexer.previous_column = parser_options.start_column;
   }
 
+  lexer_apply_erb_openers(&lexer, &parser_options);
+
   herb_parser_init(&parser, &lexer, parser_options);
 
   AST_DOCUMENT_NODE_T* document = herb_parser_parse(&parser);
@@ -68,15 +88,13 @@ HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(
 
   if (parser_options.analyze) { herb_analyze_parse_tree(document, source, &parser_options, allocator); }
 
+  if (parser_options.error_count != NULL) {
+    *parser_options.error_count = 0;
+    herb_visit_node((AST_NODE_T*) document, herb_count_node_errors, parser_options.error_count);
+  }
+
   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_annotate_prism_nodes(document, source, &parser_options, allocator);
   }
 
   if (parser_options_past_deadline(&parser_options)) {
@@ -85,7 +103,8 @@ HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(
       document->base.location.start,
       document->base.location.end,
       allocator,
-      document->base.errors
+      &document->base.errors,
+      options
     );
   }
 

data/src/include/analyze/action_view/attribute_extraction_helpers.h

@@ -7,7 +7,7 @@
 
 #include <prism.h>
 
-AST_HTML_ATTRIBUTE_NODE_T* extract_html_attribute_from_assoc(
+AST_NODE_T* extract_html_attribute_from_assoc(
   pm_assoc_node_t* assoc,
   const uint8_t* source,
   const char* original_source,

data/src/include/analyze/action_view/helper_registry.h

@@ -1,5 +1,5 @@
 // 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/include/analyze/action_view/helper_registry.h.erb
+// be modified manually. See templates/src/include/analyze/action_view/helper_registry.h.erb
 
 #ifndef HELPER_REGISTRY_H
 #define HELPER_REGISTRY_H
@@ -109,8 +109,9 @@ typedef enum {
   HELPER_TIME_SELECT,
   HELPER_TIME_TAG,
   HELPER_DEBUG,
-  HELPER_APPLY_FORM_FOR_OPTIONS_BANG,
   HELPER_BUTTON,
+  HELPER_SUBMIT,
+  HELPER_APPLY_FORM_FOR_OPTIONS_BANG,
   HELPER_CHECKBOX,
   HELPER_COLOR_FIELD,
   HELPER_DATE_FIELD,
@@ -134,7 +135,6 @@ typedef enum {
   HELPER_RADIO_BUTTON,
   HELPER_RANGE_FIELD,
   HELPER_SEARCH_FIELD,
-  HELPER_SUBMIT,
   HELPER_TELEPHONE_FIELD,
   HELPER_TEXT_FIELD,
   HELPER_TEXTAREA,
@@ -238,6 +238,11 @@ typedef enum {
   HELPER_PHONE_TO,
   HELPER_SMS_TO,
   HELPER_URL_FOR,
+  HELPER_JAVASCRIPT_IMPORT_MODULE_TAG,
+  HELPER_JAVASCRIPT_IMPORTMAP_MODULE_PRELOAD_TAGS,
+  HELPER_JAVASCRIPT_IMPORTMAP_TAGS,
+  HELPER_JAVASCRIPT_INLINE_IMPORTMAP_TAG,
+  HELPER_JAVASCRIPT_MODULE_PRELOAD_TAG,
   HELPER_TURBO_EXEMPTS_PAGE_FROM_CACHE,
   HELPER_TURBO_EXEMPTS_PAGE_FROM_CACHE_TAG,
   HELPER_TURBO_EXEMPTS_PAGE_FROM_PREVIEW,
@@ -255,7 +260,7 @@ typedef enum {
   HELPER_TURBO_STREAM_FROM,
 } helper_type_T;
 
-#define HELPER_COUNT 243
+#define HELPER_COUNT 248
 
 typedef enum {
   HELPER_DETECT_CALL_NAME,
@@ -275,6 +280,13 @@ typedef struct {
   const char* description;
 } helper_option_T;
 
+typedef struct {
+  const char* name;
+  const char* type;
+  bool optional;
+  const char* description;
+} helper_block_argument_T;
+
 typedef struct {
   const char* name;
   const char* source;
@@ -282,6 +294,14 @@ typedef struct {
   const char* wrapper;
 } helper_implicit_attribute_T;
 
+typedef struct {
+  const char* source;
+  int arg_position;
+  bool skip_if_hash;
+  bool to_s_suffix_when_single;
+  int positional_arguments_with_block;
+} helper_content_T;
+
 typedef enum {
   HELPER_OUTPUT_HTML,
   HELPER_OUTPUT_TEXT,
@@ -299,6 +319,7 @@ typedef struct {
   const char* gem;
   helper_output_T output;
   const char* visibility;
+  const char* receiver;
   const char* tag_name;
   bool is_void;
   bool supports_block;
@@ -309,10 +330,13 @@ typedef struct {
   const char* signature;
   const char* documentation_url;
   const helper_implicit_attribute_T* implicit_attribute;
+  const helper_content_T* content;
   const helper_argument_T* arguments;
   size_t arguments_count;
   const helper_option_T* options;
   size_t options_count;
+  const helper_block_argument_T* block_arguments;
+  size_t block_arguments_count;
 } helper_registry_entry_T;
 
 const helper_registry_entry_T* helper_registry_get(helper_type_T type);

data/src/include/analyze/action_view/tag_helper_handler.h

@@ -35,7 +35,7 @@ typedef struct {
 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);
+const tag_helper_handler_T* const* 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);

data/src/include/analyze/action_view/tag_helper_node_builders.h

@@ -77,6 +77,13 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal_precise(
   hb_allocator_T* allocator
 );
 
+AST_NODE_T* create_conditional_boolean_attribute(
+  const char* name_string,
+  const char* condition_source,
+  attribute_positions_T* positions,
+  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(