herb 0.9.4-arm-linux-gnu → 0.9.6-arm-linux-gnu

data/templates/lib/herb/action_view/helper_registry.rb.erb

@@ -0,0 +1,288 @@
+module Herb
+  module ActionView
+    module HelperType
+    <%- helpers.each do |helper| -%>
+      <%= helper.constant_name %> = :<%= helper.name %>
+    <%- end -%>
+
+      ALL = [
+      <%- helpers.each do |helper| -%>
+        <%= helper.constant_name %>,
+      <%- end -%>
+      ].freeze #: Array[Symbol]
+    end
+
+    class HelperArgument
+      attr_reader :name #: String
+      attr_reader :position #: Integer
+      attr_reader :type #: String
+      attr_reader :default #: String?
+      attr_reader :description #: String
+
+      #: (String, Integer, String, bool, String?, bool, String) -> void
+      def initialize(name, position, type, optional, default, splat, description)
+        @name = name
+        @position = position
+        @type = type
+        @optional = optional
+        @default = default
+        @splat = splat
+        @description = description
+      end
+
+      #: () -> bool
+      def optional? = @optional
+
+      #: () -> bool
+      def splat? = @splat
+    end
+
+    class HelperOption
+      attr_reader :name #: String
+      attr_reader :type #: String
+      attr_reader :maps_to #: String?
+      attr_reader :description #: String
+
+      #: (String, String, String?, String) -> void
+      def initialize(name, type, maps_to, description)
+        @name = name
+        @type = type
+        @maps_to = maps_to
+        @description = description
+      end
+
+      #: () -> bool
+      def maps_to_data_attribute? = maps_to&.start_with?("data-") || false
+
+      #: () -> bool
+      def maps_to_aria_attribute? = maps_to&.start_with?("aria-") || false
+    end
+
+    class HelperImplicitAttribute
+      attr_reader :name #: String
+      attr_reader :source #: String
+      attr_reader :source_with_block #: String?
+      attr_reader :wrapper #: String
+      attr_reader :skip_wrapping_for #: Array[String]
+
+      #: (String, String, String?, String, Array[String]) -> void
+      def initialize(name, source, source_with_block, wrapper, skip_wrapping_for)
+        @name = name
+        @source = source
+        @source_with_block = source_with_block
+        @wrapper = wrapper
+        @skip_wrapping_for = skip_wrapping_for
+      end
+    end
+
+    class HelperEntry
+      attr_reader :name #: String
+      attr_reader :type #: Symbol
+      attr_reader :source #: String
+      attr_reader :gem #: String
+      attr_reader :output #: Symbol
+      attr_reader :visibility #: String
+      attr_reader :tag_name #: String?
+      attr_reader :detect_style #: Symbol
+      attr_reader :description #: String
+      attr_reader :signature #: String
+      attr_reader :documentation_url #: String
+      attr_reader :implicit_attribute #: HelperImplicitAttribute?
+      attr_reader :arguments #: Array[HelperArgument]
+      attr_reader :options #: Array[HelperOption]
+      attr_reader :special_behaviors #: Array[Symbol]
+      attr_reader :aliases #: Array[String]
+
+      #: (name: String, type: Symbol, source: String, gem: String, output: Symbol, visibility: String, tag_name: String?, is_void: bool, supports_block: bool, preferred_for_tag: bool, supported: bool, detect_style: Symbol, description: String, signature: String, documentation_url: String, implicit_attribute: HelperImplicitAttribute?, arguments: Array[HelperArgument], options: Array[HelperOption], special_behaviors: Array[Symbol], aliases: Array[String]) -> void
+      def initialize( # rubocop:disable Metrics/ParameterLists
+        name:, type:, source:, gem:, output:, visibility:, tag_name:, is_void:, supports_block:,
+        preferred_for_tag:, supported:, detect_style:, description:, signature:, documentation_url:,
+        implicit_attribute:, arguments:, options:, special_behaviors:, aliases:
+      )
+        @name = name
+        @type = type
+        @source = source
+        @gem = gem
+        @output = output
+        @visibility = visibility
+        @tag_name = tag_name
+        @is_void = is_void
+        @supports_block = supports_block
+        @preferred_for_tag = preferred_for_tag
+        @supported = supported
+        @detect_style = detect_style
+        @description = description
+        @signature = signature
+        @documentation_url = documentation_url
+        @implicit_attribute = implicit_attribute
+        @arguments = arguments
+        @options = options
+        @special_behaviors = special_behaviors
+        @aliases = aliases
+      end
+
+      #: () -> bool
+      def void? = @is_void
+
+      #: () -> bool
+      def supports_block? = @supports_block
+
+      #: () -> bool
+      def preferred_for_tag? = @preferred_for_tag
+
+      #: () -> bool
+      def supported? = @supported
+
+      #: () -> bool
+      def static_tag_name? = !@tag_name.nil?
+
+      #: () -> bool
+      def implicit_attribute? = !@implicit_attribute.nil?
+
+      #: () -> bool
+      def call_name_detect? = @detect_style == :call_name
+
+      #: () -> bool
+      def receiver_call_detect? = @detect_style == :receiver_call
+    end
+
+    module HelperRegistry
+    <%- helpers.each do |helper| -%>
+      <%= helper.constant_name %> = HelperEntry.new(
+        name: "<%= helper.name %>",
+        type: HelperType::<%= helper.constant_name %>,
+        source: "<%= helper.source %>",
+        gem: "<%= helper.gem %>",
+        output: :<%= helper.output %>,
+        visibility: "<%= helper.visibility %>",
+        tag_name: <%= helper.tag_name ? "\"#{helper.tag_name}\"" : "nil" %>,
+        is_void: <%= helper.void? %>,
+        supports_block: <%= helper.supports_block %>,
+        preferred_for_tag: <%= helper.preferred_for_tag %>,
+        supported: <%= helper.supported %>,
+        detect_style: :<%= helper.detect_style || "call_name" %>,
+        description: "<%= helper.escaped_description %>",
+        signature: "<%= helper.escaped_signature %>",
+        documentation_url: "<%= helper.documentation_url %>",
+      <%- if helper.implicit_attribute? -%>
+        implicit_attribute: HelperImplicitAttribute.new(
+          "<%= helper.implicit_attribute.name %>",
+          "<%= helper.implicit_attribute.source %>",
+          <%= helper.implicit_attribute.source_with_block ? "\"#{helper.implicit_attribute.source_with_block}\"" : "nil" %>,
+          "<%= helper.implicit_attribute.wrapper %>",
+          [<%= helper.implicit_attribute.skip_wrapping_for.map { |s| "\"#{s}\"" }.join(", ") %>]
+        ),
+      <%- else -%>
+        implicit_attribute: nil,
+      <%- end -%>
+        arguments: [
+        <%- helper.arguments.each do |arg| -%>
+          HelperArgument.new("<%= arg.name %>", <%= arg.position %>, "<%= arg.type_display %>", <%= arg.optional %>, <%= arg.default ? "\"#{arg.escaped_default}\"" : "nil" %>, <%= arg.splat %>, "<%= arg.escaped_description %>"),
+        <%- end -%>
+        ],
+        options: [
+        <%- helper.options.each do |opt| -%>
+          HelperOption.new("<%= opt.name %>", "<%= opt.type_display %>", <%= opt.maps_to ? "\"#{opt.maps_to}\"" : "nil" %>, "<%= opt.escaped_description %>"),
+        <%- end -%>
+        ],
+        special_behaviors: [<%= helper.special_behaviors.map { |b| ":#{b}" }.join(", ") %>],
+        aliases: [<%= helper.aliases.map { |a| "\"#{a}\"" }.join(", ") %>],
+      ).freeze #: HelperEntry
+
+    <%- end -%>
+      ENTRIES = {
+      <%- helpers.each do |helper| -%>
+        "<%= helper.name %>" => <%= helper.constant_name %>,
+      <%- helper.aliases.each do |alias_name| -%>
+        "<%= alias_name %>" => <%= helper.constant_name %>,
+      <%- end -%>
+      <%- end -%>
+      }.freeze #: Hash[String, HelperEntry]
+
+      BY_SOURCE = {
+      <%- helpers.each do |helper| -%>
+        "<%= helper.source %>" => <%= helper.constant_name %>,
+      <%- end -%>
+      }.freeze #: Hash[String, HelperEntry]
+
+      <%- helpers_by_tag = helpers.select(&:static_tag_name?).group_by(&:tag_name) -%>
+
+      BY_TAG_NAME = {
+      <%- helpers_by_tag.each do |tag_name, helpers| -%>
+        "<%= tag_name %>" => [<%= helpers.map(&:constant_name).join(", ") %>].freeze,
+      <%- end -%>
+      }.freeze #: Hash[String, Array[HelperEntry]]
+
+      class << self
+        #: (String) -> HelperEntry?
+        def get(name)
+          ENTRIES[name.to_s]
+        end
+
+        #: (String) -> HelperEntry?
+        def find_by_source(source)
+          BY_SOURCE[source]
+        end
+
+        #: () -> Array[HelperEntry]
+        def entries
+          ENTRIES.values
+        end
+
+        #: () { (HelperEntry) -> void } -> void
+        def each(&block)
+          entries.each(&block)
+        end
+
+        #: (String) -> Array[HelperEntry]
+        def helpers_for_tag(tag_name)
+          BY_TAG_NAME[tag_name] || []
+        end
+
+        #: (String) -> HelperEntry?
+        def find_preferred_for_tag(tag_name)
+          helpers = BY_TAG_NAME[tag_name]
+          return nil unless helpers
+
+          helpers.find(&:preferred_for_tag?) || helpers.first
+        end
+
+        #: () -> Integer
+        def count
+          ENTRIES.size
+        end
+
+        #: (String) -> bool
+        def supported?(name)
+          entry = get(name)
+          entry&.supported? || false
+        end
+
+        #: (String) -> bool
+        def exists?(name)
+          ENTRIES.key?(name.to_s)
+        end
+
+        #: () -> Array[HelperEntry]
+        def supported
+          entries.select(&:supported?)
+        end
+
+        #: (String) -> Array[HelperEntry]
+        def by_gem(gem_name)
+          entries.select { |entry| entry.gem == gem_name }
+        end
+
+        #: (Symbol) -> Array[HelperEntry]
+        def by_output(output)
+          entries.select { |entry| entry.output == output }
+        end
+
+        #: (String) -> Array[HelperEntry]
+        def by_module(module_name)
+          entries.select { |entry| entry.source.split("#").first.split("::").last == module_name }
+        end
+      end
+    end
+  end
+end

data/templates/rust/src/action_view_helpers.rs.erb

@@ -0,0 +1,154 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum HelperType {
+<%- helpers.each do |helper| -%>
+  /// `<%= helper.name %>` — <%= helper.source %>
+  <%= helper.camel_case_name %>,
+<%- end -%>
+}
+
+impl HelperType {
+  pub fn as_str(&self) -> &'static str {
+    match self {
+    <%- helpers.each do |helper| -%>
+      HelperType::<%= helper.camel_case_name %> => "<%= helper.name %>",
+    <%- end -%>
+    }
+  }
+
+  pub fn from_name(name: &str) -> Option<HelperType> {
+    match name {
+    <%- helpers.each do |helper| -%>
+      "<%= helper.name %>" => Some(HelperType::<%= helper.camel_case_name %>),
+    <%- end -%>
+      _ => None,
+    }
+  }
+}
+
+#[derive(Debug, Clone)]
+pub struct HelperArgument {
+  pub name: &'static str,
+  pub position: usize,
+  pub argument_type: &'static str,
+  pub optional: bool,
+  pub default: Option<&'static str>,
+  pub splat: bool,
+  pub description: &'static str,
+}
+
+#[derive(Debug, Clone)]
+pub struct HelperOption {
+  pub name: &'static str,
+  pub option_type: &'static str,
+  pub maps_to: Option<&'static str>,
+  pub description: &'static str,
+}
+
+#[derive(Debug, Clone)]
+pub struct HelperImplicitAttribute {
+  pub name: &'static str,
+  pub source: &'static str,
+  pub source_with_block: Option<&'static str>,
+  pub wrapper: &'static str,
+  pub skip_wrapping_for: &'static [&'static str],
+}
+
+#[derive(Debug, Clone)]
+pub struct HelperEntry {
+  pub name: &'static str,
+  pub helper_type: HelperType,
+  pub source: &'static str,
+  pub gem: &'static str,
+  pub output: &'static str,
+  pub visibility: &'static str,
+  pub tag_name: Option<&'static str>,
+  pub is_void: bool,
+  pub supports_block: bool,
+  pub preferred_for_tag: bool,
+  pub supported: bool,
+  pub detect_style: &'static str,
+  pub description: &'static str,
+  pub signature: &'static str,
+  pub documentation_url: &'static str,
+  pub implicit_attribute: Option<&'static HelperImplicitAttribute>,
+  pub arguments: &'static [HelperArgument],
+  pub options: &'static [HelperOption],
+  pub special_behaviors: &'static [&'static str],
+  pub aliases: &'static [&'static str],
+}
+
+<%- helpers.each do |helper| -%>
+<%- if helper.implicit_attribute? -%>
+static <%= helper.constant_name %>_IMPLICIT_ATTR: HelperImplicitAttribute = HelperImplicitAttribute {
+  name: "<%= helper.implicit_attribute.name %>",
+  source: "<%= helper.implicit_attribute.source %>",
+  source_with_block: <%= helper.implicit_attribute.source_with_block ? "Some(\"#{helper.implicit_attribute.source_with_block}\")" : "None" %>,
+  wrapper: "<%= helper.implicit_attribute.wrapper %>",
+  skip_wrapping_for: &[<%= helper.implicit_attribute.skip_wrapping_for.map { |s| "\"#{s}\"" }.join(", ") %>],
+};
+
+<%- end -%>
+<%- end -%>
+
+static REGISTRY: [HelperEntry; <%= helpers.size %>] = [
+<%- helpers.each do |helper| -%>
+  HelperEntry {
+    name: "<%= helper.name %>",
+    helper_type: HelperType::<%= helper.camel_case_name %>,
+    source: "<%= helper.source %>",
+    gem: "<%= helper.gem %>",
+    output: "<%= helper.output %>",
+    visibility: "<%= helper.visibility %>",
+    tag_name: <%= helper.tag_name ? "Some(\"#{helper.tag_name}\")" : "None" %>,
+    is_void: <%= helper.void? %>,
+    supports_block: <%= helper.supports_block %>,
+    preferred_for_tag: <%= helper.preferred_for_tag %>,
+    supported: <%= helper.supported %>,
+    detect_style: "<%= helper.detect_style || "call_name" %>",
+    description: "<%= helper.escaped_description %>",
+    signature: "<%= helper.escaped_signature %>",
+    documentation_url: "<%= helper.documentation_url %>",
+    implicit_attribute: <%= helper.implicit_attribute? ? "Some(&#{helper.constant_name}_IMPLICIT_ATTR)" : "None" %>,
+    arguments: &[
+    <%- helper.arguments.each do |arg| -%>
+      HelperArgument { name: "<%= arg.name %>", position: <%= arg.position %>, argument_type: "<%= arg.type_display %>", optional: <%= arg.optional %>, default: <%= arg.default ? "Some(\"#{arg.escaped_default}\")" : "None" %>, splat: <%= arg.splat %>, description: "<%= arg.escaped_description %>" },
+    <%- end -%>
+    ],
+    options: &[
+    <%- helper.options.each do |opt| -%>
+      HelperOption { name: "<%= opt.name %>", option_type: "<%= opt.type_display %>", maps_to: <%= opt.maps_to ? "Some(\"#{opt.maps_to}\")" : "None" %>, description: "<%= opt.escaped_description %>" },
+    <%- end -%>
+    ],
+    special_behaviors: &[<%= helper.special_behaviors.map { |b| "\"#{b}\"" }.join(", ") %>],
+    aliases: &[<%= helper.aliases.map { |a| "\"#{a}\"" }.join(", ") %>],
+  },
+<%- end -%>
+];
+
+pub fn get(helper_type: HelperType) -> &'static HelperEntry {
+  &REGISTRY[helper_type as usize]
+}
+
+pub fn find_by_name(name: &str) -> Option<&'static HelperEntry> {
+  REGISTRY.iter().find(|entry| entry.name == name)
+}
+
+pub fn find_by_source(source: &str) -> Option<&'static HelperEntry> {
+  REGISTRY.iter().find(|entry| entry.source == source)
+}
+
+pub fn helpers_for_tag(tag_name: &str) -> Vec<&'static HelperEntry> {
+  REGISTRY.iter().filter(|entry| entry.tag_name == Some(tag_name)).collect()
+}
+
+pub fn find_preferred_for_tag(tag_name: &str) -> Option<&'static HelperEntry> {
+  REGISTRY.iter().find(|entry| entry.tag_name == Some(tag_name) && entry.preferred_for_tag)
+}
+
+pub fn entries() -> &'static [HelperEntry] {
+  &REGISTRY
+}
+
+pub fn count() -> usize {
+  REGISTRY.len()
+}

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