Parser: Support Action View tag helpers with inline blocks (#1404)

This pull request adds support for detecting Action View tag helpers
using inline brace block syntax (`{ }`) in addition to the existing
`do...end` block syntax.

Previously, the parser only recognized multi-line block forms like:
```erb
<%= content_tag :div do %>
  Content
<% end %>
```

With this change, inline block forms are now also detected and
transformed into `HTMLElementNode` representations:
```erb
<%= content_tag(:div) { "Content" } %>
```

Resolves #1369

Author: marcoroth

src/analyze/action_view/content_tag.c

@@ -38,23 +38,28 @@ char* extract_content_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, h
 char* extract_content_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 (!call_node) { return NULL; }
 
-  pm_arguments_node_t* arguments = call_node->arguments;
-  if (arguments->arguments.size < 2) { return NULL; }
+  if (call_node->arguments) {
+    pm_arguments_node_t* arguments = call_node->arguments;
 
-  pm_node_t* second_argument = arguments->arguments.nodes[1];
+    if (arguments->arguments.size >= 2) {
+      pm_node_t* second_argument = arguments->arguments.nodes[1];
 
-  if (second_argument->type == PM_KEYWORD_HASH_NODE) { return NULL; }
+      if (second_argument->type != PM_KEYWORD_HASH_NODE) {
+        if (second_argument->type == PM_STRING_NODE) {
+          pm_string_node_t* string_node = (pm_string_node_t*) second_argument;
+          size_t length = pm_string_length(&string_node->unescaped);
+          return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+        }
 
-  if (second_argument->type == PM_STRING_NODE) {
-    pm_string_node_t* string_node = (pm_string_node_t*) second_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 = second_argument->location.end - second_argument->location.start;
+        return hb_allocator_strndup(allocator, (const char*) second_argument->location.start, source_length);
+      }
+    }
   }
 
-  size_t source_length = second_argument->location.end - second_argument->location.start;
-  return hb_allocator_strndup(allocator, (const char*) second_argument->location.start, source_length);
+  return extract_inline_block_content(call_node, allocator);
 }
 
 bool content_tag_supports_block(void) {

src/analyze/action_view/link_to.c

@@ -56,7 +56,12 @@ char* extract_link_to_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, h
 char* extract_link_to_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 (!call_node) { return NULL; }
+
+  char* block_content = extract_inline_block_content(call_node, allocator);
+  if (block_content) { return block_content; }
+
+  if (!call_node->arguments) { return NULL; }
 
   pm_arguments_node_t* arguments = call_node->arguments;
   if (!arguments->arguments.size) { return NULL; }
@@ -96,6 +101,25 @@ char* extract_link_to_href(pm_call_node_t* call_node, pm_parser_t* parser, hb_al
   if (!call_node || !call_node->arguments) { return NULL; }
 
   pm_arguments_node_t* arguments = call_node->arguments;
+  bool has_inline_block = call_node->block && call_node->block->type == PM_BLOCK_NODE;
+
+  if (has_inline_block && arguments->arguments.size >= 1) {
+    pm_node_t* first_argument = arguments->arguments.nodes[0];
+
+    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;
+
+    if (is_route_helper_node(first_argument, parser)) {
+      return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+    }
+
+    return wrap_in_url_for((const char*) first_argument->location.start, source_length, allocator);
+  }
 
   // Format: "url_for(<expression>)"
   if (arguments->arguments.size == 1) {

src/analyze/action_view/registry.c

@@ -58,3 +58,26 @@ tag_helper_handler_T* get_tag_helper_handlers(void) {
 size_t get_tag_helper_handlers_count(void) {
   return handlers_count;
 }
+
+char* extract_inline_block_content(pm_call_node_t* call_node, hb_allocator_T* allocator) {
+  if (!call_node || !call_node->block || call_node->block->type != PM_BLOCK_NODE) { return NULL; }
+
+  pm_block_node_t* block_node = (pm_block_node_t*) call_node->block;
+
+  if (!block_node->body || block_node->body->type != PM_STATEMENTS_NODE) { return NULL; }
+
+  pm_statements_node_t* statements = (pm_statements_node_t*) block_node->body;
+
+  if (statements->body.size != 1) { return NULL; }
+
+  pm_node_t* statement = statements->body.nodes[0];
+
+  if (statement->type == PM_STRING_NODE) {
+    pm_string_node_t* string_node = (pm_string_node_t*) statement;
+    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 = statement->location.end - statement->location.start;
+  return hb_allocator_strndup(allocator, (const char*) statement->location.start, source_length);
+}

src/analyze/action_view/tag.c

@@ -36,20 +36,23 @@ char* extract_tag_dot_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_al
 char* extract_tag_dot_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 (!call_node) { return NULL; }
 
-  pm_arguments_node_t* arguments = call_node->arguments;
-  if (!arguments->arguments.size) { return NULL; }
+  if (call_node->arguments) {
+    pm_arguments_node_t* arguments = call_node->arguments;
 
-  pm_node_t* first_argument = arguments->arguments.nodes[0];
+    if (arguments->arguments.size) {
+      pm_node_t* first_argument = arguments->arguments.nodes[0];
 
-  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);
+      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);
+      }
+    }
   }
 
-  return NULL;
+  return extract_inline_block_content(call_node, allocator);
 }
 
 bool tag_dot_supports_block(void) {

src/analyze/action_view/tag_helpers.c

@@ -262,13 +262,29 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
   if (parse_context->info->call_node && handler->extract_content) {
     helper_content = handler->extract_content(parse_context->info->call_node, &parse_context->parser, allocator);
 
-    if (helper_content && parse_context->info->call_node->arguments) {
-      if (strcmp(handler->name, "content_tag") == 0 && parse_context->info->call_node->arguments->arguments.size >= 2) {
-        content_is_ruby_expression =
-          (parse_context->info->call_node->arguments->arguments.nodes[1]->type != PM_STRING_NODE);
-      } else if (parse_context->info->call_node->arguments->arguments.size >= 1) {
-        content_is_ruby_expression =
-          (parse_context->info->call_node->arguments->arguments.nodes[0]->type != PM_STRING_NODE);
+    if (helper_content) {
+      pm_call_node_t* call = parse_context->info->call_node;
+
+      if (call->arguments) {
+        if (strcmp(handler->name, "content_tag") == 0 && call->arguments->arguments.size >= 2
+            && call->arguments->arguments.nodes[1]->type != PM_KEYWORD_HASH_NODE) {
+          content_is_ruby_expression = (call->arguments->arguments.nodes[1]->type != PM_STRING_NODE);
+        } else if (strcmp(handler->name, "content_tag") != 0 && call->arguments->arguments.size >= 1
+                   && call->arguments->arguments.nodes[0]->type != PM_KEYWORD_HASH_NODE) {
+          content_is_ruby_expression = (call->arguments->arguments.nodes[0]->type != PM_STRING_NODE);
+        }
+      }
+
+      if (!content_is_ruby_expression && call->block && call->block->type == PM_BLOCK_NODE) {
+        pm_block_node_t* block_node = (pm_block_node_t*) call->block;
+
+        if (block_node->body && block_node->body->type == PM_STATEMENTS_NODE) {
+          pm_statements_node_t* statements = (pm_statements_node_t*) block_node->body;
+
+          if (statements->body.size == 1) {
+            content_is_ruby_expression = (statements->body.nodes[0]->type != PM_STRING_NODE);
+          }
+        }
       }
     }
   }
@@ -492,7 +508,9 @@ static AST_NODE_T* transform_link_to_helper(
 
   hb_array_T* attributes = NULL;
   pm_arguments_node_t* link_arguments = info->call_node->arguments;
-  bool keyword_hash_is_url = link_arguments && link_arguments->arguments.size == 2
+  bool has_inline_block = info->call_node->block && info->call_node->block->type == PM_BLOCK_NODE;
+
+  bool keyword_hash_is_url = !has_inline_block && link_arguments && link_arguments->arguments.size == 2
                           && link_arguments->arguments.nodes[1]->type == PM_KEYWORD_HASH_NODE;
 
   if (!keyword_hash_is_url) {
@@ -549,7 +567,12 @@ static AST_NODE_T* transform_link_to_helper(
       pm_arguments_node_t* arguments = info->call_node->arguments;
       pm_node_t* href_argument = NULL;
 
-      if (arguments->arguments.size >= 2) {
+      if (has_inline_block) {
+        if (arguments->arguments.size >= 1) {
+          href_argument = arguments->arguments.nodes[0];
+          href_is_ruby_expression = (href_argument->type != PM_STRING_NODE);
+        }
+      } else if (arguments->arguments.size >= 2) {
         href_argument = arguments->arguments.nodes[1];
         href_is_ruby_expression = (href_argument->type != PM_STRING_NODE);
       } else if (arguments->arguments.size == 1) {
@@ -602,7 +625,17 @@ static AST_NODE_T* transform_link_to_helper(
   if (info->content) {
     bool content_is_ruby_expression = false;
 
-    if (info->call_node && info->call_node->arguments && info->call_node->arguments->arguments.size >= 1) {
+    if (has_inline_block && info->call_node->block && info->call_node->block->type == PM_BLOCK_NODE) {
+      pm_block_node_t* block_node = (pm_block_node_t*) info->call_node->block;
+
+      if (block_node->body && block_node->body->type == PM_STATEMENTS_NODE) {
+        pm_statements_node_t* statements = (pm_statements_node_t*) block_node->body;
+
+        if (statements->body.size == 1) {
+          content_is_ruby_expression = (statements->body.nodes[0]->type != PM_STRING_NODE);
+        }
+      }
+    } else if (info->call_node && info->call_node->arguments && info->call_node->arguments->arguments.size >= 1) {
       pm_node_t* first_argument = info->call_node->arguments->arguments.nodes[0];
       content_is_ruby_expression = (first_argument->type != PM_STRING_NODE);
     }

src/include/analyze/action_view/tag_helper_handler.h

@@ -38,4 +38,6 @@ 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

test/analyze/action_view/tag_helper/content_tag_test.rb

@@ -149,5 +149,29 @@ class ContentTagTest < Minitest::Spec
         <% end %>
       HTML
     end
+
+    test "content_tag with inline block" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= content_tag(:details) { "Some content" } %>
+      HTML
+    end
+
+    test "content_tag with inline block and attributes" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= content_tag(:div, class: "container") { "Hello" } %>
+      HTML
+    end
+
+    test "content_tag with inline block and ruby expression" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= content_tag(:p) { @user.name } %>
+      HTML
+    end
+
+    test "content_tag with inline block and symbol tag name" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= content_tag(:span) { "Text" } %>
+      HTML
+    end
   end
 end

test/analyze/action_view/tag_helper/tag_test.rb

@@ -151,5 +151,29 @@ class TagTest < Minitest::Spec
         <% end %>
       HTML
     end
+
+    test "tag.details with inline block" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= tag.details { "Some content" } %>
+      HTML
+    end
+
+    test "tag.div with inline block and attributes" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= tag.div(class: "container") { "Hello" } %>
+      HTML
+    end
+
+    test "tag.p with inline block and ruby expression" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= tag.p { @user.name } %>
+      HTML
+    end
+
+    test "tag.span with inline block" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= tag.span { "Text" } %>
+      HTML
+    end
   end
 end

test/analyze/action_view/url_helper/link_to_test.rb

@@ -221,5 +221,35 @@ class LinkToTest < Minitest::Spec
         <% end %>
       HTML
     end
+
+    test "link_to with inline block" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= link_to("#") { "Click me" } %>
+      HTML
+    end
+
+    test "link_to with inline block and attributes" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= link_to("/about", class: "btn") { "About" } %>
+      HTML
+    end
+
+    test "link_to with inline block and data attributes" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= link_to("/profile", data: { turbo_method: "delete" }) { "Delete" } %>
+      HTML
+    end
+
+    test "link_to with inline block and path helper" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= link_to(root_path) { "Home" } %>
+      HTML
+    end
+
+    test "link_to with inline block and ruby expression" do
+      assert_parsed_snapshot(<<~HTML, action_view_helpers: true)
+        <%= link_to("#") { @user.name } %>
+      HTML
+    end
   end
 end