jscall 1.0.1 → 1.2.0

data/lib/jscall.rb

@@ -9,6 +9,16 @@ require_relative "jscall/version"
 require_relative "jscall/browser"
 
 module Jscall
+    @@debug = 0
+
+    # Current debug level (>= 0)
+    def self.debug() @@debug end
+
+    # Sets the current debug level.
+    def self.debug=(level)
+        @@debug = level
+    end
+
     TableSize = 100
 
     class JavaScriptError < RuntimeError
@@ -77,17 +87,50 @@ module Jscall
     end
 
     class RemoteRef
-        attr_reader :id
-
         def initialize(id)
             @id = id
         end
 
+        def __get_id
+            @id
+        end
+
+        def async
+            AsyncRemoteRef.new(@id)
+        end
+
+        # override Object#then
+        def then(*args)
+            send('then', *args)
+        end
+
+        # puts() calls this
+        def to_ary
+            ["#<RemoteRef @id=#{@id}>"]
+        end
+
+        # override Object#send
+        def send(name, *args)
+            Jscall.__getpipe__.funcall(self, name, args)
+        end
+
+        def async_send(name, *args)
+            Jscall.__getpipe__.async_funcall(self, name, args)
+        end
+
         def method_missing(name, *args)
             Jscall.__getpipe__.funcall(self, name, args)
         end
     end
 
+    class AsyncRemoteRef < RemoteRef
+        alias send async_send
+
+        def method_missing(name, *args)
+            Jscall.__getpipe__.async_funcall(self, name, args)
+        end
+    end
+
     class Imported      # outbound references from Ruby to Node
         attr_reader :objects
 
@@ -137,10 +180,19 @@ module Jscall
         CMD_EVAL = 1
         CMD_CALL = 2
         CMD_REPLY = 3
+        CMD_ASYNC_CALL = 4
+        CMD_ASYNC_EVAL = 5
+        CMD_RETRY = 6
+        CMD_REJECT = 7
+
         Param_array = 0
         Param_object = 1
         Param_local_object = 2
         Param_error = 3
+        Param_hash = 4
+
+        Header_size = 6
+        Header_format = '%%0%dx' % Header_size
 
         @@node_cmd = 'node'
 
@@ -148,24 +200,39 @@ module Jscall
             @@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)
+        def initialize(config)
             @exported = Exported.new
             @imported = Imported.new
             @send_counter = 0
+            @num_generated_ids = 0
+            @pending_replies = {}
+            module_names = config[:module_names] || []
+            startJS(module_names, config)
         end
 
-        # module_names: an array of [module_name, module_file_name]
+        def setup(config)
+            # called just after executing new PipeToJs(config)
+        end
+
+        # Config options.
+        #
+        # module_names: an array of [module_name, module_root, module_file_name]
+        #   For example,
+        #     [['Foo', '/home/jscall', '/lib/foo.mjs']]
+        #   this does
+        #     import * as Foo from "/home/jscall/lib/foo.mjs"
+        #
+        # options: options passed to node.js
         #
-        def startJS(module_names, options)
+        def startJS(module_names, config)
+            options = config[: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}; "
+                script2 += "import * as m#{i + 2} from \"#{module_names[i][1]}#{module_names[i][2]}\"; 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)'"
+            main_js_file = if config[:sync] then "synch.mjs" else "main.mjs" end
+            script = "'import * as m1 from \"#{__dir__}/jscall/#{main_js_file}\"; 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
@@ -184,8 +251,12 @@ module Jscall
                 obj
             elsif obj.is_a?(Array)
                 [Param_array, obj.map {|e| encode_obj(e)}]
+            elsif obj.is_a?(Hash)
+                hash2 = {}
+                obj.each {|key, value| hash2[key] = encode_obj(value) }
+                [Param_hash, hash2]
             elsif obj.is_a?(RemoteRef)
-                [Param_local_object, obj.id]
+                [Param_local_object, obj.__get_id]
             else
                 [Param_object, @exported.export(obj)]
             end
@@ -199,11 +270,15 @@ module Jscall
             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)
+                if obj[0] == Param_array
                     obj[1].map {|e| decode_obj(e)}
-                elsif (obj[0] == Param_object)
+                elsif obj[0] == Param_hash
+                    hash = {}
+                    obj[1].each {|key, value| hash[key] = decode_obj(value)}
+                    hash
+                elsif obj[0] == Param_object
                     @imported.import(obj[1])
-                elsif (obj[0] == Param_local_object)
+                elsif obj[0] == Param_local_object
                     @exported.find(obj[1])
                 else  # if Param_error
                     JavaScriptError.new(obj[1])
@@ -213,20 +288,38 @@ module Jscall
             end
         end
 
+        def fresh_id
+            @num_generated_ids += 1
+        end
+
         def funcall(receiver, name, args)
-            cmd = [CMD_CALL, encode_obj(receiver), name, args.map {|e| encode_obj(e)}]
+            cmd = [CMD_CALL, nil, encode_obj(receiver), name, args.map {|e| encode_obj(e)}]
+            send_command(cmd)
+        end
+
+        def async_funcall(receiver, name, args)
+            cmd = [CMD_ASYNC_CALL, nil, encode_obj(receiver), name, args.map {|e| encode_obj(e)}]
             send_command(cmd)
         end
 
         def exec(src)
-            cmd = [CMD_EVAL, src]
+            cmd = [CMD_EVAL, nil, src]
+            send_command(cmd)
+        end
+
+        def async_exec(src)
+            cmd = [CMD_ASYNC_EVAL, nil, 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)
+            if Jscall.debug > 0
+                encode_error("\n#{e.full_message}")
+            else
+                encode_error(location + ' ' + e.to_s)
+            end
         end
 
         def scavenge
@@ -243,7 +336,7 @@ module Jscall
                 dead_refs = @imported.dead_references()
                 if (dead_refs.length > 0)
                     cmd2 = cmd.dup
-                    cmd2[4] = dead_refs
+                    cmd2[5] = dead_refs
                     return cmd2
                 end
             end
@@ -251,55 +344,103 @@ module Jscall
         end
 
         def send_command(cmd)
+            message_id = (cmd[1] ||= fresh_id)
             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) }
+            header = (Header_format % json_data.length)
+            if header.length != Header_size
+                raise "message length limit exceeded"
             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)
+            json_data_with_header = header + json_data
+            @pipe.puts(json_data_with_header)
+
+            while true
+                reply_data = @pipe.gets
+                reply = JSON.parse(reply_data || '[]')
+                if reply.length > 5
+                    reply[5].each {|idx| @exported.remove(idx) }
+                    reply[5] = nil
                 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)
+                if @pipe.closed?
+                    raise RuntimeError.new("connection closed: #{reply}")
+                elsif reply[0] == CMD_REPLY
+                    result = decode_obj(reply[2])
+                    if reply[1] != message_id
+                        @pending_replies[reply[1]] = result
+                        send_reply(reply[1], nil, false, CMD_REJECT)
+                    elsif result.is_a?(JavaScriptError)
+                        raise result
+                    else
+                        return result
+                    end
+                elsif reply[0] == CMD_EVAL
+                    begin
+                        result = Object::TOPLEVEL_BINDING.eval(reply[2])
+                        send_reply(reply[1], result)
+                    rescue => e
+                        send_error(reply[1], e)
+                    end
+                elsif reply[0] == CMD_CALL
+                    begin
+                        receiver = decode_obj(reply[2])
+                        name = reply[3]
+                        args = reply[4].map {|e| decode_obj(e)}
+                        result = receiver.public_send(name, *args)
+                        send_reply(reply[1], result)
+                    rescue => e
+                        send_error(reply[1], e)
+                    end
+                elsif reply[0] == CMD_RETRY
+                    if reply[1] != message_id
+                        send_reply(reply[1], nil, false, CMD_REJECT)
+                    else
+                        result = @pending_replies.delete(message_id)
+                        if result.nil?
+                            raise RuntimeError.new("bad CMD_RETRY: #{reply}")
+                        elsif result.is_a?(JavaScriptError)
+                            raise result
+                        else
+                            return result
+                        end
+                    end
+                else
+                    # CMD_REJECT and other unknown commands
+                    raise RuntimeError.new("bad message: #{reply}")
                 end
-                send_command([CMD_REPLY, encoded])
+            end
+        end
+
+        def send_reply(message_id, value, erroneous = false, cmd_id=CMD_REPLY)
+            if erroneous
+                encoded = encode_eval_error(value)
             else
-                raise RuntimeError.new("bad reply: #{reply}")
+                encoded = encode_obj(value)
+            end
+            json_data = JSON.generate(send_with_piggyback([cmd_id, message_id, encoded]))
+            header = (Header_format % json_data.length)
+            if header.length != Header_size
+                raise "message length limit exceeded"
             end
+            json_data_with_header = header + json_data
+            @pipe.puts(json_data_with_header)
+        end
+
+        def send_error(message_id, e)
+            send_reply(message_id, e, true)
         end
     end
 
     @pipe = nil
-    @module_names = []
-    @options = ''
+    @configurations = {}
     @pipeToJsClass = PipeToJs
 
-    def self.config(module_names: [], options: '', browser: false)
-        @module_names = module_names
-        @options = options
+    #def self.config(module_names: [], options: '', browser: false, sync: false)
+    def self.config(**kw)
+        if kw.nil? || kw == {}
+            @configurations = {}
+        else
+            @configurations = @configurations.merge!(kw)
+        end
+        browser = @configurations[:browser]
         @pipeToJsClass = if browser then PipeToBrowser else PipeToJs end
         nil
     end
@@ -310,35 +451,65 @@ module Jscall
 
     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)
+            @pipe = @pipeToJsClass.new(@configurations)
+            @pipe.setup(@configurations)
         end
         @pipe
     end
+
+    module Interface
+        def exec(src)
+            __getpipe__.exec(src)
+        end
+
+        def async_exec(src)
+            __getpipe__.async_exec(src)
+        end
+
+        # name is a string object.
+        # Evaluating this string in JavaScript results in a JavaScript function.
+        #
+        def funcall(name, *args)
+            __getpipe__.funcall(nil, name, args)
+        end
+
+        def async_funcall(name, *args)
+            __getpipe__.async_funcall(nil, name, args)
+        end
+
+        def dyn_import(name, var_name=nil)
+            funcall('Ruby.dyn_import', name, var_name)
+        end
+
+        def method_missing(name, *args)
+            funcall(name, *args)
+        end
+    end
+
+    extend Interface
+
+    module AsyncInterface
+        include Interface
+
+        alias exec async_exec
+        alias funcall async_funcall
+    end
+
+    def self.async
+        @async ||= Class.new do
+            def __getpipe__
+                Jscall.__getpipe__
+            end
+
+            include AsyncInterface
+        end.new
+    end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jscall
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Shigeru Chiba
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-05 00:00:00.000000000 Z
+date: 2022-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: webrick
@@ -35,6 +35,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- examples/pdf-js.rb
 - jscall.gemspec
 - lib/jscall.rb
 - lib/jscall/apple-touch-icon.png
@@ -43,6 +44,7 @@ files:
 - lib/jscall/favicon.ico
 - lib/jscall/jscall.html
 - lib/jscall/main.mjs
+- lib/jscall/synch.mjs
 - lib/jscall/version.rb
 homepage: https://github.com/csg-tokyo/jscall
 licenses:
@@ -50,7 +52,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/csg-tokyo/jscall
   source_code_uri: https://github.com/csg-tokyo/jscall
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -65,8 +67,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: a library for calling JavaScript functions
 test_files: []