herb 0.9.2-arm-linux-gnu → 0.9.4-arm-linux-gnu

data/src/analyze/action_view/image_tag.c

@@ -0,0 +1,87 @@
+#include <prism.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+#include "../../include/lib/hb_buffer.h"
+
+bool detect_image_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 == 9 && strncmp((const char*) constant->start, "image_tag", 9) == 0;
+}
+
+char* extract_image_tag_name(pm_call_node_t* _call_node, pm_parser_t* _parser, hb_allocator_T* allocator) {
+  return hb_allocator_strdup(allocator, "img");
+}
+
+char* extract_image_tag_content(pm_call_node_t* _call_node, pm_parser_t* _parser, hb_allocator_T* _allocator) {
+  return NULL;
+}
+
+char* extract_image_tag_src(pm_call_node_t* call_node, pm_parser_t* _parser, hb_allocator_T* allocator) {
+  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 image_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_image_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, "image_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 image_tag_supports_block(void) {
+  return false;
+}
+
+const tag_helper_handler_T image_tag_handler = { .name = "image_tag",
+                                                 .source =
+                                                   HB_STRING_LITERAL("ActionView::Helpers::AssetTagHelper#image_tag"),
+                                                 .detect = detect_image_tag,
+                                                 .extract_tag_name = extract_image_tag_name,
+                                                 .extract_content = extract_image_tag_content,
+                                                 .supports_block = image_tag_supports_block };

data/src/analyze/action_view/javascript_include_tag.c

@@ -1,4 +1,5 @@
 #include "../../include/analyze/action_view/tag_helper_handler.h"
+#include "../../include/lib/hb_buffer.h"
 
 #include <prism.h>
 #include <stdbool.h>
@@ -62,18 +63,27 @@ bool javascript_include_tag_source_is_url(const char* source, size_t length) {
   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';
+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;
 }

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>
@@ -10,8 +10,9 @@ 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 = 6;
+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));
@@ -43,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[6];
+  static tag_helper_handler_T static_handlers[7];
   static bool initialized = false;
 
   if (!initialized) {
@@ -53,6 +54,8 @@ tag_helper_handler_T* get_tag_helper_handlers(void) {
     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,33 +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 =
-    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) {
-    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);
 
@@ -110,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
   );
@@ -159,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
   );
@@ -169,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,