herb 0.10.4 → 0.11.0

data/src/extract.c

@@ -11,7 +11,10 @@
 
 const herb_extract_ruby_options_T HERB_EXTRACT_RUBY_DEFAULT_OPTIONS = { .semicolons = true,
                                                                         .comments = false,
-                                                                        .preserve_positions = true };
+                                                                        .preserve_positions = true,
+                                                                        .custom_tags = false,
+                                                                        .erb_openers = NULL,
+                                                                        .erb_opener_count = 0 };
 
 void herb_extract_ruby_to_buffer_with_options(
   const char* source,
@@ -21,7 +24,11 @@ void herb_extract_ruby_to_buffer_with_options(
 ) {
   herb_extract_ruby_options_T extract_options = options ? *options : HERB_EXTRACT_RUBY_DEFAULT_OPTIONS;
 
-  hb_array_T* tokens = herb_lex(source, allocator);
+  parser_options_T lex_options = HERB_DEFAULT_PARSER_OPTIONS;
+  lex_options.erb_openers = extract_options.erb_openers;
+  lex_options.erb_opener_count = extract_options.erb_opener_count;
+
+  hb_array_T* tokens = herb_lex_with_options(source, &lex_options, allocator);
   bool skip_erb_content = false;
   bool is_comment_tag = false;
   bool is_erb_comment_tag = false;
@@ -75,7 +82,7 @@ void herb_extract_ruby_to_buffer_with_options(
             if (extract_options.preserve_positions) { hb_buffer_append_whitespace(output, range_length(token->range)); }
           }
         } else if (hb_string_equals(token->value, hb_string("<%%")) || hb_string_equals(token->value, hb_string("<%%="))
-                   || hb_string_equals(token->value, hb_string("<%graphql"))) {
+                   || (erb_opening_is_custom(token->value) && !extract_options.custom_tags)) {
           skip_erb_content = true;
           is_comment_tag = false;
           if (extract_options.preserve_positions) { hb_buffer_append_whitespace(output, range_length(token->range)); }
@@ -175,9 +182,11 @@ void herb_extract_ruby_to_buffer_with_options(
           } 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);
+            size_t length = range_length(token->range);
+
+            if (length >= 2) { hb_buffer_append_char(output, ' '); }
+            if (length >= 1) { hb_buffer_append_char(output, ';'); }
+            if (length >= 2) { hb_buffer_append_whitespace(output, length - 2); }
           } else {
             hb_buffer_append_whitespace(output, range_length(token->range));
           }
@@ -216,17 +225,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(

data/src/include/analyze/analyze.h

@@ -4,16 +4,26 @@
 #include "../ast/ast_nodes.h"
 #include "../lib/hb_allocator.h"
 #include "../lib/hb_array.h"
+#include "../lib/hb_buffer.h"
 #include "../parser/parser.h"
 #include "analyzed_ruby.h"
 
+typedef struct TAG_HELPER_SCOPE_STRUCT {
+  hb_buffer_T buffer;
+  pm_options_t options;
+  pm_parser_t parser;
+  pm_node_t* root;
+} tag_helper_scope_T;
+
 typedef struct ANALYZE_RUBY_CONTEXT_STRUCT {
   AST_DOCUMENT_NODE_T* document;
   AST_NODE_T* parent;
   hb_array_T* ruby_context_stack;
+  tag_helper_scope_T* tag_helper_scope;
   hb_allocator_T* allocator;
   const char* source;
   bool found_strict_locals;
+  const parser_options_T* options;
 } analyze_ruby_context_T;
 
 typedef enum {
@@ -42,6 +52,7 @@ typedef struct {
   int loop_depth;
   int rescue_depth;
   hb_allocator_T* allocator;
+  const parser_options_T* options;
 } invalid_erb_context_T;
 
 void herb_analyze_parse_errors(

data/src/include/analyze/builders.h

@@ -7,8 +7,24 @@
 #include "../location/position.h"
 #include "analyze.h"
 
+position_T erb_tag_start_position(const token_T* tag_opening, const token_T* content, location_T location);
+position_T erb_tag_end_position(
+  const token_T* tag_closing,
+  const token_T* content,
+  const token_T* tag_opening,
+  location_T location
+);
+
+position_T erb_content_start_position(const AST_ERB_CONTENT_NODE_T* erb_node);
 position_T erb_content_end_position(const AST_ERB_CONTENT_NODE_T* erb_node);
 
+location_T* compute_then_keyword_for_content(
+  token_T* content,
+  analyzed_ruby_T* analyzed_ruby,
+  control_type_t control_type,
+  hb_allocator_T* allocator
+);
+
 location_T* compute_then_keyword(
   AST_ERB_CONTENT_NODE_T* erb_node,
   control_type_t control_type,

data/src/include/analyze/helpers.h

@@ -8,6 +8,7 @@
 #include "../ast/ast_nodes.h"
 #include "../lib/hb_allocator.h"
 #include "../lib/hb_array.h"
+#include "../parser/parser.h"
 #include "analyzed_ruby.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed);
@@ -30,6 +31,9 @@ bool has_unless_node(analyzed_ruby_T* analyzed);
 bool has_yield_node(analyzed_ruby_T* analyzed);
 bool has_then_keyword(analyzed_ruby_T* analyzed);
 bool has_inline_case_condition(analyzed_ruby_T* analyzed);
+bool has_inline_pattern_match(analyzed_ruby_T* analyzed, hb_string_T content);
+bool inline_condition_keyword_offset(const analyzed_ruby_T* analyzed, uint32_t* offset);
+bool control_role_split_offset(const analyzed_ruby_T* analyzed, uint32_t* offset);
 
 bool has_error_message(analyzed_ruby_T* anlayzed, const char* message);
 
@@ -62,7 +66,7 @@ bool search_unexpected_in_nodes(analyzed_ruby_T* analyzed);
 bool search_unexpected_rescue_nodes(analyzed_ruby_T* analyzed);
 bool search_unexpected_when_nodes(analyzed_ruby_T* analyzed);
 
-void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator);
+void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator, const parser_options_T* options);
 
 hb_array_T* extract_parameters_from_prism(
   pm_parameters_node_t* parameters,
@@ -73,10 +77,27 @@ hb_array_T* extract_parameters_from_prism(
   hb_allocator_T* allocator
 );
 
+bool is_erb_output_tag(const AST_ERB_CONTENT_NODE_T* erb_node);
+
+typedef enum {
+  STATIC_OUTPUT_NODE_NONE,
+  STATIC_OUTPUT_NODE_HTML_TEXT,
+  STATIC_OUTPUT_NODE_LITERAL,
+} static_output_node_type_T;
+
+bool append_static_output_node(
+  hb_array_T* statements,
+  const pm_statements_node_t* body,
+  const analyzed_ruby_T* analyzed,
+  position_T content_start,
+  static_output_node_type_T node_type,
+  hb_allocator_T* allocator
+);
+
 hb_array_T* extract_block_arguments_from_erb_node(
   const AST_ERB_CONTENT_NODE_T* erb_node,
   const char* source,
-  hb_array_T* errors,
+  hb_array_T** errors,
   hb_allocator_T* allocator
 );
 

data/src/include/analyze/herb_directive_kinds.h

@@ -0,0 +1,41 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See templates/src/include/analyze/herb_directive_kinds.h.erb
+
+#ifndef HERB_DIRECTIVE_KINDS_H
+#define HERB_DIRECTIVE_KINDS_H
+
+#include <prism.h>
+
+/**
+ * The kind a `herb:state` default gets from the Prism node it parsed into.
+ *
+ * Returns NULL for a node type that has no plain mapping. The caller decides what those become,
+ * since a call node is a bare read or a seed depending on its shape.
+ */
+static inline const char* herb_directive_kind_for_prism_type(pm_node_type_t type) {
+  switch (type) {
+    case PM_TRUE_NODE:
+    case PM_FALSE_NODE: return "boolean";
+
+    case PM_INTEGER_NODE: return "integer";
+
+    case PM_FLOAT_NODE: return "float";
+
+    case PM_STRING_NODE: return "string";
+
+    case PM_SYMBOL_NODE: return "symbol";
+
+    case PM_NIL_NODE: return "nil";
+
+    case PM_ARRAY_NODE: return "array";
+
+    case PM_HASH_NODE:
+    case PM_KEYWORD_HASH_NODE: return "hash";
+
+    case PM_LOCAL_VARIABLE_READ_NODE: return "bare";
+
+    default: return NULL;
+  }
+}
+
+#endif

data/src/include/analyze/herb_directives.h

@@ -0,0 +1,14 @@
+#ifndef HERB_ANALYZE_HERB_DIRECTIVES_H
+#define HERB_ANALYZE_HERB_DIRECTIVES_H
+
+#include "../ast/ast_nodes.h"
+#include "../lib/hb_string.h"
+#include "analyze.h"
+
+#include <prism.h>
+#include <stdbool.h>
+
+bool transform_herb_directive_nodes(const AST_NODE_T* node, void* data);
+hb_string_T herb_directive_kind_for_prism_node(const pm_node_t* node);
+
+#endif

data/src/include/analyze/iteration_nodes.h

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

data/src/include/analyze/prism_annotate.h

@@ -4,12 +4,12 @@
 #include "../ast/ast_nodes.h"
 #include "../lib/hb_allocator.h"
 
+struct PARSER_OPTIONS_STRUCT;
+
 void herb_annotate_prism_nodes(
   AST_DOCUMENT_NODE_T* document,
   const char* source,
-  bool prism_nodes,
-  bool prism_nodes_deep,
-  bool prism_program,
+  const struct PARSER_OPTIONS_STRUCT* options,
   hb_allocator_T* allocator
 );
 

data/src/include/analyze/ternary_conditionals.h

@@ -3,10 +3,12 @@
 
 #include "../ast/ast_nodes.h"
 #include "analyze.h"
+#include "helpers.h"
 
 AST_NODE_T* transform_ternary_expression(
   AST_ERB_CONTENT_NODE_T* erb_node,
   pm_if_node_t* if_node,
+  static_output_node_type_T static_node_type,
   hb_allocator_T* allocator
 );
 

data/src/include/ast/ast_node.h

@@ -16,21 +16,17 @@ void ast_node_init(
   hb_allocator_T* allocator
 );
 void ast_node_free(AST_NODE_T* node, hb_allocator_T* allocator);
+void ast_node_rebase_tokens(AST_NODE_T* node, const char* from, const char* to, size_t length);
 
 AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token, hb_allocator_T* allocator);
 
 size_t ast_node_sizeof(void);
-size_t ast_node_child_count(AST_NODE_T* node);
 
 ast_node_type_T ast_node_type(const AST_NODE_T* node);
 
 void ast_node_set_start(AST_NODE_T* node, position_T position);
 void ast_node_set_end(AST_NODE_T* node, position_T position);
 
-size_t ast_node_errors_count(const AST_NODE_T* node);
-hb_array_T* ast_node_errors(const AST_NODE_T* node);
-void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error);
-
 void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token);
 void ast_node_set_end_from_token(AST_NODE_T* node, const token_T* token);