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

data/src/visitor.c

@@ -237,6 +237,12 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
         }
       }
 
+      if (erb_block_node->block_arguments != NULL) {
+        for (size_t index = 0; index < hb_array_size(erb_block_node->block_arguments); index++) {
+          herb_visit_node(hb_array_get(erb_block_node->block_arguments, index), visitor, data);
+        }
+      }
+
       if (erb_block_node->rescue_clause != NULL) {
         herb_visit_node((AST_NODE_T *) erb_block_node->rescue_clause, visitor, data);
       }
@@ -442,22 +448,59 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_RUBY_RENDER_KEYWORDS_NODE: {
+      const AST_RUBY_RENDER_KEYWORDS_NODE_T* ruby_render_keywords_node = ((const AST_RUBY_RENDER_KEYWORDS_NODE_T *) node);
+
+      if (ruby_render_keywords_node->locals != NULL) {
+        for (size_t index = 0; index < hb_array_size(ruby_render_keywords_node->locals); index++) {
+          herb_visit_node(hb_array_get(ruby_render_keywords_node->locals, index), visitor, data);
+        }
+      }
+
+    } break;
+
     case AST_ERB_RENDER_NODE: {
       const AST_ERB_RENDER_NODE_T* erb_render_node = ((const AST_ERB_RENDER_NODE_T *) node);
 
-      if (erb_render_node->locals != NULL) {
-        for (size_t index = 0; index < hb_array_size(erb_render_node->locals); index++) {
-          herb_visit_node(hb_array_get(erb_render_node->locals, index), visitor, data);
+      if (erb_render_node->keywords != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_render_node->keywords, visitor, data);
+      }
+
+      if (erb_render_node->body != NULL) {
+        for (size_t index = 0; index < hb_array_size(erb_render_node->body); index++) {
+          herb_visit_node(hb_array_get(erb_render_node->body, index), visitor, data);
         }
       }
 
+      if (erb_render_node->block_arguments != NULL) {
+        for (size_t index = 0; index < hb_array_size(erb_render_node->block_arguments); index++) {
+          herb_visit_node(hb_array_get(erb_render_node->block_arguments, index), visitor, data);
+        }
+      }
+
+      if (erb_render_node->rescue_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_render_node->rescue_clause, visitor, data);
+      }
+
+      if (erb_render_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_render_node->else_clause, visitor, data);
+      }
+
+      if (erb_render_node->ensure_clause != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_render_node->ensure_clause, visitor, data);
+      }
+
+      if (erb_render_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T *) erb_render_node->end_node, visitor, data);
+      }
+
     } break;
 
-    case AST_RUBY_STRICT_LOCAL_NODE: {
-      const AST_RUBY_STRICT_LOCAL_NODE_T* ruby_strict_local_node = ((const AST_RUBY_STRICT_LOCAL_NODE_T *) node);
+    case AST_RUBY_PARAMETER_NODE: {
+      const AST_RUBY_PARAMETER_NODE_T* ruby_parameter_node = ((const AST_RUBY_PARAMETER_NODE_T *) node);
 
-      if (ruby_strict_local_node->default_value != NULL) {
-        herb_visit_node((AST_NODE_T *) ruby_strict_local_node->default_value, visitor, data);
+      if (ruby_parameter_node->default_value != NULL) {
+        herb_visit_node((AST_NODE_T *) ruby_parameter_node->default_value, visitor, data);
       }
 
     } break;

data/templates/java/org/herb/ast/HelperRegistry.java.erb

@@ -0,0 +1,258 @@
+package org.herb.ast;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Type enum for all supported Action View tag helpers.
+ */
+public enum HelperType {
+<%- helpers.each_with_index do |helper, index| -%>
+  <%= helper.constant_name %>("<%= helper.name %>")<%= index < helpers.size - 1 ? "," : ";" %>
+<%- end -%>
+
+  private final String name;
+
+  HelperType(String name) {
+    this.name = name;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public static HelperType fromName(String name) {
+    for (HelperType type : values()) {
+      if (type.name.equals(name)) {
+        return type;
+      }
+    }
+    return null;
+  }
+}
+
+/**
+ * Argument metadata for a tag helper.
+ */
+class HelperArgument {
+  private final String name;
+  private final int position;
+  private final String type;
+  private final boolean optional;
+  private final String defaultValue;
+  private final boolean splat;
+  private final String description;
+
+  HelperArgument(String name, int position, String type, boolean optional, String defaultValue, boolean splat, String description) {
+    this.name = name;
+    this.position = position;
+    this.type = type;
+    this.optional = optional;
+    this.defaultValue = defaultValue;
+    this.splat = splat;
+    this.description = description;
+  }
+
+  public String getName() { return name; }
+  public int getPosition() { return position; }
+  public String getType() { return type; }
+  public boolean isOptional() { return optional; }
+  public String getDefaultValue() { return defaultValue; }
+  public boolean isSplat() { return splat; }
+  public String getDescription() { return description; }
+}
+
+/**
+ * Option metadata for a tag helper.
+ */
+class HelperOption {
+  private final String name;
+  private final String type;
+  private final String mapsTo;
+  private final String description;
+
+  HelperOption(String name, String type, String mapsTo, String description) {
+    this.name = name;
+    this.type = type;
+    this.mapsTo = mapsTo;
+    this.description = description;
+  }
+
+  public String getName() { return name; }
+  public String getType() { return type; }
+  public String getMapsTo() { return mapsTo; }
+  public String getDescription() { return description; }
+}
+
+/**
+ * Implicit attribute metadata for a tag helper.
+ */
+class HelperImplicitAttribute {
+  private final String name;
+  private final String source;
+  private final String sourceWithBlock;
+  private final String wrapper;
+
+  HelperImplicitAttribute(String name, String source, String sourceWithBlock, String wrapper) {
+    this.name = name;
+    this.source = source;
+    this.sourceWithBlock = sourceWithBlock;
+    this.wrapper = wrapper;
+  }
+
+  public String getName() { return name; }
+  public String getSource() { return source; }
+  public String getSourceWithBlock() { return sourceWithBlock; }
+  public String getWrapper() { return wrapper; }
+}
+
+/**
+ * Registry entry containing all metadata for a single tag helper.
+ */
+class HelperEntry {
+  private final String name;
+  private final HelperType type;
+  private final String source;
+  private final String gem;
+  private final String output;
+  private final String visibility;
+  private final String tagName;
+  private final boolean isVoid;
+  private final boolean supportsBlock;
+  private final boolean preferredForTag;
+  private final boolean supported;
+  private final String detectStyle;
+  private final String description;
+  private final String signature;
+  private final String documentationUrl;
+  private final HelperImplicitAttribute implicitAttribute;
+  private final List<HelperArgument> arguments;
+  private final List<HelperOption> options;
+  private final List<String> specialBehaviors;
+  private final List<String> aliases;
+
+  HelperEntry(
+    String name, HelperType type, String source, String gem, String output, String visibility, String tagName,
+    boolean isVoid, boolean supportsBlock, boolean preferredForTag, boolean supported, String detectStyle, String description,
+    String signature, String documentationUrl, HelperImplicitAttribute implicitAttribute,
+    List<HelperArgument> arguments, List<HelperOption> options, List<String> specialBehaviors, List<String> aliases
+  ) {
+    this.name = name;
+    this.type = type;
+    this.source = source;
+    this.gem = gem;
+    this.output = output;
+    this.visibility = visibility;
+    this.tagName = tagName;
+    this.isVoid = isVoid;
+    this.supportsBlock = supportsBlock;
+    this.preferredForTag = preferredForTag;
+    this.supported = supported;
+    this.detectStyle = detectStyle;
+    this.description = description;
+    this.signature = signature;
+    this.documentationUrl = documentationUrl;
+    this.implicitAttribute = implicitAttribute;
+    this.arguments = arguments;
+    this.options = options;
+    this.specialBehaviors = specialBehaviors;
+    this.aliases = aliases;
+  }
+
+  public String getName() { return name; }
+  public HelperType getType() { return type; }
+  public String getSource() { return source; }
+  public String getGem() { return gem; }
+  public String getOutput() { return output; }
+  public String getVisibility() { return visibility; }
+  public String getTagName() { return tagName; }
+  public boolean isVoid() { return isVoid; }
+  public boolean supportsBlock() { return supportsBlock; }
+  public boolean isPreferredForTag() { return preferredForTag; }
+  public boolean isSupported() { return supported; }
+  public String getDetectStyle() { return detectStyle; }
+  public String getDescription() { return description; }
+  public String getSignature() { return signature; }
+  public String getDocumentationUrl() { return documentationUrl; }
+  public HelperImplicitAttribute getImplicitAttribute() { return implicitAttribute; }
+  public List<HelperArgument> getArguments() { return arguments; }
+  public List<HelperOption> getOptions() { return options; }
+  public List<String> getSpecialBehaviors() { return specialBehaviors; }
+  public List<String> getAliases() { return aliases; }
+}
+
+/**
+ * Global registry of all supported Action View tag helpers.
+ *
+ * <p>Usage:
+ * <pre>
+ *   HelperEntry entry = HelperRegistry.get("link_to");
+ *   entry.supportsBlock();  // true
+ *   entry.getTagName();   // "a"
+ * </pre>
+ */
+public final class HelperRegistry {
+  private static final Map<String, HelperEntry> BY_NAME;
+  private static final Map<String, HelperEntry> BY_SOURCE;
+
+  static {
+    Map<String, HelperEntry> byName = new LinkedHashMap<>();
+    Map<String, HelperEntry> bySource = new LinkedHashMap<>();
+
+<%- helpers.each do |helper| -%>
+    {
+      HelperEntry entry = new HelperEntry(
+        "<%= helper.name %>",
+        HelperType.<%= helper.constant_name %>,
+        "<%= helper.source %>",
+        "<%= helper.gem %>",
+        "<%= helper.output %>",
+        "<%= helper.visibility %>",
+        <%= helper.tag_name ? "\"#{helper.tag_name}\"" : "null" %>,
+        <%= helper.void? %>,
+        <%= helper.supports_block %>,
+        <%= helper.preferred_for_tag %>,
+        <%= helper.supported %>,
+        "<%= helper.detect_style || "call_name" %>",
+        "<%= helper.escaped_description %>",
+        "<%= helper.escaped_signature %>",
+        "<%= helper.documentation_url %>",
+<%- if helper.implicit_attribute? -%>
+        new HelperImplicitAttribute("<%= helper.implicit_attribute.name %>", "<%= helper.implicit_attribute.source %>", <%= helper.implicit_attribute.source_with_block ? "\"#{helper.implicit_attribute.source_with_block}\"" : "null" %>, "<%= helper.implicit_attribute.wrapper %>"),
+<%- else -%>
+        null,
+<%- end -%>
+        List.of(<%= helper.arguments.map { |arg| "new HelperArgument(\"#{arg.name}\", #{arg.position}, \"#{arg.type_display}\", #{arg.optional}, #{arg.default ? "\"#{arg.escaped_default}\"" : "null"}, #{arg.splat}, \"#{arg.escaped_description}\")" }.join(", ") %>),
+        List.of(<%= helper.options.map { |opt| "new HelperOption(\"#{opt.name}\", \"#{opt.type_display}\", #{opt.maps_to ? "\"#{opt.maps_to}\"" : "null"}, \"#{opt.escaped_description}\")" }.join(", ") %>),
+        List.of(<%= helper.special_behaviors.map { |b| "\"#{b}\"" }.join(", ") %>),
+        List.of(<%= helper.aliases.map { |a| "\"#{a}\"" }.join(", ") %>)
+      );
+      byName.put("<%= helper.name %>", entry);
+      bySource.put("<%= helper.source %>", entry);
+    }
+
+<%- end -%>
+    BY_NAME = Collections.unmodifiableMap(byName);
+    BY_SOURCE = Collections.unmodifiableMap(bySource);
+  }
+
+  private HelperRegistry() {}
+
+  public static HelperEntry get(String name) {
+    return BY_NAME.get(name);
+  }
+
+  public static HelperEntry findBySource(String source) {
+    return BY_SOURCE.get(source);
+  }
+
+  public static List<HelperEntry> entries() {
+    return List.copyOf(BY_NAME.values());
+  }
+
+  public static int count() {
+    return BY_NAME.size();
+  }
+}

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)[] {