herb 0.9.0-arm-linux-gnu → 0.9.1-arm-linux-gnu

data/sig/serialized_ast_nodes.rbs

@@ -268,6 +268,37 @@ module Herb
     end_node: Herb::AST::ERBEndNode,
   }
 
+  type serialized_ruby_render_local_node = serialized_node & {
+    name: Herb::Token,
+    value: Herb::AST::RubyLiteralNode,
+  }
+
+  type serialized_erb_render_node = serialized_node & {
+    tag_opening: Herb::Token,
+    content: Herb::Token,
+    tag_closing: Herb::Token,
+    analyzed_ruby: nil,
+    prism_node: String,
+    partial: Herb::Token,
+    template_path: Herb::Token,
+    layout: Herb::Token,
+    file: Herb::Token,
+    inline_template: Herb::Token,
+    body: Herb::Token,
+    plain: Herb::Token,
+    html: Herb::Token,
+    renderable: Herb::Token,
+    collection: Herb::Token,
+    object: Herb::Token,
+    as_name: Herb::Token,
+    spacer_template: Herb::Token,
+    formats: Herb::Token,
+    variants: Herb::Token,
+    handlers: Herb::Token,
+    content_type: Herb::Token,
+    locals: Array[Herb::AST::RubyRenderLocalNode],
+  }
+
   type serialized_erb_yield_node = serialized_node & {
     tag_opening: Herb::Token,
     content: Herb::Token,

data/src/analyze/action_view/attribute_extraction_helpers.c

@@ -265,7 +265,7 @@ bool has_html_attributes_in_call(pm_call_node_t* call_node) {
 
   pm_node_t* last_argument = arguments->arguments.nodes[arguments->arguments.size - 1];
 
-  return last_argument && last_argument->type == PM_KEYWORD_HASH_NODE;
+  return last_argument && (last_argument->type == PM_KEYWORD_HASH_NODE || last_argument->type == PM_HASH_NODE);
 }
 
 hb_array_T* extract_html_attributes_from_call_node(
@@ -280,6 +280,19 @@ hb_array_T* extract_html_attributes_from_call_node(
   pm_arguments_node_t* arguments = call_node->arguments;
   pm_node_t* last_argument = arguments->arguments.nodes[arguments->arguments.size - 1];
 
+  if (last_argument->type == PM_HASH_NODE) {
+    pm_hash_node_t* hash_node = (pm_hash_node_t*) last_argument;
+    pm_keyword_hash_node_t synthetic = { .base = hash_node->base, .elements = hash_node->elements };
+
+    return extract_html_attributes_from_keyword_hash(
+      &synthetic,
+      source,
+      original_source,
+      erb_content_offset,
+      allocator
+    );
+  }
+
   return extract_html_attributes_from_keyword_hash(
     (pm_keyword_hash_node_t*) last_argument,
     source,

data/src/analyze/action_view/content_tag.c

@@ -38,23 +38,31 @@ 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; }
+  char* block_content = extract_inline_block_content(call_node, allocator);
+  if (block_content) { return block_content; }
 
-  pm_node_t* second_argument = arguments->arguments.nodes[1];
+  if (call_node->arguments) {
+    pm_arguments_node_t* arguments = call_node->arguments;
 
-  if (second_argument->type == PM_KEYWORD_HASH_NODE) { return NULL; }
+    if (arguments->arguments.size >= 2) {
+      pm_node_t* second_argument = arguments->arguments.nodes[1];
 
-  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_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);
+        }
+
+        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 NULL;
 }
 
 bool content_tag_supports_block(void) {

data/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) {

data/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);
+}

data/src/analyze/action_view/tag.c

@@ -36,17 +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; }
+  char* block_content = extract_inline_block_content(call_node, allocator);
+  if (block_content) { return block_content; }
 
-  pm_node_t* first_argument = arguments->arguments.nodes[0];
+  if (call_node->arguments) {
+    pm_arguments_node_t* arguments = call_node->arguments;
 
-  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 (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);
+      }
+    }
   }
 
   return NULL;

data/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,8 +508,12 @@ 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
-                          && link_arguments->arguments.nodes[1]->type == PM_KEYWORD_HASH_NODE;
+  bool has_inline_block = info->call_node->block && info->call_node->block->type == PM_BLOCK_NODE;
+
+  bool second_arg_is_hash = link_arguments && link_arguments->arguments.size == 2
+                         && (link_arguments->arguments.nodes[1]->type == PM_KEYWORD_HASH_NODE
+                             || link_arguments->arguments.nodes[1]->type == PM_HASH_NODE);
+  bool keyword_hash_is_url = !has_inline_block && second_arg_is_hash;
 
   if (!keyword_hash_is_url) {
     attributes = extract_html_attributes_from_call_node(
@@ -507,6 +527,38 @@ static AST_NODE_T* transform_link_to_helper(
 
   if (!attributes) { attributes = hb_array_init(4, allocator); }
 
+  if (has_inline_block && link_arguments && link_arguments->arguments.size >= 2) {
+    pm_node_t* second_arg = link_arguments->arguments.nodes[1];
+
+    if (second_arg->type != PM_KEYWORD_HASH_NODE && second_arg->type != PM_HASH_NODE
+        && second_arg->type != PM_STRING_NODE && second_arg->type != PM_SYMBOL_NODE) {
+      size_t source_length = second_arg->location.end - second_arg->location.start;
+      char* content = hb_allocator_strndup(allocator, (const char*) second_arg->location.start, source_length);
+
+      if (content) {
+        position_T position = prism_location_to_position_with_offset(
+          &second_arg->location,
+          parse_context->original_source,
+          parse_context->erb_content_offset,
+          parse_context->prism_source
+        );
+
+        AST_RUBY_HTML_ATTRIBUTES_SPLAT_NODE_T* splat_node = ast_ruby_html_attributes_splat_node_init(
+          hb_string_from_c_string(content),
+          HB_STRING_EMPTY,
+          position,
+          position,
+          hb_array_init(0, allocator),
+          allocator
+        );
+
+        if (splat_node) { hb_array_append(attributes, (AST_NODE_T*) splat_node); }
+
+        hb_allocator_dealloc(allocator, content);
+      }
+    }
+  }
+
   // `method:` implies `rel="nofollow"`
   bool has_data_method = false;
   hb_string_T data_method_string = hb_string("data-method");
@@ -549,7 +601,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 +659,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);
     }

data/src/analyze/analyze.c

@@ -8,6 +8,7 @@
 #include "../include/analyze/control_type.h"
 #include "../include/analyze/helpers.h"
 #include "../include/analyze/invalid_structures.h"
+#include "../include/analyze/render_nodes.h"
 #include "../include/ast_node.h"
 #include "../include/ast_nodes.h"
 #include "../include/errors.h"
@@ -859,6 +860,8 @@ void herb_analyze_parse_tree(
 
   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); }
+
   if (options && options->action_view_helpers) {
     herb_visit_node((AST_NODE_T*) document, transform_tag_helper_nodes, &context);
   }

data/src/analyze/prism_annotate.c

@@ -168,6 +168,7 @@ static void collect_prism_nodes(pm_node_t* node, hb_narray_T* list) {
 static token_T* get_content_token(const AST_NODE_T* node) {
   switch (node->type) {
     case AST_ERB_CONTENT_NODE: return ((AST_ERB_CONTENT_NODE_T*) node)->content;
+    case AST_ERB_RENDER_NODE: return ((AST_ERB_RENDER_NODE_T*) node)->content;
     case AST_ERB_IF_NODE: return ((AST_ERB_IF_NODE_T*) node)->content;
     case AST_ERB_BLOCK_NODE: return ((AST_ERB_BLOCK_NODE_T*) node)->content;
     case AST_ERB_CASE_NODE: return ((AST_ERB_CASE_NODE_T*) node)->content;
@@ -184,6 +185,7 @@ static token_T* get_content_token(const AST_NODE_T* node) {
 static void set_prism_node(AST_NODE_T* node, herb_prism_node_T prism_ref) {
   switch (node->type) {
     case AST_ERB_CONTENT_NODE: ((AST_ERB_CONTENT_NODE_T*) node)->prism_node = prism_ref; break;
+    case AST_ERB_RENDER_NODE: ((AST_ERB_RENDER_NODE_T*) node)->prism_node = prism_ref; break;
     case AST_ERB_IF_NODE: ((AST_ERB_IF_NODE_T*) node)->prism_node = prism_ref; break;
     case AST_ERB_BLOCK_NODE: ((AST_ERB_BLOCK_NODE_T*) node)->prism_node = prism_ref; break;
     case AST_ERB_CASE_NODE: ((AST_ERB_CASE_NODE_T*) node)->prism_node = prism_ref; break;
@@ -232,7 +234,7 @@ static bool annotate_visitor(const AST_NODE_T* node, void* data) {
   pm_parser_t* parser;
   hb_narray_T* node_list;
 
-  if (node->type == AST_ERB_CONTENT_NODE || context->prism_nodes_deep) {
+  if (node->type == AST_ERB_CONTENT_NODE || node->type == AST_ERB_RENDER_NODE || context->prism_nodes_deep) {
     parser = context->parser;
     node_list = context->node_list;
   } else {
@@ -248,7 +250,7 @@ static bool annotate_visitor(const AST_NODE_T* node, void* data) {
 }
 
 static bool collect_content_ranges_visitor(const AST_NODE_T* node, void* data) {
-  if (node->type != AST_ERB_CONTENT_NODE) { return true; }
+  if (node->type != AST_ERB_CONTENT_NODE && node->type != AST_ERB_RENDER_NODE) { return true; }
 
   hb_narray_T* ranges = (hb_narray_T*) data;
   token_T* content = get_content_token(node);