herb 0.11.0-x86-linux-gnu → 0.11.2-x86-linux-gnu

data/src/analyze/action_view/javascript_include_tag.c

@@ -6,7 +6,6 @@
 #include <string.h>
 
 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; }
 
@@ -22,8 +21,12 @@ char* extract_javascript_include_tag_src(pm_call_node_t* call_node, pm_parser_t*
     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);
+  const uint8_t* source = pm_parser_start(parser);
+  return hb_allocator_strndup(
+    allocator,
+    (const char*) (source + first_argument->location.start),
+    first_argument->location.length
+  );
 }
 
 bool javascript_include_tag_source_is_url(const char* source, size_t length) {

data/src/analyze/action_view/link_to.c

@@ -25,9 +25,10 @@ char* wrap_in_url_for(const char* source, size_t source_length, hb_allocator_T*
 bool detect_link_to(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);
+  const pm_constant_t* constant = pm_parser_constant(parser, call_node->name);
 
-  return constant && constant->length == 7 && strncmp((const char*) constant->start, "link_to", 7) == 0;
+  return constant && pm_constant_length(constant) == 7
+      && strncmp((const char*) pm_constant_start(constant), "link_to", 7) == 0;
 }
 
 bool is_route_helper_node(pm_node_t* node, pm_parser_t* parser) {
@@ -36,11 +37,11 @@ bool is_route_helper_node(pm_node_t* node, pm_parser_t* parser) {
   pm_call_node_t* call = (pm_call_node_t*) node;
   if (!call->name) { return false; }
 
-  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call->name);
-  if (!constant || constant->length < 5) { return false; }
+  const pm_constant_t* constant = pm_parser_constant(parser, call->name);
+  if (!constant || pm_constant_length(constant) < 5) { return false; }
 
-  const char* name = (const char*) constant->start;
-  size_t length = constant->length;
+  const char* name = (const char*) pm_constant_start(constant);
+  size_t length = pm_constant_length(constant);
 
   return (length >= 5 && strncmp(name + length - 5, "_path", 5) == 0)
       || (length >= 4 && strncmp(name + length - 4, "_url", 4) == 0);
@@ -54,11 +55,9 @@ char* extract_link_to_tag_name(pm_call_node_t* call_node, pm_parser_t* parser, h
 }
 
 char* extract_link_to_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
-  (void) parser;
-
   if (!call_node) { return NULL; }
 
-  char* block_content = extract_inline_block_content(call_node, allocator);
+  char* block_content = extract_inline_block_content(call_node, parser, allocator);
   if (block_content) { return block_content; }
 
   if (!call_node->arguments) { return NULL; }
@@ -76,7 +75,8 @@ char* extract_link_to_content(pm_call_node_t* call_node, pm_parser_t* parser, hb
     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;
+  const uint8_t* source = pm_parser_start(parser);
+  size_t source_length = first_argument->location.length;
 
   // Format: "<expression>.to_s"
   if (arguments->arguments.size == 1) {
@@ -85,21 +85,21 @@ char* extract_link_to_content(pm_call_node_t* call_node, pm_parser_t* parser, hb
     size_t total_length = source_length + suffix_len;
     char* ruby_expression = hb_allocator_alloc(allocator, total_length + 1);
 
-    memcpy(ruby_expression, (const char*) first_argument->location.start, source_length);
+    memcpy(ruby_expression, (const char*) (source + first_argument->location.start), source_length);
     memcpy(ruby_expression + source_length, suffix, suffix_len);
     ruby_expression[total_length] = '\0';
 
     return ruby_expression;
   }
 
-  return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+  return hb_allocator_strndup(allocator, (const char*) (source + first_argument->location.start), source_length);
 }
 
 char* extract_link_to_href(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
-  (void) parser;
-
   if (!call_node || !call_node->arguments) { return NULL; }
 
+  const uint8_t* source = pm_parser_start(parser);
+
   pm_arguments_node_t* arguments = call_node->arguments;
   bool has_inline_block = call_node->block && call_node->block->type == PM_BLOCK_NODE;
 
@@ -112,13 +112,13 @@ char* extract_link_to_href(pm_call_node_t* call_node, pm_parser_t* parser, hb_al
       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;
+    size_t source_length = first_argument->location.length;
 
     if (is_route_helper_node(first_argument, parser)) {
-      return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+      return hb_allocator_strndup(allocator, (const char*) (source + first_argument->location.start), source_length);
     }
 
-    return wrap_in_url_for((const char*) first_argument->location.start, source_length, allocator);
+    return wrap_in_url_for((const char*) (source + first_argument->location.start), source_length, allocator);
   }
 
   // Format: "url_for(<expression>)"
@@ -127,13 +127,13 @@ char* extract_link_to_href(pm_call_node_t* call_node, pm_parser_t* parser, hb_al
 
     if (first_argument->type == PM_STRING_NODE || first_argument->type == PM_NIL_NODE) { return NULL; }
 
-    size_t source_length = first_argument->location.end - first_argument->location.start;
+    size_t source_length = first_argument->location.length;
 
     if (is_route_helper_node(first_argument, parser)) {
-      return hb_allocator_strndup(allocator, (const char*) first_argument->location.start, source_length);
+      return hb_allocator_strndup(allocator, (const char*) (source + first_argument->location.start), source_length);
     }
 
-    return wrap_in_url_for((const char*) first_argument->location.start, source_length, allocator);
+    return wrap_in_url_for((const char*) (source + first_argument->location.start), source_length, allocator);
   }
 
   if (arguments->arguments.size < 2) { return NULL; }
@@ -146,13 +146,13 @@ char* extract_link_to_href(pm_call_node_t* call_node, pm_parser_t* parser, hb_al
     return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
   }
 
-  size_t source_length = second_argument->location.end - second_argument->location.start;
+  size_t source_length = second_argument->location.length;
 
   if (!is_route_helper_node(second_argument, parser)) {
-    return wrap_in_url_for((const char*) second_argument->location.start, source_length, allocator);
+    return wrap_in_url_for((const char*) (source + second_argument->location.start), source_length, allocator);
   }
 
-  return hb_allocator_strndup(allocator, (const char*) second_argument->location.start, source_length);
+  return hb_allocator_strndup(allocator, (const char*) (source + second_argument->location.start), source_length);
 }
 
 bool link_to_supports_block(void) {

data/src/analyze/action_view/registry.c

@@ -59,7 +59,7 @@ size_t get_tag_helper_handlers_count(void) {
   return handlers_count;
 }
 
-char* extract_inline_block_content(pm_call_node_t* call_node, hb_allocator_T* allocator) {
+char* extract_inline_block_content(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
   if (!call_node || !call_node->block || call_node->block->type != PM_BLOCK_NODE) { return NULL; }
 
   pm_block_node_t* block_node = (pm_block_node_t*) call_node->block;
@@ -78,6 +78,10 @@ char* extract_inline_block_content(pm_call_node_t* call_node, hb_allocator_T* al
     return hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_node->unescaped), length);
   }
 
-  size_t source_length = statement->location.end - statement->location.start;
-  return hb_allocator_strndup(allocator, (const char*) statement->location.start, source_length);
+  const uint8_t* source = pm_parser_start(parser);
+  return hb_allocator_strndup(
+    allocator,
+    (const char*) (source + statement->location.start),
+    statement->location.length
+  );
 }

data/src/analyze/action_view/tag_helper_node_builders.c

@@ -304,6 +304,7 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_ruby_literal(
 
 static AST_HTML_ATTRIBUTE_VALUE_NODE_T* create_interpolated_attribute_value(
   pm_interpolated_string_node_t* interpolated_node,
+  const uint8_t* source,
   position_T start_position,
   position_T end_position,
   hb_allocator_T* allocator
@@ -338,19 +339,10 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* create_interpolated_attribute_value(
       }
     } else if (part->type == PM_EMBEDDED_STATEMENTS_NODE) {
       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;
-      }
+      pm_location_t content_location = embedded->statements ? embedded->statements->base.location : part->location;
 
-      size_t ruby_length = content_end - content_start;
-      char* ruby_content = hb_allocator_strndup(allocator, (const char*) content_start, ruby_length);
+      char* ruby_content =
+        hb_allocator_strndup(allocator, (const char*) (source + content_location.start), content_location.length);
 
       if (ruby_content) {
         AST_RUBY_LITERAL_NODE_T* ruby_node = ast_ruby_literal_node_init(
@@ -368,11 +360,14 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* create_interpolated_attribute_value(
     }
   }
 
+  token_T* open_quote = create_synthetic_token(allocator, "\"", TOKEN_QUOTE, start_position, start_position);
+  token_T* close_quote = create_synthetic_token(allocator, "\"", TOKEN_QUOTE, end_position, end_position);
+
   return ast_html_attribute_value_node_init(
-    NULL,
+    open_quote,
     value_children,
-    NULL,
-    false,
+    close_quote,
+    true,
     start_position,
     end_position,
     hb_array_init(0, allocator),
@@ -383,6 +378,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* create_interpolated_attribute_value(
 AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_interpolated_value(
   const char* name_string,
   pm_interpolated_string_node_t* interpolated_node,
+  const uint8_t* source,
   position_T start_position,
   position_T end_position,
   hb_allocator_T* allocator
@@ -393,7 +389,7 @@ AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_interpolated_value(
     create_attribute_name_node(name_string, start_position, end_position, allocator);
 
   AST_HTML_ATTRIBUTE_VALUE_NODE_T* value_node =
-    create_interpolated_attribute_value(interpolated_node, start_position, end_position, allocator);
+    create_interpolated_attribute_value(interpolated_node, source, start_position, end_position, allocator);
 
   token_T* equals_token = create_synthetic_token(allocator, "=", TOKEN_EQUALS, start_position, end_position);