herb 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a552819ddaf0c50275110d19455609f491dfb3298da4b76e898eb996bc458e4a
-  data.tar.gz: 835fc30e2530c8c98aa2077d607f061f78f5ae4030e3c3d449bc2ac9796a6ea4
+  metadata.gz: 3a1a61c49f642abaffb189b7ff947009cc5c2e808d4eaa5e8103f0086b6b6b78
+  data.tar.gz: d26cdc1d962413d92cc6a2800f4c183777e690aa95c7ab918b5ef4f6591e9278
 SHA512:
-  metadata.gz: 3b9e9362ffce00e457a3df27e834419f5a8a0351ef313b7b73b0ae7a0f44dd4689dde96586342ed11ea736ac16baff2473fbab23f141b8f51bdc92aef7cc9d44
-  data.tar.gz: e76c844b40670b773106547cefd1955fb42867f08f49134557946b24f008187a1cdea4c5f010c40e27505c6dd4bdd4c4f5fa1aae16f92ab45f3a2dbff867d082
+  metadata.gz: df024e2b48dadab5af063c54e614948dc46efed4aed24f813476ca491164db7b863692a6617f580bf2e9523701a2f76a8c392935a6fb40cb4b269eece5fb1737
+  data.tar.gz: cfb04158d09179dc2a5d08b96a3300b1748ba1ec66afb71c5004e1eaabf1c4cfcfc8b1296d0fb613152eafd0927c400df43622463d5850b341ddfcb6aa03fae4

data/lib/herb/engine/compiler.rb

@@ -10,9 +10,6 @@ module Herb
 
         @engine = engine
         @escape = options.fetch(:escape) { options.fetch(:escape_html, false) }
-        @attrfunc = options.fetch(:attrfunc, @escape ? "__herb.attr" : "::Herb::Engine.attr")
-        @jsfunc = options.fetch(:jsfunc, @escape ? "__herb.js" : "::Herb::Engine.js")
-        @cssfunc = options.fetch(:cssfunc, @escape ? "__herb.css" : "::Herb::Engine.css")
         @tokens = [] #: Array[untyped]
         @element_stack = [] #: Array[String]
         @context_stack = [:html_content]
@@ -28,26 +25,16 @@ module Herb
             @engine.send(:add_text, value)
           when :code
             @engine.send(:add_code, value)
-          when :expr
-            if [:attribute_value, :script_content, :style_content].include?(context)
-              add_context_aware_expression(value, context)
-            else
-              indicator = @escape ? "==" : "="
-              @engine.send(:add_expression, indicator, value)
-            end
-          when :expr_escaped
-            if [:attribute_value, :script_content, :style_content].include?(context)
-              add_context_aware_expression(value, context)
+          when :expr, :expr_escaped
+            indicator = indicator_for(type)
+
+            if context_aware_context?(context)
+              @engine.send(:add_context_aware_expression, indicator, value, context)
             else
-              indicator = @escape ? "=" : "=="
               @engine.send(:add_expression, indicator, value)
             end
-          when :expr_block
-            indicator = @escape ? "==" : "="
-            @engine.send(:add_expression_block, indicator, value)
-          when :expr_block_escaped
-            indicator = @escape ? "=" : "=="
-            @engine.send(:add_expression_block, indicator, value)
+          when :expr_block, :expr_block_escaped
+            @engine.send(:add_expression_block, indicator_for(type), value)
           when :expr_block_end
             @engine.send(:add_expression_block_end, value, escaped: escaped)
           end
@@ -342,27 +329,6 @@ module Herb
         @context_stack.pop
       end
 
-      def add_context_aware_expression(code, context)
-        closing = code.include?("#") ? "\n))" : "))"
-
-        case context
-        when :attribute_value
-          @engine.send(:with_buffer) {
-            @engine.src << " << #{@attrfunc}((" << code << closing
-          }
-        when :script_content
-          @engine.send(:with_buffer) {
-            @engine.src << " << #{@jsfunc}((" << code << closing
-          }
-        when :style_content
-          @engine.send(:with_buffer) {
-            @engine.src << " << #{@cssfunc}((" << code << closing
-          }
-        else
-          @engine.send(:add_expression_result_escaped, code)
-        end
-      end
-
       def process_erb_tag(node, skip_comment_check: false)
         opening = node.tag_opening.value
 
@@ -503,6 +469,16 @@ module Herb
         @trim_next_whitespace = true if has_right_trim
       end
 
+      def indicator_for(type)
+        escaped = [:expr_escaped, :expr_block_escaped].include?(type)
+
+        escaped ^ @escape ? "==" : "="
+      end
+
+      def context_aware_context?(context)
+        [:attribute_value, :script_content, :style_content].include?(context)
+      end
+
       def should_escape_output?(opening)
         is_double_equals = opening == "<%=="
         is_double_equals ? !@escape : @escape

data/lib/herb/engine.rb

@@ -55,6 +55,9 @@ module Herb
       @bufvar = properties[:bufvar] || properties[:outvar] || "_buf"
       @escape = properties.fetch(:escape) { properties.fetch(:escape_html, false) }
       @escapefunc = properties.fetch(:escapefunc, @escape ? "__herb.h" : "::Herb::Engine.h")
+      @attrfunc = properties.fetch(:attrfunc, @escape ? "__herb.attr" : "::Herb::Engine.attr")
+      @jsfunc = properties.fetch(:jsfunc, @escape ? "__herb.js" : "::Herb::Engine.js")
+      @cssfunc = properties.fetch(:cssfunc, @escape ? "__herb.css" : "::Herb::Engine.css")
       @src = properties[:src] || String.new
       @chain_appends = properties[:chain_appends]
       @buffer_on_stack = false
@@ -244,6 +247,24 @@ module Herb
       end
     end
 
+    def add_context_aware_expression(indicator, code, context)
+      escapefunc = context_escape_function(context)
+
+      if escapefunc.nil?
+        add_expression(indicator, code)
+      else
+        with_buffer { @src << " << #{escapefunc}((" << code << trailing_newline(code) << "))" }
+      end
+    end
+
+    def context_escape_function(context)
+      case context
+      when :attribute_value then @attrfunc
+      when :script_content then @jsfunc
+      when :style_content then @cssfunc
+      end
+    end
+
     def add_expression_result(code)
       with_buffer {
         @src << " << (" << code << trailing_newline(code) << ").to_s"

data/lib/herb/version.rb

@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.9.1"
+  VERSION = "0.9.2"
 end

data/sig/herb/engine/compiler.rbs

@@ -89,8 +89,6 @@ module Herb
 
       def pop_context: () -> untyped
 
-      def add_context_aware_expression: (untyped code, untyped context) -> untyped
-
       def process_erb_tag: (untyped node, ?skip_comment_check: untyped) -> untyped
 
       def add_text: (untyped text) -> untyped
@@ -119,6 +117,10 @@ module Herb
 
       def process_erb_output: (untyped node, untyped opening, untyped code) -> untyped
 
+      def indicator_for: (untyped type) -> untyped
+
+      def context_aware_context?: (untyped context) -> untyped
+
       def should_escape_output?: (untyped opening) -> untyped
 
       def add_expression_with_escaping: (untyped code, untyped should_escape) -> untyped

data/sig/herb/engine.rbs

@@ -55,6 +55,10 @@ module Herb
 
     def add_expression: (untyped indicator, untyped code) -> untyped
 
+    def add_context_aware_expression: (untyped indicator, untyped code, untyped context) -> untyped
+
+    def context_escape_function: (untyped context) -> untyped
+
     def add_expression_result: (untyped code) -> untyped
 
     def add_expression_result_escaped: (untyped code) -> untyped

data/src/analyze/action_view/attribute_extraction_helpers.c

@@ -1,5 +1,6 @@
 #include "../../include/analyze/action_view/attribute_extraction_helpers.h"
 #include "../../include/analyze/action_view/tag_helper_node_builders.h"
+#include "../../include/html_util.h"
 #include "../../include/util.h"
 #include "../../include/util/hb_allocator.h"
 #include "../../include/util/hb_array.h"
@@ -58,6 +59,14 @@ static AST_HTML_ATTRIBUTE_NODE_T* create_attribute_from_value(
     hb_allocator_dealloc(allocator, value_string);
 
     return attribute;
+  } else if (value_node->type == PM_TRUE_NODE) {
+    if (is_boolean_attribute(hb_string((char*) name_string))) {
+      return create_html_attribute_node(name_string, NULL, start_position, end_position, allocator);
+    }
+    return create_html_attribute_node(name_string, "true", start_position, end_position, allocator);
+  } else if (value_node->type == PM_FALSE_NODE) {
+    if (is_boolean_attribute(hb_string((char*) name_string))) { return NULL; }
+    return create_html_attribute_node(name_string, "false", start_position, end_position, allocator);
   } else if (value_node->type == PM_INTERPOLATED_STRING_NODE) {
     return create_html_attribute_with_interpolated_value(
       name_string,

data/src/analyze/action_view/javascript_include_tag.c

@@ -0,0 +1,92 @@
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+bool detect_javascript_include_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
+  if (!call_node || !call_node->name) { return false; }
+
+  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  return constant && constant->length == 22
+      && strncmp((const char*) constant->start, "javascript_include_tag", 22) == 0;
+}
+
+char* extract_javascript_include_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  (void) call_node;
+  (void) parser;
+
+  return hb_allocator_strdup(allocator, "script");
+}
+
+char* extract_javascript_include_tag_content(
+  pm_call_node_t* call_node,
+  pm_parser_t* parser,
+  hb_allocator_T* allocator
+) {
+  (void) call_node;
+  (void) parser;
+  (void) allocator;
+
+  return NULL;
+}
+
+char* extract_javascript_include_tag_src(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  (void) parser;
+
+  if (!call_node || !call_node->arguments) { return NULL; }
+
+  pm_arguments_node_t* arguments = call_node->arguments;
+  if (!arguments->arguments.size) { return NULL; }
+
+  pm_node_t* first_argument = arguments->arguments.nodes[0];
+
+  if (first_argument->type == PM_STRING_NODE) {
+    pm_string_node_t* string_node = (pm_string_node_t*) first_argument;
+    size_t length = pm_string_length(&string_node->unescaped);
+
+    return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+  }
+
+  size_t source_length = first_argument->location.end - first_argument->location.start;
+  return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+}
+
+bool javascript_include_tag_source_is_url(const char* source, size_t length) {
+  if (!source || length == 0) { return false; }
+
+  if (length >= 2 && source[0] == '/' && source[1] == '/') { return true; }
+  if (strstr(source, "://") != NULL) { return true; }
+
+  return false;
+}
+
+char* wrap_in_javascript_path(const char* source, size_t source_length, hb_allocator_T* allocator) {
+  const char* prefix = "javascript_path(";
+  const char* suffix = ")";
+  size_t prefix_length = strlen(prefix);
+  size_t suffix_length = strlen(suffix);
+  size_t total_length = prefix_length + source_length + suffix_length;
+  char* result = hb_allocator_alloc(allocator, total_length + 1);
+
+  memcpy(result, prefix, prefix_length);
+  memcpy(result + prefix_length, source, source_length);
+  memcpy(result + prefix_length + source_length, suffix, suffix_length);
+  result[total_length] = '\0';
+
+  return result;
+}
+
+bool javascript_include_tag_supports_block(void) {
+  return false;
+}
+
+const tag_helper_handler_T javascript_include_tag_handler = {
+  .name = "javascript_include_tag",
+  .source = HB_STRING_LITERAL("ActionView::Helpers::AssetTagHelper#javascript_include_tag"),
+  .detect = detect_javascript_include_tag,
+  .extract_tag_name = extract_javascript_include_tag_name,
+  .extract_content = extract_javascript_include_tag_content,
+  .supports_block = javascript_include_tag_supports_block
+};

data/src/analyze/action_view/javascript_tag.c

@@ -0,0 +1,55 @@
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+bool detect_javascript_tag(pm_call_node_t* call_node, pm_parser_t* parser) {
+  if (!call_node || !call_node->name) { return false; }
+
+  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  return constant && constant->length == 14 && strncmp((const char*) constant->start, "javascript_tag", 14) == 0;
+}
+
+char* extract_javascript_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  (void) call_node;
+  (void) parser;
+
+  return hb_allocator_strdup(allocator, "script");
+}
+
+char* extract_javascript_tag_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  (void) parser;
+
+  if (!call_node || !call_node->arguments) { return NULL; }
+
+  pm_arguments_node_t* arguments = call_node->arguments;
+  if (!arguments->arguments.size) { return NULL; }
+
+  pm_node_t* first_argument = arguments->arguments.nodes[0];
+
+  if (first_argument->type == PM_KEYWORD_HASH_NODE) { return NULL; }
+
+  if (first_argument->type == PM_STRING_NODE) {
+    pm_string_node_t* string_node = (pm_string_node_t*) first_argument;
+    size_t length = pm_string_length(&string_node->unescaped);
+    return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
+  }
+
+  size_t source_length = first_argument->location.end - first_argument->location.start;
+  return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+}
+
+bool javascript_tag_supports_block(void) {
+  return true;
+}
+
+const tag_helper_handler_T javascript_tag_handler = {
+  .name = "javascript_tag",
+  .source = HB_STRING_LITERAL("ActionView::Helpers::JavaScriptHelper#javascript_tag"),
+  .detect = detect_javascript_tag,
+  .extract_tag_name = extract_javascript_tag_name,
+  .extract_content = extract_javascript_tag_content,
+  .supports_block = javascript_tag_supports_block
+};

data/src/analyze/action_view/registry.c

@@ -8,8 +8,10 @@ extern const tag_helper_handler_T content_tag_handler;
 extern const tag_helper_handler_T tag_dot_handler;
 extern const tag_helper_handler_T link_to_handler;
 extern const tag_helper_handler_T turbo_frame_tag_handler;
+extern const tag_helper_handler_T javascript_tag_handler;
+extern const tag_helper_handler_T javascript_include_tag_handler;
 
-static size_t handlers_count = 4;
+static size_t handlers_count = 6;
 
 tag_helper_info_T* tag_helper_info_init(hb_allocator_T* allocator) {
   tag_helper_info_T* info = hb_allocator_alloc(allocator, sizeof(tag_helper_info_T));
@@ -41,7 +43,7 @@ void tag_helper_info_free(tag_helper_info_T** info) {
 }
 
 tag_helper_handler_T* get_tag_helper_handlers(void) {
-  static tag_helper_handler_T static_handlers[4];
+  static tag_helper_handler_T static_handlers[6];
   static bool initialized = false;
 
   if (!initialized) {
@@ -49,6 +51,8 @@ tag_helper_handler_T* get_tag_helper_handlers(void) {
     static_handlers[1] = tag_dot_handler;
     static_handlers[2] = link_to_handler;
     static_handlers[3] = turbo_frame_tag_handler;
+    static_handlers[4] = javascript_tag_handler;
+    static_handlers[5] = javascript_include_tag_handler;
     initialized = true;
   }
 

data/src/analyze/action_view/tag_helper_node_builders.c

@@ -88,7 +88,8 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_node(
   AST_HTML_ATTRIBUTE_NAME_NODE_T* name_node =
     create_attribute_name_node(name_string, start_position, end_position, allocator);
 
-  token_T* equals_token = create_synthetic_token(allocator, "=", TOKEN_EQUALS, start_position, end_position);
+  token_T* equals_token =
+    value_string ? create_synthetic_token(allocator, "=", TOKEN_EQUALS, start_position, end_position) : NULL;
   AST_HTML_ATTRIBUTE_VALUE_NODE_T* value_node = NULL;
 
   if (value_string) {
@@ -210,8 +211,20 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* create_interpolated_attribute_value(
         }
       }
     } else if (part->type == PM_EMBEDDED_STATEMENTS_NODE) {
-      size_t ruby_length = part->location.end - part->location.start;
-      char* ruby_content = hb_allocator_strndup(allocator, (const char*) part->location.start, ruby_length);
+      pm_embedded_statements_node_t* embedded = (pm_embedded_statements_node_t*) part;
+      const uint8_t* content_start;
+      const uint8_t* content_end;
+
+      if (embedded->statements) {
+        content_start = embedded->statements->base.location.start;
+        content_end = embedded->statements->base.location.end;
+      } else {
+        content_start = part->location.start;
+        content_end = part->location.end;
+      }
+
+      size_t ruby_length = content_end - content_start;
+      char* ruby_content = hb_allocator_strndup(allocator, (const char*) content_start, ruby_length);
 
       if (ruby_content) {
         AST_RUBY_LITERAL_NODE_T* ruby_node = ast_ruby_literal_node_init(

data/src/analyze/action_view/tag_helpers.c

@@ -5,6 +5,7 @@
 #include "../../include/analyze/analyze.h"
 #include "../../include/ast_nodes.h"
 #include "../../include/html_util.h"
+#include "../../include/parser_helpers.h"
 #include "../../include/position.h"
 #include "../../include/util/hb_allocator.h"
 #include "../../include/util/hb_array.h"
@@ -22,6 +23,10 @@ extern char* wrap_in_url_for(const char*, size_t, hb_allocator_T*);
 extern char* extract_link_to_href(pm_call_node_t*, pm_parser_t*, hb_allocator_T*);
 extern bool detect_turbo_frame_tag(pm_call_node_t*, pm_parser_t*);
 extern char* extract_turbo_frame_tag_id(pm_call_node_t*, pm_parser_t*, hb_allocator_T*);
+extern bool detect_javascript_include_tag(pm_call_node_t*, pm_parser_t*);
+extern char* extract_javascript_include_tag_src(pm_call_node_t*, pm_parser_t*, hb_allocator_T*);
+extern char* wrap_in_javascript_path(const char*, size_t, hb_allocator_T*);
+extern bool javascript_include_tag_source_is_url(const char*, size_t);
 
 typedef struct {
   pm_parser_t parser;
@@ -310,6 +315,47 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
     }
   }
 
+  if (detect_javascript_include_tag(parse_context->info->call_node, &parse_context->parser)
+      && parse_context->info->call_node->arguments && parse_context->info->call_node->arguments->arguments.size >= 1) {
+    char* source_value =
+      extract_javascript_include_tag_src(parse_context->info->call_node, &parse_context->parser, allocator);
+
+    if (source_value) {
+      if (!attributes) { attributes = hb_array_init(4, allocator); }
+
+      pm_node_t* first_argument = parse_context->info->call_node->arguments->arguments.nodes[0];
+      position_T source_start, source_end;
+      prism_node_location_to_positions(&first_argument->location, parse_context, &source_start, &source_end);
+      bool source_is_string = (first_argument->type == PM_STRING_NODE);
+
+      size_t source_length = strlen(source_value);
+      bool is_url = javascript_include_tag_source_is_url(source_value, source_length);
+
+      char* source_attribute_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';
+
+        source_attribute_value = wrap_in_javascript_path(quoted_source, quoted_length, allocator);
+        hb_allocator_dealloc(allocator, quoted_source);
+      }
+
+      AST_HTML_ATTRIBUTE_NODE_T* source_attribute =
+        is_url
+          ? create_html_attribute_node("src", source_attribute_value, source_start, source_end, allocator)
+          : create_html_attribute_with_ruby_literal("src", source_attribute_value, source_start, source_end, allocator);
+
+      if (source_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) source_attribute, allocator); }
+
+      if (source_attribute_value != source_value) { hb_allocator_dealloc(allocator, source_attribute_value); }
+      hb_allocator_dealloc(allocator, source_value);
+    }
+  }
+
   token_T* tag_name_token =
     tag_name ? create_synthetic_token(allocator, tag_name, TOKEN_IDENTIFIER, tag_name_start, tag_name_end) : NULL;
 
@@ -372,6 +418,166 @@ 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) {
+  if (!call_node || !call_node->arguments) { return 0; }
+
+  size_t count = 0;
+  pm_arguments_node_t* arguments = call_node->arguments;
+
+  for (size_t i = 0; i < arguments->arguments.size; i++) {
+    pm_node_t* arg = arguments->arguments.nodes[i];
+    if (arg->type == PM_KEYWORD_HASH_NODE) { break; }
+    count++;
+  }
+
+  return count;
+}
+
+static AST_NODE_T* create_javascript_include_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,
+  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, "script", TOKEN_IDENTIFIER, tag_name_start, tag_name_end);
+
+  char* source_value = NULL;
+  bool source_is_string = (source_argument->type == PM_STRING_NODE);
+
+  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 source_length = source_argument->location.end - source_argument->location.start;
+    source_value = hb_allocator_strndup(allocator, (const char*) source_argument->location.start, source_length);
+  }
+
+  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 = javascript_include_tag_source_is_url(source_value, source_length);
+
+  char* source_attribute_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';
+
+    source_attribute_value = wrap_in_javascript_path(quoted_source, quoted_length, allocator);
+    hb_allocator_dealloc(allocator, quoted_source);
+  }
+
+  hb_array_T* attributes = hb_array_init(hb_array_size(shared_attributes) + 1, allocator);
+
+  AST_HTML_ATTRIBUTE_NODE_T* source_attribute =
+    is_url
+      ? create_html_attribute_node("src", source_attribute_value, source_start, source_end, allocator)
+      : create_html_attribute_with_ruby_literal("src", source_attribute_value, source_start, source_end, allocator);
+  if (source_attribute) { hb_array_append(attributes, source_attribute); }
+
+  for (size_t i = 0; i < hb_array_size(shared_attributes); i++) {
+    hb_array_append(attributes, hb_array_get(shared_attributes, i));
+  }
+
+  if (source_attribute_value != source_value) { hb_allocator_dealloc(allocator, source_attribute_value); }
+  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,
+    tag_name_token,
+    attributes,
+    erb_node->base.location.start,
+    erb_node->base.location.end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+
+  AST_HTML_VIRTUAL_CLOSE_TAG_NODE_T* virtual_close = ast_html_virtual_close_tag_node_init(
+    tag_name_token,
+    erb_node->base.location.end,
+    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,
+    tag_name_token,
+    hb_array_init(0, allocator),
+    (AST_NODE_T*) virtual_close,
+    false,
+    parse_context->matched_handler->source,
+    erb_node->base.location.start,
+    erb_node->base.location.end,
+    hb_array_init(0, allocator),
+    allocator
+  );
+}
+
+static hb_array_T* transform_javascript_include_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_javascript_include_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,
+    allocator
+  );
+  if (!shared_attributes) { shared_attributes = hb_array_init(0, 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, allocator);
+
+    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);
+    }
+  }
+
+  return elements;
+}
+
 static AST_NODE_T* transform_erb_block_to_tag_helper(
   AST_ERB_BLOCK_NODE_T* block_node,
   analyze_ruby_context_T* context,
@@ -478,6 +684,27 @@ static AST_NODE_T* transform_erb_block_to_tag_helper(
   hb_array_T* body = block_node->body ? block_node->body : hb_array_init(0, allocator);
   AST_NODE_T* close_tag = (AST_NODE_T*) block_node->end_node;
 
+  if (tag_name && parser_is_foreign_content_tag(hb_string_from_c_string(tag_name)) && context->source
+      && block_node->body && hb_array_size(block_node->body) > 0) {
+    size_t start_offset = block_node->tag_closing->range.to;
+    size_t end_offset = block_node->end_node->tag_opening->range.from;
+
+    if (end_offset > start_offset) {
+      position_T body_start = block_node->tag_closing->location.end;
+      position_T body_end = block_node->end_node->tag_opening->location.start;
+
+      size_t content_length = end_offset - start_offset;
+      char* raw_copy = hb_allocator_strndup(allocator, context->source + start_offset, content_length);
+      hb_string_T raw_content = { .data = raw_copy, .length = content_length };
+
+      AST_LITERAL_NODE_T* literal_node =
+        ast_literal_node_init(raw_content, body_start, body_end, hb_array_init(0, allocator), allocator);
+
+      body = hb_array_init(1, allocator);
+      hb_array_append(body, literal_node);
+    }
+  }
+
   AST_HTML_ELEMENT_NODE_T* element = ast_html_element_node_init(
     (AST_NODE_T*) open_tag_node,
     tag_name_token,
@@ -787,7 +1014,33 @@ void transform_tag_helper_blocks(const AST_NODE_T* node, analyze_ruby_context_T*
           parse_tag_helper_content(erb_string, context->source, erb_content_offset, context->allocator);
 
         if (parse_context) {
-          if (strcmp(parse_context->matched_handler->name, "link_to") == 0) {
+          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);
+
+            if (multi && hb_array_size(multi) > 0) {
+              size_t old_size = hb_array_size(array);
+              size_t multi_size = hb_array_size(multi);
+              hb_array_T* new_array = hb_array_init(old_size - 1 + multi_size, context->allocator);
+
+              for (size_t j = 0; j < old_size; j++) {
+                if (j == i) {
+                  for (size_t k = 0; k < multi_size; k++) {
+                    hb_array_append(new_array, hb_array_get(multi, k));
+                  }
+                } else {
+                  hb_array_append(new_array, hb_array_get(array, j));
+                }
+              }
+
+              array->items = new_array->items;
+              array->size = new_array->size;
+              array->capacity = new_array->capacity;
+
+              i += multi_size - 1;
+            }
+          } else if (strcmp(parse_context->matched_handler->name, "link_to") == 0) {
             replacement = transform_link_to_helper(erb_node, context, parse_context);
           } else {
             replacement = transform_tag_helper_with_attributes(erb_node, context, parse_context);

data/src/html_util.c

@@ -27,6 +27,46 @@ static hb_string_T void_tags[] = HB_STRING_LIST(
   "wbr"
 );
 
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#boolean-attributes
+static hb_string_T boolean_attributes[] = HB_STRING_LIST(
+  "allowfullscreen",
+  "async",
+  "autofocus",
+  "autoplay",
+  "checked",
+  "compact",
+  "controls",
+  "declare",
+  "default",
+  "defer",
+  "disabled",
+  "formnovalidate",
+  "hidden",
+  "inert",
+  "ismap",
+  "itemscope",
+  "loop",
+  "multiple",
+  "muted",
+  "nomodule",
+  "nohref",
+  "noresize",
+  "noshade",
+  "novalidate",
+  "nowrap",
+  "open",
+  "playsinline",
+  "readonly",
+  "required",
+  "reversed",
+  "scoped",
+  "seamless",
+  "selected",
+  "sortable",
+  "truespeed",
+  "typemustmatch"
+);
+
 // https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
 static hb_string_T optional_end_tags[] = HB_STRING_LIST(
   "li",
@@ -112,6 +152,16 @@ bool is_void_element(hb_string_T tag_name) {
   return false;
 }
 
+bool is_boolean_attribute(hb_string_T attribute_name) {
+  if (hb_string_is_empty(attribute_name)) { return false; }
+
+  for (size_t i = 0; i < sizeof(boolean_attributes) / sizeof(boolean_attributes[0]); i++) {
+    if (hb_string_equals_case_insensitive(attribute_name, boolean_attributes[i])) { return true; }
+  }
+
+  return false;
+}
+
 bool has_optional_end_tag(hb_string_T tag_name) {
   if (hb_string_is_empty(tag_name)) { return false; }
 

data/src/include/html_util.h

@@ -7,6 +7,7 @@
 struct hb_allocator;
 
 bool is_void_element(hb_string_T tag_name);
+bool is_boolean_attribute(hb_string_T attribute_name);
 bool has_optional_end_tag(hb_string_T tag_name);
 bool should_implicitly_close(hb_string_T open_tag_name, hb_string_T next_tag_name);
 bool parent_closes_element(hb_string_T open_tag_name, hb_string_T parent_close_tag_name);

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.9.1"
+#define HERB_VERSION "0.9.2"
 
 #endif

data/src/util/hb_arena.c

@@ -70,16 +70,12 @@ static bool hb_arena_append_page(hb_arena_T* allocator, size_t page_size) {
   page->position = 0;
 
   if (allocator->head == NULL) {
+    assert(allocator->tail == NULL);
+
     allocator->head = page;
     allocator->tail = page;
   } else {
-    hb_arena_page_T* last = allocator->head;
-
-    while (last->next != NULL) {
-      last = last->next;
-    }
-
-    last->next = page;
+    allocator->tail->next = page;
     allocator->tail = page;
   }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - Marco Roth
@@ -111,6 +111,8 @@ files:
 - sig/serialized_ast_nodes.rbs
 - src/analyze/action_view/attribute_extraction_helpers.c
 - src/analyze/action_view/content_tag.c
+- src/analyze/action_view/javascript_include_tag.c
+- src/analyze/action_view/javascript_tag.c
 - src/analyze/action_view/link_to.c
 - src/analyze/action_view/registry.c
 - src/analyze/action_view/tag.c