herb 0.9.5-arm-linux-gnu → 0.9.7-arm-linux-gnu

data/templates/src/analyze/action_view/generated_handlers.c.erb

@@ -0,0 +1,230 @@
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+#include "../../include/lib/hb_allocator.h"
+#include "../../include/lib/hb_string.h"
+
+#include <prism.h>
+#include <stdbool.h>
+#include <string.h>
+
+<%- supported_helpers = helpers.select(&:supported?).reject(&:custom_transform?) -%>
+// ==========================================================================
+// Generated detect functions
+// ==========================================================================
+<%- supported_helpers.each do |helper| -%>
+<%- if helper.call_name_detect? -%>
+
+bool detect_<%= helper.safe_name %>(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 == <%= helper.name.length %> && strncmp((const char*) constant->start, "<%= helper.name %>", <%= helper.name.length %>) == 0;
+}
+<%- elsif helper.receiver_call_detect? -%>
+
+bool detect_<%= helper.safe_name %>(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;
+}
+<%- end -%>
+<%- end -%>
+
+// ==========================================================================
+// Generated extract_tag_name functions
+// ==========================================================================
+<%- supported_helpers.each do |helper| -%>
+<%- if helper.tag_name -%>
+
+static char* extract_<%= helper.safe_name %>_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, "<%= helper.tag_name %>");
+}
+<%- elsif helper.name == "content_tag" -%>
+
+static char* extract_<%= helper.safe_name %>_tag_name(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);
+  } 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);
+  }
+
+  return NULL;
+}
+<%- elsif helper.name == "tag" -%>
+
+extern bool is_ruby_introspection_method(hb_string_T method_name);
+
+static char* extract_<%= helper.safe_name %>_tag_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; }
+
+  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++) {
+    if (name[i] == '_') { name[i] = '-'; }
+  }
+
+  return name;
+}
+<%- end -%>
+<%- end -%>
+
+// ==========================================================================
+// Generated extract_content functions
+// ==========================================================================
+<%- supported_helpers.each do |helper| -%>
+<%- content = helper.content -%>
+<%- if content.nil? -%>
+
+static char* extract_<%= helper.safe_name %>_content(pm_call_node_t* _call_node, pm_parser_t* _parser, hb_allocator_T* _allocator) {
+  (void) _call_node;
+  (void) _parser;
+  (void) _allocator;
+
+  return NULL;
+}
+<%- elsif content.first_arg? -%>
+
+static char* extract_<%= helper.safe_name %>_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 content.skip_if_hash -%>
+  if (first_argument->type == PM_KEYWORD_HASH_NODE) { return NULL; }
+  <%- end -%>
+
+  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);
+}
+<%- elsif content.block_or_arg? -%>
+
+static char* extract_<%= helper.safe_name %>_content(pm_call_node_t* call_node, pm_parser_t* <%= helper.receiver_call_detect? ? "parser" : "_parser" %>, hb_allocator_T* allocator) {
+  (void) <%= helper.receiver_call_detect? ? "parser" : "_parser" %>;
+
+  if (!call_node) { return NULL; }
+
+  <%- if helper.receiver_call_detect? -%>
+  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;
+    }
+  }
+  <%- end -%>
+
+  char* block_content = extract_inline_block_content(call_node, allocator);
+  if (block_content) { return block_content; }
+
+  <%- arg_index = (content.arg_position || 1) - 1 -%>
+
+  <%- if content.arg_position -%>
+  if (call_node->arguments) {
+    pm_arguments_node_t* arguments = call_node->arguments;
+
+    if (arguments->arguments.size >= <%= content.arg_position %>) {
+      pm_node_t* argument = arguments->arguments.nodes[<%= arg_index %>];
+
+      <%- if content.skip_if_hash -%>
+      if (argument->type != PM_KEYWORD_HASH_NODE) {
+      <%- end -%>
+
+        if (argument->type == PM_STRING_NODE) {
+          pm_string_node_t* string_node = (pm_string_node_t*) 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 = argument->location.end - argument->location.start;
+
+        <%- if content.to_s_suffix_when_single -%>
+        if (arguments->arguments.size == 1 && argument->type != PM_NIL_NODE) {
+          const char* suffix = ".to_s";
+          size_t suffix_length = strlen(suffix);
+          size_t total_length = source_length + suffix_length;
+          char* ruby_expression = hb_allocator_alloc(allocator, total_length + 1);
+
+          memcpy(ruby_expression, (const char*) argument->location.start, source_length);
+          memcpy(ruby_expression + source_length, suffix, suffix_length);
+          ruby_expression[total_length] = '\0';
+
+          return ruby_expression;
+        }
+        <%- end -%>
+
+        return hb_allocator_strndup(allocator, (const char*) argument->location.start, source_length);
+
+      <%- if content.skip_if_hash -%>
+      }
+      <%- end -%>
+    }
+  }
+<%- end -%>
+
+  return NULL;
+}
+<%- end -%>
+<%- end -%>
+
+// ==========================================================================
+// Generated supports_block functions
+// ==========================================================================
+<%- supported_helpers.each do |helper| -%>
+
+static bool <%= helper.safe_name %>_supports_block(void) {
+  return <%= helper.supports_block %>;
+}
+<%- end -%>
+
+// ==========================================================================
+// Generated handler structs
+// ==========================================================================
+<%- supported_helpers.each do |helper| -%>
+
+const tag_helper_handler_T <%= helper.safe_name %>_handler = {
+  .name = "<%= helper.name %>",
+  .source = HB_STRING_LITERAL("<%= helper.source %>"),
+  .detect = detect_<%= helper.safe_name %>,
+  .extract_tag_name = extract_<%= helper.safe_name %>_tag_name,
+  .extract_content = extract_<%= helper.safe_name %>_content,
+  .supports_block = <%= helper.safe_name %>_supports_block,
+};
+<%- end -%>

data/templates/src/analyze/action_view/generated_handlers.h.erb

@@ -0,0 +1,12 @@
+#ifndef GENERATED_HANDLERS_H
+#define GENERATED_HANDLERS_H
+
+#include "../../include/analyze/action_view/tag_helper_handler.h"
+
+<%- supported_helpers = helpers.select(&:supported?) -%>
+<%- supported_helpers.each do |helper| -%>
+<%- next if helper.custom_transform? -%>
+extern const tag_helper_handler_T <%= helper.safe_name %>_handler;
+<%- end -%>
+
+#endif

data/templates/src/analyze/action_view/helper_registry.c.erb

@@ -0,0 +1,114 @@
+#include "../../include/analyze/action_view/helper_registry.h"
+#include "../../include/lib/hb_string.h"
+
+#include <string.h>
+
+<%- helpers.each do |helper| -%>
+<%- if helper.implicit_attribute? -%>
+static const helper_implicit_attribute_T <%= helper.safe_name %>_implicit_attribute = {
+  .name = "<%= helper.implicit_attribute.name %>",
+  .source = "<%= helper.implicit_attribute.source %>",
+<%- if helper.implicit_attribute.source_with_block -%>
+  .source_with_block = "<%= helper.implicit_attribute.source_with_block %>",
+<%- else -%>
+  .source_with_block = NULL,
+<%- end -%>
+  .wrapper = "<%= helper.implicit_attribute.wrapper %>",
+};
+
+<%- end -%>
+<%- if helper.arguments.any? -%>
+static const helper_argument_T <%= helper.safe_name %>_arguments[] = {
+<%- helper.arguments.each do |arg| -%>
+  { .name = "<%= arg.name %>", .type = "<%= arg.type_display %>", .description = "<%= arg.escaped_description %>" },
+<%- end -%>
+};
+
+<%- end -%>
+<%- if helper.options.any? -%>
+static const helper_option_T <%= helper.safe_name %>_options[] = {
+<%- helper.options.each do |opt| -%>
+  { .name = "<%= opt.name %>", .type = "<%= opt.type_display %>", .maps_to = <%= opt.maps_to ? "\"#{opt.maps_to}\"" : "NULL" %>, .description = "<%= opt.escaped_description %>" },
+<%- end -%>
+};
+
+<%- end -%>
+<%- end -%>
+static const helper_registry_entry_T registry_entries[HELPER_COUNT] = {
+<%- helpers.each do |helper| -%>
+  {
+    .type = HELPER_<%= helper.constant_name %>,
+    .name = "<%= helper.name %>",
+    .name_length = <%= helper.name.length %>,
+    .source = HB_STRING_LITERAL("<%= helper.source %>"),
+    .gem = "<%= helper.gem %>",
+    .output = HELPER_OUTPUT_<%= helper.output.upcase %>,
+    .visibility = "<%= helper.visibility %>",
+    .tag_name = <%= helper.tag_name ? "\"#{helper.tag_name}\"" : "NULL" %>,
+    .is_void = <%= helper.void? %>,
+    .supports_block = <%= helper.supports_block %>,
+    .preferred_for_tag = <%= helper.preferred_for_tag %>,
+    .supported = <%= helper.supported %>,
+    .detect_style = <%= helper.call_name_detect? ? "HELPER_DETECT_CALL_NAME" : "HELPER_DETECT_RECEIVER_CALL" %>,
+    .description = "<%= helper.escaped_description %>",
+    .signature = "<%= helper.escaped_signature %>",
+    .documentation_url = "<%= helper.documentation_url %>",
+    .implicit_attribute = <%= helper.implicit_attribute? ? "&#{helper.safe_name}_implicit_attribute" : "NULL" %>,
+    .arguments = <%= helper.arguments.any? ? "#{helper.safe_name}_arguments" : "NULL" %>,
+    .arguments_count = <%= helper.arguments.size %>,
+    .options = <%= helper.options.any? ? "#{helper.safe_name}_options" : "NULL" %>,
+    .options_count = <%= helper.options.size %>,
+  },
+<%- end -%>
+};
+
+const helper_registry_entry_T* helper_registry_get(helper_type_T type) {
+  if (type < 0 || type >= HELPER_COUNT) { return NULL; }
+
+  return &registry_entries[type];
+}
+
+const helper_registry_entry_T* helper_registry_find_by_name(const char* name, size_t length) {
+  for (size_t i = 0; i < HELPER_COUNT; i++) {
+    if (registry_entries[i].name_length == length && strncmp(registry_entries[i].name, name, length) == 0) {
+      return &registry_entries[i];
+    }
+  }
+
+  return NULL;
+}
+
+const helper_registry_entry_T* helper_registry_find_by_source(const char* source) {
+  if (!source) { return NULL; }
+
+  size_t source_length = strlen(source);
+
+  for (size_t i = 0; i < HELPER_COUNT; i++) {
+    if (registry_entries[i].source.length == source_length && strncmp(registry_entries[i].source.data, source, source_length) == 0) {
+      return &registry_entries[i];
+    }
+  }
+
+  return NULL;
+}
+
+const helper_registry_entry_T* helper_registry_find_preferred_for_tag(const char* tag_name) {
+  if (!tag_name) { return NULL; }
+
+  for (size_t i = 0; i < HELPER_COUNT; i++) {
+    if (registry_entries[i].tag_name && registry_entries[i].preferred_for_tag
+        && strcmp(registry_entries[i].tag_name, tag_name) == 0) {
+      return &registry_entries[i];
+    }
+  }
+
+  return NULL;
+}
+
+const helper_registry_entry_T* helper_registry_entries(void) {
+  return registry_entries;
+}
+
+size_t helper_registry_count(void) {
+  return HELPER_COUNT;
+}

data/templates/src/include/analyze/action_view/helper_registry.h.erb

@@ -0,0 +1,82 @@
+#ifndef HELPER_REGISTRY_H
+#define HELPER_REGISTRY_H
+
+#include "../../lib/hb_string.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef enum {
+<%- helpers.each do |helper| -%>
+  HELPER_<%= helper.constant_name %>,
+<%- end -%>
+} helper_type_T;
+
+#define HELPER_COUNT <%= helpers.size %>
+
+typedef enum {
+  HELPER_DETECT_CALL_NAME,
+  HELPER_DETECT_RECEIVER_CALL,
+} helper_detect_style_T;
+
+typedef struct {
+  const char* name;
+  const char* type;
+  const char* description;
+} helper_argument_T;
+
+typedef struct {
+  const char* name;
+  const char* type;
+  const char* maps_to;
+  const char* description;
+} helper_option_T;
+
+typedef struct {
+  const char* name;
+  const char* source;
+  const char* source_with_block;
+  const char* wrapper;
+} helper_implicit_attribute_T;
+
+typedef enum {
+  HELPER_OUTPUT_HTML,
+  HELPER_OUTPUT_TEXT,
+  HELPER_OUTPUT_URL,
+  HELPER_OUTPUT_BOOLEAN,
+  HELPER_OUTPUT_VOID,
+  HELPER_OUTPUT_OBJECT,
+} helper_output_T;
+
+typedef struct {
+  helper_type_T type;
+  const char* name;
+  size_t name_length;
+  hb_string_T source;
+  const char* gem;
+  helper_output_T output;
+  const char* visibility;
+  const char* tag_name;
+  bool is_void;
+  bool supports_block;
+  bool preferred_for_tag;
+  bool supported;
+  helper_detect_style_T detect_style;
+  const char* description;
+  const char* signature;
+  const char* documentation_url;
+  const helper_implicit_attribute_T* implicit_attribute;
+  const helper_argument_T* arguments;
+  size_t arguments_count;
+  const helper_option_T* options;
+  size_t options_count;
+} helper_registry_entry_T;
+
+const helper_registry_entry_T* helper_registry_get(helper_type_T type);
+const helper_registry_entry_T* helper_registry_find_by_name(const char* name, size_t length);
+const helper_registry_entry_T* helper_registry_find_by_source(const char* source);
+const helper_registry_entry_T* helper_registry_find_preferred_for_tag(const char* tag_name);
+const helper_registry_entry_T* helper_registry_entries(void);
+size_t helper_registry_count(void);
+
+#endif