wands 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0f4387102cd8565a88e6d29beeda55459d62afa1b6d553d3024726898ce25ff
-  data.tar.gz: 786f17cecaf4093a46f2b7ab1d50084402a367f42cd222ec67fe33c4f6cca48e
+  metadata.gz: 6e201c2b884e875383da0c4b25335479096504879e2af95cf8690b4247a3e94c
+  data.tar.gz: c9f0b8eba9649ed9fce87441fc4be0c8a7f2fdf12d566d47a86adb074ef1f85f
 SHA512:
-  metadata.gz: 1d53f26ba63a535f853a29d70a28f5bf8be05e820e2b0fd39519e0351091c7587b53a0cef3777fa8099fe1cd0272c1bd74aeb41269ae307a98109fbb2ef2d61f
-  data.tar.gz: 8e7195b9106893b2bc1fea0031b2cd88affbf374840db4dc3d196b12ed0c8366051ab8ba7d3b4b76505fbe83ecfb184ca00f39d5e2dc509ea586faef6677edb2
+  metadata.gz: 4b10687d17cbcb7f4ca7504c4f0752f443d7608415c6413643a2ae04a8b8d8bc87c4e4e9d25125f9aa4f55bad746776e1f1d5445cb968b6581746d4060988ca6
+  data.tar.gz: a122263cab3fbe0c90d1be53c1282d02e228d3b753c1e2e1e06e5a983eba8d2b7feb7fe1182629d86874e6f08c5c717e8302351dd2a89a3bf69d97ae35c59a29

data/Rakefile

@@ -10,3 +10,23 @@ require "rubocop/rake_task"
 RuboCop::RakeTask.new
 
 task default: %i[test rubocop]
+
+namespace :wasm do
+  desc "Build Ruby WASM and install gems"
+  task :build do
+    Dir.chdir("dist") do
+      ENV["BUNDLE_GEMFILE"] = File.expand_path("gems.rb")
+      sh "bundle install"
+      sh "bundle exec rbwasm build --ruby-version 3.4 -o ruby+wands.wasm"
+      sh "cp ruby+wands.wasm ../examples/ruby_wasm/dist"
+    end
+  end
+
+  desc "Test Ruby WASM in Node.js"
+  task :test do
+    Dir.chdir("node_wasi_test") do
+      sh "npm install"
+      sh "npm test"
+    end
+  end
+end

data/dist/.gitignore

@@ -0,0 +1,3 @@
+build
+rubies
+ruby+wands.wasm

data/dist/gems.locked

@@ -0,0 +1,29 @@
+PATH
+  remote: ..
+  specs:
+    wands (0.8.0)
+      protocol-websocket (~> 0.20)
+      webrick (~> 1.9)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    js (2.7.1)
+    logger (1.6.6)
+    protocol-http (0.49.0)
+    protocol-websocket (0.20.1)
+      protocol-http (~> 0.2)
+    ruby_wasm (2.7.1-x86_64-linux)
+    webrick (1.9.1)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  js (~> 2.7)
+  logger (~> 1.6)
+  ruby_wasm (~> 2.7)
+  wands!
+
+BUNDLED WITH
+   2.6.2

data/dist/gems.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "wands", path: "../"
+
+gem "ruby_wasm", "~> 2.7"
+
+gem "js", "~> 2.7"
+
+gem "logger", "~> 1.6"

data/lib/wands/java_script/array_buffer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "js"
+
+module Wands
+  module JavaScript
+    # A wrapper around JavaScript ArrayBuffer
+    class ArrayBuffer
+      def initialize(js_array_buffer = nil)
+        @data = "".b
+
+        return unless js_array_buffer
+        raise ArgumentError, "Expected a JavaScript ArrayBuffer" unless JS.is_a?(js_array_buffer,
+                                                                                 JS.global[:ArrayBuffer])
+
+        uint8_array = JS.global[:Uint8Array].new(js_array_buffer)
+
+        (0...js_array_buffer[:byteLength].to_i).each do |index|
+          @data << uint8_array[index].to_i.chr
+        end
+      end
+
+      def write(binary_string)
+        raise ArgumentError, "must be ASCII-8BIT encoded" unless binary_string.encoding == Encoding::ASCII_8BIT
+
+        @data << binary_string
+      end
+
+      def to_js_array_buffer
+        uint8_array = JS.global[:Uint8Array].new(@data.bytesize)
+
+        @data.bytes.each_with_index do |byte, index|
+          uint8_array[index] = byte
+        end
+
+        uint8_array[:buffer]
+      end
+
+      def read
+        @data.dup
+      end
+
+      def size
+        @data.bytesize
+      end
+    end
+  end
+end

data/lib/wands/java_script/js_error.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Wands
+  module JavaScript
+    # Represents a JavaScript error event, inheriting from Ruby's Error class.
+    class JSError < StandardError
+      attr_reader :stack
+
+      def initialize(js_error_event, message = nil)
+        super("#{message}#{dig_js_values(js_error_event, :message)}")
+        @stack = dig_js_values(js_error_event, :error, :stack)
+      end
+
+      private
+
+      # Recursively digs into a nested object using the provided keys, returning nil if any key is not found
+      # or if the value is `JS::Undefined`.
+      def dig_js_values(object, *keys)
+        keys.reduce(object) do |value, key|
+          return nil if value.nil?
+
+          next_value = value[key]
+          next_value == JS::Undefined ? nil : next_value
+        end
+      end
+    end
+  end
+end

data/lib/wands/java_script/queue.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Wands
+  module JavaScript
+    # Asynchronous event queuing mechanism utilizing JavaScript's Promise;
+    # since it uses JavaScript's API, only objects that can be converted to
+    # JavaScript objects can pass through this queue.
+    class Queue
+      def self.wait_once
+        queue = new
+        yield queue
+        queue.pop
+      end
+
+      def initialize
+        @waiter = nil
+        @buffer = []
+      end
+
+      # Only objects that can be converted to JavaScript object can be pushed.
+      def push(message)
+        js_object = JS.try_convert(message)
+        raise TypeError, "#{message.class} is not a JS::Object like object" unless js_object
+
+        if @waiter
+          @waiter.apply message
+          @waiter = nil
+        else
+          @buffer << js_object
+        end
+      end
+      alias << push
+
+      # The popped object is a JavaScript object.
+      # For example, when you push Ruby's false,
+      # the pop method will return JS::True.
+      def pop
+        # message is received
+        # return message
+        return @buffer.shift unless @buffer.empty?
+
+        # message is not received
+        # set promise and wait
+        resolve = nil
+        promise = JS.global[:Promise].new { resolve = it }
+        @waiter = resolve
+        promise.await
+      end
+    end
+  end
+end

data/lib/wands/java_script/web_socket.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "uri"
+require_relative "queue"
+require_relative "js_error"
+require_relative "array_buffer"
+
+module Wands
+  module JavaScript
+    # WebSocket class for when JavaScript is available in the browser.
+    # All methods are synchronous and blocking, compatible with the Socket class.
+    module WebSocket
+      def self.prepended(base) = base.singleton_class.prepend(ClassMethods)
+
+      # The class methods module
+      module ClassMethods
+        def open(host, port)
+          uri = URI::HTTP.build(host:, port:)
+          ws = JS.global[:WebSocket].new(uri.to_s)
+          ws[:binaryType] = "arraybuffer"
+
+          instance = new(ws)
+          ws.addEventListener("message") { instance << it }
+          wait_until_ready ws
+          instance
+        end
+
+        private
+
+        def wait_until_ready(js_ws)
+          return if js_ws[:readyState] == 1
+
+          js_event = Queue.wait_once do |queue|
+            js_ws.addEventListener("open") { queue.push it }
+            js_ws.addEventListener("error") { queue.push it }
+          end
+
+          return unless js_event[:type].to_s == "error"
+
+          raise JSError.new js_event, "WebSocket connection to #{js_ws[:url]} failed: "
+        end
+      end
+
+      def initialize(web_socket)
+        @socket = web_socket
+        @buffer = Queue.new
+        @binary_message = "".b
+      end
+
+      def gets = @buffer.pop.to_s
+
+      def puts(str)
+        raise "socket is closed" unless @socket[:readyState] == 1
+
+        @socket.send(str)
+      end
+
+      def write(str)
+        raise "socket is closed" unless @socket[:readyState] == 1
+
+        array_buffer = ArrayBuffer.new
+        array_buffer.write(str)
+        @socket.send(array_buffer.to_js_array_buffer, binary: true)
+      end
+
+      # Add an text flame into the buffer
+      def <<(event) = @buffer << event[:data]
+
+      private
+
+      def read_next_binary_frame
+        ArrayBuffer.new(@buffer.pop).read
+      end
+    end
+  end
+end

data/lib/wands/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wands
-  VERSION = "0.7.2"
+  VERSION = "0.8.0"
 end

data/lib/wands/web_socket.rb

@@ -7,7 +7,7 @@ require "protocol/websocket/text_frame"
 require_relative "upgrade_request"
 require_relative "http_response"
 require_relative "response_exception"
-require_relative "js/web_socket" if defined? JS
+require_relative "java_script/web_socket" if defined? JS
 
 module Wands
   # This is a class that represents WebSocket, which has the same interface as TCPSocket.
@@ -26,7 +26,7 @@ module Wands
   class WebSocket
     include Protocol::WebSocket::Headers
     extend Forwardable
-    prepend JS::WebSocket if defined? JS
+    prepend JavaScript::WebSocket if defined? JS
 
     def_delegators :@socket, :addr, :remote_address, :close, :to_io, :eof?
 

data/node_wasi_test/.gitignore

@@ -0,0 +1 @@
+node_modules

data/node_wasi_test/package-lock.json

@@ -0,0 +1,67 @@
+{
+  "name": "node_wasi_test",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "node_wasi_test",
+      "version": "1.0.0",
+      "license": "ISC",
+      "devDependencies": {
+        "@ruby/wasm-wasi": "^2.7.1",
+        "ws": "^8.18.1"
+      },
+      "engines": {
+        "node": ">=22.0.0"
+      }
+    },
+    "node_modules/@bjorn3/browser_wasi_shim": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/@bjorn3/browser_wasi_shim/-/browser_wasi_shim-0.3.0.tgz",
+      "integrity": "sha512-FlRBYttPRLcWORzBe6g8nmYTafBkOEFeOqMYM4tAHJzFsQy4+xJA94z85a9BCs8S+Uzfh9LrkpII7DXr2iUVFg==",
+      "dev": true,
+      "license": "MIT OR Apache-2.0"
+    },
+    "node_modules/@ruby/wasm-wasi": {
+      "version": "2.7.1",
+      "resolved": "https://registry.npmjs.org/@ruby/wasm-wasi/-/wasm-wasi-2.7.1.tgz",
+      "integrity": "sha512-2f4NqiJuFoeYiXNr60PH3TbH5c+z/xP2Hq36Av2yahp05AaLDyJxWZwr9EGmfoFsmVTmeDdEW2KjPTfpue6xeg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@bjorn3/browser_wasi_shim": "^0.3.0",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD"
+    },
+    "node_modules/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-RKW2aJZMXeMxVpnZ6bck+RswznaxmzdULiBr6KY7XkTnW8uvt0iT9H5DkHUChXrc+uurzwa0rVI16n/Xzjdz1w==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

data/node_wasi_test/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "node_wasi_test",
+  "version": "1.0.0",
+  "main": "index.js",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "test": "node --experimental-wasi-unstable-preview1 ./run-test-unit.mjs"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "@ruby/wasm-wasi": "^2.7.1",
+    "ws": "^8.18.1"
+  }
+}

data/node_wasi_test/run-test-unit.mjs

@@ -0,0 +1,49 @@
+import fs from "fs/promises";
+import path from "path";
+import * as nodeWasi from "wasi";
+import { RubyVM } from "@ruby/wasm-wasi";
+import startEchoServer from "./start-echo-server.mjs";
+
+async function instantiateNodeWasi() {
+  const dirname = path.dirname(new URL(import.meta.url).pathname);
+  const binaryPath = "../dist/ruby+wands.wasm";
+  const binary = await fs.readFile(binaryPath);
+  const rubyModule = await WebAssembly.compile(binary);
+
+  const wasi = new nodeWasi.WASI({
+    preopens: { "__root__": path.join(dirname, ".") },
+    version: "preview1",
+  });
+
+  const { vm } = await RubyVM.instantiateModule({
+    module: rubyModule,
+    wasip1: wasi,
+  });
+  return vm;
+}
+
+async function test() {
+  const vm = await instantiateNodeWasi();
+
+  await vm.evalAsync(`
+    require 'test/unit'
+
+    require_relative '/__root__/tests/test_unit.rb'
+    ok = Test::Unit::AutoRunner.run
+    exit(1) unless ok
+  `);
+}
+
+async function main() {
+  const stopServer = startEchoServer(8080);
+
+  try{
+    Error.stackTraceLimit = Infinity;
+    await test();
+  } finally {
+    stopServer();
+  }
+}
+
+main();
+

data/node_wasi_test/start-echo-server.mjs

@@ -0,0 +1,16 @@
+import { WebSocketServer } from 'ws';
+
+export default function startTextEchoServer(port) {
+  const wss = new WebSocketServer({ port });
+
+  console.log(`Echo server starts at port:${port}`);
+
+  wss.on('connection', (ws) => {
+    ws.on('message', (message, isBinary) => {
+      ws.send(message, { binary: isBinary });
+    });
+  });
+
+  // return a function to stop the server
+  return () => wss.close();
+}

data/node_wasi_test/tests/test_unit.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "unit/test_queue"
+require_relative "unit/test_array_buffer"
+require_relative "unit/test_web_socket"

data/node_wasi_test/tests/unit/test_array_buffer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "test-unit"
+require "js"
+require "wands/java_script/array_buffer"
+
+module Wands
+  module JavaScript
+    # Test Wands::JavaScript::ArrayBuffer
+    class TestArrayBuffer < Test::Unit::TestCase
+      # rubocop:disable Naming/MethodName
+      def test_to_js_array_buffer_returns_ArrayBuffer
+        @buffer = ArrayBuffer.new
+        @buffer.write("\x10\x20\x30".b)
+        js_buffer = @buffer.to_js_array_buffer
+
+        assert_true(JS.is_a?(js_buffer, JS.global[:ArrayBuffer]))
+        assert_equal(3, JS.global[:Uint8Array].new(js_buffer)[:length])
+      end
+      # rubocop:enable Naming/MethodName
+
+      def test_initialize_with_js_array_buffer
+        original = "\xaa\xbb\xcc".b
+        @buffer = ArrayBuffer.new
+        @buffer.write(original)
+        js_buf = @buffer.to_js_array_buffer
+
+        new_buffer = ArrayBuffer.new(js_buf)
+        assert_equal(original, new_buffer.read)
+      end
+    end
+  end
+end

data/node_wasi_test/tests/unit/test_queue.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "test-unit"
+require "js"
+require "wands/java_script/queue"
+
+module Wands
+  module JavaScript
+    # Test Wands::JavaScirpt::Queue
+    class TestQueue < Test::Unit::TestCase
+      def test_push_and_pop
+        queue = Queue.new
+        queue.push("Hello World!")
+        message = queue.pop
+
+        assert_true message.is_a?(JS::Object)
+        assert_equal "Hello World!", message.to_s
+      end
+
+      def test_wait_once
+        start = Time.now
+        Queue.wait_once do |queue|
+          JS.global.setTimeout(-> { queue.push(nil) }, 100)
+        end
+        assert_in_delta 0.1, Time.now - start, 0.05
+      end
+
+      def test_push_no_js_like_object
+        queue = Queue.new
+        assert_raise(TypeError) { queue.push(Object.new) }
+      end
+    end
+  end
+end

data/node_wasi_test/tests/unit/test_web_socket.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "test-unit"
+require "js"
+require "wands/web_socket"
+
+module Wands
+  # Test Wands::WebSocket
+  class TestWebSocket < Test::Unit::TestCase
+    def test_open_failure
+      assert_raise(JavaScript::JSError) { WebSocket.open("localhost", 23_456) }
+    end
+
+    def test_open_success
+      web_socket = WebSocket.open("localhost", 8080)
+      assert_instance_of(WebSocket, web_socket)
+      web_socket.close
+    end
+
+    def test_puts_and_gets
+      web_socket = WebSocket.open("localhost", 8080)
+      web_socket.puts("Hello World!")
+
+      received = web_socket.gets
+      assert_instance_of(String, received)
+      assert_equal("Hello World!", received)
+
+      web_socket.close
+    end
+
+    def test_write_and_read
+      web_socket = WebSocket.open("localhost", 8080)
+      binary_data = "\x48\x65\x6C\x6C\x6F\x20\x57\x6F\x72\x6C\x64\x21".b # "Hello World!" as binary
+      web_socket.write(binary_data)
+
+      received = web_socket.read(12)
+      assert_instance_of(String, received)
+      assert_equal(received.encoding, Encoding::ASCII_8BIT)
+      assert_equal(binary_data, received)
+
+      web_socket.close
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: wands
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
 platform: ruby
 authors:
 - shigeru.nakajima
 bindir: exe
 cert_chain: []
-date: 2025-03-20 00:00:00.000000000 Z
+date: 2025-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: protocol-websocket
@@ -54,15 +54,29 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- dist/.gitignore
+- dist/gems.locked
+- dist/gems.rb
 - lib/wands.rb
 - lib/wands/http_response.rb
-- lib/wands/js/queue.rb
-- lib/wands/js/web_socket.rb
+- lib/wands/java_script/array_buffer.rb
+- lib/wands/java_script/js_error.rb
+- lib/wands/java_script/queue.rb
+- lib/wands/java_script/web_socket.rb
 - lib/wands/response_exception.rb
 - lib/wands/upgrade_request.rb
 - lib/wands/version.rb
 - lib/wands/web_socket.rb
 - lib/wands/web_socket_server.rb
+- node_wasi_test/.gitignore
+- node_wasi_test/package-lock.json
+- node_wasi_test/package.json
+- node_wasi_test/run-test-unit.mjs
+- node_wasi_test/start-echo-server.mjs
+- node_wasi_test/tests/test_unit.rb
+- node_wasi_test/tests/unit/test_array_buffer.rb
+- node_wasi_test/tests/unit/test_queue.rb
+- node_wasi_test/tests/unit/test_web_socket.rb
 - sig/wands.rbs
 homepage: https://github.com/ledsun/wands
 licenses:

data/lib/wands/js/queue.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Wands
-  module JS
-    # A blocking queue that can be used for waiting for asynchronous events.
-    class Queue
-
-      def self.wait_once
-        queue = new
-        yield queue
-        queue.pop
-      end
-
-      def initialize
-        @waiter = nil
-        @buffer = []
-      end
-
-      def push(message)
-        if @waiter
-          @waiter.apply message
-          @waiter = nil
-        else
-          @buffer << message
-        end
-      end
-      alias << push
-
-      def pop
-        # message is received
-        # return message
-        return @buffer.shift unless @buffer.empty?
-
-        # message is not received
-        # set promise and wait
-        resolve = nil
-        promise = ::JS.global[:Promise].new { resolve = it }
-        @waiter = resolve
-        promise.await
-      end
-    end
-  end
-end

data/lib/wands/js/web_socket.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-require_relative "queue"
-
-module Wands
-  module JS
-    # WebSocket class for when JavaScript is available in the browser.
-    # All methods are synchronous and blocking, compatible with the Socket class.
-    module WebSocket
-      def self.prepended(base) = base.singleton_class.prepend(ClassMethods)
-
-      # The class methods module
-      module ClassMethods
-        def open(host, port)
-          uri = URI::HTTP.build(host:, port:)
-          ws = ::JS.global[:WebSocket].new(uri.to_s)
-
-          instance = new(ws)
-          ws.addEventListener("message") do |event|
-            instance << event
-          end
-
-          Queue.wait_once do |queue|
-            ws.addEventListener("open") { queue.push(nil) }
-          end
-
-          instance
-        end
-      end
-
-      def initialize(web_socket)
-        @ws = web_socket
-        @queue = Queue.new
-      end
-
-      def puts(str)
-        raise "socket is closed" unless @ws[:readyState] == 1
-
-        @ws.send(str)
-      end
-
-      def gets = @queue.pop
-
-      def <<(event) = @queue << event[:data]
-    end
-  end
-end