herb 0.10.4-arm-linux-gnu → 0.11.1-arm-linux-gnu

data/src/analyze/action_view/tag_helpers.c

@@ -14,6 +14,7 @@
 #include "../../include/location/position.h"
 #include "../../include/parser/parser_helpers.h"
 #include "../../include/util/html_util.h"
+#include "../../include/util/utf8.h"
 #include "../../include/util/util.h"
 #include "../../include/visitor.h"
 
@@ -36,6 +37,9 @@ extern bool detect_image_tag(pm_call_node_t*, pm_parser_t*);
 extern char* extract_image_tag_src(pm_call_node_t*, pm_parser_t*, hb_allocator_T*);
 extern char* wrap_in_image_path(const char*, size_t, const char*, hb_allocator_T*);
 extern bool image_tag_source_is_url(const char*, size_t);
+extern bool detect_stylesheet_link_tag(pm_call_node_t*, pm_parser_t*);
+extern char* wrap_in_stylesheet_path(const char*, size_t, const char*, hb_allocator_T*);
+extern bool stylesheet_link_tag_source_is_url(const char*, size_t);
 
 typedef struct {
   pm_parser_t parser;
@@ -48,10 +52,135 @@ typedef struct {
   size_t erb_content_offset;
 } tag_helper_parse_context_T;
 
+typedef struct {
+  tag_helper_scope_T* scope;
+  hb_array_T* constants;
+  size_t from;
+  size_t to;
+} local_read_search_T;
+
+static void append_local_read_constant(local_read_search_T* search, pm_constant_id_t constant_id) {
+  pm_constant_t* constant = pm_constant_pool_id_to_constant(&search->scope->parser.constant_pool, constant_id);
+
+  if (!constant || constant->length == 0) { return; }
+
+  for (size_t index = 0; index < hb_array_size(search->constants); index++) {
+    pm_constant_t* existing = hb_array_get(search->constants, index);
+
+    if (existing && existing->length == constant->length
+        && memcmp(existing->start, constant->start, constant->length) == 0) {
+      return;
+    }
+  }
+
+  hb_array_append(search->constants, constant);
+}
+
+static bool search_local_variable_reads(const pm_node_t* node, void* data) {
+  local_read_search_T* search = (local_read_search_T*) data;
+  const uint8_t* base = (const uint8_t*) search->scope->buffer.value;
+
+  size_t start = (size_t) (node->location.start - base);
+  size_t end = (size_t) (node->location.end - base);
+
+  if (end <= search->from || start >= search->to) { return false; }
+
+  if (PM_NODE_TYPE(node) == PM_LOCAL_VARIABLE_READ_NODE && start >= search->from && end <= search->to) {
+    append_local_read_constant(search, ((pm_local_variable_read_node_t*) node)->name);
+  }
+
+  return true;
+}
+
+static bool build_scope_options_from_context(
+  analyze_ruby_context_T* context,
+  pm_options_t* options,
+  size_t from,
+  size_t to
+) {
+  if (!context || !context->tag_helper_scope || !context->tag_helper_scope->root) { return false; }
+  if (to <= from) { return false; }
+
+  local_read_search_T search = { .scope = context->tag_helper_scope,
+                                 .constants = hb_array_init(4, context->allocator),
+                                 .from = from,
+                                 .to = to };
+
+  pm_visit_node(context->tag_helper_scope->root, search_local_variable_reads, &search);
+
+  size_t locals_count = hb_array_size(search.constants);
+  bool built = false;
+
+  if (locals_count > 0 && pm_options_scopes_init(options, 1)) {
+    pm_options_scope_t* scope = &options->scopes[0];
+
+    if (pm_options_scope_init(scope, locals_count)) {
+      for (size_t index = 0; index < locals_count; index++) {
+        pm_constant_t* constant = hb_array_get(search.constants, index);
+
+        pm_string_constant_init(&scope->locals[index], (const char*) constant->start, constant->length);
+      }
+
+      built = true;
+    } else {
+      pm_options_free(options);
+    }
+  }
+
+  hb_array_free(&search.constants);
+
+  return built;
+}
+
+static bool symbol_node_equals(pm_node_t* node, const char* name) {
+  if (!node || node->type != PM_SYMBOL_NODE) { return false; }
+
+  pm_symbol_node_t* symbol = (pm_symbol_node_t*) node;
+  size_t length = pm_string_length(&symbol->unescaped);
+
+  return length == strlen(name) && strncmp((const char*) pm_string_source(&symbol->unescaped), name, length) == 0;
+}
+
+static bool asset_tag_resolves_at_render_time(pm_call_node_t* call_node, const char* helper_name) {
+  bool is_stylesheet_link_tag = string_equals(helper_name, "stylesheet_link_tag");
+
+  if (!is_stylesheet_link_tag && !string_equals(helper_name, "javascript_include_tag")) { return false; }
+  if (!call_node || !call_node->arguments) { return false; }
+
+  pm_node_list_t* arguments = &call_node->arguments->arguments;
+
+  for (size_t i = 0; i < arguments->size; i++) {
+    pm_node_t* argument = arguments->nodes[i];
+
+    if (argument->type == PM_SPLAT_NODE || argument->type == PM_ARRAY_NODE) { return true; }
+
+    if (is_stylesheet_link_tag && i == 0
+        && (symbol_node_equals(argument, "all") || symbol_node_equals(argument, "app"))) {
+      return true;
+    }
+
+    if (argument->type != PM_KEYWORD_HASH_NODE) { continue; }
+
+    pm_keyword_hash_node_t* hash = (pm_keyword_hash_node_t*) argument;
+
+    for (size_t j = 0; j < hash->elements.size; j++) {
+      pm_node_t* element = hash->elements.nodes[j];
+      if (element->type != PM_ASSOC_NODE) { continue; }
+
+      pm_assoc_node_t* assoc = (pm_assoc_node_t*) element;
+
+      if (symbol_node_equals(assoc->key, "integrity") && assoc->value->type != PM_STRING_NODE) { return true; }
+    }
+  }
+
+  return false;
+}
+
 static tag_helper_parse_context_T* parse_tag_helper_content(
   const char* content_string,
   const char* original_source,
   size_t erb_content_offset,
+  analyze_ruby_context_T* context,
   hb_allocator_T* allocator
 ) {
   if (!content_string) { return NULL; }
@@ -64,9 +193,22 @@ static tag_helper_parse_context_T* parse_tag_helper_content(
   parse_context->original_source = original_source;
   parse_context->erb_content_offset = erb_content_offset;
 
-  pm_parser_init(&parse_context->parser, parse_context->prism_source, strlen(parse_context->content_string), NULL);
+  size_t content_length = strlen(parse_context->content_string);
+
+  pm_options_t options = { 0 };
+  bool has_scope_options =
+    build_scope_options_from_context(context, &options, erb_content_offset, erb_content_offset + content_length);
+
+  pm_parser_init(
+    &parse_context->parser,
+    parse_context->prism_source,
+    content_length,
+    has_scope_options ? &options : NULL
+  );
   parse_context->root = pm_parse(&parse_context->parser);
 
+  if (has_scope_options) { pm_options_free(&options); }
+
   if (!parse_context->root) {
     pm_parser_free(&parse_context->parser);
     hb_allocator_dealloc(allocator, parse_context->content_string);
@@ -83,7 +225,8 @@ static tag_helper_parse_context_T* parse_tag_helper_content(
                                       .found = false };
   pm_visit_node(parse_context->root, search_tag_helper_node, &search);
 
-  if (!search.found) {
+  if (!search.found
+      || asset_tag_resolves_at_render_time(parse_context->info->call_node, search.matched_handler->name)) {
     tag_helper_info_free(&parse_context->info);
     pm_node_destroy(&parse_context->parser, parse_context->root);
     pm_parser_free(&parse_context->parser);
@@ -116,22 +259,25 @@ bool search_tag_helper_node(const pm_node_t* node, void* data) {
 
   if (node->type == PM_CALL_NODE) {
     pm_call_node_t* call_node = (pm_call_node_t*) node;
-    tag_helper_handler_T* handlers = get_tag_helper_handlers();
+    const tag_helper_handler_T* const* handlers = get_tag_helper_handlers();
     size_t handlers_count = get_tag_helper_handlers_count();
 
     for (size_t i = 0; i < handlers_count; i++) {
-      if (handlers[i].detect(call_node, search_data->parser)) {
+      if (handlers[i]->detect(call_node, search_data->parser)) {
         search_data->tag_helper_node = node;
-        search_data->matched_handler = &handlers[i];
+        search_data->matched_handler = handlers[i];
         search_data->found = true;
 
         if (search_data->info) {
+          hb_allocator_T* info_allocator = search_data->info->allocator;
+
+          hb_allocator_dealloc(info_allocator, search_data->info->tag_name);
+          hb_allocator_dealloc(info_allocator, search_data->info->content);
+
           search_data->info->call_node = call_node;
-          search_data->info->tag_name =
-            handlers[i].extract_tag_name(call_node, search_data->parser, search_data->info->allocator);
-          search_data->info->content =
-            handlers[i].extract_content(call_node, search_data->parser, search_data->info->allocator);
-          search_data->info->has_block = handlers[i].supports_block();
+          search_data->info->tag_name = handlers[i]->extract_tag_name(call_node, search_data->parser, info_allocator);
+          search_data->info->content = handlers[i]->extract_content(call_node, search_data->parser, info_allocator);
+          search_data->info->has_block = handlers[i]->supports_block();
         }
 
         return false;
@@ -151,13 +297,17 @@ position_T byte_offset_to_position(const char* source, size_t offset) {
 
   if (!source) { return position; }
 
-  for (size_t i = 0; i < offset && source[i] != '\0'; i++) {
-    if (source[i] == '\n') {
-      position.line++;
-      position.column = 1;
-    } else {
-      position.column++;
-    }
+  const char* cursor = source;
+  const char* end = source + strnlen(source, offset);
+  const char* newline = NULL;
+
+  while ((newline = memchr(cursor, '\n', (size_t) (end - cursor))) != NULL) {
+    position.line++;
+    cursor = newline + 1;
+  }
+
+  for (; cursor < end; cursor++) {
+    if (!utf8_is_valid_continuation_byte((unsigned char) *cursor)) { position.column++; }
   }
 
   return position;
@@ -176,33 +326,40 @@ position_T prism_location_to_position_with_offset(
   size_t offset_in_erb = (size_t) (pm_location->start - erb_content_source);
   size_t total_offset = erb_content_offset + offset_in_erb;
 
-  size_t source_length = strlen(original_source);
-  if (total_offset > source_length) { return byte_offset_to_position(original_source, erb_content_offset); }
+  if (strnlen(original_source, total_offset) < total_offset) {
+    return byte_offset_to_position(original_source, erb_content_offset);
+  }
 
   return byte_offset_to_position(original_source, total_offset);
 }
 
 size_t calculate_byte_offset_from_position(const char* source, position_T position) {
   if (!source) { return 0; }
+  if (position.line == 0) { return strlen(source); }
+
+  const char* line_start = source;
+
+  for (uint32_t line = 1; line < position.line; line++) {
+    const char* newline = strchr(line_start, '\n');
+
+    if (!newline) { return (size_t) (line_start - source) + strlen(line_start); }
 
-  size_t offset = 0;
-  uint32_t line = 1;
+    line_start = newline + 1;
+  }
+
+  size_t offset = (size_t) (line_start - source);
   uint32_t column = 1;
 
   while (source[offset] != '\0') {
-    if (line == position.line && column == position.column) { return offset; }
+    if (column == position.column) { return offset; }
+    if (source[offset] == '\n') { break; }
 
-    if (source[offset] == '\n') {
-      line++;
-      column = 1;
-    } else {
-      column++;
-    }
+    if (!utf8_is_valid_continuation_byte((unsigned char) source[offset])) { column++; }
 
     offset++;
   }
 
-  return offset;
+  return offset + strlen(source + offset);
 }
 
 static void prism_node_location_to_positions(
@@ -243,6 +400,7 @@ static void calculate_tag_name_positions(
 }
 
 static const char* JAVASCRIPT_INCLUDE_TAG_PATH_OPTIONS[] = { "protocol", "extname", "host", "skip_pipeline", NULL };
+static const char* STYLESHEET_LINK_TAG_PATH_OPTIONS[] = { "protocol", "extname", "host", "skip_pipeline", NULL };
 static const char* IMAGE_TAG_PATH_OPTIONS[] = { "skip_pipeline", NULL };
 
 static char* extract_path_options_from_keyword_hash(
@@ -334,6 +492,75 @@ static AST_NODE_T* remove_attribute_by_name(hb_array_T* attributes, const char*
 
   return NULL;
 }
+
+static void discard_attribute_by_name(hb_array_T* attributes, const char* name, hb_allocator_T* allocator) {
+  ast_node_free(remove_attribute_by_name(attributes, name), allocator);
+}
+
+static hb_array_T* prepend_stylesheet_link_tag_attributes(
+  hb_array_T* attributes,
+  tag_helper_parse_context_T* parse_context,
+  pm_node_t* source_argument,
+  const char* path_options,
+  hb_allocator_T* allocator
+) {
+  bool source_is_string = (source_argument->type == PM_STRING_NODE);
+  char* source_value = NULL;
+
+  if (source_is_string) {
+    pm_string_node_t* string_node = (pm_string_node_t*) source_argument;
+    size_t length = pm_string_length(&string_node->unescaped);
+    source_value = hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+  } else {
+    size_t length = source_argument->location.end - source_argument->location.start;
+    source_value = hb_allocator_strndup(allocator, (const char*) source_argument->location.start, length);
+  }
+
+  if (!source_value) { return attributes; }
+
+  position_T source_start, source_end;
+  prism_node_location_to_positions(&source_argument->location, parse_context, &source_start, &source_end);
+
+  size_t source_length = strlen(source_value);
+  bool is_url = stylesheet_link_tag_source_is_url(source_value, source_length);
+  bool source_is_path_helper = is_route_helper_node(source_argument, &parse_context->parser);
+
+  char* href_value = source_value;
+
+  if (source_is_string && !is_url) {
+    size_t quoted_length = source_length + 2;
+    char* quoted_source = hb_allocator_alloc(allocator, quoted_length + 1);
+    quoted_source[0] = '"';
+    memcpy(quoted_source + 1, source_value, source_length);
+    quoted_source[quoted_length - 1] = '"';
+    quoted_source[quoted_length] = '\0';
+
+    href_value = wrap_in_stylesheet_path(quoted_source, quoted_length, path_options, allocator);
+    hb_allocator_dealloc(allocator, quoted_source);
+  } else if (!source_is_string && !is_url && !source_is_path_helper) {
+    href_value = wrap_in_stylesheet_path(source_value, source_length, path_options, allocator);
+  }
+
+  AST_HTML_ATTRIBUTE_NODE_T* href_attribute =
+    is_url ? create_html_attribute_node("href", href_value, source_start, source_end, allocator)
+           : create_html_attribute_with_ruby_literal("href", href_value, source_start, source_end, allocator);
+
+  if (href_value != source_value) { hb_allocator_dealloc(allocator, href_value); }
+  hb_allocator_dealloc(allocator, source_value);
+
+  if (href_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) href_attribute, allocator); }
+
+  AST_NODE_T* rel_attribute = remove_attribute_by_name(attributes, "rel");
+
+  if (!rel_attribute) {
+    rel_attribute = (AST_NODE_T*) create_html_attribute_node("rel", "stylesheet", source_start, source_end, allocator);
+  }
+
+  if (rel_attribute) { attributes = prepend_attribute(attributes, rel_attribute, allocator); }
+
+  return attributes;
+}
+
 static AST_NODE_T* transform_tag_helper_with_attributes(
   AST_ERB_CONTENT_NODE_T* erb_node,
   analyze_ruby_context_T* context,
@@ -366,7 +593,8 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
   }
 
   if (attributes && handler->name
-      && (strcmp(handler->name, "javascript_include_tag") == 0 || strcmp(handler->name, "javascript_tag") == 0)) {
+      && (strcmp(handler->name, "javascript_include_tag") == 0 || strcmp(handler->name, "javascript_tag") == 0
+          || strcmp(handler->name, "stylesheet_link_tag") == 0)) {
     resolve_nonce_attribute(attributes, allocator);
   }
 
@@ -379,16 +607,29 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
       allocator
     );
 
-    remove_attribute_by_name(attributes, "extname");
-    remove_attribute_by_name(attributes, "host");
-    remove_attribute_by_name(attributes, "protocol");
-    remove_attribute_by_name(attributes, "skip-pipeline");
+    discard_attribute_by_name(attributes, "extname", allocator);
+    discard_attribute_by_name(attributes, "host", allocator);
+    discard_attribute_by_name(attributes, "protocol", allocator);
+    discard_attribute_by_name(attributes, "skip-pipeline", allocator);
+  }
+
+  if (attributes && handler->name && strcmp(handler->name, "stylesheet_link_tag") == 0) {
+    path_options = extract_path_options_from_keyword_hash(
+      parse_context->info->call_node,
+      STYLESHEET_LINK_TAG_PATH_OPTIONS,
+      allocator
+    );
+
+    discard_attribute_by_name(attributes, "extname", allocator);
+    discard_attribute_by_name(attributes, "host", allocator);
+    discard_attribute_by_name(attributes, "protocol", allocator);
+    discard_attribute_by_name(attributes, "skip-pipeline", allocator);
   }
 
   if (attributes && handler->name && strcmp(handler->name, "image_tag") == 0) {
     path_options =
       extract_path_options_from_keyword_hash(parse_context->info->call_node, IMAGE_TAG_PATH_OPTIONS, allocator);
-    remove_attribute_by_name(attributes, "skip-pipeline");
+    discard_attribute_by_name(attributes, "skip-pipeline", allocator);
 
     AST_NODE_T* size_node = remove_attribute_by_name(attributes, "size");
 
@@ -472,6 +713,8 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
           }
         }
       }
+
+      ast_node_free(size_node, allocator);
     }
   }
 
@@ -622,15 +865,29 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
     }
   }
 
+  if (detect_stylesheet_link_tag(parse_context->info->call_node, &parse_context->parser)
+      && parse_context->info->call_node->arguments && parse_context->info->call_node->arguments->arguments.size >= 1) {
+    pm_node_t* first_argument = parse_context->info->call_node->arguments->arguments.nodes[0];
+
+    if (first_argument->type != PM_KEYWORD_HASH_NODE) {
+      if (!attributes) { attributes = hb_array_init(4, allocator); }
+
+      attributes =
+        prepend_stylesheet_link_tag_attributes(attributes, parse_context, first_argument, path_options, allocator);
+    }
+  }
+
   token_T* tag_name_token =
     tag_name ? create_synthetic_token(allocator, tag_name, TOKEN_IDENTIFIER, tag_name_start, tag_name_end) : NULL;
 
+  hb_allocator_dealloc(allocator, path_options);
+
   hb_array_T* open_tag_children = attributes ? attributes : hb_array_init(0, allocator);
 
   AST_ERB_OPEN_TAG_NODE_T* open_tag_node = ast_erb_open_tag_node_init(
-    erb_node->tag_opening,
-    erb_node->content,
-    erb_node->tag_closing,
+    token_copy(erb_node->tag_opening, allocator),
+    token_copy(erb_node->content, allocator),
+    token_copy(erb_node->tag_closing, allocator),
     tag_name_token,
     open_tag_children,
     erb_node->base.location.start,
@@ -643,7 +900,7 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
   hb_array_T* element_errors = hb_array_init(0, allocator);
   bool is_void = tag_name && is_void_element(hb_string_from_c_string(tag_name))
               && (string_equals(handler->name, "tag") || string_equals(handler->name, "content_tag")
-                  || string_equals(handler->name, "image_tag"));
+                  || string_equals(handler->name, "image_tag") || string_equals(handler->name, "stylesheet_link_tag"));
 
   if (helper_content) {
     if (is_void && tag_name) {
@@ -686,8 +943,11 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
         content_start,
         content_end,
         allocator,
-        element_errors
+        &element_errors,
+        context->options
       );
+
+      hb_buffer_free(&helper_name_buffer);
     }
 
     if (string_equals(handler->name, "javascript_tag")) {
@@ -728,7 +988,7 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
 
   if (!is_void) {
     AST_HTML_VIRTUAL_CLOSE_TAG_NODE_T* virtual_close = ast_html_virtual_close_tag_node_init(
-      tag_name_token,
+      token_copy(tag_name_token, allocator),
       erb_node->base.location.end,
       erb_node->base.location.end,
       hb_array_init(0, allocator),
@@ -739,7 +999,7 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
 
   AST_HTML_ELEMENT_NODE_T* element = ast_html_element_node_init(
     (AST_NODE_T*) open_tag_node,
-    tag_name_token,
+    token_copy(tag_name_token, allocator),
     body,
     close_tag,
     is_void,
@@ -754,7 +1014,7 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
   return (AST_NODE_T*) element;
 }
 
-static size_t count_javascript_include_tag_sources(pm_call_node_t* call_node) {
+static size_t count_asset_tag_sources(pm_call_node_t* call_node) {
   if (!call_node || !call_node->arguments) { return 0; }
 
   size_t count = 0;
@@ -835,9 +1095,9 @@ static AST_NODE_T* create_javascript_include_tag_element(
   hb_allocator_dealloc(allocator, source_value);
 
   AST_ERB_OPEN_TAG_NODE_T* open_tag_node = ast_erb_open_tag_node_init(
-    erb_node->tag_opening,
-    erb_node->content,
-    erb_node->tag_closing,
+    token_copy(erb_node->tag_opening, allocator),
+    token_copy(erb_node->content, allocator),
+    token_copy(erb_node->tag_closing, allocator),
     tag_name_token,
     attributes,
     erb_node->base.location.start,
@@ -847,7 +1107,7 @@ static AST_NODE_T* create_javascript_include_tag_element(
   );
 
   AST_HTML_VIRTUAL_CLOSE_TAG_NODE_T* virtual_close = ast_html_virtual_close_tag_node_init(
-    tag_name_token,
+    token_copy(tag_name_token, allocator),
     erb_node->base.location.end,
     erb_node->base.location.end,
     hb_array_init(0, allocator),
@@ -856,7 +1116,7 @@ static AST_NODE_T* create_javascript_include_tag_element(
 
   return (AST_NODE_T*) ast_html_element_node_init(
     (AST_NODE_T*) open_tag_node,
-    tag_name_token,
+    token_copy(tag_name_token, allocator),
     hb_array_init(0, allocator),
     (AST_NODE_T*) virtual_close,
     false,
@@ -868,6 +1128,31 @@ static AST_NODE_T* create_javascript_include_tag_element(
   );
 }
 
+static hb_array_T* build_asset_tag_attributes(
+  pm_call_node_t* call_node,
+  tag_helper_parse_context_T* parse_context,
+  hb_allocator_T* allocator
+) {
+  hb_array_T* attributes = extract_html_attributes_from_call_node(
+    call_node,
+    parse_context->prism_source,
+    parse_context->original_source,
+    parse_context->erb_content_offset,
+    allocator
+  );
+
+  if (!attributes) { attributes = hb_array_init(0, allocator); }
+
+  resolve_nonce_attribute(attributes, allocator);
+
+  discard_attribute_by_name(attributes, "extname", allocator);
+  discard_attribute_by_name(attributes, "host", allocator);
+  discard_attribute_by_name(attributes, "protocol", allocator);
+  discard_attribute_by_name(attributes, "skip-pipeline", allocator);
+
+  return attributes;
+}
+
 static hb_array_T* transform_javascript_include_tag_multi_source(
   AST_ERB_CONTENT_NODE_T* erb_node,
   analyze_ruby_context_T* context,
@@ -875,40 +1160,121 @@ static hb_array_T* transform_javascript_include_tag_multi_source(
 ) {
   hb_allocator_T* allocator = context->allocator;
   pm_call_node_t* call_node = parse_context->info->call_node;
-  size_t source_count = count_javascript_include_tag_sources(call_node);
+  size_t source_count = count_asset_tag_sources(call_node);
 
   if (source_count == 0) { return NULL; }
 
-  hb_array_T* shared_attributes = extract_html_attributes_from_call_node(
-    call_node,
-    parse_context->prism_source,
-    parse_context->original_source,
-    parse_context->erb_content_offset,
+  char* path_options =
+    extract_path_options_from_keyword_hash(call_node, JAVASCRIPT_INCLUDE_TAG_PATH_OPTIONS, allocator);
+  hb_array_T* elements = hb_array_init(source_count * 2, allocator);
+
+  for (size_t i = 0; i < source_count; i++) {
+    pm_node_t* source_arg = call_node->arguments->arguments.nodes[i];
+    hb_array_T* attributes = build_asset_tag_attributes(call_node, parse_context, allocator);
+
+    AST_NODE_T* element =
+      create_javascript_include_tag_element(erb_node, parse_context, source_arg, attributes, path_options, allocator);
+
+    hb_array_free(&attributes);
+
+    if (element) {
+      if (hb_array_size(elements) > 0) {
+        position_T position = erb_node->base.location.start;
+        AST_HTML_TEXT_NODE_T* newline = ast_html_text_node_init(
+          hb_string_from_c_string("\n"),
+          position,
+          position,
+          hb_array_init(0, allocator),
+          allocator
+        );
+        if (newline) { hb_array_append(elements, (AST_NODE_T*) newline); }
+      }
+
+      hb_array_append(elements, element);
+    }
+  }
+
+  hb_allocator_dealloc(allocator, path_options);
+
+  return elements;
+}
+
+static AST_NODE_T* create_stylesheet_link_tag_element(
+  AST_ERB_CONTENT_NODE_T* erb_node,
+  tag_helper_parse_context_T* parse_context,
+  pm_node_t* source_argument,
+  hb_array_T* shared_attributes,
+  const char* path_options,
+  hb_allocator_T* allocator
+) {
+  position_T tag_name_start, tag_name_end;
+  calculate_tag_name_positions(
+    parse_context,
+    erb_node->base.location.start,
+    erb_node->base.location.end,
+    &tag_name_start,
+    &tag_name_end
+  );
+
+  token_T* tag_name_token = create_synthetic_token(allocator, "link", TOKEN_IDENTIFIER, tag_name_start, tag_name_end);
+
+  hb_array_T* attributes = hb_array_init(hb_array_size(shared_attributes) + 2, allocator);
+
+  for (size_t i = 0; i < hb_array_size(shared_attributes); i++) {
+    hb_array_append(attributes, hb_array_get(shared_attributes, i));
+  }
+
+  attributes =
+    prepend_stylesheet_link_tag_attributes(attributes, parse_context, source_argument, path_options, allocator);
+
+  AST_ERB_OPEN_TAG_NODE_T* open_tag_node = ast_erb_open_tag_node_init(
+    token_copy(erb_node->tag_opening, allocator),
+    token_copy(erb_node->content, allocator),
+    token_copy(erb_node->tag_closing, allocator),
+    tag_name_token,
+    attributes,
+    erb_node->base.location.start,
+    erb_node->base.location.end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+
+  return (AST_NODE_T*) ast_html_element_node_init(
+    (AST_NODE_T*) open_tag_node,
+    token_copy(tag_name_token, allocator),
+    hb_array_init(0, allocator),
+    NULL,
+    true,
+    parse_context->matched_handler->source,
+    erb_node->base.location.start,
+    erb_node->base.location.end,
+    hb_array_init(0, allocator),
     allocator
   );
-  if (!shared_attributes) { shared_attributes = hb_array_init(0, allocator); }
+}
 
-  resolve_nonce_attribute(shared_attributes, allocator);
+static hb_array_T* transform_stylesheet_link_tag_multi_source(
+  AST_ERB_CONTENT_NODE_T* erb_node,
+  analyze_ruby_context_T* context,
+  tag_helper_parse_context_T* parse_context
+) {
+  hb_allocator_T* allocator = context->allocator;
+  pm_call_node_t* call_node = parse_context->info->call_node;
+  size_t source_count = count_asset_tag_sources(call_node);
 
-  char* path_options =
-    extract_path_options_from_keyword_hash(call_node, JAVASCRIPT_INCLUDE_TAG_PATH_OPTIONS, allocator);
-  remove_attribute_by_name(shared_attributes, "extname");
-  remove_attribute_by_name(shared_attributes, "host");
-  remove_attribute_by_name(shared_attributes, "protocol");
-  remove_attribute_by_name(shared_attributes, "skip-pipeline");
+  if (source_count == 0) { return NULL; }
 
+  char* path_options = extract_path_options_from_keyword_hash(call_node, STYLESHEET_LINK_TAG_PATH_OPTIONS, allocator);
   hb_array_T* elements = hb_array_init(source_count * 2, allocator);
 
   for (size_t i = 0; i < source_count; i++) {
     pm_node_t* source_arg = call_node->arguments->arguments.nodes[i];
-    AST_NODE_T* element = create_javascript_include_tag_element(
-      erb_node,
-      parse_context,
-      source_arg,
-      shared_attributes,
-      path_options,
-      allocator
-    );
+    hb_array_T* attributes = build_asset_tag_attributes(call_node, parse_context, allocator);
+
+    AST_NODE_T* element =
+      create_stylesheet_link_tag_element(erb_node, parse_context, source_arg, attributes, path_options, allocator);
+
+    hb_array_free(&attributes);
 
     if (element) {
       if (hb_array_size(elements) > 0) {
@@ -927,6 +1293,8 @@ static hb_array_T* transform_javascript_include_tag_multi_source(
     }
   }
 
+  hb_allocator_dealloc(allocator, path_options);
+
   return elements;
 }
 
@@ -1073,9 +1441,9 @@ static AST_NODE_T* transform_erb_block_to_tag_helper(
   hb_array_T* open_tag_children = attributes ? attributes : hb_array_init(0, allocator);
 
   AST_ERB_OPEN_TAG_NODE_T* open_tag_node = ast_erb_open_tag_node_init(
-    block_node->tag_opening,
-    block_node->content,
-    block_node->tag_closing,
+    token_copy(block_node->tag_opening, allocator),
+    token_copy(block_node->content, allocator),
+    token_copy(block_node->tag_closing, allocator),
     tag_name_token,
     open_tag_children,
     block_node->tag_opening->location.start,
@@ -1117,7 +1485,8 @@ static AST_NODE_T* transform_erb_block_to_tag_helper(
       block_node->base.location.start,
       block_node->base.location.end,
       allocator,
-      element_errors
+      &element_errors,
+      context->options
     );
   }
 
@@ -1135,9 +1504,9 @@ static AST_NODE_T* transform_erb_block_to_tag_helper(
         end_offset = swallowed_end->tag_opening->range.from;
 
         AST_ERB_END_NODE_T* end_node = ast_erb_end_node_init(
-          swallowed_end->tag_opening,
-          swallowed_end->content,
-          swallowed_end->tag_closing,
+          token_copy(swallowed_end->tag_opening, allocator),
+          token_copy(swallowed_end->content, allocator),
+          token_copy(swallowed_end->tag_closing, allocator),
           swallowed_end->base.location.start,
           swallowed_end->base.location.end,
           hb_array_init(0, allocator),
@@ -1163,13 +1532,26 @@ static AST_NODE_T* transform_erb_block_to_tag_helper(
       body_options.start_column = body_start.column;
 
       AST_DOCUMENT_NODE_T* body_document = herb_parse(raw_copy, &body_options, allocator);
+
       body = body_document->children;
+      body_document->children = NULL;
+
+      ast_node_free((AST_NODE_T*) body_document, allocator);
+
+      for (size_t index = 0; index < hb_array_size(body); index++) {
+        ast_node_rebase_tokens(hb_array_get(body, index), raw_copy, context->source + start_offset, content_length);
+      }
+
+      hb_allocator_dealloc(allocator, raw_copy);
     }
   }
 
+  if (body == block_node->body) { block_node->body = NULL; }
+  if (!is_void && close_tag == (AST_NODE_T*) block_node->end_node) { block_node->end_node = NULL; }
+
   AST_HTML_ELEMENT_NODE_T* element = ast_html_element_node_init(
     (AST_NODE_T*) open_tag_node,
-    tag_name_token,
+    token_copy(tag_name_token, allocator),
     body,
     is_void ? NULL : close_tag,
     is_void,
@@ -1339,9 +1721,9 @@ static AST_NODE_T* transform_link_to_helper(
   token_T* tag_name_token = create_synthetic_token(allocator, "a", TOKEN_IDENTIFIER, tag_name_start, tag_name_end);
 
   AST_ERB_OPEN_TAG_NODE_T* open_tag_node = ast_erb_open_tag_node_init(
-    erb_node->tag_opening,
-    erb_node->content,
-    erb_node->tag_closing,
+    token_copy(erb_node->tag_opening, allocator),
+    token_copy(erb_node->content, allocator),
+    token_copy(erb_node->tag_closing, allocator),
     tag_name_token,
     attributes,
     erb_node->base.location.start,
@@ -1392,16 +1774,16 @@ static AST_NODE_T* transform_link_to_helper(
   }
 
   AST_HTML_VIRTUAL_CLOSE_TAG_NODE_T* virtual_close = ast_html_virtual_close_tag_node_init(
-    tag_name_token,
+    token_copy(tag_name_token, allocator),
     erb_node->base.location.end,
     erb_node->base.location.end,
     hb_array_init(0, allocator),
     allocator
   );
 
-  AST_HTML_ELEMENT_NODE_T* element = ast_html_element_node_init(
+  return (AST_NODE_T*) ast_html_element_node_init(
     (AST_NODE_T*) open_tag_node,
-    tag_name_token,
+    token_copy(tag_name_token, allocator),
     body,
     (AST_NODE_T*) virtual_close,
     false,
@@ -1411,8 +1793,6 @@ static AST_NODE_T* transform_link_to_helper(
     hb_array_init(0, allocator),
     allocator
   );
-
-  return (AST_NODE_T*) element;
 }
 
 void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* context) {
@@ -1430,8 +1810,7 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
       if (token_is_escaped_erb_tag_opening(block_node->tag_opening)) { continue; }
 
       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; }
+        if (!hb_string_contains_character(block_node->tag_opening->value, '=')) { continue; }
       }
 
       token_T* block_content = block_node->content;
@@ -1445,7 +1824,7 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
         }
 
         tag_helper_parse_context_T* parse_context =
-          parse_tag_helper_content(block_string, context->source, erb_content_offset, context->allocator);
+          parse_tag_helper_content(block_string, context->source, erb_content_offset, context, context->allocator);
 
         if (parse_context) {
           replacement = transform_erb_block_to_tag_helper(block_node, context, parse_context);
@@ -1461,10 +1840,8 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
       if (token_is_escaped_erb_tag_opening(tag_opening)) { continue; }
 
       if (tag_opening && !hb_string_is_empty(tag_opening->value)) {
-        const char* opening_string = tag_opening->value.data;
-
-        if (opening_string && strstr(opening_string, "#") != NULL) { continue; }
-        if (opening_string && strstr(opening_string, "=") == NULL) { continue; }
+        if (hb_string_contains_character(tag_opening->value, '#')) { continue; }
+        if (!hb_string_contains_character(tag_opening->value, '=')) { continue; }
       }
 
       token_T* erb_content = erb_node->content;
@@ -1478,13 +1855,18 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
         }
 
         tag_helper_parse_context_T* parse_context =
-          parse_tag_helper_content(erb_string, context->source, erb_content_offset, context->allocator);
+          parse_tag_helper_content(erb_string, context->source, erb_content_offset, context, context->allocator);
 
         if (parse_context) {
-          if (strcmp(parse_context->matched_handler->name, "javascript_include_tag") == 0
-              && parse_context->info->call_node
-              && count_javascript_include_tag_sources(parse_context->info->call_node) > 1) {
-            hb_array_T* multi = transform_javascript_include_tag_multi_source(erb_node, context, parse_context);
+          bool is_multi_source_asset_tag = (strcmp(parse_context->matched_handler->name, "javascript_include_tag") == 0
+                                            || strcmp(parse_context->matched_handler->name, "stylesheet_link_tag") == 0)
+                                        && parse_context->info->call_node
+                                        && count_asset_tag_sources(parse_context->info->call_node) > 1;
+
+          if (is_multi_source_asset_tag) {
+            hb_array_T* multi = strcmp(parse_context->matched_handler->name, "stylesheet_link_tag") == 0
+                                ? transform_stylesheet_link_tag_multi_source(erb_node, context, parse_context)
+                                : transform_javascript_include_tag_multi_source(erb_node, context, parse_context);
 
             if (multi && hb_array_size(multi) > 0) {
               size_t old_size = hb_array_size(array);
@@ -1501,9 +1883,9 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
                 }
               }
 
-              array->items = new_array->items;
-              array->size = new_array->size;
-              array->capacity = new_array->capacity;
+              hb_array_replace_contents(array, &new_array);
+              hb_array_free(&multi);
+              ast_node_free(child, context->allocator);
 
               i += multi_size - 1;
             }
@@ -1538,9 +1920,9 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
                 }
               }
 
-              array->items = new_array->items;
-              array->size = new_array->size;
-              array->capacity = new_array->capacity;
+              hb_array_replace_contents(array, &new_array);
+              hb_array_free(&attributes);
+              ast_node_free(child, context->allocator);
 
               i += attributes_size - 1;
             }
@@ -1573,7 +1955,7 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
             }
 
             tag_helper_parse_context_T* parse_context =
-              parse_tag_helper_content(erb_string, context->source, erb_content_offset, context->allocator);
+              parse_tag_helper_content(erb_string, context->source, erb_content_offset, context, context->allocator);
 
             if (parse_context && string_equals(parse_context->matched_handler->name, "tag")
                 && parse_context->info->tag_name && string_equals(parse_context->info->tag_name, "attributes")) {
@@ -1604,9 +1986,9 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
                   }
                 }
 
-                array->items = new_array->items;
-                array->size = new_array->size;
-                array->capacity = new_array->capacity;
+                hb_array_replace_contents(array, &new_array);
+                hb_array_free(&attributes);
+                ast_node_free(child, context->allocator);
 
                 i += attributes_size - 1;
               }
@@ -1684,9 +2066,9 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
               }
             }
 
-            array->items = new_array->items;
-            array->size = new_array->size;
-            array->capacity = new_array->capacity;
+            hb_array_replace_contents(array, &new_array);
+            ast_node_free(child, context->allocator);
+
             i++;
             continue;
           }
@@ -1694,6 +2076,7 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
       }
 
       hb_array_set(array, i, replacement);
+      ast_node_free(child, context->allocator);
     }
   }
 }
@@ -1714,6 +2097,9 @@ void transform_tag_helper_blocks(const AST_NODE_T* node, analyze_ruby_context_T*
       transform_tag_helper_array(((AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node)->children, context);
       break;
     case AST_ERB_BLOCK_NODE: transform_tag_helper_array(((AST_ERB_BLOCK_NODE_T*) node)->body, context); break;
+    case AST_ERB_ITERATION_BLOCK_NODE:
+      transform_tag_helper_array(((AST_ERB_ITERATION_BLOCK_NODE_T*) node)->body, context);
+      break;
     case AST_ERB_IF_NODE: transform_tag_helper_array(((AST_ERB_IF_NODE_T*) node)->statements, context); break;
     case AST_ERB_ELSE_NODE: transform_tag_helper_array(((AST_ERB_ELSE_NODE_T*) node)->statements, context); break;
     case AST_ERB_UNLESS_NODE: transform_tag_helper_array(((AST_ERB_UNLESS_NODE_T*) node)->statements, context); break;