Herb: Expose Herb.parse_puby to parse Ruby with Prism

Author: marcoroth

java/herb_jni.c

@@ -185,6 +185,35 @@ Java_org_herb_Herb_extractRuby(JNIEnv* env, jclass clazz, jstring source, jobjec
   return result;
 }
 
+JNIEXPORT jbyteArray JNICALL
+Java_org_herb_Herb_parseRuby(JNIEnv* env, jclass clazz, jstring source) {
+  const char* src = (*env)->GetStringUTFChars(env, source, 0);
+  size_t src_len = strlen(src);
+
+  herb_ruby_parse_result_T* parse_result = herb_parse_ruby(src, src_len);
+
+  if (!parse_result) {
+    (*env)->ReleaseStringUTFChars(env, source, src);
+    return NULL;
+  }
+
+  pm_buffer_t buffer = { 0 };
+  pm_serialize(&parse_result->parser, parse_result->root, &buffer);
+
+  jbyteArray result = NULL;
+
+  if (buffer.length > 0) {
+    result = (*env)->NewByteArray(env, (jsize) buffer.length);
+    (*env)->SetByteArrayRegion(env, result, 0, (jsize) buffer.length, (const jbyte*) buffer.value);
+  }
+
+  pm_buffer_free(&buffer);
+  herb_free_ruby_parse_result(parse_result);
+  (*env)->ReleaseStringUTFChars(env, source, src);
+
+  return result;
+}
+
 JNIEXPORT jstring JNICALL
 Java_org_herb_Herb_extractHTML(JNIEnv* env, jclass clazz, jstring source) {
   const char* src = (*env)->GetStringUTFChars(env, source, 0);

java/herb_jni.h

@@ -13,6 +13,7 @@ JNIEXPORT jobject JNICALL Java_org_herb_Herb_parse(JNIEnv*, jclass, jstring, job
 JNIEXPORT jobject JNICALL Java_org_herb_Herb_lex(JNIEnv*, jclass, jstring);
 JNIEXPORT jstring JNICALL Java_org_herb_Herb_extractRuby(JNIEnv*, jclass, jstring, jobject);
 JNIEXPORT jstring JNICALL Java_org_herb_Herb_extractHTML(JNIEnv*, jclass, jstring);
+JNIEXPORT jbyteArray JNICALL Java_org_herb_Herb_parseRuby(JNIEnv*, jclass, jstring);
 
 #ifdef __cplusplus
 }

java/org/herb/Herb.java

@@ -20,6 +20,7 @@ public class Herb {
   public static native LexResult lex(String source);
   public static native String extractRuby(String source, ExtractRubyOptions options);
   public static native String extractHTML(String source);
+  public static native byte[] parseRuby(String source);
 
   public static ParseResult parse(String source) {
     return parse(source, null);

java/org/herb/HerbTest.java

@@ -147,6 +147,22 @@ void testParserOptionsPrismNodesDeep() {
     assertTrue(inspectShallow.contains("prism_node:"));
   }
 
+  @Test
+  void testParseRuby() {
+    byte[] result = Herb.parseRuby("link_to('Home', root_path)");
+
+    assertNotNull(result);
+    assertTrue(result.length > 0);
+  }
+
+  @Test
+  void testParseRubyEmpty() {
+    byte[] result = Herb.parseRuby("");
+
+    assertNotNull(result);
+    assertTrue(result.length > 0);
+  }
+
   @Test
   void testParserOptionsAnalyze() {
     String source = "<% if true %><div></div><% end %>";

javascript/packages/core/src/backend.ts

@@ -11,6 +11,8 @@ interface LibHerbBackendFunctions {
   extractRuby: (source: string, options?: ExtractRubyOptions) => string
   extractHTML: (source: string) => string
 
+  parseRuby: (source: string) => Uint8Array | null
+
   version: () => string
 }
 
@@ -21,6 +23,7 @@ const expectedFunctions = [
   "lex",
   "extractRuby",
   "extractHTML",
+  "parseRuby",
   "version",
 ] as const
 

javascript/packages/core/src/herb-backend.ts

@@ -5,10 +5,12 @@ import { LexResult } from "./lex-result.js"
 import { ParseResult } from "./parse-result.js"
 import { DEFAULT_PARSER_OPTIONS } from "./parser-options.js"
 import { DEFAULT_EXTRACT_RUBY_OPTIONS } from "./extract-ruby-options.js"
+import { deserializePrismParseResult } from "./prism/index.js"
 
 import type { LibHerbBackend, BackendPromise } from "./backend.js"
 import type { ParseOptions } from "./parser-options.js"
 import type { ExtractRubyOptions } from "./extract-ruby-options.js"
+import type { PrismParseResult } from "./prism/index.js"
 
 /**
  * The main Herb parser interface, providing methods to lex and parse input.
@@ -97,6 +99,24 @@ export abstract class HerbBackend {
     return this.backend.extractRuby(ensureString(source), mergedOptions)
   }
 
+  /**
+   * Parses a Ruby source string using Prism via the libherb backend.
+   * @param source - The Ruby source code to parse.
+   * @returns A Prism ParseResult containing the AST.
+   * @throws Error if the backend is not loaded.
+   */
+  parseRuby(source: string): PrismParseResult {
+    this.ensureBackend()
+
+    const bytes = this.backend.parseRuby(ensureString(source))
+
+    if (!bytes) {
+      throw new Error("Failed to parse Ruby source")
+    }
+
+    return deserializePrismParseResult(bytes, source)
+  }
+
   /**
    * Extracts HTML from the given source.
    * @param source - The source code to extract HTML from.

javascript/packages/node/extension/herb.cpp

@@ -285,6 +285,43 @@ napi_value Herb_extract_html(napi_env env, napi_callback_info info) {
   return result;
 }
 
+napi_value Herb_parse_ruby(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  char* string = CheckString(env, args[0]);
+  if (!string) { return nullptr; }
+
+  herb_ruby_parse_result_T* parse_result = herb_parse_ruby(string, strlen(string));
+
+  if (!parse_result) {
+    free(string);
+    return nullptr;
+  }
+
+  pm_buffer_t buffer = { 0 };
+  pm_serialize(&parse_result->parser, parse_result->root, &buffer);
+
+  napi_value result = nullptr;
+
+  if (buffer.length > 0) {
+    void* data;
+    napi_create_buffer_copy(env, buffer.length, buffer.value, &data, &result);
+  }
+
+  pm_buffer_free(&buffer);
+  herb_free_ruby_parse_result(parse_result);
+  free(string);
+
+  return result;
+}
+
 napi_value Herb_version(napi_env env, napi_callback_info info) {
   const char* libherb_version = herb_version();
   const char* libprism_version = herb_prism_version();
@@ -305,6 +342,7 @@ napi_value Init(napi_env env, napi_value exports) {
     { "extractRuby", nullptr, Herb_extract_ruby, nullptr, nullptr, nullptr, napi_default, nullptr },
     { "extractHTML", nullptr, Herb_extract_html, nullptr, nullptr, nullptr, napi_default, nullptr },
     { "version", nullptr, Herb_version, nullptr, nullptr, nullptr, napi_default, nullptr },
+    { "parseRuby", nullptr, Herb_parse_ruby, nullptr, nullptr, nullptr, napi_default, nullptr },
   };
 
   napi_define_properties(env, exports, sizeof(descriptors) / sizeof(descriptors[0]), descriptors);

lib/herb.rb

@@ -77,6 +77,14 @@ def parse_file(path, **options)
       parse(File.read(path), **options)
     end
 
+    #: (String source) -> Prism::ParseResult
+    def parse_ruby(source)
+      require "prism"
+
+      ruby = extract_ruby(source, semicolons: true, preserve_positions: true)
+      Prism.parse(ruby, partial_script: true)
+    end
+
     def configuration(project_path = nil)
       @configuration ||= Configuration.load(project_path)
     end

sig/herb.rbs

@@ -10,6 +10,7 @@
 
 #include <prism.h>
 #include <stdlib.h>
+#include <string.h>
 
 HERB_EXPORTED_FUNCTION hb_array_T* herb_lex(const char* source, hb_allocator_T* allocator) {
   if (!source) { source = ""; }
@@ -83,3 +84,26 @@ HERB_EXPORTED_FUNCTION const char* herb_version(void) {
 HERB_EXPORTED_FUNCTION const char* herb_prism_version(void) {
   return PRISM_VERSION;
 }
+
+HERB_EXPORTED_FUNCTION herb_ruby_parse_result_T* herb_parse_ruby(const char* source, size_t length) {
+  if (!source) { return NULL; }
+
+  herb_ruby_parse_result_T* result = malloc(sizeof(herb_ruby_parse_result_T));
+  if (!result) { return NULL; }
+
+  memset(&result->options, 0, sizeof(pm_options_t));
+  pm_parser_init(&result->parser, (const uint8_t*) source, length, &result->options);
+  result->root = pm_parse(&result->parser);
+
+  return result;
+}
+
+HERB_EXPORTED_FUNCTION void herb_free_ruby_parse_result(herb_ruby_parse_result_T* result) {
+  if (!result) { return; }
+
+  if (result->root) { pm_node_destroy(&result->parser, result->root); }
+
+  pm_parser_free(&result->parser);
+  pm_options_free(&result->options);
+  free(result);
+}