herb 0.10.4-x86_64-linux-gnu → 0.11.1-x86_64-linux-gnu

data/templates/java/nodes.c.erb

@@ -9,35 +9,35 @@
 
 #include <stdlib.h>
 
-jobject NodeFromCStruct(JNIEnv* env, AST_NODE_T* node);
-jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array);
+jobject NodeFromCStruct(JNIEnv* env, AST_NODE_T* node, const parser_options_T* options);
+jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array, const parser_options_T* options);
 
 <%- nodes.each do |node| -%>
-jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= node.human %>) {
+jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= node.human %>, const parser_options_T* options) {
   if (!<%= node.human %>) { return NULL; }
 
   jclass nodeClass = (*env)->FindClass(env, "org/herb/ast/<%= node.name %>");
   if (!nodeClass) { return NULL; }
 
   jstring type = (*env)->NewStringUTF(env, "<%= node.name %>");
-  jobject location = CreateLocation(env, <%= node.human %>->base.location);
+  jobject location = options->track_locations ? CreateLocation(env, <%= node.human %>->base.location) : NULL;
   jobject errors = ErrorsArrayFromCArray(env, <%= node.human %>->base.errors);
 
   <%- node.fields.each do |field| -%>
   <%- if field.is_a?(Herb::Template::StringField) -%>
   jstring <%= field.name %> = CreateStringFromHbString(env, <%= node.human %>-><%= field.name %>);
   <%- elsif field.is_a?(Herb::Template::TokenField) -%>
-  jobject <%= field.name %> = <%= node.human %>-><%= field.name %> ? CreateToken(env, <%= node.human %>-><%= field.name %>) : NULL;
+  jobject <%= field.name %> = <%= node.human %>-><%= field.name %> ? CreateToken(env, <%= node.human %>-><%= field.name %>, options) : NULL;
   <%- elsif field.is_a?(Herb::Template::BooleanField) -%>
   jboolean <%= field.name %> = <%= node.human %>-><%= field.name %> ? JNI_TRUE : JNI_FALSE;
   <%- elsif field.is_a?(Herb::Template::ArrayField) -%>
-  jobject <%= field.name %> = NodesArrayFromCArray(env, <%= node.human %>-><%= field.name %>);
+  jobject <%= field.name %> = NodesArrayFromCArray(env, <%= node.human %>-><%= field.name %>, options);
   <%- elsif field.is_a?(Herb::Template::NodeField) || field.is_a?(Herb::Template::BorrowedNodeField) -%>
-  jobject <%= field.name %> = <%= node.human %>-><%= field.name %> ? NodeFromCStruct(env, (AST_NODE_T*) <%= node.human %>-><%= field.name %>) : NULL;
+  jobject <%= field.name %> = <%= node.human %>-><%= field.name %> ? NodeFromCStruct(env, (AST_NODE_T*) <%= node.human %>-><%= field.name %>, options) : NULL;
   <%- elsif field.is_a?(Herb::Template::ElementSourceField) -%>
   jstring <%= field.name %> = <%= node.human %>-><%= field.name %>.data ? (*env)->NewStringUTF(env, <%= node.human %>-><%= field.name %>.data) : NULL;
   <%- elsif field.is_a?(Herb::Template::LocationField) -%>
-  jobject <%= field.name %> = <%= node.human %>-><%= field.name %> ? CreateLocation(env, *<%= node.human %>-><%= field.name %>) : NULL;
+  jobject <%= field.name %> = (options->track_locations && <%= node.human %>-><%= field.name %>) ? CreateLocation(env, *<%= node.human %>-><%= field.name %>) : NULL;
   <%- elsif field.is_a?(Herb::Template::PrismSerializedField) -%>
   jbyteArray <%= field.name %>;
   if (<%= node.human %>-><%= field.name %>.data != NULL && <%= node.human %>-><%= field.name %>.length > 0) {
@@ -50,7 +50,7 @@ jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= no
   jbyteArray <%= field.name %>;
   if (<%= node.human %>-><%= field.name %>.node != NULL && <%= node.human %>-><%= field.name %>.parser != NULL) {
     pm_buffer_t pm_buffer = { 0 };
-    pm_serialize(<%= node.human %>-><%= field.name %>.parser, <%= node.human %>-><%= field.name %>.node, &pm_buffer);
+    herb_prism_node_serialize(<%= node.human %>-><%= field.name %>, &pm_buffer);
     if (pm_buffer.length > 0) {
       <%= field.name %> = (*env)->NewByteArray(env, (jsize)pm_buffer.length);
       (*env)->SetByteArrayRegion(env, <%= field.name %>, 0, (jsize)pm_buffer.length, (const jbyte*)pm_buffer.value);
@@ -66,8 +66,8 @@ jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= no
   <%- end -%>
   <%- end -%>
 
-  const char* signature = "(Ljava/lang/String;Lorg/herb/Location;Ljava/util/List;<%- node.fields.each do |f| -%><%- unless f.is_a?(Herb::Template::AnalyzedRubyField) || f.is_a?(Herb::Template::PrismContextField) -%><%- if f.is_a?(Herb::Template::StringField) -%>Ljava/lang/String;<%- elsif f.is_a?(Herb::Template::TokenField) -%>Lorg/herb/Token;<%- elsif f.is_a?(Herb::Template::BooleanField) -%>Z<%- elsif f.is_a?(Herb::Template::ArrayField) -%>Ljava/util/List;<%- elsif f.is_a?(Herb::Template::NodeField) -%>Lorg/herb/ast/<%= f.specific_kind || 'Node' %>;<%- elsif f.is_a?(Herb::Template::ElementSourceField) -%>Ljava/lang/String;<%- elsif f.is_a?(Herb::Template::LocationField) -%>Lorg/herb/Location;<%- elsif f.is_a?(Herb::Template::PrismSerializedField) || f.is_a?(Herb::Template::PrismNodeField) -%>[B<%- end -%><%- end -%><%- end -%>)V";
-  jmethodID constructor = (*env)->GetMethodID(env, nodeClass, "<init>", signature);
+  const char* constructor_signature = "(Ljava/lang/String;Lorg/herb/Location;Ljava/util/List;<%- node.fields.each do |f| -%><%- unless f.is_a?(Herb::Template::AnalyzedRubyField) || f.is_a?(Herb::Template::PrismContextField) -%><%- if f.is_a?(Herb::Template::StringField) -%>Ljava/lang/String;<%- elsif f.is_a?(Herb::Template::TokenField) -%>Lorg/herb/Token;<%- elsif f.is_a?(Herb::Template::BooleanField) -%>Z<%- elsif f.is_a?(Herb::Template::ArrayField) -%>Ljava/util/List;<%- elsif f.is_a?(Herb::Template::NodeField) -%>Lorg/herb/ast/<%= f.specific_kind || 'Node' %>;<%- elsif f.is_a?(Herb::Template::ElementSourceField) -%>Ljava/lang/String;<%- elsif f.is_a?(Herb::Template::LocationField) -%>Lorg/herb/Location;<%- elsif f.is_a?(Herb::Template::PrismSerializedField) || f.is_a?(Herb::Template::PrismNodeField) -%>[B<%- end -%><%- end -%><%- end -%>)V";
+  jmethodID constructor = (*env)->GetMethodID(env, nodeClass, "<init>", constructor_signature);
   if (!constructor) { return NULL; }
 
   jobject result = (*env)->NewObject(env, nodeClass, constructor, type, location, errors<%- node.fields.each do |field| -%><%- unless field.is_a?(Herb::Template::AnalyzedRubyField) || field.is_a?(Herb::Template::PrismContextField) -%>, <%= field.name %><%- end -%><%- end -%>);
@@ -77,20 +77,20 @@ jobject <%= node.name %>FromCStruct(JNIEnv* env, <%= node.struct_type %>* <%= no
 
 <%- end -%>
 
-jobject NodeFromCStruct(JNIEnv* env, AST_NODE_T* node) {
+jobject NodeFromCStruct(JNIEnv* env, AST_NODE_T* node, const parser_options_T* options) {
   if (!node) { return NULL; }
 
   switch (node->type) {
   <%- nodes.each do |node| -%>
   case <%= node.type %>:
-    return <%= node.name %>FromCStruct(env, (<%= node.struct_type %>*) node);
+    return <%= node.name %>FromCStruct(env, (<%= node.struct_type %>*) node, options);
   <%- end -%>
   default:
     return NULL;
   }
 }
 
-jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array) {
+jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array, const parser_options_T* options) {
   jclass arrayListClass = (*env)->FindClass(env, "java/util/ArrayList");
   jmethodID arrayListConstructor = (*env)->GetMethodID(env, arrayListClass, "<init>", "(I)V");
   jmethodID addMethod = (*env)->GetMethodID(env, arrayListClass, "add", "(Ljava/lang/Object;)Z");
@@ -105,7 +105,7 @@ jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array) {
     AST_NODE_T* child_node = (AST_NODE_T*) hb_array_get(array, i);
 
     if (child_node) {
-      jobject nodeObj = NodeFromCStruct(env, child_node);
+      jobject nodeObj = NodeFromCStruct(env, child_node, options);
       (*env)->CallBooleanMethod(env, javaList, addMethod, nodeObj);
     }
   }
@@ -113,9 +113,13 @@ jobject NodesArrayFromCArray(JNIEnv* env, hb_array_T* array) {
   return javaList;
 }
 
+jobject CreateASTNode(JNIEnv* env, AST_NODE_T* node, const parser_options_T* options) {
+  return NodeFromCStruct(env, node, options);
+}
+
 <%- nodes.each do |node| -%>
-jobject Create<%= node.name %>(JNIEnv* env, <%= node.struct_type %>* <%= node.human %>) {
-  return <%= node.name %>FromCStruct(env, <%= node.human %>);
+jobject Create<%= node.name %>(JNIEnv* env, <%= node.struct_type %>* <%= node.human %>, const parser_options_T* options) {
+  return <%= node.name %>FromCStruct(env, <%= node.human %>, options);
 }
 
 <%- end -%>

data/templates/java/nodes.h.erb

@@ -4,17 +4,18 @@
 #include <jni.h>
 
 #include "../../src/include/ast/ast_nodes.h"
+#include "../../src/include/parser/parser.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 <%- nodes.each do |node| -%>
-jobject Create<%= node.name %>(JNIEnv* env, <%= node.struct_type %>* node);
+jobject Create<%= node.name %>(JNIEnv* env, <%= node.struct_type %>* node, const parser_options_T* options);
 <%- end -%>
 
 jobject CreateErrorNode(JNIEnv* env, AST_NODE_T* error_node);
-jobject CreateASTNode(JNIEnv* env, AST_NODE_T* node);
+jobject CreateASTNode(JNIEnv* env, AST_NODE_T* node, const parser_options_T* options);
 
 #ifdef __cplusplus
 }

data/templates/java/org/herb/ParserOptions.java.erb

@@ -0,0 +1,24 @@
+package org.herb;
+
+public class ParserOptions {
+<%- parser_options.fields_for(:java).each do |field| -%>
+  private <%= field.java_type %> <%= field.camel_case %> = <%= field.java_default %>;
+<%- end -%>
+
+  public ParserOptions() {}
+
+<%- parser_options.fields_for(:java).each do |field| -%>
+  public ParserOptions <%= field.camel_case %>(<%= field.java_type %> value) {
+    this.<%= field.camel_case %> = value;
+    return this;
+  }
+
+  public <%= field.java_type %> <%= field.java_getter %>() {
+    return <%= field.camel_case %>;
+  }
+
+<%- end -%>
+  public static ParserOptions create() {
+    return new ParserOptions();
+  }
+}

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

@@ -5,34 +5,6 @@ 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.
  */
@@ -86,6 +58,28 @@ class HelperOption {
   public String getDescription() { return description; }
 }
 
+class HelperBlockArgument {
+  private final String name;
+  private final int position;
+  private final String type;
+  private final boolean optional;
+  private final String description;
+
+  HelperBlockArgument(String name, int position, String type, boolean optional, String description) {
+    this.name = name;
+    this.position = position;
+    this.type = type;
+    this.optional = optional;
+    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 getDescription() { return description; }
+}
+
 /**
  * Implicit attribute metadata for a tag helper.
  */
@@ -108,6 +102,31 @@ class HelperImplicitAttribute {
   public String getWrapper() { return wrapper; }
 }
 
+/**
+ * Content metadata describing where a helper takes its rendered content from.
+ */
+class HelperContent {
+  private final String source;
+  private final Integer argPosition;
+  private final boolean skipIfHash;
+  private final boolean toSSuffixWhenSingle;
+  private final Integer positionalArgumentsWithBlock;
+
+  HelperContent(String source, Integer argPosition, boolean skipIfHash, boolean toSSuffixWhenSingle, Integer positionalArgumentsWithBlock) {
+    this.source = source;
+    this.argPosition = argPosition;
+    this.skipIfHash = skipIfHash;
+    this.toSSuffixWhenSingle = toSSuffixWhenSingle;
+    this.positionalArgumentsWithBlock = positionalArgumentsWithBlock;
+  }
+
+  public String getSource() { return source; }
+  public Integer getArgPosition() { return argPosition; }
+  public boolean skipIfHash() { return skipIfHash; }
+  public boolean toSSuffixWhenSingle() { return toSSuffixWhenSingle; }
+  public Integer getPositionalArgumentsWithBlock() { return positionalArgumentsWithBlock; }
+}
+
 /**
  * Registry entry containing all metadata for a single tag helper.
  */
@@ -118,6 +137,7 @@ class HelperEntry {
   private final String gem;
   private final String output;
   private final String visibility;
+  private final String receiver;
   private final String tagName;
   private final boolean isVoid;
   private final boolean supportsBlock;
@@ -128,16 +148,19 @@ class HelperEntry {
   private final String signature;
   private final String documentationUrl;
   private final HelperImplicitAttribute implicitAttribute;
+  private final HelperContent content;
   private final List<HelperArgument> arguments;
   private final List<HelperOption> options;
+  private final List<HelperBlockArgument> blockArguments;
   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,
+    String name, HelperType type, String source, String gem, String output, String visibility, String receiver, 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
+    String signature, String documentationUrl, HelperImplicitAttribute implicitAttribute, HelperContent content,
+    List<HelperArgument> arguments, List<HelperOption> options, List<HelperBlockArgument> blockArguments,
+    List<String> specialBehaviors, List<String> aliases
   ) {
     this.name = name;
     this.type = type;
@@ -145,6 +168,7 @@ class HelperEntry {
     this.gem = gem;
     this.output = output;
     this.visibility = visibility;
+    this.receiver = receiver;
     this.tagName = tagName;
     this.isVoid = isVoid;
     this.supportsBlock = supportsBlock;
@@ -155,8 +179,10 @@ class HelperEntry {
     this.signature = signature;
     this.documentationUrl = documentationUrl;
     this.implicitAttribute = implicitAttribute;
+    this.content = content;
     this.arguments = arguments;
     this.options = options;
+    this.blockArguments = blockArguments;
     this.specialBehaviors = specialBehaviors;
     this.aliases = aliases;
   }
@@ -167,6 +193,7 @@ class HelperEntry {
   public String getGem() { return gem; }
   public String getOutput() { return output; }
   public String getVisibility() { return visibility; }
+  public String getReceiver() { return receiver; }
   public String getTagName() { return tagName; }
   public boolean isVoid() { return isVoid; }
   public boolean supportsBlock() { return supportsBlock; }
@@ -177,8 +204,10 @@ class HelperEntry {
   public String getSignature() { return signature; }
   public String getDocumentationUrl() { return documentationUrl; }
   public HelperImplicitAttribute getImplicitAttribute() { return implicitAttribute; }
+  public HelperContent getContent() { return content; }
   public List<HelperArgument> getArguments() { return arguments; }
   public List<HelperOption> getOptions() { return options; }
+  public List<HelperBlockArgument> getBlockArguments() { return blockArguments; }
   public List<String> getSpecialBehaviors() { return specialBehaviors; }
   public List<String> getAliases() { return aliases; }
 }
@@ -210,6 +239,7 @@ public final class HelperRegistry {
         "<%= helper.gem %>",
         "<%= helper.output %>",
         "<%= helper.visibility %>",
+        "<%= helper.receiver %>",
         <%= helper.tag_name ? "\"#{helper.tag_name}\"" : "null" %>,
         <%= helper.void? %>,
         <%= helper.supports_block %>,
@@ -223,9 +253,15 @@ public final class HelperRegistry {
         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 -%>
+<%- if helper.content? -%>
+        new HelperContent("<%= helper.content.source %>", <%= helper.content.arg_position || "null" %>, <%= helper.content.skip_if_hash %>, <%= helper.content.to_s_suffix_when_single %>, <%= helper.content.positional_arguments_with_block || "null" %>),
+<%- 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.block_arguments.map { |arg| "new HelperBlockArgument(\"#{arg.name}\", #{arg.position}, \"#{arg.type_display}\", #{arg.optional}, \"#{arg.escaped_description}\")" }.join(", ") %>),
         List.of(<%= helper.special_behaviors.map { |b| "\"#{b}\"" }.join(", ") %>),
         List.of(<%= helper.aliases.map { |a| "\"#{a}\"" }.join(", ") %>)
       );

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

@@ -0,0 +1,29 @@
+package org.herb.ast;
+
+/**
+ * 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;
+  }
+}

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

@@ -162,7 +162,7 @@ class <%= node.name %> extends BaseNode {
   public String inspect(String source) {
     StringBuilder output = new StringBuilder();
 
-    output.append("@ <%= node.name %> ").append(location != null ? "(location: " + location.toString() + ")" : "no-location").append("\n");
+    output.append("@ <%= node.name %> ").append("(location: " + (location != null ? location.toString() : "∅") + ")").append("\n");
     <%- if node.fields.any? -%>
     output.append(inspectErrors("│   "));
     <%- else -%>
@@ -250,10 +250,16 @@ class <%= node.name %> extends BaseNode {
 
   @Override
   public List<Node> recursiveErrors() {
-    List<Node> result = new ArrayList<>();
+    List<Node> accumulator = new ArrayList<>();
+    collectErrors(accumulator);
 
+    return accumulator;
+  }
+
+  @Override
+  protected void collectErrors(List<Node> accumulator) {
     if (errors != null) {
-      result.addAll(errors);
+      accumulator.addAll(errors);
     }
 
     <%- if node.fields.any? -%>
@@ -263,21 +269,19 @@ class <%= node.name %> extends BaseNode {
     if (<%= field.name %> != null) {
       for (Node child : <%= field.name %>) {
         if (child != null) {
-          result.addAll(child.recursiveErrors());
+          ((BaseNode) child).collectErrors(accumulator);
         }
       }
     }
 
     <%- elsif field.is_a?(Herb::Template::NodeField) || field.is_a?(Herb::Template::BorrowedNodeField) -%>
     if (<%= field.name %> != null) {
-      result.addAll(<%= field.name %>.recursiveErrors());
+      ((BaseNode) <%= field.name %>).collectErrors(accumulator);
     }
 
     <%- end -%>
     <%- end -%>
     <%- end -%>
-
-    return result;
   }
 
   @Override

data/templates/java/parser_options_helpers.c.erb

@@ -0,0 +1,45 @@
+#include "parser_options_helpers.h"
+
+void herb_extract_parser_options(JNIEnv* env, jobject options, parser_options_T* parser_options) {
+  if (options == NULL) { return; }
+
+  jclass optionsClass = (*env)->GetObjectClass(env, options);
+<%- parser_options.extractable_fields_for(:java).each do |field| -%>
+
+<%- if field.boolean? -%>
+  {
+    jmethodID method = (*env)->GetMethodID(env, optionsClass, "<%= field.java_getter %>", "<%= field.java_jni_signature %>");
+
+    if (method != NULL) {
+      jboolean value = (*env)->CallBooleanMethod(env, options, method);
+      parser_options-><%= field.c_name %> = (value == JNI_TRUE);
+    }
+  }
+<%- elsif field.nullable? -%>
+  {
+    jmethodID method = (*env)->GetMethodID(env, optionsClass, "<%= field.java_getter %>", "<%= field.java_jni_signature %>");
+
+    if (method != NULL) {
+      jobject value = (*env)->CallObjectMethod(env, options, method);
+
+      if (value == NULL) {
+        parser_options-><%= field.c_name %> = <%= field.null_sentinel %>;
+      } else {
+        jclass integerClass = (*env)->FindClass(env, "java/lang/Integer");
+        jmethodID intValue = (*env)->GetMethodID(env, integerClass, "intValue", "()I");
+        parser_options-><%= field.c_name %> = (uint32_t) (*env)->CallIntMethod(env, value, intValue);
+      }
+    }
+  }
+<%- else -%>
+  {
+    jmethodID method = (*env)->GetMethodID(env, optionsClass, "<%= field.java_getter %>", "<%= field.java_jni_signature %>");
+
+    if (method != NULL) {
+      jint value = (*env)->CallIntMethod(env, options, method);
+      parser_options-><%= field.c_name %> = (uint32_t) value;
+    }
+  }
+<%- end -%>
+<%- end -%>
+}

data/templates/java/parser_options_helpers.h.erb

@@ -0,0 +1,10 @@
+#ifndef HERB_JAVA_PARSER_OPTIONS_HELPERS_H
+#define HERB_JAVA_PARSER_OPTIONS_HELPERS_H
+
+#include "../src/include/parser/parser_options.h"
+
+#include <jni.h>
+
+void herb_extract_parser_options(JNIEnv* env, jobject options, parser_options_T* parser_options);
+
+#endif

data/templates/javascript/packages/client/src/state-kinds.ts.erb

@@ -0,0 +1,49 @@
+export type StateDefaultKind =
+<%- state_kinds.each do |kind| -%>
+  | <%= kind.name.inspect %>
+<%- end -%>
+
+export type StateValueKind =
+<%- state_kinds.select(&:value?).each do |kind| -%>
+  | <%= kind.name.inspect %>
+<%- end -%>
+
+export const STATE_DEFAULT_KINDS: readonly StateDefaultKind[] = [<%= state_kinds.map { |kind| kind.name.inspect }.join(", ") %>]
+
+export const LITERAL_STATE_KINDS: ReadonlySet<string> = new Set([<%= state_kinds.select(&:literal?).map { |kind| kind.name.inspect }.join(", ") %>])
+
+export const UNKNOWN_STATE_KINDS: ReadonlySet<string> = new Set([<%= state_kinds.select(&:unknown?).map { |kind| kind.name.inspect }.join(", ") %>])
+
+export const FALSY_STATE_KINDS: ReadonlySet<string> = new Set([<%= state_kinds.select(&:falsy?).map { |kind| kind.name.inspect }.join(", ") %>])
+
+export const NILABLE_STATE_KINDS: ReadonlySet<string> = new Set([<%= state_kinds.select(&:nilable?).map { |kind| kind.name.inspect }.join(", ") %>])
+
+export const PRISM_LITERAL_KINDS: Record<string, StateDefaultKind> = {
+<%- state_kinds.select(&:literal?).each do |kind| -%>
+<%- kind.prism_nodes.each do |node| -%>
+  <%= node.inspect %>: <%= kind.name.inspect %>,
+<%- end -%>
+<%- end -%>
+}
+
+const STATE_KIND_ARTICLES: Record<string, string> = {
+<%- state_kinds.each do |kind| -%>
+  <%= kind.name.inspect %>: <%= kind.article.inspect %>,
+<%- end -%>
+}
+
+export function stateKindArticle(kind: string): string {
+  const known = STATE_KIND_ARTICLES[kind]
+
+  if (known) {
+    return known
+  }
+
+  const spelled = kind.charAt(0).toUpperCase() + kind.slice(1)
+
+  if (spelled === "") {
+    return "a value"
+  }
+
+  return /^[AEIOU]/.test(spelled) ? `an ${spelled}` : `a ${spelled}`
+}

data/templates/javascript/packages/client/src/state-operators.ts.erb

@@ -0,0 +1,15 @@
+export const MIRRORED_COMPARISONS: Record<string, string> = {
+<%- state_operators.select(&:mirrored).each do |operator| -%>
+  <%= operator.operator.inspect %>: <%= operator.mirrored.inspect %>,
+<%- end -%>
+}
+
+export const NEGATED_COMPARISONS: Record<string, string> = {
+<%- state_operators.each do |operator| -%>
+  <%= operator.operator.inspect %>: <%= operator.negated.inspect %>,
+<%- end -%>
+}
+
+export const ORDERED_COMPARISONS: ReadonlySet<string> = new Set([<%= state_operators.select(&:ordered?).map { |operator| operator.operator.inspect }.join(", ") %>])
+
+export const COMPARISON_OPERATORS: ReadonlySet<string> = new Set([<%= state_operators.map { |operator| operator.operator.inspect }.join(", ") %>])

data/templates/javascript/packages/client/src/state-predicates.ts.erb

@@ -0,0 +1,27 @@
+export interface StatePredicate {
+  readonly comparand?: string
+  readonly operator?: string
+  readonly kinds: string[] | null
+  readonly only: string
+  readonly rewrite?: string
+}
+
+export const STATE_PREDICATES: Record<string, StatePredicate> = {
+<%- state_predicates.each do |predicate| -%>
+  <%= predicate.literal(predicate.name) %>: {
+<%- if predicate.comparand -%>
+    comparand: <%= predicate.literal(predicate.comparand) %>,
+<%- end -%>
+<%- if predicate.operator -%>
+    operator: <%= predicate.literal(predicate.operator) %>,
+<%- end -%>
+    kinds: <%= predicate.typescript_kinds %>,
+    only: <%= predicate.literal(predicate.only) %>,
+<%- if predicate.rewrite -%>
+    rewrite: <%= predicate.literal(predicate.rewrite) %>,
+<%- end -%>
+  },
+<%- end -%>
+}
+
+export const STATE_PREDICATE_NAMES = Object.keys(STATE_PREDICATES)

data/templates/javascript/packages/client/src/state-transforms.ts.erb

@@ -0,0 +1,19 @@
+export interface StateTransform {
+  readonly operation: string
+  readonly kinds: string[] | null
+  readonly returns: string
+  readonly only: string
+}
+
+export const STATE_TRANSFORMS: Record<string, StateTransform> = {
+<%- state_transforms.each do |transform| -%>
+  <%= transform.name.inspect %>: {
+    operation: <%= transform.operation.inspect %>,
+    kinds: <%= transform.typescript_kinds %>,
+    returns: <%= transform.returns.inspect %>,
+    only: <%= transform.only.inspect %>,
+  },
+<%- end -%>
+}
+
+export const STATE_TRANSFORM_NAMES = Object.keys(STATE_TRANSFORMS)