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

data/templates/javascript/packages/core/src/action-view-helpers.ts.erb

@@ -0,0 +1,171 @@
+export enum HelperType {
+<%- helpers.each do |helper| -%>
+  <%= helper.camel_case_name %> = "<%= helper.name %>",
+<%- end -%>
+}
+
+export type HelperDetectStyle = "call_name" | "receiver_call"
+export type HelperOutput = "html" | "text" | "url" | "boolean" | "void" | "object"
+
+export interface HelperArgument {
+  readonly name: string
+  readonly position: number
+  readonly type: string
+  readonly optional: boolean
+  readonly default: string | null
+  readonly splat: boolean
+  readonly description: string
+}
+
+export interface HelperOption {
+  readonly name: string
+  readonly type: string
+  readonly mapsTo: string | null
+  readonly description: string
+}
+
+export interface HelperImplicitAttribute {
+  readonly name: string
+  readonly source: string
+  readonly sourceWithBlock: string | null
+  readonly wrapper: string
+  readonly skipWrappingFor: string[]
+}
+
+export interface HelperEntry {
+  readonly name: string
+  readonly type: HelperType
+  readonly source: string
+  readonly gem: string
+  readonly output: HelperOutput
+  readonly visibility: "public" | "internal"
+  readonly tagName: string | null
+  readonly isVoid: boolean
+  readonly supportsBlock: boolean
+  readonly preferredForTag: boolean
+  readonly supported: boolean
+  readonly detectStyle: HelperDetectStyle
+  readonly description: string
+  readonly signature: string
+  readonly documentationURL: string
+  readonly implicitAttribute: HelperImplicitAttribute | null
+  readonly arguments: HelperArgument[]
+  readonly options: HelperOption[]
+  readonly specialBehaviors: string[]
+  readonly aliases: string[]
+}
+
+<%- helpers.each do |helper| -%>
+const <%= helper.lower_camel_case_name %>Entry: HelperEntry = {
+  name: "<%= helper.name %>",
+  type: HelperType.<%= helper.camel_case_name %>,
+  source: "<%= helper.source %>",
+  gem: "<%= helper.gem %>",
+  output: "<%= helper.output %>",
+  visibility: "<%= helper.visibility %>",
+  tagName: <%= helper.tag_name ? "\"#{helper.tag_name}\"" : "null" %>,
+  isVoid: <%= helper.void? %>,
+  supportsBlock: <%= helper.supports_block %>,
+  preferredForTag: <%= helper.preferred_for_tag %>,
+  supported: <%= helper.supported %>,
+  detectStyle: "<%= helper.detect_style || "call_name" %>",
+  description: "<%= helper.escaped_description %>",
+  signature: "<%= helper.escaped_signature %>",
+  documentationURL: "<%= helper.documentation_url %>",
+  <%- if helper.implicit_attribute? -%>
+  implicitAttribute: {
+    name: "<%= helper.implicit_attribute.name %>",
+    source: "<%= helper.implicit_attribute.source %>",
+    sourceWithBlock: <%= helper.implicit_attribute.source_with_block ? "\"#{helper.implicit_attribute.source_with_block}\"" : "null" %>,
+    wrapper: "<%= helper.implicit_attribute.wrapper %>",
+    skipWrappingFor: [<%= helper.implicit_attribute.skip_wrapping_for.map { |s| "\"#{s}\"" }.join(", ") %>],
+  },
+  <%- else -%>
+  implicitAttribute: null,
+  <%- end -%>
+  arguments: [
+  <%- helper.arguments.each do |arg| -%>
+    { name: "<%= arg.name %>", position: <%= arg.position %>, type: "<%= arg.type_display %>", optional: <%= arg.optional %>, default: <%= arg.default ? "\"#{arg.escaped_default}\"" : "null" %>, splat: <%= arg.splat %>, description: "<%= arg.escaped_description %>" },
+  <%- end -%>
+  ],
+  options: [
+  <%- helper.options.each do |opt| -%>
+    { name: "<%= opt.name %>", type: "<%= opt.type_display %>", mapsTo: <%= opt.maps_to ? "\"#{opt.maps_to}\"" : "null" %>, description: "<%= opt.escaped_description %>" },
+  <%- end -%>
+  ],
+  specialBehaviors: [<%= helper.special_behaviors.map { |b| "\"#{b}\"" }.join(", ") %>],
+  aliases: [<%= helper.aliases.map { |a| "\"#{a}\"" }.join(", ") %>],
+}
+
+<%- end -%>
+export const HELPER_REGISTRY: Record<string, HelperEntry> = {
+<%- helpers.each do |helper| -%>
+  "<%= helper.name %>": <%= helper.lower_camel_case_name %>Entry,
+<%- helper.aliases.each do |alias_name| -%>
+  "<%= alias_name %>": <%= helper.lower_camel_case_name %>Entry,
+<%- end -%>
+<%- end -%>
+}
+
+export const HELPER_BY_SOURCE: Record<string, HelperEntry> = {
+<%- helpers.each do |helper| -%>
+  "<%= helper.source %>": <%= helper.lower_camel_case_name %>Entry,
+<%- end -%>
+}
+
+<%- helpers_by_tag = helpers.select(&:static_tag_name?).group_by(&:tag_name) -%>
+export const HELPERS_BY_TAG_NAME: Record<string, HelperEntry[]> = {
+<%- helpers_by_tag.each do |tag_name, helpers| -%>
+  "<%= tag_name %>": [<%= helpers.map { |h| "#{h.lower_camel_case_name}Entry" }.join(", ") %>],
+<%- end -%>
+}
+
+export function getHelper(name: string): HelperEntry | undefined {
+  return HELPER_REGISTRY[name]
+}
+
+export function getHelperBySource(source: string): HelperEntry | undefined {
+  return HELPER_BY_SOURCE[source]
+}
+
+export function getHelperEntries(): HelperEntry[] {
+  return Object.values(HELPER_REGISTRY)
+}
+
+export function isHelperSupported(name: string): boolean {
+  return HELPER_REGISTRY[name]?.supported ?? false
+}
+
+export function helperExists(name: string): boolean {
+  return name in HELPER_REGISTRY
+}
+
+export function getHelpersForTag(tagName: string): HelperEntry[] {
+  return HELPERS_BY_TAG_NAME[tagName] ?? []
+}
+
+export function findPreferredHelperForTag(tagName: string): HelperEntry | undefined {
+  const helpers = HELPERS_BY_TAG_NAME[tagName]
+  if (!helpers) return undefined
+
+  return helpers.find(entry => entry.preferredForTag) ?? helpers[0]
+}
+
+export function getSupportedHelpers(): HelperEntry[] {
+  return Object.values(HELPER_REGISTRY).filter(entry => entry.supported)
+}
+
+export function getHelpersByGem(gem: string): HelperEntry[] {
+  return Object.values(HELPER_REGISTRY).filter(entry => entry.gem === gem)
+}
+
+export function getHelpersByOutput(output: HelperOutput): HelperEntry[] {
+  return Object.values(HELPER_REGISTRY).filter(entry => entry.output === output)
+}
+
+export function getHelpersByModule(moduleName: string): HelperEntry[] {
+  return Object.values(HELPER_REGISTRY).filter(entry => {
+    const parts = entry.source.split("#")[0].split("::")
+    return parts[parts.length - 1] === moduleName
+  })
+}

data/templates/javascript/packages/core/src/nodes.ts.erb

@@ -318,7 +318,11 @@ export class <%= node.name %> extends Node {
   }
 
   accept(visitor: Visitor): void {
-    visitor.visit<%= node.name %>(this)
+    const visitMethod = visitor.visit<%= node.name %> as ((node: <%= node.name %>) => void) | undefined
+
+    if (typeof visitMethod === "function") {
+      visitMethod.call(visitor, this)
+    }
   }
 
   childNodes(): (Node | null | undefined)[] {

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()
+}