nodo 1.5.4 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68a024656d2aaacddb3f52790316307d06acd432c0e5f43d149ad6c716888899
-  data.tar.gz: 07020ab3ca97f25f90e2e0f2b26ecdf43f78312a308852e6f5f0a50e6ad57d73
+  metadata.gz: c7c6ed5581192d2d679c8d41e72925c58d68aec32831b2a556fdb3630c4357b7
+  data.tar.gz: 3da48a3ca955dedead870d27dcd73d96d74f62b09b31f18e124e3b4e626bd920
 SHA512:
-  metadata.gz: 89c52ca6b172f94b4bc55730cad6d9934fe4c1fc914b0236665202ec26f5d98b77790336aed67af275fd2b4d5050dce4675b43d02639a9a5911d2836b651e6ae
-  data.tar.gz: 9a7fe1128ed3198d2ae4a936eda189d806f3a5e3221efb745d71b7b2a92dff546855e7f06a457648241860e1515ec0aae6ea8bc63703d64b0a9ba87a298174c5
+  metadata.gz: 96168d93c24f3543926536d047785f230a588bb5f555550507d33f555f98cbc606465be9195b9af01fe4301c6c52931ea4ba9fb97f262ab2bfbeba015a3d67a0
+  data.tar.gz: 0bcf160a3b8a539979372fcc2f4141f4a1d26889053fcfed93e510e19d2009f30c5b9b64d598c460df93447f63bf8589fb908b5601b9fcfeb2a9d5623dbd4033

data/README.md

@@ -1,4 +1,5 @@
-[![Gem Version](https://badge.fury.io/rb/nodo.svg)](http://badge.fury.io/rb/nodo)  [![build](https://github.com/mtgrosser/nodo/actions/workflows/build.yml/badge.svg)](https://github.com/mtgrosser/nodo/actions/workflows/build.yml)
+[![Gem Version](https://badge.fury.io/rb/nodo.svg)](http://badge.fury.io/rb/nodo)
+[![build](https://github.com/mtgrosser/nodo/actions/workflows/build.yml/badge.svg)](https://github.com/mtgrosser/nodo/actions/workflows/build.yml)
 
 # Nōdo – call Node.js from Ruby
 
@@ -39,13 +40,13 @@ In Nodo, you define JS functions as you would define Ruby methods:
 
 ```ruby
 class Foo < Nodo::Core
-  
+
   function :say_hi, <<~JS
     (name) => {
       return `Hello ${name}!`;
     }
   JS
-  
+
 end
 
 foo = Foo.new
@@ -90,6 +91,14 @@ class FooBar < Nodo::Core
 end
 ```
 
+### Alternate function definition syntax
+
+JS code can also be supplied using the `code:` keyword argument:
+
+```ruby
+function :hello, code: "() => 'world'"
+```
+
 ### Setting NODE_PATH
 
 By default, `./node_modules` is used as the `NODE_PATH`.
@@ -99,13 +108,7 @@ To set a custom path:
 Nodo.modules_root = 'path/to/node_modules'
 ```
 
-For Rails applications, it will be set to `vendor/node_modules`. 
-To use the Rails 6 default of putting `node_modules` to `RAILS_ROOT`:
-
-```ruby
-# config/initializers/nodo.rb
-Nodo.modules_root = Rails.root.join('node_modules')
-```
+Also see: [Clean your Rails root](#Clean-your-Rails-root)
 
 ### Defining JS constants
 
@@ -130,7 +133,8 @@ end
 
 ### Inheritance
 
-Subclasses will inherit functions, constants, dependencies and scripts from their superclasses, while only functions can be overwritten.
+Subclasses will inherit functions, constants, dependencies and scripts from
+their superclasses, while only functions can be overwritten.
 
 ```ruby
 class Foo < Nodo::Core
@@ -153,7 +157,8 @@ SubSubFoo.new.bar => "callingsubsubclass"
 ### Async functions
 
 `Nodo` supports calling `async` functions from Ruby. 
-The Ruby call will happen synchronously, i.e. it will block until the JS function resolves:
+The Ruby call will happen synchronously, i.e. it will block until the JS
+function resolves:
 
 ```ruby
 class SyncFoo < Nodo::Core
@@ -162,3 +167,72 @@ class SyncFoo < Nodo::Core
   JS
 end
 ```
+
+### Limiting function execution time
+
+The default timeout for a single JS function call is 60 seconds and can be
+set globally:
+
+```ruby
+Nodo.timeout = 5
+```
+
+If the execution of a single function call exceeds the timeout, `Nodo::TimeoutError`
+is raised.
+
+The timeout can also be set on a per-function basis:
+
+```ruby
+class Foo < Nodo::Core
+  function :sleep, timeout: 1, code: <<~'JS'
+    async (sec) => await new Promise(resolve => setTimeout(resolve, sec * 1000))
+  JS
+end
+
+Foo.new.sleep(2)
+=>  Nodo::TimeoutError raised
+```
+
+### Logging
+
+By default, JS errors will be logged to `STDOUT`.
+
+To set a custom logger:
+
+```ruby
+Nodo.logger = Logger.new('nodo.log')
+```
+
+In Rails applications, `Rails.logger` will automatically be set.
+
+
+### Debugging
+
+To get verbose debug output, set
+
+```ruby
+Nodo.debug = true
+```
+
+before instantiating any worker instances. The debug mode will be active during
+the current process run.
+
+
+### Clean your Rails root
+
+For Rails applications, Nodo enables you to move `node_modules`, `package.json` and
+`yarn.lock` into your application's `vendor` folder by setting the `NODE_PATH` in
+an initializer:
+
+```ruby
+# config/initializers/nodo.rb
+Nodo.modules_root = Rails.root.join('vendor', 'node_modules')
+```
+
+The rationale behind this is NPM modules being external vendor dependencies, which
+should not clutter the application root directory.
+
+With this new default, all `yarn` operations should be done after `cd`ing to `vendor`.
+
+This repo provides an [adapted version](https://github.com/mtgrosser/nodo/blob/master/install/yarn.rake)
+of the `yarn:install` rake task which will automatically take care of the vendored module location.

data/lib/nodo/core.rb

@@ -62,10 +62,13 @@ module Nodo
         self.dependencies = dependencies + mods.merge(deps).map { |name, package| Dependency.new(name, package) }
       end
 
-      def function(name, _code = nil, timeout: 60, code: nil)
+      def function(name, _code = nil, timeout: Nodo.timeout, code: nil)
+        raise ArgumentError, "reserved method name #{name.inspect}" if Nodo::Core.method_defined?(name) || name.to_s == DEFINE_METHOD
         code = (code ||= _code).strip
         raise ArgumentError, 'function code is required' if '' == code
-        self.functions = functions.merge(name => Function.new(name, _code || code, caller.first, timeout))
+        loc = caller_locations(1, 1)[0]
+        source_location = "#{loc.path}:#{loc.lineno}: in `#{name}'"
+        self.functions = functions.merge(name => Function.new(name, _code || code, source_location, timeout))
         define_method(name) { |*args| call_js_method(name, args) }
       end
       
@@ -93,7 +96,7 @@ module Nodo
             nodo.core.close(() => { process.exit(0) });
           };
 
-          process.on('SIGINT', shutdown);
+          // process.on('SIGINT', shutdown);
           process.on('SIGTERM', shutdown);
 
           nodo.core.run(socket);
@@ -145,6 +148,11 @@ module Nodo
       self.class.clsid
     end
     
+    def log_exception(e)
+      return unless logger = Nodo.logger
+      logger.error "\n#{e.class} (#{e.message}):\n\n#{e.backtrace.join("\n")}"
+    end
+    
     def ensure_process_is_spawned
       return if node_pid
       spawn_process
@@ -159,6 +167,7 @@ module Nodo
     def spawn_process
       @@tmpdir = Pathname.new(Dir.mktmpdir('nodo'))
       env = Nodo.env.merge('NODE_PATH' => Nodo.modules_root.to_s)
+      env['NODO_DEBUG'] = '1' if Nodo.debug
       @@node_pid = Process.spawn(env, Nodo.binary, '-e', self.class.generate_core_code, '--', socket_path.to_s, err: :out)
       at_exit do
         Process.kill(:SIGTERM, node_pid) rescue Errno::ECHILD
@@ -174,7 +183,7 @@ module Nodo
         begin
           break if socket = UNIXSocket.new(socket_path)
         rescue Errno::ENOENT, Errno::ECONNREFUSED, Errno::ENOTDIR
-          sleep 0.2
+          Kernel.sleep(0.2)
         end
       end
       socket.close if socket
@@ -206,9 +215,14 @@ module Nodo
     def handle_error(response, function)
       if response.body
         result = parse_response(response)
-        raise JavaScriptError.new(result['error'], function) if result.is_a?(Hash) && result.key?('error')
+        error = if result.is_a?(Hash) && result['error'].is_a?(Hash)
+          attrs = result['error']
+          (attrs['nodo_dependency'] ? DependencyError : JavaScriptError).new(attrs, function)
+        end
       end
-      raise CallError, "Node returned #{response.code}"
+      error ||= CallError.new("Node returned #{response.code}")
+      log_exception(error)
+      raise error
     end
     
     def parse_response(response)

data/lib/nodo/dependency.rb

@@ -7,7 +7,16 @@ module Nodo
     end
   
     def to_js
-      "const #{name} = require(#{package.to_json});\n"
+      <<~JS
+        const #{name} = (() => {
+          try {
+            return require(#{package.to_json});
+          } catch(e) {
+            e.nodo_dependency = #{package.to_json};
+            throw e;
+          }
+        })();
+      JS
     end
   end
 end

data/lib/nodo/errors.rb

@@ -38,12 +38,22 @@ module Nodo
     
     def generate_message
       message = "#{attributes['message'] || 'Unknown error'}"
-      if loc = attributes['loc']
-        message << loc.inject(' in') { |s, (key, value)| s << " #{key}: #{value}" }
-      end
-      message
+      message << format_location(attributes['loc'])
+    end
+    
+    def format_location(loc)
+      return '' unless loc
+      loc.inject(' in') { |s, (key, value)| s << " #{key}: #{value}" }
     end
   end
   
-  class DependencyError < JavaScriptError; end
+  class DependencyError < JavaScriptError
+    private
+    
+    def generate_message
+      message = "#{attributes['message'] || 'Dependency error'}\n"
+      message << "The specified dependency '#{attributes['nodo_dependency']}' could not be loaded. "
+      message << "Run 'yarn add #{attributes['nodo_dependency']}' to install it.\n"
+    end
+  end
 end

data/lib/nodo/nodo.js

@@ -1,5 +1,6 @@
 module.exports = (function() {
   const DEFINE_METHOD = '__nodo_define_class__';
+  const DEBUG = process.env.NODO_DEBUG;
 
   const vm = require('vm');
   const http = require('http');
@@ -24,7 +25,7 @@ module.exports = (function() {
   function respond_with_error(res, code, name) {
     res.statusCode = code;
     const rendered = render_error(name);
-    log(`Error ${code} ${rendered}`);
+    debug(`Error ${code} ${rendered}`);
     res.end(rendered, 'utf8');
   }
   
@@ -35,22 +36,24 @@ module.exports = (function() {
     if (start) {
       timing = ` in ${(performance.now() - start).toFixed(2)}ms`;
     }
-    log(`Completed 200 OK${timing}`);
+    debug(`Completed 200 OK${timing}\n`);
   }
 
-  function log(message) {
-    // fs.appendFileSync('log/nodo.log', `${message}\n`);
-    // console.log(`[Nodo] ${message}`);
+  function debug(message) {
+    if (DEBUG) {
+      // fs.appendFileSync('log/nodo.log', `${message}\n`);
+      console.log(`[Nodo] ${message}`);
+    }
   }
   
   const core = {
     run: (socket) => {
-      log('Starting up...');
+      debug('Starting up...');
       server = http.createServer((req, res) => {
         const start = performance.now();
         
         res.setHeader('Content-Type', 'application/json');
-        log(`${req.method} ${req.url}`);
+        debug(`${req.method} ${req.url}`);
 
         if (req.method !== 'POST' || !req.url.startsWith('/')) {
           return respond_with_error(res, 405, 'Method Not Allowed');
@@ -103,12 +106,12 @@ module.exports = (function() {
 
       //server.maxConnections = 64;
       server.listen(socket, () => {
-        log(`server ready, listening on ${socket} (max connections: ${server.maxConnections})`);
+        debug(`server ready, listening on ${socket} (max connections: ${server.maxConnections})`);
       });
     },
     
     close: (finalizer) => {
-      log("Shutting down");
+      debug("Shutting down");
       if (!closing) {
         closing = true;
         server.close(finalizer);
@@ -116,5 +119,5 @@ module.exports = (function() {
     }
   };
   
-  return { core: core, log: log };
+  return { core: core, debug: debug };
 })();

data/lib/nodo/railtie.rb

@@ -3,6 +3,7 @@ require 'active_support'
 
 class Nodo::Railtie < Rails::Railtie
   initializer 'nodo' do |app|
-    Nodo.modules_root = Rails.root.join('vendor', 'node_modules')
+    Nodo.env['NODE_ENV'] = Rails.env.to_s
+    Nodo.logger = Rails.logger
   end
 end

data/lib/nodo/version.rb

@@ -1,3 +1,3 @@
 module Nodo
-  VERSION = '1.5.4'
+  VERSION = '1.6.1'
 end

data/lib/nodo.rb

@@ -3,16 +3,20 @@ require 'json'
 require 'fileutils'
 require 'tmpdir'
 require 'tempfile'
+require 'logger'
 require 'socket'
 require 'forwardable'
 
 module Nodo
   class << self
-    attr_accessor :modules_root, :env, :binary
+    attr_accessor :modules_root, :env, :binary, :logger, :debug, :timeout
   end
   self.modules_root = './node_modules'
   self.env = {}
   self.binary = 'node'
+  self.logger = Logger.new(STDOUT)
+  self.debug  = false
+  self.timeout = 60
 end
 
 require_relative 'nodo/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nodo
 version: !ruby/object:Gem::Version
-  version: 1.5.4
+  version: 1.6.1
 platform: ruby
 authors:
 - Matthias Grosser
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-06 00:00:00.000000000 Z
+date: 2021-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler