parsanol 3.0.0

data/lib/parsanol/wasm/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@parsanol/wasm",
+  "version": "0.1.0",
+  "description": "High-performance PEG parser using WebAssembly for Opal and JavaScript",
+  "main": "parsanol.js",
+  "module": "parsanol.js",
+  "types": "parsanol.d.ts",
+  "browser": "parsanol.js",
+  "files": [
+    "parsanol.js",
+    "parsanol.d.ts",
+    "parsanol_native.js",
+    "parsanol_native_bg.js",
+    "parsanol_native_bg.wasm",
+    "parsanol_native.d.ts"
+  ],
+  "scripts": {
+    "build": "cd ../../ext/parsanol_native && wasm-pack build --features wasm --target web --out-dir ../../lib/parsanol/wasm",
+    "build:node": "cd ../../ext/parsanol_native && wasm-pack build --features wasm --target nodejs --out-dir ../../lib/parsanol/wasm-node",
+    "test": "node test/parsanol.test.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "parser",
+    "peg",
+    "parsing-expression-grammar",
+    "wasm",
+    "webassembly",
+    "opal",
+    "ruby",
+    "performance"
+  ],
+  "author": "Ribose Inc. <open.source@ribose.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parsanol/parsanol-rs.git",
+    "directory": "lib/parsanol/wasm"
+  },
+  "bugs": {
+    "url": "https://github.com/parsanol/parsanol-ruby/issues"
+  },
+  "homepage": "https://github.com/parsanol/parsanol-ruby#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "sideEffects": [
+    "parsanol_native.js",
+    "parsanol_native_bg.js"
+  ]
+}

data/lib/parsanol/wasm/parsanol.js

@@ -0,0 +1,252 @@
+/**
+ * Parsanol WASM Parser
+ *
+ * High-performance parser using WebAssembly for use in browsers and Node.js.
+ * Compatible with Opal (Ruby in JavaScript) for parsing in the browser.
+ *
+ * @example
+ * // Browser/ESM
+ * import { ParsanolParser } from '@parsanol/wasm';
+ * const parser = new ParsanolParser(grammarJson);
+ * const result = parser.parse('input text');
+ *
+ * @example
+ * // Node.js
+ * const { ParsanolParser } = require('@parsanol/wasm');
+ * const parser = new ParsanolParser(grammarJson);
+ * const result = parser.parse('input text');
+ *
+ * @example
+ * // Opal
+ * %x{
+ *   var parser = new ParsanolNative.WasmParser(#{grammar_json});
+ *   var result = parser.parse(#{input});
+ *   return result;
+ * }
+ */
+
+import init, { WasmParser } from './parsanol_native.js';
+
+let initialized = false;
+let initPromise = null;
+
+/**
+ * Initialize the WASM module
+ * Must be called before creating parsers (automatically called on first use)
+ *
+ * @returns {Promise<void>}
+ */
+export async function initParsanol() {
+  if (initialized) return;
+  if (initPromise) return initPromise;
+
+  initPromise = init().then(() => {
+    initialized = true;
+  });
+
+  return initPromise;
+}
+
+/**
+ * Check if the WASM module is initialized
+ *
+ * @returns {boolean}
+ */
+export function isInitialized() {
+  return initialized;
+}
+
+/**
+ * High-performance parser using WebAssembly
+ *
+ * Usage:
+ *   const parser = new ParsanolParser(grammarJson);
+ *   const result = parser.parse('input');
+ *   console.log(result);
+ */
+export class ParsanolParser {
+  #parser = null;
+  #grammarJson = null;
+
+  /**
+   * Create a new parser instance
+   *
+   * @param {string|object} grammar - Grammar JSON string or object
+   * @throws {Error} If WASM not initialized or grammar is invalid
+   */
+  constructor(grammar) {
+    if (!initialized) {
+      throw new Error('Parsanol WASM not initialized. Call initParsanol() first.');
+    }
+
+    this.#grammarJson = typeof grammar === 'string' ? grammar : JSON.stringify(grammar);
+    this.#parser = new WasmParser(this.#grammarJson);
+  }
+
+  /**
+   * Parse input string and return AST
+   *
+   * @param {string} input - Input string to parse
+   * @returns {object} Parsed AST as JavaScript object
+   * @throws {Error} If parsing fails
+   */
+  parse(input) {
+    return this.#parser.parse(input);
+  }
+
+  /**
+   * Parse input and return flat array format
+   * More efficient for large results (avoids object creation)
+   *
+   * @param {string} input - Input string to parse
+   * @returns {BigUint64Array} Flat array with tagged values
+   * @throws {Error} If parsing fails
+   */
+  parseFlat(input) {
+    return this.#parser.parse_flat(input);
+  }
+
+  /**
+   * Parse input and return JSON string
+   * Useful for transferring to other contexts
+   *
+   * @param {string} input - Input string to parse
+   * @returns {string} JSON string of parsed AST
+   * @throws {Error} If parsing fails
+   */
+  parseJson(input) {
+    return this.#parser.parse_json(input);
+  }
+
+  /**
+   * Reset parser state for reuse
+   */
+  reset() {
+    // Parser state is reset automatically on each parse
+  }
+}
+
+/**
+ * Decode flat array format to JavaScript object
+ *
+ * Tag format:
+ * - 0x00: nil
+ * - 0x01: bool (followed by 0 or 1)
+ * - 0x02: int (followed by value)
+ * - 0x03: float (followed by bits)
+ * - 0x04: string (followed by offset, length)
+ * - 0x05: array start
+ * - 0x06: array end
+ * - 0x07: hash start
+ * - 0x08: hash end
+ * - 0x09: hash key
+ *
+ * @param {BigUint64Array} flat - Flat array from parseFlat()
+ * @param {string} input - Original input string for string references
+ * @returns {any} Decoded JavaScript value
+ */
+export function decodeFlatArray(flat, input) {
+  const TAG_NIL = 0x00n;
+  const TAG_BOOL = 0x01n;
+  const TAG_INT = 0x02n;
+  const TAG_FLOAT = 0x03n;
+  const TAG_STRING = 0x04n;
+  const TAG_ARRAY_START = 0x05n;
+  const TAG_ARRAY_END = 0x06n;
+  const TAG_HASH_START = 0x07n;
+  const TAG_HASH_END = 0x08n;
+  const TAG_HASH_KEY = 0x09n;
+
+  let pos = 0;
+
+  function decode() {
+    const tag = flat[pos++];
+
+    switch (tag) {
+      case TAG_NIL:
+        return null;
+
+      case TAG_BOOL:
+        return flat[pos++] !== 0n;
+
+      case TAG_INT:
+        return Number(flat[pos++]);
+
+      case TAG_FLOAT: {
+        const bits = flat[pos++];
+        return new Float64Array(new BigUint64Array([bits]).buffer)[0];
+      }
+
+      case TAG_STRING: {
+        const offset = Number(flat[pos++]);
+        const length = Number(flat[pos++]);
+        return input.substring(offset, offset + length);
+      }
+
+      case TAG_ARRAY_START: {
+        const arr = [];
+        while (flat[pos] !== TAG_ARRAY_END) {
+          arr.push(decode());
+        }
+        pos++; // Skip ARRAY_END
+        return arr;
+      }
+
+      case TAG_HASH_START: {
+        const obj = {};
+        while (flat[pos] !== TAG_HASH_END) {
+          // Skip TAG_HASH_KEY
+          pos++;
+
+          // Read key
+          const keyLen = Number(flat[pos++]);
+          // Skip placeholder
+          pos++;
+
+          // Read key bytes
+          let key = '';
+          const numChunks = Math.ceil(keyLen / 8);
+          for (let i = 0; i < numChunks; i++) {
+            const chunk = flat[pos++];
+            for (let j = 0; j < 8 && key.length < keyLen; j++) {
+              const byte = Number((chunk >> BigInt(j * 8)) & 0xffn);
+              key += String.fromCharCode(byte);
+            }
+          }
+
+          // Read value
+          const value = decode();
+          obj[key] = value;
+        }
+        pos++; // Skip HASH_END
+        return obj;
+      }
+
+      default:
+        throw new Error(`Unknown tag: ${tag}`);
+    }
+  }
+
+  return decode();
+}
+
+/**
+ * Create a parser with automatic initialization
+ * Convenience function that handles async initialization
+ *
+ * @param {string|object} grammar - Grammar JSON string or object
+ * @returns {Promise<ParsanolParser>} Initialized parser
+ */
+export async function createParser(grammar) {
+  await initParsanol();
+  return new ParsanolParser(grammar);
+}
+
+// Default export
+export default {
+  initParsanol,
+  isInitialized,
+  ParsanolParser,
+  decodeFlatArray,
+  createParser
+};

data/lib/parsanol/wasm/parslet.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Type definitions for Parslet WASM Parser
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Initialize the WASM module
+ * Must be called before creating parsers
+ */
+export function initParslet(): Promise<void>;
+
+/**
+ * Check if the WASM module is initialized
+ */
+export function isInitialized(): boolean;
+
+/**
+ * Grammar specification for the parser
+ *
+ * The grammar is a JSON object with atoms and a root index.
+ */
+export interface Grammar {
+  /** Array of atom definitions */
+  atoms: Atom[];
+  /** Index of the root atom */
+  root: number;
+}
+
+/**
+ * Atom types in the grammar
+ */
+export type Atom =
+  | { Str: { pattern: string } }
+  | { Re: { pattern: string } }
+  | { Sequence: { atoms: number[] } }
+  | { Alternative: { atoms: number[] } }
+  | { Repetition: { atom: number; min: number; max: number | null } }
+  | { Named: { name: string; atom: number } }
+  | { Entity: { atom: number } }
+  | { Lookahead: { atom: number; positive: boolean } }
+  | 'Cut';
+
+/**
+ * Parse result - can be various types
+ */
+export type ParseResult =
+  | null
+  | boolean
+  | number
+  | string
+  | ParseResult[]
+  | { [key: string]: ParseResult };
+
+/**
+ * High-performance parser using WebAssembly
+ */
+export class ParsletParser {
+  /**
+   * Create a new parser instance
+   *
+   * @param grammar - Grammar JSON string or object
+   * @throws {Error} If WASM not initialized or grammar is invalid
+   */
+  constructor(grammar: string | Grammar);
+
+  /**
+   * Parse input string and return AST
+   *
+   * @param input - Input string to parse
+   * @returns Parsed AST as JavaScript object
+   * @throws {Error} If parsing fails
+   */
+  parse(input: string): ParseResult;
+
+  /**
+   * Parse input and return flat array format
+   *
+   * @param input - Input string to parse
+   * @returns Flat array with tagged values
+   * @throws {Error} If parsing fails
+   */
+  parseFlat(input: string): BigUint64Array;
+
+  /**
+   * Parse input and return JSON string
+   *
+   * @param input - Input string to parse
+   * @returns JSON string of parsed AST
+   * @throws {Error} If parsing fails
+   */
+  parseJson(input: string): string;
+}
+
+/**
+ * Decode flat array format to JavaScript object
+ *
+ * @param flat - Flat array from parseFlat()
+ * @param input - Original input string for string references
+ * @returns Decoded JavaScript value
+ */
+export function decodeFlatArray(flat: BigUint64Array, input: string): ParseResult;
+
+/**
+ * Create a parser with automatic initialization
+ *
+ * @param grammar - Grammar JSON string or object
+ * @returns Promise resolving to initialized parser
+ */
+export function createParser(grammar: string | Grammar): Promise<ParsletParser>;
+
+/**
+ * Low-level WASM parser (from wasm-bindgen)
+ *
+ * @internal
+ */
+export class WasmParser {
+  constructor(grammarJson: string);
+  parse(input: string): any;
+  parse_flat(input: string): BigUint64Array;
+  parse_json(input: string): string;
+}
+
+/**
+ * WASM module initialization function
+ *
+ * @internal
+ */
+export default function init(): Promise<void>;

data/lib/parsanol/wasm_parser.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Parsanol
+  # WASM-based parser for Opal environments
+  #
+  # This class provides a bridge between Opal (Ruby compiled to JavaScript)
+  # and the WASM parser. It uses the Parslet WASM module.
+  #
+  # @example In Opal environment
+  #   # First, ensure WASM is loaded (in your HTML/JS)
+  #   # <script src="parslet_wasm.js"></script>
+  #   # <script>
+  #   #   ParsletWasm.init().then(() => console.log('ready'));
+  #   # </script>
+  #
+  #   # Then in Ruby/Opal:
+  #   grammar_json = parser.to_json
+  #   wasm_parser = Parsanol::WasmParser.new(grammar_json)
+  #   result = wasm_parser.parse(input)
+  #
+  class WasmParser
+    # Tags for flat array format
+    TAG_NIL         = 0x00
+    TAG_BOOL        = 0x01
+    TAG_INT         = 0x02
+    TAG_FLOAT       = 0x03
+    TAG_STRING      = 0x04
+    TAG_ARRAY_START = 0x05
+    TAG_ARRAY_END   = 0x06
+    TAG_HASH_START  = 0x07
+    TAG_HASH_END    = 0x08
+    TAG_HASH_KEY    = 0x09
+
+    # @return [String] The grammar JSON
+    attr_reader :grammar_json
+
+    # Create a new WASM parser
+    #
+    # @param grammar_json [String, Hash] Grammar JSON string or hash
+    # @raise [RuntimeError] If WASM is not initialized
+    #
+    def initialize(grammar_json)
+      @grammar_json = grammar_json.is_a?(Hash) ? grammar_json.to_json : grammar_json
+      @parser = nil
+    end
+
+    # Parse input string and return AST
+    #
+    # @param input [String] Input string to parse
+    # @return [Hash, Array, String, nil] Parsed AST
+    # @raise [RuntimeError] If parsing fails
+    #
+    def parse(input)
+      ensure_initialized
+      result = `#{@parser}.parse(#{input})`
+      convert_js_to_ruby(result)
+    end
+
+    # Parse input and return flat array (more efficient for large results)
+    #
+    # @param input [String] Input string to parse
+    # @return [Array] Flat array with tagged values
+    # @raise [RuntimeError] If parsing fails
+    #
+    def parse_flat(input)
+      ensure_initialized
+      flat = `#{@parser}.parseFlat(#{input})`
+      decode_flat(flat, input)
+    end
+
+    # Parse input and return JSON string
+    #
+    # @param input [String] Input string to parse
+    # @return [String] JSON string of parsed AST
+    # @raise [RuntimeError] If parsing fails
+    #
+    def parse_json(input)
+      ensure_initialized
+      `#{@parser}.parseJson(#{input})`
+    end
+
+    # Check if WASM is available and initialized
+    #
+    # @return [Boolean]
+    #
+    def self.available?
+      %x{
+        if (typeof ParsletWasm === 'undefined') {
+          return false;
+        }
+        return ParsletWasm.isInitialized ? ParsletWasm.isInitialized() : false;
+      }
+    end
+
+    # Initialize WASM module (async)
+    #
+    # @return [Promise] Promise that resolves when WASM is ready
+    #
+    def self.init
+      %x{
+        if (typeof ParsletWasm !== 'undefined' && ParsletWasm.initParslet) {
+          return ParsletWasm.initParslet();
+        }
+        return Promise.reject(new Error('ParsletWasm not loaded'));
+      }
+    end
+
+    private
+
+    def ensure_initialized
+      return if @parser
+
+      %x{
+        if (typeof ParsletWasm === 'undefined') {
+          throw new Error('ParsletWasm not loaded. Include parslet.js and parsanol_native_bg.wasm');
+        }
+        if (!ParsletWasm.isInitialized || !ParsletWasm.isInitialized()) {
+          throw new Error('WASM not initialized. Call Parsanol::WasmParser.init first');
+        }
+        #{@parser} = new ParsletWasm.ParsletParser(#{@grammar_json});
+      }
+    end
+
+    # Convert JavaScript result to Ruby
+    def convert_js_to_ruby(js_obj)
+      %x{
+        if (js_obj === null || js_obj === undefined) {
+          return nil;
+        }
+        if (typeof js_obj === 'boolean') {
+          return js_obj;
+        }
+        if (typeof js_obj === 'number') {
+          return js_obj;
+        }
+        if (typeof js_obj === 'string') {
+          return js_obj;
+        }
+        if (Array.isArray(js_obj)) {
+          return js_obj.map(function(item) {
+            return #{convert_js_to_ruby(`item`)};
+          });
+        }
+        if (typeof js_obj === 'object') {
+          var hash = {};
+          Object.keys(js_obj).forEach(function(key) {
+            hash[key] = #{convert_js_to_ruby(`js_obj[key]`)};
+          });
+          return hash;
+        }
+        return nil;
+      }
+    end
+
+    # Decode flat array format to Ruby objects
+    def decode_flat(flat, input)
+      stack = []
+      i = 0
+      length = `#{flat}.length`
+
+      while i < length
+        tag = `#{flat}[#{i}]`
+
+        case tag
+        when TAG_NIL
+          stack << nil
+          i += 1
+        when TAG_BOOL
+          stack << (`#{flat}[#{i + 1}]` != 0)
+          i += 2
+        when TAG_INT
+          stack << `#{flat}[#{i + 1}]`
+          i += 2
+        when TAG_FLOAT
+          bits = `#{flat}[#{i + 1}]`
+          float = `new Float64Array(new BigUint64Array([#{bits}]).buffer)[0]`
+          stack << float
+          i += 2
+        when TAG_STRING
+          offset = `#{flat}[#{i + 1}]`
+          len = `#{flat}[#{i + 2}]`
+          stack << input.byteslice(offset, len)
+          i += 3
+        when TAG_ARRAY_START
+          stack << :array_marker
+          i += 1
+        when TAG_ARRAY_END
+          items = []
+          items.unshift(stack.pop) while stack.last != :array_marker
+          stack.pop # Remove marker
+          stack << items
+          i += 1
+        when TAG_HASH_START
+          stack << :hash_marker
+          i += 1
+        when TAG_HASH_END
+          pairs = []
+          while stack.last != :hash_marker
+            value = stack.pop
+            key = stack.pop
+            pairs.unshift([key, value])
+          end
+          stack.pop # Remove marker
+          stack << pairs.to_h
+          i += 1
+        when TAG_HASH_KEY
+          len = `#{flat}[#{i + 1}]`
+          i += 3 # Skip tag, len, and placeholder
+          # Read key bytes
+          key_bytes = []
+          chunks = (len + 7) / 8
+          chunks.times do |j|
+            chunk = `#{flat}[#{i + j}]`
+            8.times do |k|
+              break if key_bytes.length >= len
+              key_bytes << ((chunk >> (k * 8)) & 0xff)
+            end
+          end
+          i += chunks
+          key = key_bytes.pack('C*').force_encoding('UTF-8')
+          stack << key
+        else
+          raise "Unknown tag: #{tag} at index #{i}"
+        end
+      end
+
+      stack.first
+    end
+  end
+
+  # Factory method to create appropriate parser
+  #
+  # @param grammar_json [String, Hash] Grammar JSON
+  # @return [WasmParser, Object] Appropriate parser for current environment
+  #
+  def self.create_wasm_parser(grammar_json)
+    WasmParser.new(grammar_json)
+  end
+end