jscall 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2c3d95c5cc2e431807e613c0ba1f3fa4c7bc2d74b14974bd780eb787e9db4d13
+  data.tar.gz: 6a301b76f12d69fde106d923f0f22e355e38450c1f4c1d7673508984c222d64f
+SHA512:
+  metadata.gz: 572d0824bc9d2058a4016e28a469fec90bf718124ce4fdd647ef4543fca98b5d6f5b2e43ff06aa2bc11bdcf898cfb0cd7655ef0d09e4ac60263f8c689e72bc6d
+  data.tar.gz: 4a7ce3b1340f3df751c6f5b5467d3242fe53e0a557018d99a0b4475855f54661de8c638376de8e2c4d0a38609f1e9acf9de91dd3ecb25c0dca6534ba9de211d8

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in jscall.gemspec
+gemspec
+
+gem "webrick", "~> 1.4"
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022- Shigeru Chiba.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,260 @@
+# Jscall
+
+Jscall allows executing a program in JavaScript on node.js or a web browser.
+By default, node.js is used for the execution.
+To choose a web browser, call `Jscall.config`.
+
+```
+Jscall.config(browser: true)
+```
+
+To run JavaScript code, call `Jscall.exec`.
+For example,
+
+```
+Jscall.exec '1 + 1'
+```
+
+This returns `2`.  The argument passed to `Jscall.exec` can be
+multipe lines.  It is executed as source code written in JavaScript.
+
+`Jscall.exec` returns a resulting value.  Numbers, character strings (and symbols), boolean values, and `nil` (and `null`)
+are copied when passing between Ruby and JavaScript.  An array is also shallow-copied.
+Other objects are not copied.  When they are passed, a remote reference is created at the destination.
+
+A remote reference is a proxy object.  A method call on a remote reference invokes a method on the corresponding object on the remote site.  For example,
+
+```
+js_obj = Jscall.exec '({ foo: (x) => x + 1, bar: 7 })'
+js_obj.foo(3)    # 4
+js_obj.bar       # 7
+js_obj.baz = 9
+js_obj.baz       # 9
+```
+
+The `foo` method is executed in JavaScript.
+Since `bar` is not a function, its value is returned to Ruby as it is.
+
+Setting a object property to a given value is also
+allowed.  The expression `js_obj.baz = 9` above sets
+the object property `baz` to 9.
+
+To call a JavaScript function from Ruby, call a mehtod on `Jscall`.
+For example,
+
+```
+Jscall.exec <<CODE
+  function foo(x) {
+    return x + 1
+  }
+CODE
+Jscall.foo(7)    # 8
+```
+
+`Jscall.foo(7)` invokes the JavaScript function with the name following `Jscall.`
+with the given argument.  In this case,
+the `foo` function is executed with the argument `7`.
+
+When a Ruby object is passed to a JavaScript function/method,
+it can call a method on the passed Ruby object.
+
+```
+Jscall.exec <<CODE
+  async function foo(obj) {
+    return await obj.to_a()
+  }
+CODE
+Jscall.foo((1..3))    # [], 2, 3]
+```
+
+Here, `obj.to_a()` calls the `to_a` method on a `Range` object
+created in Ruby.
+Note that you must `await` every call to Ruby object since it is
+asynchronous call.
+
+In JavaScript, `Ruby.exec` is availale to run a program in Ruby.
+For example,
+
+```
+Jscall.exec <<CODE
+  async function foo() {
+    return await Ruby.exec('RUBY_VERSION')
+  }
+CODE
+Jscall.foo()
+```
+
+`Jscall.foo()` returns the result of evaluating `RUBY_VERSION`
+in Ruby.
+Don't forget to `await` a call to `Ruby.exec`.
+
+Remote references will be automatically reclaimed when they are no
+longer used.  To reclaim them immediately, call:
+
+```
+Jscall.scavenge_references
+```
+
+## DOM manipulation
+
+When JavaScript code is run on a browser, some utility methods
+are available in Ruby for manipulating DOM objects.
+
+- `Jscall.dom.append_css(css_file_path)`
+
+This adds a `link` element to the DOM tree so that the specified
+css file will be linked.  For example, `append_css('/mystyle.css')`
+links `mystyle.css` in the current directory.
+
+- `Jscall.dom.print(msg)`
+
+This adds a `p` element to the DOM tree.
+
+
+## Variable scope
+
+Since Jscall uses `eval` to execute JavaScript code, the scope of
+variable/constant names is within the code passed to `eval`.
+For example,
+
+```
+Jscall.exec 'const k = 3'
+Jscall.exec 'k + 3'         # Can't find variable: k
+```
+
+The second line causes an error.  `k` is not visible
+when `'k + 3'` is executed.
+
+To avoid this, use a global variable.
+
+```
+Jscall.exec 'k = 3'
+Jscall.exec 'globalThis.j = 4'
+Jscall.exec 'k + j'             # 7
+```
+
+## Loading a module
+
+When JavaScript code is executed on node.js, `require` is available in JavaScript
+for loading a CommonJS module.  For example,
+
+```
+Jscall.exec "mime = require('./mime.js')"
+```
+
+The file `./mime.js` is loaded and the module is bound to a global variable `mime`.
+
+You may want to call `Jscall.dyn_import` in Ruby.
+
+```
+fs = Jscall.dyn_import('fs')
+```
+
+This executes dynamic importing in JavaScript.
+For node.js, the file name of the imported module should be a full path name.  For a web browser, the root directory is a current working directory.  So `Jscall.dyn_import('/mine.mjs')` loads the file `./mine.mjs`.
+
+`Jscall.dyn_import` takes the second argument.  If it is given,
+a global variable in JavaScript is bound to the loaded module.
+
+```
+fs = Jscall.dyn_import('fs', 'fs_module')
+```
+
+This is quite equivalent to the following JavaScript code:
+
+```
+fs_module = await load('fs')
+```
+
+
+## Configuration
+
+To import JavaScript modules when node.js starts,
+
+```
+Jscall.config(module_names: [["Foo", "./foo.mjs"], ["Bar", "./bar.mjs"]], options: "--use-strict")
+```
+
+This specifies that `./foo.mjs` and `./bar.mjs` are impoted when node.js starts.
+This is equivalent to the following import declarations:
+
+```
+import * as "Foo" from "./foo.mjs"
+import * as "Bar" from "./bar.mjs"
+```
+
+`'--use-strict'` is passed to node.js as a command line argument.
+
+`module_names:` and `options:` are optional arguments to `Jscall.config`.
+
+To change the name of the node command,
+
+```
+Jscall::PipeToJs.node_command = "node.exe"
+```
+
+The default command name is `"node"`.
+
+When running JavaScript code on a web browser,
+
+```
+Jscall.config(browser: true, options: {port: 10082})
+```
+
+`options:` is an optional argument.
+The example above specifies that Ruby receives http requests
+sent to http://localhost:10082 from JavaScript on a web browser.
+
+Passing `false` for `browser:` to `Jscall.config` switches
+the execution engine to node.js.
+Call `Jscall.close` to detach the current execution engine.
+A new enigine with a new configuration will be created.
+
+To change the command for launching a web browser,
+
+```
+Jscall::FetchServer.open_command = "open -a '/Applications/Safari.app'"
+```
+
+By default, the command name is `open` for macOS, `start` for Windows,
+or `xdg-open` for Linux.
+Jscall launches a web browser by the command like the following:
+
+```
+open http://localhost:10082/jscall/jscall.html
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jscall'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install jscall
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/csg-tokyo/jscall.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Acknowledgement
+
+The icon image for jscall was created by partly using the Ruby logo, which was obtained
+from https://www.ruby-lang.org/en/about/logo/ under CC BY-SA 2.5.

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test
+# task default: %i[]

data/jscall.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/jscall/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "jscall"
+  spec.version = Jscall::VERSION
+  spec.authors = ["Shigeru Chiba"]
+  spec.email = ["?"]
+
+  spec.summary = "a library for calling JavaScript functions"
+  spec.description = "a library for executing JavaScript code on node.js or a web browser"
+  spec.homepage = "https://github.com/csg-tokyo/jscall"
+  spec.required_ruby_version = ">= 2.6.0"
+
+#  spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+#  spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "webrick", "~> 1.4"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/jscall/browser.mjs

@@ -0,0 +1,67 @@
+// Copyright (C) 2022- Shigeru Chiba.  All rights reserved.
+
+export class HttpStream {
+    constructor() {
+        this.send_buffer = ['start']
+        this.send_callback = null
+    }
+
+    [Symbol.asyncIterator]() {
+        const http_stream = this
+        return {
+            next() {
+                let msg = http_stream.send_buffer.shift()
+                if (msg === undefined)
+                    return new Promise((resolve, reject) => {
+                        if (http_stream.send_callback === null)
+                            http_stream.send_callback = resolve
+                        else
+                            throw new Error('(fatal) send_callback is not null!')
+                    }).then(() => this.next())
+                else
+                    return http_stream.do_fetch(msg)
+            }
+        }
+    }
+
+    do_fetch(msg) {
+        const hs = new Headers()
+        hs.append('Content-Type', 'text/plain')
+        return fetch('/cmd/', { method: 'POST', headers: hs, body: msg })
+                .then(async (response) => {
+                        if (response.ok) {
+                            const text = await response.text()
+                            return { value: text, done: text === 'done' }
+                        }
+                        else
+                            throw new Error(`HTTP error! Status: ${response.status}`)
+                    },
+                    (reason) => { return { value: 'failure', done: true } })
+    }
+
+    puts(msg) {
+        this.send_buffer.push(msg)
+        if (this.send_callback !== null) {
+            const callback = this.send_callback
+            this.send_callback = null
+            callback()
+        }
+    }
+
+    setEncoding(encoding) {}
+}
+
+export const Jscall = new class {
+    print(msg) {
+        const e = document.createElement('p')
+        e.textContent = msg
+        document.body.append(e)
+    }
+
+    append_css(file_name) {
+        const link = document.createElement('link')
+        link.rel = "stylesheet"
+        link.href = file_name
+        document.head.append(link)
+    }
+}

data/lib/jscall/browser.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2022- Shigeru Chiba.  All rights reserved.
+
+require 'webrick'
+
+module Jscall
+    WEBrick::HTTPUtils::DefaultMimeTypes['mjs'] ||= "application/javascript"
+
+    class Dom
+        def method_missing(name, *args)
+            Jscall.__getpipe__.funcall(nil, "Jscall.#{name}", args)
+        end
+    end
+
+    @js_dom = Dom.new
+
+    def self.dom
+        @js_dom
+    end
+
+    class PipeToJs
+    end
+
+    class PipeToBrowser < PipeToJs
+        def startJS(module_names, options)
+            port = 10081
+            port = options[:port] if options.is_a?(Hash) && options.has_key?(:port)
+            @pipe = FetchServer.new(port)
+            @pipe.open
+        end
+
+        def close
+            @pipe.shutdown
+            sleep(0.5)
+            true
+        end
+
+        def soft_close
+            @pipe.close
+            false
+        end
+    end
+
+    class FetchServer
+        @@webpage = '/jscall/jscall.html'
+
+        @@run_cmd = case RbConfig::CONFIG['host_os']
+        when /linux/
+            'xdg-open'
+        when /darwin|mac os/
+            'open'
+        else
+            'start'
+        end
+
+        def self.open_command=(name)
+            @@run_cmd = name
+        end
+
+        def initialize(port)
+            @send_buffer = Thread::Queue.new
+            @receive_buffer = Thread::Queue.new
+            @server_running = false
+
+            @server = WEBrick::HTTPServer.new(
+                # :DoNotReverseLookup => true,
+                :DocumentRoot => './',
+                :BindAddress => '0.0.0.0',
+                :Port => port,
+                :ServerType => Thread,
+                :Logger => WEBrick::Log.new(nil, WEBrick::Log::ERROR),
+                :AccessLog => []
+            )
+
+            @server.mount_proc('/') do |req, res|
+                peer_address  = req.peeraddr[3]
+                if peer_address != '127.0.0.1'
+                    $stderr.puts "access denied address=#{peer_address}"
+                    raise WEBrick::HTTPStatus::Forbidden
+                end
+
+                if req.path.start_with?('/cmd/')
+                    read_stream(req, res)
+                else
+                    read_file(req, res)
+                end
+            end
+        end
+
+        def read_stream(req, res)
+            body = req.body
+            @receive_buffer.push(if body.nil? then '' else body end)
+            res.content_type = "text/plain"
+            res.body = @send_buffer.pop
+        end
+
+        def read_file(req, res)
+            if req.path.start_with?('/jscall/')
+                root = "#{__dir__}/../"
+            else
+                root = @server.config[:DocumentRoot]
+            end
+            WEBrick::HTTPServlet::FileHandler.new(@server, root).service(req, res)
+        end
+
+        def open
+            if @server_running
+                close
+            else
+                @server_running = true
+                if @server.status != :Running
+                    Signal.trap(:INT){ @server.shutdown }
+                    @server.start
+                    Thread.pass
+                end
+            end
+            raise "A web page was reloaded" unless @receive_buffer.empty?
+            status = system "#{@@run_cmd} http://localhost:#{@server[:Port]}#{@@webpage}"
+            raise "cannot launch a web browser by '#{@@run_cmd}'" if status.nil?
+            unless @receive_buffer.pop == 'start'
+                raise 'failed to initialize JavaScript'
+            end
+        end
+
+        def close
+            puts('done')
+            @server_running = false
+        end
+
+        def closed?
+            !@server_running
+        end
+
+        def autoclose=(value)
+            false
+        end
+
+        def shutdown
+            close
+            @server.stop
+        end
+
+        def puts(msg)
+            @send_buffer.push(msg)
+            Thread.pass
+        end
+
+        def gets
+            @receive_buffer.pop
+        end
+    end
+end

data/lib/jscall/jscall.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>Jscall</title>
+  <link rel="icon" type="image/png" sizes="32x32" href="./favicon.ico">
+  <link rel="apple-touch-icon" href="./apple-touch-icon.png">
+
+  <script type="module" src="./main.mjs"></script>
+  <script type="module" src="./browser.mjs"></script>
+  <script type="module">
+    import * as Ruby from './main.mjs'
+    import { HttpStream, Jscall } from './browser.mjs'
+    globalThis.Ruby = Ruby
+    globalThis.Jscall = Jscall
+    Ruby.start(new HttpStream(), false)
+  </script>
+</head>
+
+<body>
+</body>
+</html>

data/lib/jscall/main.mjs

@@ -0,0 +1,340 @@
+// Copyright (C) 2022- Shigeru Chiba.  All rights reserved.
+
+const cmd_eval = 1
+const cmd_call = 2
+const cmd_reply = 3
+const param_array = 0
+const param_object = 1
+const param_local_object = 2
+const param_error = 3
+
+const table_size = 100
+
+const exported = new class {
+    constructor() {
+        this.objects = Array(table_size).fill().map((_, i) => i + 1)
+        this.objects[table_size - 1] = -1
+        this.free_element = 0
+        this.hashtable = new Map()
+    }
+
+    export(obj) {
+        const idx = this.hashtable.get(obj)
+        if (idx !== undefined)
+            return idx
+        else {
+            const idx = this.next_element()
+            this.objects[idx] = obj
+            this.hashtable.set(obj, idx)
+            return idx
+        }
+    }
+
+    export_remoteref(prref) {   // proxy for remote reference
+        return prref.__self__.id
+    }
+
+    next_element() {
+        const idx = this.free_element
+        if (idx < 0)
+            return this.objects.length
+        else {
+            this.free_element = this.objects[idx]
+            return idx
+        }
+    }
+
+    find(idx) {
+        const obj = this.objects[idx]
+        if (typeof obj === 'number')
+            throw `unknown index is given to find(): ${idx}`
+        else
+            return obj
+    }
+
+    remove(idx) {
+        const obj = this.objects[idx]
+        if (typeof obj === 'number')
+            throw `unknown index is given to remove(): ${idx}`
+        else {
+            this.objects[idx] = this.free_element
+            this.free_element = idx
+            this.hashtable.delete(obj)
+        }
+    }
+}
+
+const RemoteRef = class {
+    constructor(id) {
+        this.id = id
+    }
+}
+
+const remoteRefHandler = new class {
+    get(obj, name) {
+        if (name === '__self__')
+            return obj
+        else
+            return (...args) => {
+                // this returns Promise
+                return funcall_to_ruby(obj.id, name, args)
+            }
+    }
+}
+
+const imported = new class {
+    constructor() {
+        this.objects = Array(table_size).fill(null)
+        this.canary = new WeakRef(new RemoteRef(-1))
+    }
+
+    import(index) {
+        const wref = this.objects[index]
+        const obj = wref === null || wref === undefined ? null : wref.deref()
+        if (obj !== null && obj !== undefined)
+            return obj
+        else {
+            const rref = new Proxy(new RemoteRef(index), remoteRefHandler)
+            this.objects[index] = new WeakRef(rref)
+            return rref
+        }
+    }
+
+    kill_canary() { this.canary = null }
+
+    // collect reclaimed RemoteRef objects.
+    dead_references() {
+        if (this.canary === null || this.canary.deref() === undefined)
+            this.canary = new WeakRef(new RemoteRef(-1))
+        else
+            return []   // the canary is alive, so no GC has happened yet.
+
+        const deads = []
+        this.objects.forEach((wref, index) => {
+            if (wref !== null && wref !== undefined && wref.deref() === undefined) {
+                this.objects[index] = null
+                deads.push(index)
+            }
+        })
+        return deads
+    }
+}
+
+const encode_obj = obj => {
+    if (typeof obj === 'number' || typeof obj === 'string' || obj === true || obj === false || obj === null)
+        return obj
+    else if (obj === undefined)
+        return null
+    else if (obj.constructor === Array)
+        return [param_array, obj.map(e => encode_obj(e))]
+    else if (obj instanceof RemoteRef)
+        return [param_local_object, exported.export_remoteref(obj)]
+    else
+        return [param_object, exported.export(obj)]
+}
+
+const encode_error = msg => [param_error, msg]
+
+const RubyError = class {
+    constructor(msg) { this.message = msg }
+    get() { return 'RubyError: ' + this.message }
+}
+
+const decode_obj = obj => {
+    if (typeof obj === 'number' || typeof obj === 'string' || obj === true || obj === false || obj === null)
+        return obj
+    else if (obj.constructor === Array && obj.length == 2)
+        if (obj[0] == param_array)
+            return obj[1].map(e => decode_obj(e))
+        else if (obj[0] == param_object)
+            return imported.import(obj[1])
+        else if (obj[0] == param_local_object)
+            return exported.find(obj[1])
+        else if (obj[0] == param_error)
+            return new RubyError(obj[1])
+
+    throw `decode_obj: unsupported value, ${obj}`
+}
+
+const js_eval = eval
+
+const funcall_from_ruby = cmd => {
+    const receiver = decode_obj(cmd[1])
+    const name = cmd[2]
+    const args = cmd[3].map(e => decode_obj(e))
+    if (name.endsWith('=')) {
+        const name2 = name.substring(0, name.length - 1)
+        if (receiver === null)
+            throw `assignment to a global object ${name2} is not supported`
+        else if (args.length === 1) {
+            if (Reflect.set(receiver, name2, args[0]))
+                return args[0]
+        }
+        throw `faild to set an object property ${name2}`
+    }
+
+    if (receiver === null) {
+        const f = js_eval(name)
+        if (typeof f === 'function')
+            return f.apply(this, args)
+        else if (args.length === 0)
+            return f    // obtain a property
+    }
+    else {
+        const f = Reflect.get(receiver, name)
+        if (f)
+            if (typeof f === 'function')
+                return Reflect.apply(f, receiver, args)
+            else if (args.length === 0)
+                return f    // obtain a propety
+    }
+
+    throw `unknown function/method was called, ${name}`
+}
+
+let stdout_puts = console.log
+
+const reply = value => {
+    if (value instanceof Promise)
+        value.then(result => { reply(result) })
+             .catch(err => reply_error(err))
+    else {
+        if (last_callback_stack_depth < callback_stack.length)
+            throw 'Ruby code was called without await.  Call Jscall.close for recovery'
+
+        try {
+            const cmd = reply_with_piggyback([cmd_reply, encode_obj(value)])
+            const data = JSON.stringify(cmd)
+            stdout_puts(data)
+        } catch (e) {
+            reply_error(e)
+        }
+    }
+}
+
+const reply_error = e => {
+    const cmd = reply_with_piggyback([cmd_reply, encode_error(e)])
+    stdout_puts(JSON.stringify(cmd))
+}
+
+export const scavenge_references = () => {
+    reply_counter = 200
+    imported.kill_canary()
+    return true
+}
+
+const reply_with_piggyback = cmd => {
+    const threashold = 100
+    if (++reply_counter > threashold) {
+        reply_counter = 0
+        const dead_refs = imported.dead_references()
+        if (dead_refs.length > 0) {
+            const cmd2 = cmd.concat()
+            cmd2[4] = dead_refs
+            return cmd2
+        }
+    }
+
+    return cmd
+}
+
+const callback_stack = []
+let last_callback_stack_depth = 0
+let reply_counter = 0
+
+export const exec = src => {
+    return new Promise((resolve, reject) => {
+        const cmd = reply_with_piggyback([cmd_eval, src])
+        callback_stack.push([resolve, reject])
+        stdout_puts(JSON.stringify(cmd))
+    })
+}
+
+const funcall_to_ruby = (receiver_id, name, args) => {
+    return new Promise((resolve, reject) => {
+        const receiver = [param_local_object, receiver_id]
+        const encoded_args = args.map(e => encode_obj(e))
+        const cmd = reply_with_piggyback([cmd_call, receiver, name, encoded_args])
+        callback_stack.push([resolve, reject])
+        stdout_puts(JSON.stringify(cmd))
+    })
+}
+
+const returned_from_callback = cmd => {
+    const result = decode_obj(cmd[1])
+    const callback = callback_stack.pop()
+    if (result instanceof RubyError)
+        callback[1](result.get())
+    else
+        callback[0](result)
+}
+
+class JsonReader {
+    constructor(stream) {
+        this.stream     = stream
+        this.acc        = ""
+    }
+
+    async *[Symbol.asyncIterator]() {
+        for await (let data of this.stream) {
+            this.acc += data
+            try {
+                yield JSON.parse(this.acc)
+                this.acc = ""
+            } catch {
+                // keep data in this.acc
+            }
+        }
+        if (this.acc != "") {
+            yield JSON.parse(this.acc)
+        }
+    }
+}
+
+export const start = async (stdin, use_stdout) => {
+    if (use_stdout)
+        console.log = console.error         // on node.js
+    else
+        stdout_puts = (m) => stdin.puts(m)  // on browser
+
+    stdin.setEncoding('utf8')
+    for await (const cmd of new JsonReader(stdin)) {
+        try {
+            last_callback_stack_depth = callback_stack.length
+
+            // scavenge remote references
+            if (cmd.length > 4)
+                cmd[4].forEach(i => exported.remove(i))
+
+            if (cmd[0] == cmd_eval) {
+                const result = js_eval(cmd[1])
+                reply(result)
+            }
+            else if (cmd[0] == cmd_call) {
+                const result = funcall_from_ruby(cmd)
+                reply(result)
+            }
+            else if (cmd[0] == cmd_reply)
+                returned_from_callback(cmd)
+            else
+                reply_error('invalid command')
+        } catch (error) {
+            const msg = typeof error === 'string' ? error : error.toString() +
+                                                            '\n  ---\n' + error.stack
+            reply_error(msg)
+        }
+    }
+}
+
+// for testing and debugging
+export const get_exported_imported = () => {
+    return [exported, imported]
+}
+
+export const dyn_import = async (file_name, var_name) => {
+    const m = await import(file_name)     // dynamic import
+    if (var_name)
+        eval(`(v)=>{globalThis.${var_name} = v}`)(m)
+
+    return m
+}

data/lib/jscall/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2022- Shigeru Chiba.  All rights reserved.
+
+module Jscall
+  VERSION = "1.0.0"
+end

data/lib/jscall.rb

@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2022- Shigeru Chiba.  All rights reserved.
+
+require "json"
+require "weakref"
+
+require_relative "jscall/version"
+require_relative "jscall/browser"
+
+module Jscall
+    TableSize = 100
+
+    class JavaScriptError < RuntimeError
+        def initialize(msg)
+            super(msg)
+        end
+    end
+
+    class HiddenRef
+        def initialize(obj)
+            @object = obj
+        end
+        def __getobj__()
+            @object
+        end
+    end
+
+    class Exported      # inbound referneces from Node to Ruby
+        attr_reader :objects
+
+        def initialize
+            ary = Array.new(Jscall::TableSize) {|i| i + 1}
+            ary[-1] = -1
+            @objects = HiddenRef.new(ary)
+            @free_element = 0
+            @hashtable = HiddenRef.new({})
+        end
+
+        def export(obj)
+            hash = @hashtable.__getobj__
+            if hash.include?(obj)
+                hash[obj]
+            else
+                objs = @objects.__getobj__
+                idx = @free_element
+                if idx < 0
+                    idx = objs.size
+                else
+                    @free_element = objs[idx]
+                end
+                objs[idx] = obj
+                hash[obj] = idx   # return idx
+            end
+        end
+
+        def find(idx)
+            obj = @objects.__getobj__[idx]
+            if obj.is_a?(Numeric)
+                raise JavaScriptError.new("unknown index is given to find(): #{idx}")
+            else
+                obj
+            end
+        end
+
+        def remove(idx)
+            objects = @objects.__getobj__
+            obj = objects[idx]
+            if obj.is_a?(Numeric)
+                raise JavaScriptError.new("unknown index is given to remove(): #{idx}")
+            else
+                objects[idx] = @free_element
+                @free_element = idx
+                @hashtable.__getobj__.delete(obj)
+            end
+        end
+    end
+
+    class RemoteRef
+        attr_reader :id
+
+        def initialize(id)
+            @id = id
+        end
+
+        def method_missing(name, *args)
+            Jscall.__getpipe__.funcall(self, name, args)
+        end
+    end
+
+    class Imported      # outbound references from Ruby to Node
+        attr_reader :objects
+
+        def initialize
+            ary = Array.new(Jscall::TableSize, nil)
+            @objects = HiddenRef.new(ary)
+            @canary = WeakRef.new(RemoteRef.new(-1))
+        end
+
+        def import(index)
+            objects = @objects.__getobj__
+            wref = objects[index]
+            if  wref&.weakref_alive?
+                wref.__getobj__
+            else
+                rref = RemoteRef.new(index)
+                objects[index] = WeakRef.new(rref)
+                rref
+            end
+        end
+
+        # forces dead_references() to check the liveness of references.
+        def kill_canary
+            @canary = nil
+        end
+
+        def dead_references()
+            if @canary&.weakref_alive?
+                return []
+            else
+                @canary = WeakRef.new(RemoteRef.new(-1))
+            end
+            deads = []
+            objects = @objects.__getobj__
+            objects.each_index do |index|
+                wref = objects[index]
+                if !wref.nil? && !wref.weakref_alive?
+                    objects[index] = nil
+                    deads << index
+                end
+            end
+            deads
+        end
+    end
+
+    class PipeToJs
+        CMD_EVAL = 1
+        CMD_CALL = 2
+        CMD_REPLY = 3
+        Param_array = 0
+        Param_object = 1
+        Param_local_object = 2
+        Param_error = 3
+
+        @@node_cmd = 'node'
+
+        def self.node_command=(cmd)
+            @@node_cmd = cmd
+        end
+
+        # do import * as 'module_names[i][0]' from 'module_names[i][1]' 
+        #
+        def initialize(module_names=[], options='')
+            startJS(module_names, options)
+            @exported = Exported.new
+            @imported = Imported.new
+            @send_counter = 0
+        end
+
+        # module_names: an array of [module_name, module_file_name]
+        #
+        def startJS(module_names, options)
+            script2 = ''
+            module_names.each_index do |i|
+                script2 += "import * as m#{i + 2} from \"#{module_names[i][1]}\"; globalThis.#{module_names[i][0]} = m#{i + 2}; "
+            end
+            script2 += "import { createRequire } from \"node:module\"; globalThis.require = createRequire(\"file://#{Dir.pwd}/\");"
+            script = "'import * as m1 from \"#{__dir__}/jscall/main.mjs\"; globalThis.Ruby = m1; #{script2}; Ruby.start(process.stdin, true)'"
+            @pipe = IO.popen("#{@@node_cmd} #{options} --input-type 'module' -e #{script}", "r+t")
+            @pipe.autoclose = true
+        end
+
+        def get_exported_imported
+            [@exported, @imported]
+        end
+
+        def close
+            @pipe.close
+            true
+        end
+
+        def encode_obj(obj)
+            if obj.is_a?(Numeric) || obj.is_a?(String) || obj.is_a?(Symbol) || obj == true || obj == false || obj == nil
+                obj
+            elsif obj.is_a?(Array)
+                [Param_array, obj.map {|e| encode_obj(e)}]
+            elsif obj.is_a?(RemoteRef)
+                [Param_local_object, obj.id]
+            else
+                [Param_object, @exported.export(obj)]
+            end
+        end
+
+        def encode_error(msg)
+            [Param_error, msg]
+        end
+
+        def decode_obj(obj)
+            if obj.is_a?(Numeric) || obj.is_a?(String) || obj == true || obj == false || obj == nil
+                obj
+            elsif obj.is_a?(Array) && obj.size == 2
+                if (obj[0] == Param_array)
+                    obj[1].map {|e| decode_obj(e)}
+                elsif (obj[0] == Param_object)
+                    @imported.import(obj[1])
+                elsif (obj[0] == Param_local_object)
+                    @exported.find(obj[1])
+                else  # if Param_error
+                    JavaScriptError.new(obj[1])
+                end
+            else
+                raise JavaScriptError.new('the result is a broken value')
+            end
+        end
+
+        def funcall(receiver, name, args)
+            cmd = [CMD_CALL, encode_obj(receiver), name, args.map {|e| encode_obj(e)}]
+            send_command(cmd)
+        end
+
+        def exec(src)
+            cmd = [CMD_EVAL, src]
+            send_command(cmd)
+        end
+
+        def encode_eval_error(e)
+            traces = e.backtrace
+            location = if traces.size > 0 then traces[0] else '' end
+            encode_error(location + ' ' + e.to_s)
+        end
+
+        def scavenge
+            @send_counter = 200
+            @imported.kill_canary
+            exec 'Ruby.scavenge_references()'
+        end
+
+        def send_with_piggyback(cmd)
+            threashold = 100
+            @send_counter += 1
+            if (@send_counter > threashold)
+                @send_counter = 0
+                dead_refs = @imported.dead_references()
+                if (dead_refs.length > 0)
+                    cmd2 = cmd.dup
+                    cmd2[4] = dead_refs
+                    return cmd2
+                end
+            end
+            return cmd
+        end
+
+        def send_command(cmd)
+            json_data = JSON.generate(send_with_piggyback(cmd))
+            @pipe.puts(json_data)
+            reply_data = @pipe.gets
+            reply = JSON.parse(reply_data || '[]')
+            if reply.length > 4
+                reply[4].each {|idx| @exported.remove(idx) }
+            end
+            if @pipe.closed?
+                raise RuntimeError.new("connection closed: #{reply}")
+            elsif reply[0] == CMD_REPLY
+                result = decode_obj(reply[1])
+                if result.is_a?(JavaScriptError)
+                    raise result
+                else
+                    return result
+                end
+            elsif reply[0] == CMD_EVAL
+                begin
+                    result = Object::TOPLEVEL_BINDING.eval(reply[1])
+                    encoded = encode_obj(result)
+                rescue => e
+                    encoded = encode_eval_error(e)
+                end
+                send_command([CMD_REPLY, encoded])
+            elsif reply[0] == CMD_CALL
+                begin
+                    receiver = decode_obj(reply[1])
+                    name = reply[2]
+                    args = reply[3].map {|e| decode_obj(e)}
+                    result = receiver.public_send(name, *args)
+                    encoded = encode_obj(result)
+                rescue => e
+                    encoded = encode_eval_error(e)
+                end
+                send_command([CMD_REPLY, encoded])
+            else
+                raise RuntimeError.new("bad reply: #{reply}")
+            end
+        end
+    end
+
+    @pipe = nil
+    @module_names = []
+    @options = ''
+    @pipeToJsClass = PipeToJs
+
+    def self.config(module_names: [], options: '', browser: false)
+        @module_names = module_names
+        @options = options
+        @pipeToJsClass = if browser then PipeToBrowser else PipeToJs end
+        nil
+    end
+
+    def self.close
+        @pipe = nil if @pipe.close  unless @pipe.nil?
+    end
+
+    Signal.trap(0) { self.close }  # close before termination
+
+    def self.exec(src)
+        __getpipe__.exec(src)
+    end
+
+    def self.dyn_import(name, var_name=nil)
+        __getpipe__.funcall(nil, 'Ruby.dyn_import', [name, var_name])
+    end
+
+    # name is a string object.
+    # Evaluating this string in JavaScript results in a JavaScript function.
+    #
+    def self.funcall(name, *args)
+        __getpipe__.funcall(nil, name, args)
+    end
+
+    # reclaim unused remote references.
+    #
+    def self.scavenge_references
+        __getpipe__.scavenge
+    end
+
+    def self.method_missing(name, *args)
+        __getpipe__.funcall(nil, name, args)
+    end
+
+    def self.__getpipe__
+        if @pipe.nil?
+            @pipe = @pipeToJsClass.new(@module_names, @options)
+        end
+        @pipe
+    end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: jscall
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Shigeru Chiba
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: a library for executing JavaScript code on node.js or a web browser
+email:
+- "?"
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- jscall.gemspec
+- lib/jscall.rb
+- lib/jscall/apple-touch-icon.png
+- lib/jscall/browser.mjs
+- lib/jscall/browser.rb
+- lib/jscall/favicon.ico
+- lib/jscall/jscall.html
+- lib/jscall/main.mjs
+- lib/jscall/version.rb
+homepage: https://github.com/csg-tokyo/jscall
+licenses: []
+metadata:
+  homepage_uri: https://github.com/csg-tokyo/jscall
+  source_code_uri: https://github.com/csg-tokyo/jscall
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: a library for calling JavaScript functions
+test_files: []