herb 0.9.5-aarch64-linux-gnu → 0.9.6-aarch64-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,54 +1,11 @@
-#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; }
-
-  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;
-
-  return hb_allocator_strdup(allocator, "script");
-}
-
-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; }
-
-  pm_arguments_node_t* arguments = call_node->arguments;
-  if (!arguments->arguments.size) { return NULL; }
-
-  pm_node_t* first_argument = arguments->arguments.nodes[0];
-
-  if (first_argument->type == PM_KEYWORD_HASH_NODE) { return NULL; }
-
-  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);
-  }
-
-  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);
-}
-
-bool javascript_tag_supports_block(void) {
-  return true;
-}
 
 bool wrap_javascript_tag_body_visitor(const AST_NODE_T* node, void* data) {
   hb_allocator_T* allocator = (hb_allocator_T*) data;
@@ -82,12 +39,3 @@ bool wrap_javascript_tag_body_visitor(const AST_NODE_T* node, void* data) {
 
   return false;
 }
-
-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
-};

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_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;
@@ -1542,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)) {
@@ -1557,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);
         }
 
@@ -1571,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;
@@ -1654,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"
@@ -1029,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); }