nodo 1.6.1 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7c6ed5581192d2d679c8d41e72925c58d68aec32831b2a556fdb3630c4357b7
-  data.tar.gz: 3da48a3ca955dedead870d27dcd73d96d74f62b09b31f18e124e3b4e626bd920
+  metadata.gz: 95d8c9823753373c6be5ad0c493e7f14346950b611d4ca0d90c5a96bcabfa5e6
+  data.tar.gz: 3ad4b37694f4ef33cfadad03794ce7b4bf2a9fd42dc4e0abb319ec981e529b33
 SHA512:
-  metadata.gz: 96168d93c24f3543926536d047785f230a588bb5f555550507d33f555f98cbc606465be9195b9af01fe4301c6c52931ea4ba9fb97f262ab2bfbeba015a3d67a0
-  data.tar.gz: 0bcf160a3b8a539979372fcc2f4141f4a1d26889053fcfed93e510e19d2009f30c5b9b64d598c460df93447f63bf8589fb908b5601b9fcfeb2a9d5623dbd4033
+  metadata.gz: 0e0004a84541cb4edd4cc398250fe17ee5623aed13f1bbb76b31eee531867906cffd87c5e0f71b50c0c72fdae4f26e57d24f654fdd2623bee90b20c60f3ff0b4
+  data.tar.gz: 539b75f4a8283f4db872db614158403129651f4b0811d9e7f9ef5dfa1f506bedcf238fa0b93896fe776ae936bbc8eba9cbd44ea86fa8f80b87142e5d69cfe957

data/README.md

@@ -217,8 +217,63 @@ Nodo.debug = true
 before instantiating any worker instances. The debug mode will be active during
 the current process run.
 
+To print a debug message from JS code:
 
-### Clean your Rails root
+```js
+nodo.debug("Debug message");
+```
+
+### Evaluation
+
+While `Nodo` is mainly function-based, it is possible to evaluate JS code in the
+context of the defined object.
+
+```ruby
+foo = Foo.new.evaluate("3 + 5")
+=> 8
+```
+
+Evaluated code can access functions, required dependencies and constants:
+
+```ruby
+class Foo < Nodo::Core
+  const :BAR, 'bar'
+  require :uuid
+  function :hello, code: '() => "world"'
+end
+
+foo = Foo.new
+
+foo.evaluate('BAR')
+=> "bar"
+
+foo.evaluate('uuid.v4()')
+=> "f258bef3-0d6f-4566-ad39-d8dec973ef6b"
+
+foo.evaluate('hello()')
+=> "world"
+```
+
+Variables defined by evaluation are local to the current instance:
+
+```ruby
+one = Foo.new
+one.evaluate('a = 1')
+two = Foo.new
+two.evaluate('a = 2')
+one.evaluate('a') => 1
+two.evaluate('a') => 2
+```
+
+⚠️ Evaluation comes with the usual caveats:
+
+- Avoid modifying any of your predefined identifiers. Remember that in JS,
+  as in Ruby, constants are not necessarily constant.
+- Never evaluate any code which includes un-checked user data. The Node.js process
+  has full read/write access to your filesystem! 💥
+
+
+## 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
@@ -229,7 +284,7 @@ an initializer:
 Nodo.modules_root = Rails.root.join('vendor', 'node_modules')
 ```
 
-The rationale behind this is NPM modules being external vendor dependencies, which
+The rationale for 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`.

data/lib/nodo/constant.rb

@@ -7,7 +7,7 @@ module Nodo
     end
 
     def to_js
-      "const #{name} = #{value.to_json};\n"
+      "const #{name} =  __nodo_klass__.#{name} = #{value.to_json};\n"
     end
   end
 end

data/lib/nodo/core.rb

@@ -1,8 +1,11 @@
 module Nodo
   class Core
     SOCKET_NAME = 'nodo.sock'
-    DEFINE_METHOD = '__nodo_define_class__'
-    TIMEOUT = 5
+    DEFINE_METHOD = '__nodo_define_class__'.freeze
+    EVALUATE_METHOD = '__nodo_evaluate__'.freeze
+    GC_METHOD = '__nodo_gc__'.freeze
+    INTERNAL_METHODS = [DEFINE_METHOD, EVALUATE_METHOD, GC_METHOD].freeze
+    LAUNCH_TIMEOUT = 5
     ARRAY_CLASS_ATTRIBUTES = %i[dependencies constants scripts].freeze
     HASH_CLASS_ATTRIBUTES = %i[functions].freeze
     CLASS_ATTRIBUTES = (ARRAY_CLASS_ATTRIBUTES + HASH_CLASS_ATTRIBUTES).freeze
@@ -10,6 +13,7 @@ module Nodo
     @@node_pid = nil
     @@tmpdir = nil
     @@mutex = Mutex.new
+    @@exiting = nil
     
     class << self
       extend Forwardable
@@ -21,15 +25,11 @@ module Nodo
           subclass.send "#{attr}=", send(attr).dup
         end
       end
-
+      
       def instance
         @instance ||= new
       end
       
-      def class_function(*methods)
-        singleton_class.def_delegators(:instance, *methods)
-      end
-      
       def class_defined?
         !!class_defined
       end
@@ -42,6 +42,7 @@ module Nodo
         define_method "#{attr}=" do |value|
           instance_variable_set :"@#{attr}", value
         end
+        protected "#{attr}="
       end
       
       ARRAY_CLASS_ATTRIBUTES.each do |attr|
@@ -55,30 +56,6 @@ module Nodo
           instance_variable_get(:"@#{attr}") || instance_variable_set(:"@#{attr}", {})
         end
       end
-      
-      def require(*mods)
-        deps = mods.last.is_a?(Hash) ? mods.pop : {}
-        mods = mods.map { |m| [m, m] }.to_h
-        self.dependencies = dependencies + mods.merge(deps).map { |name, package| Dependency.new(name, package) }
-      end
-
-      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
-        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
-      
-      def const(name, value)
-        self.constants = constants + [Constant.new(name, value)]
-      end
-      
-      def script(code)
-        self.scripts = scripts + [Script.new(code)]
-      end
 
       def generate_core_code
         <<~JS
@@ -106,8 +83,7 @@ module Nodo
       def generate_class_code
         <<~JS
           (() => {
-            const __nodo_log = nodo.log;
-            const __nodo_klass__ = {};
+            const __nodo_klass__ = { nodo: global.nodo };
             #{dependencies.map(&:to_js).join}
             #{constants.map(&:to_js).join}
             #{functions.values.map(&:to_js).join}
@@ -117,14 +93,57 @@ module Nodo
         JS
       end
       
+      protected
+      
+      def finalize_context(context_id)
+        proc do
+          if not @@exiting and core = Nodo::Core.instance
+            core.send(:call_js_method, GC_METHOD, context_id)
+          end
+        end
+      end
+      
       private
       
+      def require(*mods)
+        deps = mods.last.is_a?(Hash) ? mods.pop : {}
+        mods = mods.map { |m| [m, m] }.to_h
+        self.dependencies = dependencies + mods.merge(deps).map { |name, package| Dependency.new(name, package) }
+      end
+
+      def function(name, _code = nil, timeout: Nodo.timeout, code: nil)
+        raise ArgumentError, "reserved method name #{name.inspect}" if reserved_method_name?(name)
+        code = (code ||= _code).strip
+        raise ArgumentError, 'function code is required' if '' == code
+        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
+      
+      def class_function(*methods)
+        singleton_class.def_delegators(:instance, *methods)
+      end
+
+      def const(name, value)
+        self.constants = constants + [Constant.new(name, value)]
+      end
+      
+      def script(code)
+        self.scripts = scripts + [Script.new(code)]
+      end
+      
       def nodo_js
         Pathname.new(__FILE__).dirname.join('nodo.js').to_s.to_json
       end
+      
+      def reserved_method_name?(name)
+        Nodo::Core.method_defined?(name, false) || Nodo::Core.private_method_defined?(name, false) || name.to_s == DEFINE_METHOD
+      end
     end
     
     def initialize
+      raise ClassError, :new if self.class == Nodo::Core
       @@mutex.synchronize do
         ensure_process_is_spawned
         wait_for_socket
@@ -132,6 +151,13 @@ module Nodo
       end
     end
     
+    def evaluate(code)
+      ensure_context_is_defined
+      call_js_method(EVALUATE_METHOD, code)
+    end
+    
+    private
+    
     def node_pid
       @@node_pid
     end
@@ -148,9 +174,15 @@ module Nodo
       self.class.clsid
     end
     
+    def context_defined?
+      @context_defined
+    end
+    
     def log_exception(e)
       return unless logger = Nodo.logger
-      logger.error "\n#{e.class} (#{e.message}):\n\n#{e.backtrace.join("\n")}"
+      message = "\n#{e.class} (#{e.message})"
+      message << ":\n\n#{e.backtrace.join("\n")}" if e.backtrace
+      logger.error message
     end
     
     def ensure_process_is_spawned
@@ -164,12 +196,22 @@ module Nodo
       self.class.class_defined = true
     end
     
+    def ensure_context_is_defined
+      return if context_defined?
+      @@mutex.synchronize do
+        call_js_method(EVALUATE_METHOD, '')
+        ObjectSpace.define_finalizer(self, self.class.send(:finalize_context, self.object_id))
+        @context_defined = true
+      end
+    end
+    
     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
+        @@exiting = true
         Process.kill(:SIGTERM, node_pid) rescue Errno::ECHILD
         Process.wait(node_pid) rescue Errno::ECHILD
         FileUtils.remove_entry(tmpdir) if File.directory?(tmpdir)
@@ -179,7 +221,7 @@ module Nodo
     def wait_for_socket
       start = Time.now
       socket = nil
-      while Time.now - start < TIMEOUT
+      while Time.now - start < LAUNCH_TIMEOUT
         begin
           break if socket = UNIXSocket.new(socket_path)
         rescue Errno::ENOENT, Errno::ECONNREFUSED, Errno::ENOTDIR
@@ -192,10 +234,16 @@ module Nodo
 
     def call_js_method(method, args)
       raise CallError, 'Node process not ready' unless node_pid
-      raise CallError, "Class #{clsid} not defined" unless self.class.class_defined? || method == DEFINE_METHOD
+      raise CallError, "Class #{clsid} not defined" unless self.class.class_defined? || INTERNAL_METHODS.include?(method)
       function = self.class.functions[method]
-      raise NameError, "undefined function `#{method}' for #{self.class}" unless function || method == DEFINE_METHOD
-      request = Net::HTTP::Post.new("/#{clsid}/#{method}", 'Content-Type': 'application/json')
+      raise NameError, "undefined function `#{method}' for #{self.class}" unless function || INTERNAL_METHODS.include?(method)
+      context_id = case method
+        when DEFINE_METHOD then 0
+        when GC_METHOD then args.first
+      else
+        object_id
+      end
+      request = Net::HTTP::Post.new("/#{clsid}/#{context_id}/#{method}", 'Content-Type': 'application/json')
       request.body = JSON.dump(args)
       client = Client.new("unix://#{socket_path}")
       client.read_timeout = function.timeout if function

data/lib/nodo/dependency.rb

@@ -8,7 +8,7 @@ module Nodo
   
     def to_js
       <<~JS
-        const #{name} = (() => {
+        const #{name} = __nodo_klass__.#{name} = (() => {
           try {
             return require(#{package.to_json});
           } catch(e) {

data/lib/nodo/errors.rb

@@ -2,6 +2,11 @@ module Nodo
   class Error < StandardError; end
   class TimeoutError < Error; end
   class CallError < Error; end
+  class ClassError < Error
+    def initialize(method = nil)
+      super("Cannot call method `#{method}' on Nodo::Core, use subclass instead")
+    end
+  end
   
   class JavaScriptError < Error
     attr_reader :attributes
@@ -37,7 +42,7 @@ module Nodo
     end
     
     def generate_message
-      message = "#{attributes['message'] || 'Unknown error'}"
+      message = "#{attributes['message'] || attributes['name'] || 'Unknown error'}"
       message << format_location(attributes['loc'])
     end
     
@@ -51,7 +56,7 @@ module Nodo
     private
     
     def generate_message
-      message = "#{attributes['message'] || 'Dependency error'}\n"
+      message = "#{attributes['message'] || attributes['name'] || '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

data/lib/nodo/nodo.js

@@ -1,5 +1,7 @@
 module.exports = (function() {
   const DEFINE_METHOD = '__nodo_define_class__';
+  const EVALUATE_METHOD = '__nodo_evaluate__';
+  const GC_METHOD = '__nodo_gc__';
   const DEBUG = process.env.NODO_DEBUG;
 
   const vm = require('vm');
@@ -10,6 +12,7 @@ module.exports = (function() {
   
   let server, closing;
   const classes = {};
+  const contexts = {};
   
   function render_error(e) {
     let errInfo = {};
@@ -60,12 +63,17 @@ module.exports = (function() {
         }
         
         const url = req.url.substring(1);
-        const [class_name, method] = url.split('/');
-        let klass;
+        const [class_name, object_id, method] = url.split('/');
+        let klass, context;
         
         if (classes.hasOwnProperty(class_name)) {
           klass = classes[class_name];
-          if (!klass.hasOwnProperty(method)) {
+          if (EVALUATE_METHOD == method) {
+            if (!contexts.hasOwnProperty(object_id)) {
+              contexts[object_id] = vm.createContext({ require: require, ...klass });
+            }
+            context = contexts[object_id];
+          } else if (!klass.hasOwnProperty(method) && !GC_METHOD == method) {
             return respond_with_error(res, 404, `Method ${class_name}#${method} not found`);
           }
         } else if (DEFINE_METHOD != method) {
@@ -87,13 +95,21 @@ module.exports = (function() {
 
           try {
             if (DEFINE_METHOD == method) {
-              let new_class = vm.runInThisContext(input, class_name);
-              classes[class_name] = new_class;
+              classes[class_name] = vm.runInThisContext(input, class_name);
               respond_with_data(res, class_name, start);
+            } else if (EVALUATE_METHOD == method) {
+              Promise.resolve(vm.runInNewContext(input, context)).then((result) => {
+                respond_with_data(res, result, start);
+              }).catch((error) => {
+                respond_with_error(res, 500, error);
+              });
+            } else if (GC_METHOD == method) {
+              delete contexts[object_id];
+              respond_with_data(res, true, start);
             } else {
-              Promise.resolve(klass[method].apply(null, input)).then(function (result) {
+              Promise.resolve(klass[method].apply(null, input)).then((result) => {
                 respond_with_data(res, result, start);
-              }).catch(function(error) {
+              }).catch((error) => {
                 respond_with_error(res, 500, error);
               });
             }

data/lib/nodo/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nodo
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.6.2
 platform: ruby
 authors:
 - Matthias Grosser