@herb-tools/node 0.8.10 → 0.9.1

package/extension/libherb/analyze/action_view/tag.c

@@ -0,0 +1,70 @@
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+bool detect_tag_dot(pm_call_node_t* call_node, pm_parser_t* parser) {
+  if (!call_node || !call_node->receiver) { return false; }
+  if (call_node->receiver->type != PM_CALL_NODE) { return false; }
+
+  pm_call_node_t* receiver_node = (pm_call_node_t*) call_node->receiver;
+  if (!receiver_node->name) { return false; }
+
+  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, receiver_node->name);
+
+  return constant && constant->length == 3 && strncmp((const char*) constant->start, "tag", 3) == 0;
+}
+
+char* extract_tag_dot_name(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator) {
+  if (!call_node || !call_node->name) { return NULL; }
+
+  pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call_node->name);
+  if (!constant) { 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++) {
+    if (name[i] == '_') { name[i] = '-'; }
+  }
+
+  return name;
+}
+
+// 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; }
+
+  char* block_content = extract_inline_block_content(call_node, allocator);
+  if (block_content) { return block_content; }
+
+  if (call_node->arguments) {
+    pm_arguments_node_t* arguments = call_node->arguments;
+
+    if (arguments->arguments.size) {
+      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);
+      }
+    }
+  }
+
+  return NULL;
+}
+
+bool tag_dot_supports_block(void) {
+  return true;
+}
+
+const tag_helper_handler_T tag_dot_handler = { .name = "tag",
+                                               .source = HB_STRING_LITERAL("ActionView::Helpers::TagHelper#tag"),
+                                               .detect = detect_tag_dot,
+                                               .extract_tag_name = extract_tag_dot_name,
+                                               .extract_content = extract_tag_dot_content,
+                                               .supports_block = tag_dot_supports_block };

package/extension/libherb/analyze/action_view/tag_helper_handler.h

@@ -0,0 +1,43 @@
+#ifndef TAG_HELPER_HANDLER_H
+#define TAG_HELPER_HANDLER_H
+
+#include "../../util/hb_allocator.h"
+#include "../../util/hb_array.h"
+#include "../../util/hb_string.h"
+#include <prism.h>
+#include <stdbool.h>
+
+typedef struct {
+  char* tag_name;
+  pm_call_node_t* call_node;
+  hb_array_T* attributes;
+  char* content;
+  bool content_is_ruby_expression;
+  bool has_block;
+  hb_allocator_T* allocator;
+} tag_helper_info_T;
+
+typedef struct {
+  const char* name;
+  hb_string_T source;
+  bool (*detect)(pm_call_node_t* call_node, pm_parser_t* parser);
+  char* (*extract_tag_name)(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator);
+  char* (*extract_content)(pm_call_node_t* call_node, pm_parser_t* parser, hb_allocator_T* allocator);
+  hb_array_T* (*extract_attributes)(
+    pm_call_node_t* call_node,
+    const uint8_t* source,
+    const char* original_source,
+    size_t erb_content_offset
+  );
+  bool (*supports_block)(void);
+} tag_helper_handler_T;
+
+tag_helper_info_T* tag_helper_info_init(hb_allocator_T* allocator);
+void tag_helper_info_free(tag_helper_info_T** info);
+
+tag_helper_handler_T* get_tag_helper_handlers(void);
+size_t get_tag_helper_handlers_count(void);
+
+char* extract_inline_block_content(pm_call_node_t* call_node, hb_allocator_T* allocator);
+
+#endif

package/extension/libherb/analyze/action_view/tag_helper_node_builders.c

@@ -0,0 +1,305 @@
+#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 <prism.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+token_T* create_synthetic_token(
+  hb_allocator_T* allocator,
+  const char* value,
+  token_type_T type,
+  position_T start,
+  position_T end
+) {
+  token_T* token = hb_allocator_alloc(allocator, sizeof(token_T));
+  if (!token) { return NULL; }
+
+  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 };
+  } else {
+    token->value = HB_STRING_EMPTY;
+  }
+
+  token->type = type;
+  location_from_positions(&token->location, start, end);
+  token->range = (range_T) { .from = 0, .to = 0 };
+
+  return token;
+}
+
+AST_HTML_ATTRIBUTE_NAME_NODE_T* create_attribute_name_node(
+  const char* name_string,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+) {
+  AST_LITERAL_NODE_T* name_literal = ast_literal_node_init(
+    hb_string_from_c_string(name_string),
+    start_position,
+    end_position,
+    hb_array_init(0, allocator),
+    allocator
+  );
+
+  hb_array_T* name_children = hb_array_init(1, allocator);
+  hb_array_append(name_children, (AST_NODE_T*) name_literal);
+
+  return ast_html_attribute_name_node_init(
+    name_children,
+    start_position,
+    end_position,
+    hb_array_init(0, allocator),
+    allocator
+  );
+}
+
+hb_array_T* prepend_attribute(hb_array_T* attributes, AST_NODE_T* attribute, hb_allocator_T* allocator) {
+  hb_array_T* new_attributes = hb_array_init(hb_array_size(attributes) + 1, allocator);
+  hb_array_append(new_attributes, attribute);
+
+  for (size_t i = 0; i < hb_array_size(attributes); i++) {
+    hb_array_append(new_attributes, hb_array_get(attributes, i));
+  }
+
+  hb_array_free(&attributes);
+  return new_attributes;
+}
+
+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
+) {
+  if (!name_string) { 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_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);
+
+    AST_LITERAL_NODE_T* value_literal = ast_literal_node_init(
+      hb_string_from_c_string(value_string),
+      start_position,
+      end_position,
+      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);
+
+    value_node = ast_html_attribute_value_node_init(
+      open_quote,
+      value_children,
+      close_quote,
+      true,
+      start_position,
+      end_position,
+      hb_array_init(0, allocator),
+      allocator
+    );
+  }
+
+  return ast_html_attribute_node_init(
+    name_node,
+    equals_token,
+    value_node,
+    start_position,
+    end_position,
+    hb_array_init(0, allocator),
+    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
+) {
+  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);
+
+  AST_RUBY_LITERAL_NODE_T* ruby_node = ast_ruby_literal_node_init(
+    hb_string_from_c_string(ruby_content),
+    start_position,
+    end_position,
+    hb_array_init(0, allocator),
+    allocator
+  );
+
+  hb_array_T* value_children = hb_array_init(1, allocator);
+  hb_array_append(value_children, (AST_NODE_T*) ruby_node);
+
+  AST_HTML_ATTRIBUTE_VALUE_NODE_T* value_node = ast_html_attribute_value_node_init(
+    NULL,
+    value_children,
+    NULL,
+    false,
+    start_position,
+    end_position,
+    hb_array_init(0, allocator),
+    allocator
+  );
+
+  return ast_html_attribute_node_init(
+    name_node,
+    equals_token,
+    value_node,
+    start_position,
+    end_position,
+    hb_array_init(0, allocator),
+    allocator
+  );
+}
+
+static AST_HTML_ATTRIBUTE_VALUE_NODE_T* create_interpolated_attribute_value(
+  pm_interpolated_string_node_t* interpolated_node,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+) {
+  if (!interpolated_node) { return NULL; }
+
+  hb_array_T* value_children = hb_array_init(8, allocator);
+
+  for (size_t i = 0; i < interpolated_node->parts.size; i++) {
+    pm_node_t* part = interpolated_node->parts.nodes[i];
+
+    if (part->type == PM_STRING_NODE) {
+      pm_string_node_t* string_part = (pm_string_node_t*) part;
+      size_t content_length = pm_string_length(&string_part->unescaped);
+
+      if (content_length > 0) {
+        char* content =
+          hb_allocator_strndup(allocator, (const char*) pm_string_source(&string_part->unescaped), content_length);
+        if (content) {
+          AST_LITERAL_NODE_T* literal_node = ast_literal_node_init(
+            hb_string_from_c_string(content),
+            start_position,
+            end_position,
+            hb_array_init(0, allocator),
+            allocator
+          );
+
+          if (literal_node) { hb_array_append(value_children, (AST_NODE_T*) literal_node); }
+
+          hb_allocator_dealloc(allocator, content);
+        }
+      }
+    } 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);
+
+      if (ruby_content) {
+        AST_RUBY_LITERAL_NODE_T* ruby_node = ast_ruby_literal_node_init(
+          hb_string_from_c_string(ruby_content),
+          start_position,
+          end_position,
+          hb_array_init(0, allocator),
+          allocator
+        );
+
+        if (ruby_node) { hb_array_append(value_children, (AST_NODE_T*) ruby_node); }
+
+        hb_allocator_dealloc(allocator, ruby_content);
+      }
+    }
+  }
+
+  return ast_html_attribute_value_node_init(
+    NULL,
+    value_children,
+    NULL,
+    false,
+    start_position,
+    end_position,
+    hb_array_init(0, allocator),
+    allocator
+  );
+}
+
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_interpolated_value(
+  const char* name_string,
+  pm_interpolated_string_node_t* interpolated_node,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+) {
+  if (!name_string || !interpolated_node) { return NULL; }
+
+  AST_HTML_ATTRIBUTE_NAME_NODE_T* name_node =
+    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);
+
+  token_T* equals_token = create_synthetic_token(allocator, "=", TOKEN_EQUALS, start_position, end_position);
+
+  return ast_html_attribute_node_init(
+    name_node,
+    equals_token,
+    value_node,
+    start_position,
+    end_position,
+    hb_array_init(0, allocator),
+    allocator
+  );
+}
+
+AST_HTML_ATTRIBUTE_NODE_T* create_href_attribute(
+  const char* href,
+  bool is_ruby_expression,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+) {
+  return is_ruby_expression
+         ? create_html_attribute_with_ruby_literal("href", href, start_position, end_position, allocator)
+         : create_html_attribute_node("href", href, start_position, end_position, allocator);
+}
+
+void append_body_content_node(
+  hb_array_T* body,
+  const char* content,
+  bool is_ruby_expression,
+  position_T start,
+  position_T end,
+  hb_allocator_T* allocator
+) {
+  if (!content || !body) { return; }
+
+  if (is_ruby_expression) {
+    AST_RUBY_LITERAL_NODE_T* ruby_node =
+      ast_ruby_literal_node_init(hb_string_from_c_string(content), start, end, hb_array_init(0, allocator), allocator);
+
+    if (ruby_node) { hb_array_append(body, (AST_NODE_T*) ruby_node); }
+  } else {
+    AST_HTML_TEXT_NODE_T* text_node =
+      ast_html_text_node_init(hb_string_from_c_string(content), start, end, hb_array_init(0, allocator), allocator);
+
+    if (text_node) { hb_array_append(body, (AST_NODE_T*) text_node); }
+  }
+}

package/extension/libherb/analyze/action_view/tag_helper_node_builders.h

@@ -0,0 +1,70 @@
+#ifndef HERB_ANALYZE_TAG_HELPER_NODE_BUILDERS_H
+#define HERB_ANALYZE_TAG_HELPER_NODE_BUILDERS_H
+
+#include "../../ast_nodes.h"
+#include "../../position.h"
+#include "../../token_struct.h"
+#include "../../util/hb_allocator.h"
+#include "../../util/hb_array.h"
+
+#include <prism.h>
+
+token_T* create_synthetic_token(
+  hb_allocator_T* allocator,
+  const char* value,
+  token_type_T type,
+  position_T start,
+  position_T end
+);
+
+AST_HTML_ATTRIBUTE_NAME_NODE_T* create_attribute_name_node(
+  const char* name_string,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* 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
+);
+
+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
+);
+
+AST_HTML_ATTRIBUTE_NODE_T* create_html_attribute_with_interpolated_value(
+  const char* name_string,
+  pm_interpolated_string_node_t* interpolated_node,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+);
+
+hb_array_T* prepend_attribute(hb_array_T* attributes, AST_NODE_T* attribute, hb_allocator_T* allocator);
+
+AST_HTML_ATTRIBUTE_NODE_T* create_href_attribute(
+  const char* href,
+  bool is_ruby_expression,
+  position_T start_position,
+  position_T end_position,
+  hb_allocator_T* allocator
+);
+
+void append_body_content_node(
+  hb_array_T* body,
+  const char* content,
+  bool is_ruby_expression,
+  position_T start,
+  position_T end,
+  hb_allocator_T* allocator
+);
+
+#endif