herb 0.9.1-aarch64-linux-gnu → 0.9.3-aarch64-linux-gnu

data/src/analyze/action_view/javascript_include_tag.c

@@ -0,0 +1,102 @@
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+#include "../../include/lib/hb_buffer.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,
+  const char* path_options,
+  hb_allocator_T* allocator
+) {
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, source_length + 32, allocator);
+
+  hb_buffer_append(&buffer, "javascript_path(");
+  hb_buffer_append_with_length(&buffer, source, source_length);
+
+  if (path_options && strlen(path_options) > 0) {
+    hb_buffer_append(&buffer, ", ");
+    hb_buffer_append(&buffer, path_options);
+  }
+
+  hb_buffer_append(&buffer, ")");
+
+  char* result = hb_allocator_strdup(allocator, hb_buffer_value(&buffer));
+  hb_buffer_free(&buffer);
+
+  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

@@ -1,5 +1,5 @@
 #include "../../include/analyze/action_view/tag_helper_handler.h"
-#include "../../include/util/hb_allocator.h"
+#include "../../include/lib/hb_allocator.h"
 
 #include <stdbool.h>
 #include <stdlib.h>
@@ -8,8 +8,11 @@ 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;
+extern const tag_helper_handler_T image_tag_handler;
 
-static size_t handlers_count = 4;
+static size_t handlers_count = 7;
 
 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 +44,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[7];
   static bool initialized = false;
 
   if (!initialized) {
@@ -49,6 +52,10 @@ 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;
+    static_handlers[6] = image_tag_handler;
+
     initialized = true;
   }
 

data/src/analyze/action_view/tag.c

@@ -1,4 +1,5 @@
 #include "../../include/analyze/action_view/tag_helper_handler.h"
+#include "../../include/util/ruby_util.h"
 
 #include <prism.h>
 #include <stdbool.h>
@@ -23,6 +24,10 @@ char* extract_tag_dot_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_al
   pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
   if (!constant) { return NULL; }
 
+  if (is_ruby_introspection_method(hb_string_from_data((const char*) constant->start, constant->length))) {
+    return NULL;
+  }
+
   char* name = hb_allocator_strndup(allocator, (const char*) constant->start, constant->length);
 
   for (size_t i = 0; i < constant->length && name[i] != '\0'; i++) {
@@ -34,10 +39,17 @@ char* extract_tag_dot_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_al
 
 // TODO: this should probably be an array of nodes
 char* extract_tag_dot_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
-  (void) parser;
-
   if (!call_node) { return NULL; }
 
+  if (call_node->name) {
+    pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+
+    if (constant
+        && is_ruby_introspection_method(hb_string_from_data((const char*) constant->start, constant->length))) {
+      return NULL;
+    }
+  }
+
   char* block_content = extract_inline_block_content(call_node, allocator);
   if (block_content) { return block_content; }
 
@@ -47,11 +59,16 @@ char* extract_tag_dot_content(pm_call_node_t* call_node, pm_parser_t* parser, hb
     if (arguments->arguments.size) {
       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);
     }
   }
 

data/src/analyze/action_view/tag_helper_node_builders.c

@@ -1,12 +1,12 @@
 #include "../../include/analyze/action_view/tag_helper_node_builders.h"
-#include "../../include/ast_nodes.h"
-#include "../../include/location.h"
-#include "../../include/position.h"
-#include "../../include/range.h"
-#include "../../include/token_struct.h"
-#include "../../include/util/hb_allocator.h"
-#include "../../include/util/hb_array.h"
-#include "../../include/util/hb_string.h"
+#include "../../include/ast/ast_nodes.h"
+#include "../../include/lexer/token_struct.h"
+#include "../../include/lib/hb_allocator.h"
+#include "../../include/lib/hb_array.h"
+#include "../../include/lib/hb_string.h"
+#include "../../include/location/location.h"
+#include "../../include/location/position.h"
+#include "../../include/location/range.h"
 
 #include <prism.h>
 #include <stdbool.h>
@@ -26,7 +26,7 @@ token_T* create_synthetic_token(
   if (value) {
     size_t length = strlen(value);
     char* copied = hb_allocator_strndup(allocator, value, length);
-    token->value = (hb_string_T) { .data = copied, .length = (uint32_t) length };
+    token->value = hb_string_from_data(copied, length);
   } else {
     token->value = HB_STRING_EMPTY;
   }
@@ -76,32 +76,47 @@ hb_array_T* prepend_attribute(hb_array_T* attributes, AST_NODE_T* attribute, hb_
   return new_attributes;
 }
 
-AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_node(
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_node_precise(
   const char* name_string,
   const char* value_string,
-  position_T start_position,
-  position_T end_position,
+  attribute_positions_T* positions,
   hb_allocator_T* allocator
 ) {
   if (!name_string) { return NULL; }
 
   AST_HTML_ATTRIBUTE_NAME_NODE_T* name_node =
-    create_attribute_name_node(name_string, start_position, end_position, allocator);
+    create_attribute_name_node(name_string, positions->name_start, positions->name_end, allocator);
+
+  token_T* equals_token = value_string ? create_synthetic_token(
+                                           allocator,
+                                           positions->separator_string,
+                                           positions->separator_type,
+                                           positions->separator_start,
+                                           positions->separator_end
+                                         )
+                                       : NULL;
 
-  token_T* equals_token = create_synthetic_token(allocator, "=", TOKEN_EQUALS, start_position, end_position);
   AST_HTML_ATTRIBUTE_VALUE_NODE_T* value_node = NULL;
 
   if (value_string) {
-    token_T* open_quote = create_synthetic_token(allocator, "\"", TOKEN_QUOTE, start_position, end_position);
-    token_T* close_quote = create_synthetic_token(allocator, "\"", TOKEN_QUOTE, end_position, end_position);
+    token_T* open_quote =
+      positions->quoted
+        ? create_synthetic_token(allocator, "\"", TOKEN_QUOTE, positions->value_start, positions->content_start)
+        : NULL;
+
+    token_T* close_quote =
+      positions->quoted
+        ? create_synthetic_token(allocator, "\"", TOKEN_QUOTE, positions->content_end, positions->value_end)
+        : NULL;
 
     AST_LITERAL_NODE_T* value_literal = ast_literal_node_init(
       hb_string_from_c_string(value_string),
-      start_position,
-      end_position,
+      positions->content_start,
+      positions->content_end,
       hb_array_init(0, allocator),
       allocator
     );
+
     hb_array_T* value_children = hb_array_init(1, allocator);
     hb_array_append(value_children, (AST_NODE_T*) value_literal);
 
@@ -109,43 +124,50 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_node(
       open_quote,
       value_children,
       close_quote,
-      true,
-      start_position,
-      end_position,
+      positions->quoted,
+      positions->value_start,
+      positions->value_end,
       hb_array_init(0, allocator),
       allocator
     );
   }
 
+  position_T attribute_end = value_string ? positions->value_end : positions->name_end;
+
   return ast_html_attribute_node_init(
     name_node,
     equals_token,
     value_node,
-    start_position,
-    end_position,
+    positions->name_start,
+    attribute_end,
     hb_array_init(0, allocator),
     allocator
   );
 }
 
-AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal(
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal_precise(
   const char* name_string,
   const char* ruby_content,
-  position_T start_position,
-  position_T end_position,
+  attribute_positions_T* positions,
   hb_allocator_T* allocator
 ) {
   if (!name_string || !ruby_content) { return NULL; }
 
   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_COLON, start_position, end_position);
+    create_attribute_name_node(name_string, positions->name_start, positions->name_end, allocator);
+
+  token_T* equals_token = create_synthetic_token(
+    allocator,
+    positions->separator_string,
+    positions->separator_type,
+    positions->separator_start,
+    positions->separator_end
+  );
 
   AST_RUBY_LITERAL_NODE_T* ruby_node = ast_ruby_literal_node_init(
     hb_string_from_c_string(ruby_content),
-    start_position,
-    end_position,
+    positions->content_start,
+    positions->content_end,
     hb_array_init(0, allocator),
     allocator
   );
@@ -158,8 +180,8 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal(
     value_children,
     NULL,
     false,
-    start_position,
-    end_position,
+    positions->content_start,
+    positions->content_end,
     hb_array_init(0, allocator),
     allocator
   );
@@ -168,13 +190,61 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal(
     name_node,
     equals_token,
     value_node,
-    start_position,
-    end_position,
+    positions->name_start,
+    positions->content_end,
     hb_array_init(0, allocator),
     allocator
   );
 }
 
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_node(
+  const char* name_string,
+  const char* value_string,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+) {
+  attribute_positions_T positions = {
+    .name_start = start_position,
+    .name_end = end_position,
+    .separator_string = "=",
+    .separator_type = TOKEN_EQUALS,
+    .separator_start = start_position,
+    .separator_end = end_position,
+    .value_start = start_position,
+    .value_end = end_position,
+    .content_start = start_position,
+    .content_end = end_position,
+    .quoted = true,
+  };
+
+  return create_html_attribute_node_precise(name_string, value_string, &positions, allocator);
+}
+
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal(
+  const char* name_string,
+  const char* ruby_content,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+) {
+  attribute_positions_T positions = {
+    .name_start = start_position,
+    .name_end = end_position,
+    .separator_string = ":",
+    .separator_type = TOKEN_COLON,
+    .separator_start = start_position,
+    .separator_end = end_position,
+    .value_start = start_position,
+    .value_end = end_position,
+    .content_start = start_position,
+    .content_end = end_position,
+    .quoted = false,
+  };
+
+  return create_html_attribute_with_ruby_literal_precise(name_string, ruby_content, &positions, allocator);
+}
+
 static AST_HTML_ATTRIBUTE_VALUE_NODE_T* create_interpolated_attribute_value(
   pm_interpolated_string_node_t* interpolated_node,
   position_T start_position,
@@ -210,8 +280,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(