herb 0.9.4-arm-linux-gnu → 0.9.6-arm-linux-gnu

data/src/analyze/action_view/image_tag.c

@@ -1,26 +1,10 @@
+#include "../../include/lib/hb_allocator.h"
+#include "../../include/lib/hb_buffer.h"
+
 #include <prism.h>
 #include <stdbool.h>
-#include <stdlib.h>
 #include <string.h>
 
-#include "../../include/analyze/action_view/tag_helper_handler.h"
-#include "../../include/lib/hb_buffer.h"
-
-bool detect_image_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
-  if (!call_node || !call_node->name) { return false; }
-
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
-  return constant && constant->length == 9 && strncmp((const char*) constant->start, "image_tag", 9) == 0;
-}
-
-char* extract_image_tag_name(pm_call_node_t* _call_node, pm_parser_t* _parser, hb_allocator_T* allocator) {
-  return hb_allocator_strdup(allocator, "img");
-}
-
-char* extract_image_tag_content(pm_call_node_t* _call_node, pm_parser_t* _parser, hb_allocator_T* _allocator) {
-  return NULL;
-}
-
 char* extract_image_tag_src(pm_call_node_t* call_node, pm_parser_t* _parser, hb_allocator_T* allocator) {
   if (!call_node || !call_node->arguments) { return NULL; }
 
@@ -37,6 +21,7 @@ char* extract_image_tag_src(pm_call_node_t* call_node, pm_parser_t* _parser, hb_
   }
 
   size_t source_length = first_argument->location.end - first_argument->location.start;
+
   return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
 }
 
@@ -73,15 +58,3 @@ char* wrap_in_image_path(
 
   return result;
 }
-
-bool image_tag_supports_block(void) {
-  return false;
-}
-
-const tag_helper_handler_T image_tag_handler = { .name = "image_tag",
-                                                 .source =
-                                                   HB_STRING_LITERAL("ActionView::Helpers::AssetTagHelper#image_tag"),
-                                                 .detect = detect_image_tag,
-                                                 .extract_tag_name = extract_image_tag_name,
-                                                 .extract_content = extract_image_tag_content,
-                                                 .supports_block = image_tag_supports_block };

data/src/analyze/action_view/javascript_include_tag.c

@@ -1,38 +1,10 @@
-#include "../../include/analyze/action_view/tag_helper_handler.h"
+#include "../../include/lib/hb_allocator.h"
 #include "../../include/lib/hb_buffer.h"
 
 #include <prism.h>
 #include <stdbool.h>
-#include <stdlib.h>
 #include <string.h>
 
-bool detect_javascript_include_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
-  if (!call_node || !call_node->name) { return false; }
-
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
-  return constant && constant->length == 22
-      && strncmp((const char*) constant->start, "javascript_include_tag", 22) == 0;
-}
-
-char* extract_javascript_include_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
-  (void) call_node;
-  (void) parser;
-
-  return hb_allocator_strdup(allocator, "script");
-}
-
-char* extract_javascript_include_tag_content(
-  pm_call_node_t* call_node,
-  pm_parser_t* parser,
-  hb_allocator_T* allocator
-) {
-  (void) call_node;
-  (void) parser;
-  (void) allocator;
-
-  return NULL;
-}
-
 char* extract_javascript_include_tag_src(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   (void) parser;
 
@@ -87,16 +59,3 @@ char* wrap_in_javascript_path(
 
   return result;
 }
-
-bool javascript_include_tag_supports_block(void) {
-  return false;
-}
-
-const tag_helper_handler_T javascript_include_tag_handler = {
-  .name = "javascript_include_tag",
-  .source = HB_STRING_LITERAL("ActionView::Helpers::AssetTagHelper#javascript_include_tag"),
-  .detect = detect_javascript_include_tag,
-  .extract_tag_name = extract_javascript_include_tag_name,
-  .extract_content = extract_javascript_include_tag_content,
-  .supports_block = javascript_include_tag_supports_block
-};

data/src/analyze/action_view/javascript_tag.c

@@ -1,55 +1,41 @@
-#include "../../include/analyze/action_view/tag_helper_handler.h"
+#include "../../include/analyze/action_view/tag_helper_node_builders.h"
+#include "../../include/ast/ast_nodes.h"
+#include "../../include/lib/hb_array.h"
+#include "../../include/lib/hb_string.h"
+#include "../../include/visitor.h"
 
-#include <prism.h>
 #include <stdbool.h>
 #include <stdlib.h>
-#include <string.h>
 
-bool detect_javascript_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
-  if (!call_node || !call_node->name) { return false; }
+bool wrap_javascript_tag_body_visitor(const AST_NODE_T* node, void* data) {
+  hb_allocator_T* allocator = (hb_allocator_T*) data;
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
-  return constant && constant->length == 14 && strncmp((const char*) constant->start, "javascript_tag", 14) == 0;
-}
-
-char* extract_javascript_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
-  (void) call_node;
-  (void) parser;
+  if (node == NULL || node->type != AST_HTML_ELEMENT_NODE) { return true; }
 
-  return hb_allocator_strdup(allocator, "script");
-}
+  AST_HTML_ELEMENT_NODE_T* element = (AST_HTML_ELEMENT_NODE_T*) node;
 
-char* extract_javascript_tag_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
-  (void) parser;
-
-  if (!call_node || !call_node->arguments) { return NULL; }
+  if (!hb_string_equals(element->element_source, hb_string("ActionView::Helpers::JavaScriptHelper#javascript_tag"))) {
+    return true;
+  }
 
-  pm_arguments_node_t* arguments = call_node->arguments;
-  if (!arguments->arguments.size) { return NULL; }
+  if (element->body == NULL || hb_array_size(element->body) == 0) { return false; }
 
-  pm_node_t* first_argument = arguments->arguments.nodes[0];
+  for (size_t i = 0; i < hb_array_size(element->body); i++) {
+    AST_NODE_T* child = (AST_NODE_T*) hb_array_get(element->body, i);
+    if (child && child->type == AST_CDATA_NODE) { return false; }
+  }
 
-  if (first_argument->type == PM_KEYWORD_HASH_NODE) { return NULL; }
+  hb_array_T* cdata_children = hb_array_init(hb_array_size(element->body), allocator);
 
-  if (first_argument->type == PM_STRING_NODE) {
-    pm_string_node_t* string_node = (pm_string_node_t*) first_argument;
-    size_t length = pm_string_length(&string_node->unescaped);
-    return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+  for (size_t i = 0; i < hb_array_size(element->body); i++) {
+    hb_array_append(cdata_children, hb_array_get(element->body, i));
   }
 
-  size_t source_length = first_argument->location.end - first_argument->location.start;
-  return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
-}
+  AST_CDATA_NODE_T* cdata_node =
+    create_javascript_cdata_node(cdata_children, element->base.location.start, element->base.location.end, allocator);
 
-bool javascript_tag_supports_block(void) {
-  return true;
-}
+  element->body->size = 0;
+  hb_array_append(element->body, (AST_NODE_T*) cdata_node);
 
-const tag_helper_handler_T javascript_tag_handler = {
-  .name = "javascript_tag",
-  .source = HB_STRING_LITERAL("ActionView::Helpers::JavaScriptHelper#javascript_tag"),
-  .detect = detect_javascript_tag,
-  .extract_tag_name = extract_javascript_tag_name,
-  .extract_content = extract_javascript_tag_content,
-  .supports_block = javascript_tag_supports_block
-};
+  return false;
+}

data/src/analyze/action_view/registry.c

@@ -5,7 +5,7 @@
 #include <stdlib.h>
 
 extern const tag_helper_handler_T content_tag_handler;
-extern const tag_helper_handler_T tag_dot_handler;
+extern const tag_helper_handler_T tag_handler;
 extern const tag_helper_handler_T link_to_handler;
 extern const tag_helper_handler_T turbo_frame_tag_handler;
 extern const tag_helper_handler_T javascript_tag_handler;
@@ -49,7 +49,7 @@ tag_helper_handler_T* get_tag_helper_handlers(void) {
 
   if (!initialized) {
     static_handlers[0] = content_tag_handler;
-    static_handlers[1] = tag_dot_handler;
+    static_handlers[1] = tag_handler;
     static_handlers[2] = link_to_handler;
     static_handlers[3] = turbo_frame_tag_handler;
     static_handlers[4] = javascript_tag_handler;

data/src/analyze/action_view/tag_helper_node_builders.c

@@ -124,7 +124,7 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_node_precise(
       open_quote,
       value_children,
       close_quote,
-      positions->quoted,
+      true,
       positions->value_start,
       positions->value_end,
       hb_array_init(0, allocator),
@@ -179,7 +179,7 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal_precise(
     NULL,
     value_children,
     NULL,
-    false,
+    true,
     positions->content_start,
     positions->content_end,
     hb_array_init(0, allocator),
@@ -385,3 +385,24 @@ void append_body_content_node(
     if (text_node) { hb_array_append(body, (AST_NODE_T*) text_node); }
   }
 }
+
+AST_CDATA_NODE_T* create_javascript_cdata_node(
+  hb_array_T* children,
+  position_T start,
+  position_T end,
+  hb_allocator_T* allocator
+) {
+  token_T* cdata_opening = create_synthetic_token(allocator, "\n//<![CDATA[\n", TOKEN_CDATA_START, start, end);
+
+  token_T* cdata_closing = create_synthetic_token(allocator, "\n//]]>\n", TOKEN_CDATA_END, start, end);
+
+  return ast_cdata_node_init(
+    cdata_opening,
+    children,
+    cdata_closing,
+    start,
+    end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+}

data/src/analyze/action_view/tag_helpers.c

@@ -45,8 +45,6 @@ typedef struct {
   const tag_helper_handler_T* matched_handler;
   const char* original_source;
   size_t erb_content_offset;
-  char* condition_source;
-  char* condition_type;
 } tag_helper_parse_context_T;
 
 static tag_helper_parse_context_T* parse_tag_helper_content(
@@ -76,15 +74,12 @@ static tag_helper_parse_context_T* parse_tag_helper_content(
   }
 
   parse_context->info = tag_helper_info_init(allocator);
-  parse_context->condition_source = NULL;
-  parse_context->condition_type = NULL;
 
   tag_helper_search_data_T search = { .tag_helper_node = NULL,
                                       .source = parse_context->prism_source,
                                       .parser = &parse_context->parser,
                                       .info = parse_context->info,
-                                      .found = false,
-                                      .postfix_conditional_node = NULL };
+                                      .found = false };
   pm_visit_node(parse_context->root, search_tag_helper_node, &search);
 
   if (!search.found) {
@@ -96,22 +91,6 @@ static tag_helper_parse_context_T* parse_tag_helper_content(
     return NULL;
   }
 
-  if (search.postfix_conditional_node) {
-    if (search.postfix_conditional_node->type == PM_IF_NODE) {
-      pm_if_node_t* if_node = (pm_if_node_t*) search.postfix_conditional_node;
-      size_t predicate_length = if_node->predicate->location.end - if_node->predicate->location.start;
-      parse_context->condition_source =
-        hb_allocator_strndup(allocator, (const char*) if_node->predicate->location.start, predicate_length);
-      parse_context->condition_type = hb_allocator_strdup(allocator, "if");
-    } else if (search.postfix_conditional_node->type == PM_UNLESS_NODE) {
-      pm_unless_node_t* unless_node = (pm_unless_node_t*) search.postfix_conditional_node;
-      size_t predicate_length = unless_node->predicate->location.end - unless_node->predicate->location.start;
-      parse_context->condition_source =
-        hb_allocator_strndup(allocator, (const char*) unless_node->predicate->location.start, predicate_length);
-      parse_context->condition_type = hb_allocator_strdup(allocator, "unless");
-    }
-  }
-
   parse_context->matched_handler = search.matched_handler;
   return parse_context;
 }
@@ -131,92 +110,6 @@ static void free_tag_helper_parse_context(tag_helper_parse_context_T* parse_cont
   }
 }
 
-static AST_NODE_T* wrap_in_conditional_if_needed(
-  AST_NODE_T* element,
-  tag_helper_parse_context_T* parse_context,
-  hb_allocator_T* allocator
-) {
-  if (!element || !parse_context || !parse_context->condition_source || !parse_context->condition_type) {
-    return element;
-  }
-
-  position_T start = element->location.start;
-  position_T end = element->location.end;
-
-  hb_buffer_T content_buffer;
-  hb_buffer_init(&content_buffer, 64, allocator);
-  hb_buffer_append(&content_buffer, " ");
-  hb_buffer_append(&content_buffer, parse_context->condition_type);
-  hb_buffer_append(&content_buffer, " ");
-  hb_buffer_append(&content_buffer, parse_context->condition_source);
-  hb_buffer_append(&content_buffer, " ");
-  const char* content_string = hb_buffer_value(&content_buffer);
-
-  token_T* tag_opening = create_synthetic_token(allocator, "<%", TOKEN_ERB_START, start, start);
-  token_T* content_token = create_synthetic_token(allocator, content_string, TOKEN_ERB_CONTENT, start, end);
-  token_T* tag_closing = create_synthetic_token(allocator, "%>", TOKEN_ERB_END, end, end);
-
-  hb_array_T* statements = hb_array_init(1, allocator);
-  hb_array_append(statements, element);
-
-  token_T* end_opening = create_synthetic_token(allocator, "<%", TOKEN_ERB_START, end, end);
-  token_T* end_content = create_synthetic_token(allocator, " end ", TOKEN_ERB_CONTENT, end, end);
-  token_T* end_closing = create_synthetic_token(allocator, "%>", TOKEN_ERB_END, end, end);
-
-  AST_ERB_END_NODE_T* end_node =
-    ast_erb_end_node_init(end_opening, end_content, end_closing, end, end, hb_array_init(0, allocator), allocator);
-
-  herb_prism_node_T empty_prism_node = HERB_PRISM_NODE_EMPTY;
-
-  if (strcmp(parse_context->condition_type, "if") == 0) {
-    AST_ERB_IF_NODE_T* if_node = ast_erb_if_node_init(
-      tag_opening,
-      content_token,
-      tag_closing,
-      NULL,
-      empty_prism_node,
-      statements,
-      NULL,
-      end_node,
-      start,
-      end,
-      hb_array_init(0, allocator),
-      allocator
-    );
-
-    return (AST_NODE_T*) if_node;
-  } else {
-    AST_ERB_UNLESS_NODE_T* unless_node = ast_erb_unless_node_init(
-      tag_opening,
-      content_token,
-      tag_closing,
-      NULL,
-      empty_prism_node,
-      statements,
-      NULL,
-      end_node,
-      start,
-      end,
-      hb_array_init(0, allocator),
-      allocator
-    );
-
-    return (AST_NODE_T*) unless_node;
-  }
-}
-
-static bool is_postfix_if_node(const pm_node_t* node) {
-  if (node->type != PM_IF_NODE) { return false; }
-  pm_if_node_t* if_node = (pm_if_node_t*) node;
-  return if_node->if_keyword_loc.start != NULL && if_node->end_keyword_loc.start == NULL;
-}
-
-static bool is_postfix_unless_node(const pm_node_t* node) {
-  if (node->type != PM_UNLESS_NODE) { return false; }
-  pm_unless_node_t* unless_node = (pm_unless_node_t*) node;
-  return unless_node->keyword_loc.start != NULL && unless_node->end_keyword_loc.start == NULL;
-}
-
 bool search_tag_helper_node(const pm_node_t* node, void* data) {
   tag_helper_search_data_T* search_data = (tag_helper_search_data_T*) data;
 
@@ -247,16 +140,6 @@ bool search_tag_helper_node(const pm_node_t* node, void* data) {
     return false;
   }
 
-  if (is_postfix_if_node(node) || is_postfix_unless_node(node)) {
-    const pm_node_t* saved = search_data->postfix_conditional_node;
-    search_data->postfix_conditional_node = node;
-    pm_visit_child_nodes(node, search_tag_helper_node, search_data);
-
-    if (!search_data->found) { search_data->postfix_conditional_node = saved; }
-
-    return search_data->found;
-  }
-
   pm_visit_child_nodes(node, search_tag_helper_node, search_data);
 
   return search_data->found;
@@ -639,7 +522,15 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
         id_is_ruby_expression ? create_html_attribute_with_ruby_literal("id", id_value, id_start, id_end, allocator)
                               : create_html_attribute_node("id", id_value, id_start, id_end, allocator);
 
-      if (id_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) id_attribute, allocator); }
+      if (id_attribute) {
+        AST_NODE_T* src_node = remove_attribute_by_name(attributes, "src");
+        AST_NODE_T* target_node = remove_attribute_by_name(attributes, "target");
+
+        hb_array_append(attributes, (AST_NODE_T*) id_attribute);
+
+        if (src_node) { hb_array_append(attributes, src_node); }
+        if (target_node) { hb_array_append(attributes, target_node); }
+      }
 
       hb_allocator_dealloc(allocator, id_value);
     }
@@ -679,7 +570,7 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
           ? create_html_attribute_node("src", source_attribute_value, source_start, source_end, allocator)
           : create_html_attribute_with_ruby_literal("src", source_attribute_value, source_start, source_end, allocator);
 
-      if (source_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) source_attribute, allocator); }
+      if (source_attribute) { hb_array_append(attributes, (AST_NODE_T*) source_attribute); }
 
       if (source_attribute_value != source_value) { hb_allocator_dealloc(allocator, source_attribute_value); }
       hb_allocator_dealloc(allocator, source_value);
@@ -723,7 +614,7 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
           ? create_html_attribute_node("src", source_attribute_value, source_start, source_end, allocator)
           : create_html_attribute_with_ruby_literal("src", source_attribute_value, source_start, source_end, allocator);
 
-      if (source_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) source_attribute, allocator); }
+      if (source_attribute) { hb_array_append(attributes, (AST_NODE_T*) source_attribute); }
       if (source_attribute_value != source_value) { hb_allocator_dealloc(allocator, source_attribute_value); }
 
       hb_allocator_dealloc(allocator, source_value);
@@ -798,14 +689,37 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
       );
     }
 
-    append_body_content_node(
-      body,
-      helper_content,
-      content_is_ruby_expression,
-      erb_node->base.location.start,
-      erb_node->base.location.end,
-      allocator
-    );
+    if (string_equals(handler->name, "javascript_tag")) {
+      hb_array_T* cdata_children = hb_array_init(1, allocator);
+
+      append_body_content_node(
+        cdata_children,
+        helper_content,
+        content_is_ruby_expression,
+        erb_node->base.location.start,
+        erb_node->base.location.end,
+        allocator
+      );
+
+      AST_CDATA_NODE_T* cdata_node = create_javascript_cdata_node(
+        cdata_children,
+        erb_node->base.location.start,
+        erb_node->base.location.end,
+        allocator
+      );
+
+      if (cdata_node) { hb_array_append(body, (AST_NODE_T*) cdata_node); }
+    } else {
+      append_body_content_node(
+        body,
+        helper_content,
+        content_is_ruby_expression,
+        erb_node->base.location.start,
+        erb_node->base.location.end,
+        allocator
+      );
+    }
+
     hb_allocator_dealloc(allocator, helper_content);
   }
 
@@ -1117,7 +1031,7 @@ static AST_NODE_T* transform_erb_block_to_tag_helper(
       AST_HTML_ATTRIBUTE_NODE_T* href_attribute =
         create_href_attribute(href, href_is_ruby_expression, href_start, href_end, allocator);
 
-      if (href_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) href_attribute, allocator); }
+      if (href_attribute) { hb_array_append(attributes, (AST_NODE_T*) href_attribute); }
 
       hb_allocator_dealloc(allocator, href);
     }
@@ -1138,7 +1052,15 @@ static AST_NODE_T* transform_erb_block_to_tag_helper(
         id_is_ruby_expression ? create_html_attribute_with_ruby_literal("id", id_value, id_start, id_end, allocator)
                               : create_html_attribute_node("id", id_value, id_start, id_end, allocator);
 
-      if (id_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) id_attribute, allocator); }
+      if (id_attribute) {
+        AST_NODE_T* src_node = remove_attribute_by_name(attributes, "src");
+        AST_NODE_T* target_node = remove_attribute_by_name(attributes, "target");
+
+        hb_array_append(attributes, (AST_NODE_T*) id_attribute);
+
+        if (src_node) { hb_array_append(attributes, src_node); }
+        if (target_node) { hb_array_append(attributes, target_node); }
+      }
 
       hb_allocator_dealloc(allocator, id_value);
     }
@@ -1395,7 +1317,7 @@ static AST_NODE_T* transform_link_to_helper(
     AST_HTML_ATTRIBUTE_NODE_T* href_attribute =
       create_href_attribute(href, href_is_ruby_expression, href_start, href_end, allocator);
 
-    if (href_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) href_attribute, allocator); }
+    if (href_attribute) { hb_array_append(attributes, (AST_NODE_T*) href_attribute); }
     if (!info->content) {
       href_for_body = hb_allocator_strdup(allocator, href);
       href_for_body_is_ruby_expression = href_is_ruby_expression;
@@ -1503,6 +1425,12 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
 
     if (child->type == AST_ERB_BLOCK_NODE) {
       AST_ERB_BLOCK_NODE_T* block_node = (AST_ERB_BLOCK_NODE_T*) child;
+
+      if (block_node->tag_opening && !hb_string_is_empty(block_node->tag_opening->value)) {
+        const char* opening_string = block_node->tag_opening->value.data;
+        if (opening_string && strstr(opening_string, "=") == NULL) { continue; }
+      }
+
       token_T* block_content = block_node->content;
 
       if (block_content && !hb_string_is_empty(block_content->value)) {
@@ -1518,7 +1446,6 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
 
         if (parse_context) {
           replacement = transform_erb_block_to_tag_helper(block_node, context, parse_context);
-          replacement = wrap_in_conditional_if_needed(replacement, parse_context, context->allocator);
           free_tag_helper_parse_context(parse_context);
         }
 
@@ -1532,6 +1459,7 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
         const char* opening_string = tag_opening->value.data;
 
         if (opening_string && strstr(opening_string, "#") != NULL) { continue; }
+        if (opening_string && strstr(opening_string, "=") == NULL) { continue; }
       }
 
       token_T* erb_content = erb_node->content;
@@ -1615,7 +1543,6 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
             replacement = transform_tag_helper_with_attributes(erb_node, context, parse_context);
           }
 
-          replacement = wrap_in_conditional_if_needed(replacement, parse_context, context->allocator);
           free_tag_helper_parse_context(parse_context);
         }
 

data/src/analyze/action_view/turbo_frame_tag.c

@@ -1,32 +1,9 @@
-#include "../../include/analyze/action_view/tag_helper_handler.h"
+#include "../../include/lib/hb_allocator.h"
 
 #include <prism.h>
 #include <stdbool.h>
-#include <stdlib.h>
 #include <string.h>
 
-bool detect_turbo_frame_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
-  if (!call_node || !call_node->name) { return false; }
-
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
-  return constant && constant->length == 15 && strncmp((const char*) constant->start, "turbo_frame_tag", 15) == 0;
-}
-
-char* extract_turbo_frame_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
-  (void) call_node;
-  (void) parser;
-
-  return hb_allocator_strdup(allocator, "turbo-frame");
-}
-
-char* extract_turbo_frame_tag_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
-  (void) call_node;
-  (void) parser;
-  (void) allocator;
-
-  return NULL;
-}
-
 char* extract_turbo_frame_tag_id(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   if (!call_node || !call_node->arguments) { return NULL; }
 
@@ -74,15 +51,3 @@ char* extract_turbo_frame_tag_id(pm_call_node_t* call_node, pm_parser_t* parser,
 
   return result;
 }
-
-bool turbo_frame_tag_supports_block(void) {
-  return true;
-}
-
-const tag_helper_handler_T turbo_frame_tag_handler = { .name = "turbo_frame_tag",
-                                                       .source =
-                                                         HB_STRING_LITERAL("Turbo::FramesHelper#turbo_frame_tag"),
-                                                       .detect = detect_turbo_frame_tag,
-                                                       .extract_tag_name = extract_turbo_frame_tag_name,
-                                                       .extract_content = extract_turbo_frame_tag_content,
-                                                       .supports_block = turbo_frame_tag_supports_block };

data/src/analyze/analyze.c

@@ -8,8 +8,10 @@
 #include "../include/analyze/control_type.h"
 #include "../include/analyze/helpers.h"
 #include "../include/analyze/invalid_structures.h"
+#include "../include/analyze/postfix_conditionals.h"
 #include "../include/analyze/render_nodes.h"
 #include "../include/analyze/strict_locals.h"
+#include "../include/analyze/ternary_conditionals.h"
 #include "../include/ast/ast_node.h"
 #include "../include/ast/ast_nodes.h"
 #include "../include/errors.h"
@@ -736,12 +738,32 @@ static size_t process_block_structure(
   hb_array_T* block_errors = erb_node->base.errors;
   erb_node->base.errors = NULL;
 
+  // Filter out "incomplete block" Prism errors since we've matched the block with its end tag.
+  if (block_errors) {
+    for (size_t error_index = hb_array_size(block_errors); error_index > 0; error_index--) {
+      ERROR_T* error = hb_array_get(block_errors, error_index - 1);
+      if (!error || error->type != RUBY_PARSE_ERROR) { continue; }
+
+      RUBY_PARSE_ERROR_T* parse_error = (RUBY_PARSE_ERROR_T*) error;
+
+      if (string_equals(parse_error->diagnostic_id.data, "block_term_end")
+          || string_equals(parse_error->diagnostic_id.data, "block_term_brace")
+          || string_equals(parse_error->diagnostic_id.data, "unexpected_token_close_context")) {
+        hb_array_remove(block_errors, error_index - 1);
+      }
+    }
+  }
+
+  hb_array_T* block_arguments =
+    extract_block_arguments_from_erb_node(erb_node, context->source, block_errors, allocator);
+
   AST_ERB_BLOCK_NODE_T* block_node = ast_erb_block_node_init(
     erb_node->tag_opening,
     erb_node->content,
     erb_node->tag_closing,
     HERB_PRISM_NODE_EMPTY,
     children,
+    block_arguments,
     rescue_clause,
     else_clause,
     ensure_clause,
@@ -942,6 +964,7 @@ hb_array_T* get_node_children_array(const AST_NODE_T* node) {
     case AST_ERB_ENSURE_NODE: return ((AST_ERB_ENSURE_NODE_T*) node)->statements;
     case AST_ERB_CASE_NODE: return ((AST_ERB_CASE_NODE_T*) node)->children;
     case AST_ERB_WHEN_NODE: return ((AST_ERB_WHEN_NODE_T*) node)->statements;
+    case AST_ERB_RENDER_NODE: return ((AST_ERB_RENDER_NODE_T*) node)->body;
     default: return NULL;
   }
 }
@@ -1008,6 +1031,11 @@ void herb_analyze_parse_tree(
     .source = source,
   };
 
+  if (options && (options->transform_conditionals || options->action_view_helpers)) {
+    herb_visit_node((AST_NODE_T*) document, transform_conditional_nodes, &context);
+    herb_visit_node((AST_NODE_T*) document, transform_ternary_conditional_nodes, &context);
+  }
+
   herb_visit_node((AST_NODE_T*) document, transform_erb_nodes, &context);
 
   if (options && options->render_nodes) { herb_visit_node((AST_NODE_T*) document, transform_render_nodes, &context); }