@herb-tools/node 0.9.0 → 0.9.1

package/binding.gyp

@@ -21,6 +21,7 @@
         "./extension/libherb/analyze/missing_end.c",
         "./extension/libherb/analyze/parse_errors.c",
         "./extension/libherb/analyze/prism_annotate.c",
+        "./extension/libherb/analyze/render_nodes.c",
         "./extension/libherb/analyze/transform.c",
         "./extension/libherb/analyze/action_view/attribute_extraction_helpers.c",
         "./extension/libherb/analyze/action_view/content_tag.c",

package/dist/herb-node.cjs

@@ -9,7 +9,7 @@ var node_fs = require('node:fs');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 var name = "@herb-tools/node";
-var version = "0.9.0";
+var version = "0.9.1";
 var packageJSON = {
 	name: name,
 	version: version};

package/dist/herb-node.esm.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'url';
 import { readFileSync } from 'node:fs';
 
 var name = "@herb-tools/node";
-var version = "0.9.0";
+var version = "0.9.1";
 var packageJSON = {
 	name: name,
 	version: version};

package/extension/error_helpers.cpp

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/javascript/packages/node/extension/error_helpers.cpp.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.1/templates/javascript/packages/node/extension/error_helpers.cpp.erb
 
 #include <node_api.h>
 #include "error_helpers.h"
@@ -669,6 +669,188 @@ napi_value NestedERBTagErrorFromCStruct(napi_env env, NESTED_ERB_TAG_ERROR_T* ne
   return result;
 }
 
+napi_value RenderAmbiguousLocalsErrorFromCStruct(napi_env env, RENDER_AMBIGUOUS_LOCALS_ERROR_T* render_ambiguous_locals_error) {
+  if (!render_ambiguous_locals_error) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateStringFromHbString(env, error_type_to_string(&render_ambiguous_locals_error->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value message = CreateStringFromHbString(env, render_ambiguous_locals_error->base.message);
+  napi_set_named_property(env, result, "message", message);
+
+  napi_value location = CreateLocation(env, render_ambiguous_locals_error->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+  napi_value partial = CreateStringFromHbString(env, render_ambiguous_locals_error->partial);
+  napi_set_named_property(env, result, "partial", partial);
+
+
+  return result;
+}
+
+napi_value RenderMissingLocalsErrorFromCStruct(napi_env env, RENDER_MISSING_LOCALS_ERROR_T* render_missing_locals_error) {
+  if (!render_missing_locals_error) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateStringFromHbString(env, error_type_to_string(&render_missing_locals_error->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value message = CreateStringFromHbString(env, render_missing_locals_error->base.message);
+  napi_set_named_property(env, result, "message", message);
+
+  napi_value location = CreateLocation(env, render_missing_locals_error->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+  napi_value partial = CreateStringFromHbString(env, render_missing_locals_error->partial);
+  napi_set_named_property(env, result, "partial", partial);
+
+  napi_value keywords = CreateStringFromHbString(env, render_missing_locals_error->keywords);
+  napi_set_named_property(env, result, "keywords", keywords);
+
+
+  return result;
+}
+
+napi_value RenderNoArgumentsErrorFromCStruct(napi_env env, RENDER_NO_ARGUMENTS_ERROR_T* render_no_arguments_error) {
+  if (!render_no_arguments_error) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateStringFromHbString(env, error_type_to_string(&render_no_arguments_error->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value message = CreateStringFromHbString(env, render_no_arguments_error->base.message);
+  napi_set_named_property(env, result, "message", message);
+
+  napi_value location = CreateLocation(env, render_no_arguments_error->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+
+  return result;
+}
+
+napi_value RenderConflictingPartialErrorFromCStruct(napi_env env, RENDER_CONFLICTING_PARTIAL_ERROR_T* render_conflicting_partial_error) {
+  if (!render_conflicting_partial_error) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateStringFromHbString(env, error_type_to_string(&render_conflicting_partial_error->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value message = CreateStringFromHbString(env, render_conflicting_partial_error->base.message);
+  napi_set_named_property(env, result, "message", message);
+
+  napi_value location = CreateLocation(env, render_conflicting_partial_error->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+  napi_value positional_partial = CreateStringFromHbString(env, render_conflicting_partial_error->positional_partial);
+  napi_set_named_property(env, result, "positional_partial", positional_partial);
+
+  napi_value keyword_partial = CreateStringFromHbString(env, render_conflicting_partial_error->keyword_partial);
+  napi_set_named_property(env, result, "keyword_partial", keyword_partial);
+
+
+  return result;
+}
+
+napi_value RenderInvalidAsOptionErrorFromCStruct(napi_env env, RENDER_INVALID_AS_OPTION_ERROR_T* render_invalid_as_option_error) {
+  if (!render_invalid_as_option_error) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateStringFromHbString(env, error_type_to_string(&render_invalid_as_option_error->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value message = CreateStringFromHbString(env, render_invalid_as_option_error->base.message);
+  napi_set_named_property(env, result, "message", message);
+
+  napi_value location = CreateLocation(env, render_invalid_as_option_error->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+  napi_value as_value = CreateStringFromHbString(env, render_invalid_as_option_error->as_value);
+  napi_set_named_property(env, result, "as_value", as_value);
+
+
+  return result;
+}
+
+napi_value RenderObjectAndCollectionErrorFromCStruct(napi_env env, RENDER_OBJECT_AND_COLLECTION_ERROR_T* render_object_and_collection_error) {
+  if (!render_object_and_collection_error) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateStringFromHbString(env, error_type_to_string(&render_object_and_collection_error->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value message = CreateStringFromHbString(env, render_object_and_collection_error->base.message);
+  napi_set_named_property(env, result, "message", message);
+
+  napi_value location = CreateLocation(env, render_object_and_collection_error->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+
+  return result;
+}
+
+napi_value RenderLayoutWithoutBlockErrorFromCStruct(napi_env env, RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T* render_layout_without_block_error) {
+  if (!render_layout_without_block_error) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateStringFromHbString(env, error_type_to_string(&render_layout_without_block_error->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value message = CreateStringFromHbString(env, render_layout_without_block_error->base.message);
+  napi_set_named_property(env, result, "message", message);
+
+  napi_value location = CreateLocation(env, render_layout_without_block_error->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+  napi_value layout = CreateStringFromHbString(env, render_layout_without_block_error->layout);
+  napi_set_named_property(env, result, "layout", layout);
+
+
+  return result;
+}
+
 
 napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_value result;
@@ -764,6 +946,27 @@ napi_value ErrorFromCStruct(napi_env env, ERROR_T* error) {
     case NESTED_ERB_TAG_ERROR:
       return NestedERBTagErrorFromCStruct(env, (NESTED_ERB_TAG_ERROR_T*) error);
       break;
+    case RENDER_AMBIGUOUS_LOCALS_ERROR:
+      return RenderAmbiguousLocalsErrorFromCStruct(env, (RENDER_AMBIGUOUS_LOCALS_ERROR_T*) error);
+      break;
+    case RENDER_MISSING_LOCALS_ERROR:
+      return RenderMissingLocalsErrorFromCStruct(env, (RENDER_MISSING_LOCALS_ERROR_T*) error);
+      break;
+    case RENDER_NO_ARGUMENTS_ERROR:
+      return RenderNoArgumentsErrorFromCStruct(env, (RENDER_NO_ARGUMENTS_ERROR_T*) error);
+      break;
+    case RENDER_CONFLICTING_PARTIAL_ERROR:
+      return RenderConflictingPartialErrorFromCStruct(env, (RENDER_CONFLICTING_PARTIAL_ERROR_T*) error);
+      break;
+    case RENDER_INVALID_AS_OPTION_ERROR:
+      return RenderInvalidAsOptionErrorFromCStruct(env, (RENDER_INVALID_AS_OPTION_ERROR_T*) error);
+      break;
+    case RENDER_OBJECT_AND_COLLECTION_ERROR:
+      return RenderObjectAndCollectionErrorFromCStruct(env, (RENDER_OBJECT_AND_COLLECTION_ERROR_T*) error);
+      break;
+    case RENDER_LAYOUT_WITHOUT_BLOCK_ERROR:
+      return RenderLayoutWithoutBlockErrorFromCStruct(env, (RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T*) error);
+      break;
     default:
       napi_value null_value;
       napi_get_null(env, &null_value);

package/extension/error_helpers.h

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/javascript/packages/node/extension/error_helpers.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.1/templates/javascript/packages/node/extension/error_helpers.h.erb
 
 #ifndef HERB_EXTENSION_ERRORS_H
 #define HERB_EXTENSION_ERRORS_H
@@ -36,5 +36,12 @@ napi_value MissingAttributeValueErrorFromCStruct(napi_env env, MISSING_ATTRIBUTE
 napi_value UnclosedERBTagErrorFromCStruct(napi_env env, UNCLOSED_ERB_TAG_ERROR_T* unclosed_erb_tag_error);
 napi_value StrayERBClosingTagErrorFromCStruct(napi_env env, STRAY_ERB_CLOSING_TAG_ERROR_T* stray_erb_closing_tag_error);
 napi_value NestedERBTagErrorFromCStruct(napi_env env, NESTED_ERB_TAG_ERROR_T* nested_erb_tag_error);
+napi_value RenderAmbiguousLocalsErrorFromCStruct(napi_env env, RENDER_AMBIGUOUS_LOCALS_ERROR_T* render_ambiguous_locals_error);
+napi_value RenderMissingLocalsErrorFromCStruct(napi_env env, RENDER_MISSING_LOCALS_ERROR_T* render_missing_locals_error);
+napi_value RenderNoArgumentsErrorFromCStruct(napi_env env, RENDER_NO_ARGUMENTS_ERROR_T* render_no_arguments_error);
+napi_value RenderConflictingPartialErrorFromCStruct(napi_env env, RENDER_CONFLICTING_PARTIAL_ERROR_T* render_conflicting_partial_error);
+napi_value RenderInvalidAsOptionErrorFromCStruct(napi_env env, RENDER_INVALID_AS_OPTION_ERROR_T* render_invalid_as_option_error);
+napi_value RenderObjectAndCollectionErrorFromCStruct(napi_env env, RENDER_OBJECT_AND_COLLECTION_ERROR_T* render_object_and_collection_error);
+napi_value RenderLayoutWithoutBlockErrorFromCStruct(napi_env env, RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T* render_layout_without_block_error);
 
 #endif

package/extension/extension_helpers.cpp

@@ -173,12 +173,13 @@ napi_value CreateParseResult(napi_env env, AST_DOCUMENT_NODE_T* root, napi_value
   napi_value options_object;
   napi_create_object(env, &options_object);
 
-  napi_value strict_value, track_whitespace_value, analyze_value, action_view_helpers_value, prism_program_value, prism_nodes_value, prism_nodes_deep_value;
+  napi_value strict_value, track_whitespace_value, analyze_value, action_view_helpers_value, render_nodes_value, prism_program_value, prism_nodes_value, prism_nodes_deep_value;
 
   napi_get_boolean(env, options->strict, &strict_value);
   napi_get_boolean(env, options->track_whitespace, &track_whitespace_value);
   napi_get_boolean(env, options->analyze, &analyze_value);
   napi_get_boolean(env, options->action_view_helpers, &action_view_helpers_value);
+  napi_get_boolean(env, options->render_nodes, &render_nodes_value);
   napi_get_boolean(env, options->prism_program, &prism_program_value);
   napi_get_boolean(env, options->prism_nodes, &prism_nodes_value);
   napi_get_boolean(env, options->prism_nodes_deep, &prism_nodes_deep_value);
@@ -187,6 +188,7 @@ napi_value CreateParseResult(napi_env env, AST_DOCUMENT_NODE_T* root, napi_value
   napi_set_named_property(env, options_object, "track_whitespace", track_whitespace_value);
   napi_set_named_property(env, options_object, "analyze", analyze_value);
   napi_set_named_property(env, options_object, "action_view_helpers", action_view_helpers_value);
+  napi_set_named_property(env, options_object, "render_nodes", render_nodes_value);
   napi_set_named_property(env, options_object, "prism_program", prism_program_value);
   napi_set_named_property(env, options_object, "prism_nodes", prism_nodes_value);
   napi_set_named_property(env, options_object, "prism_nodes_deep", prism_nodes_deep_value);

package/extension/herb.cpp

@@ -119,6 +119,17 @@ napi_value Herb_parse(napi_env env, napi_callback_info info) {
         parser_options.action_view_helpers = action_view_helpers_value;
       }
 
+      napi_value render_nodes_prop;
+      bool has_render_nodes_prop;
+      napi_has_named_property(env, args[1], "render_nodes", &has_render_nodes_prop);
+
+      if (has_render_nodes_prop) {
+        napi_get_named_property(env, args[1], "render_nodes", &render_nodes_prop);
+        bool render_nodes_value;
+        napi_get_value_bool(env, render_nodes_prop, &render_nodes_value);
+        parser_options.render_nodes = render_nodes_value;
+      }
+
       napi_value prism_nodes_prop;
       bool has_prism_nodes_prop;
       napi_has_named_property(env, args[1], "prism_nodes", &has_prism_nodes_prop);

package/extension/libherb/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,

package/extension/libherb/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) {

package/extension/libherb/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) {

package/extension/libherb/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);
+}

package/extension/libherb/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;

package/extension/libherb/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

package/extension/libherb/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);
     }

package/extension/libherb/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);
   }

package/extension/libherb/analyze/missing_end.c

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/src/analyze/missing_end.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.1/templates/src/analyze/missing_end.c.erb
 
 #include "../include/analyze/helpers.h"
 #include "../include/errors.h"