@herb-tools/node 0.8.9 → 0.9.0

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

@@ -0,0 +1,38 @@
+#ifndef HERB_ANALYZE_TAG_HELPERS_H
+#define HERB_ANALYZE_TAG_HELPERS_H
+
+#include "../../ast_nodes.h"
+#include "../../position.h"
+#include "../../util/hb_array.h"
+#include "../analyze.h"
+#include "tag_helper_handler.h"
+
+#include <prism.h>
+#include <stdbool.h>
+
+typedef struct {
+  const pm_node_t* tag_helper_node;
+  const uint8_t* source;
+  pm_parser_t* parser;
+  tag_helper_info_T* info;
+  const tag_helper_handler_T* matched_handler;
+  bool found;
+} tag_helper_search_data_T;
+
+bool search_tag_helper_node(const pm_node_t* node, void* data);
+
+position_T prism_location_to_position_with_offset(
+  const pm_location_t* pm_location,
+  const char* original_source,
+  size_t erb_content_offset,
+  const uint8_t* erb_content_source
+);
+
+position_T byte_offset_to_position(const char* source, size_t offset);
+
+size_t calculate_byte_offset_from_position(const char* source, position_T position);
+
+void transform_tag_helper_blocks(const AST_NODE_T* node, analyze_ruby_context_T* context);
+bool transform_tag_helper_nodes(const AST_NODE_T* node, void* data);
+
+#endif

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

@@ -0,0 +1,88 @@
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+bool detect_turbo_frame_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 == 15 && strncmp((const char*) constant->start, "turbo_frame_tag", 15) == 0;
+}
+
+char* extract_turbo_frame_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, "turbo-frame");
+}
+
+char* extract_turbo_frame_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_turbo_frame_tag_id(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);
+  } else if (first_argument->type == PM_SYMBOL_NODE) {
+    pm_symbol_node_t* symbol_node = (pm_symbol_node_t*) first_argument;
+    size_t length = pm_string_length(&symbol_node->unescaped);
+
+    return hb_allocator_strndup(allocator, (const char*) pm_string_source(&symbol_node->unescaped), length);
+  }
+
+  size_t source_length = first_argument->location.end - first_argument->location.start;
+  const char* source = (const char*) first_argument->location.start;
+
+  if (first_argument->type == PM_CALL_NODE) {
+    pm_call_node_t* call = (pm_call_node_t*) first_argument;
+    pm_constant_t* call_constant = pm_constant_pool_id_to_constant(&parser->constant_pool, call->name);
+
+    if (call_constant && call_constant->length == 6 && strncmp((const char*) call_constant->start, "dom_id", 6) == 0) {
+      return hb_allocator_strndup(allocator, source, source_length);
+    }
+  }
+
+  const char* prefix = "dom_id(";
+  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 turbo_frame_tag_supports_block(void) {
+  return true;
+}
+
+const tag_helper_handler_T turbo_frame_tag_handler = { .name = "turbo_frame_tag",
+                                                       .source =
+                                                         HB_STRING_LITERAL("Turbo::FramesHelper#turbo_frame_tag"),
+                                                       .detect = detect_turbo_frame_tag,
+                                                       .extract_tag_name = extract_turbo_frame_tag_name,
+                                                       .extract_content = extract_turbo_frame_tag_content,
+                                                       .supports_block = turbo_frame_tag_supports_block };