nodo 1.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8f997b2c506f2cec9bfd235c68cb0db93fcb103fa7f9b40f03740ca27b59ffb4
+  data.tar.gz: 8a1ba6ae691ee2a992b2af5a127c43c70178cc403134db04a08f9597dd8588b3
+SHA512:
+  metadata.gz: 77c7a96627569da1b4093eb0fbfb6ab94c0c7dae4e425b019d52e06183f098daac57b88f68924fbe117afc1a0cf8be3aec143fd8e6935c839ebd573dde5afd70
+  data.tar.gz: 8057351d0968d8bc357af3926b805f82ce6e05949ee54efb9df40293ba4faf0ce8d337550318de0114c7f9dc2df05958ea481dc35aa2981a0d95501c9cb18c64

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Matthias Grosser
+
+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,128 @@
+[![Gem Version](https://badge.fury.io/rb/nodo.svg)](http://badge.fury.io/rb/nodo)
+
+# Nōdo – call Node.js from Ruby
+
+`Nodo` provides a Ruby environment to interact with JavaScript running inside a Node process.
+
+ノード means "node" in Japanese.
+
+## Why Nodo?
+
+Nodo will dispatch all JS function calls to a single long-running Node process.
+
+JavaScript code is run in a namespaced environment, where you can access your initialized
+JS objects during sequential function calls without having to re-initialize them.
+
+IPC is done via unix sockets, greatly improving performance over classic process/eval solutions.
+
+## Installation
+
+In your Gemfile:
+
+```ruby
+gem 'nodo'
+```
+
+### Node.js
+
+Nodo requires a working installation of Node.js.
+
+If the executable is located in your `PATH`, no configuration is required. Otherwise, the path to to binary can be set using:
+
+```ruby
+Nodo.binary = '/usr/local/bin/node'
+```
+
+## Usage
+
+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
+foo.say_hi('Nodo')
+=> "Hello Nodo!"
+```
+
+### Using npm modules
+
+Install your modules to `node_modules`:
+
+```shell
+$ yarn add uuid
+```
+
+Then `require` your dependencies:
+
+```ruby
+class Bar < Nodo::Core
+  require :uuid
+
+  function :v4, <<~JS
+    () => {
+      return uuid.v4();
+    }
+  JS
+end
+
+bar = Bar.new
+bar.v4 => "b305f5c4-db9a-4504-b0c3-4e097a5ec8b9"
+```
+
+### Aliasing requires
+
+```ruby
+class FooBar < Nodo::Core
+  require commonjs: '@rollup/plugin-commonjs'
+end
+```
+
+### Setting NODE_PATH
+
+By default, `./node_modules` is used as the `NODE_PATH`.
+
+To set a custom path:
+```ruby
+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')
+```
+
+### Defining JS constants
+
+```ruby
+class BarFoo < Nodo::Core
+  const :HELLO, "World"
+end
+```
+
+### Execute some custom JS during initialization
+
+```ruby
+class BarFoo < Nodo::Core
+
+  script <<~JS
+    // some custom JS
+    // to be executed during initialization
+  JS
+end
+```
+
+### Inheritance
+
+Subclasses will inherit functions, constants, dependencies and scripts from their superclasses, while only functions can be overwritten.

data/lib/nodo/client.rb

@@ -0,0 +1,38 @@
+require 'net/http'
+
+module Nodo
+  class Client < Net::HTTP
+    UNIX_REGEXP = /\Aunix:\/\//i
+
+    def initialize(address, port = nil)
+      super(address, port)
+      case address
+      when UNIX_REGEXP
+        @socket_type = 'unix'
+        @socket_path = address.sub(UNIX_REGEXP, '')
+        # Host header is required for HTTP/1.1
+        @address = 'localhost'
+        @port = 80
+      else
+        @socket_type = 'inet'
+      end
+    end
+
+    def connect
+      if @socket_type == 'unix'
+        connect_unix
+      else
+        super
+      end
+    end
+
+    def connect_unix
+      s = Timeout.timeout(@open_timeout) { UNIXSocket.open(@socket_path) }
+      @socket = Net::BufferedIO.new(s)
+      @socket.read_timeout = @read_timeout
+      @socket.continue_timeout = @continue_timeout
+      @socket.debug_output = @debug_output
+      on_connect
+    end
+  end
+end

data/lib/nodo/constant.rb

@@ -0,0 +1,13 @@
+module Nodo
+  class Constant
+    attr_reader :name, :value
+  
+    def initialize(name, value)
+      @name, @value = name, value
+    end
+
+    def to_js
+      "const #{name} = #{value.to_json};\n"
+    end
+  end
+end

data/lib/nodo/core.rb

@@ -0,0 +1,209 @@
+module Nodo
+  class Core
+    SOCKET_NAME = 'nodo.sock'
+    DEFINE_METHOD = '__nodo_define_class__'
+    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
+    
+    @@node_pid = nil
+    @@tmpdir = nil
+    @@mutex = Mutex.new
+    
+    class << self
+      
+      attr_accessor :class_defined
+      
+      def inherited(subclass)
+        CLASS_ATTRIBUTES.each do |attr|
+          subclass.send "#{attr}=", send(attr).dup
+        end
+      end
+
+      def instance
+        @instance ||= new
+      end
+      
+      def class_defined?
+        !!class_defined
+      end
+      
+      def clsid
+        name || "Class:0x#{object_id.to_s(0x10)}"
+      end
+      
+      CLASS_ATTRIBUTES.each do |attr|
+        define_method "#{attr}=" do |value|
+          instance_variable_set :"@#{attr}", value
+        end
+      end
+      
+      ARRAY_CLASS_ATTRIBUTES.each do |attr|
+        define_method "#{attr}" do
+          instance_variable_get(:"@#{attr}") || instance_variable_set(:"@#{attr}", [])
+        end
+      end
+      
+      HASH_CLASS_ATTRIBUTES.each do |attr|
+        define_method "#{attr}" do
+          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)
+        self.functions = functions.merge(name => Function.new(name, code, caller.first))
+        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
+          global.nodo = require(#{nodo_js});
+          
+          const socket = process.argv[1];
+          if (!socket) {
+            process.stderr.write('Socket path is required\\n');
+            process.exit(1);
+          }
+          
+          const shutdown = () => {
+            nodo.core.close(() => { process.exit(0) });
+          };
+
+          process.on('SIGINT', shutdown);
+          process.on('SIGTERM', shutdown);
+
+          nodo.core.run(socket);
+        JS
+      end
+
+      def generate_class_code
+        <<~JS
+          (() => {
+            const __nodo_log = nodo.log;
+            const __nodo_klass__ = {};
+            #{dependencies.map(&:to_js).join}
+            #{constants.map(&:to_js).join}
+            #{functions.values.map(&:to_js).join}
+            #{scripts.map(&:to_js).join}
+            return __nodo_klass__;
+          })()
+        JS
+      end
+
+      protected
+
+      def finalize(pid, tmpdir)
+        proc do
+          Process.kill(:SIGTERM, pid)
+          Process.wait(pid)
+          FileUtils.remove_entry(tmpdir) if File.directory?(tmpdir)
+        end
+      end
+      
+      private
+      
+      def nodo_js
+        Pathname.new(__FILE__).dirname.join('nodo.js').to_s.to_json
+      end
+    end
+    
+    def initialize
+      @@mutex.synchronize do
+        ensure_process_is_spawned
+        wait_for_socket
+        ensure_class_is_defined
+      end
+    end
+    
+    def node_pid
+      @@node_pid
+    end
+    
+    def tmpdir
+      @@tmpdir
+    end
+
+    def socket_path
+      tmpdir && tmpdir.join(SOCKET_NAME)
+    end
+    
+    def clsid
+      self.class.clsid
+    end
+    
+    def ensure_process_is_spawned
+      return if node_pid
+      spawn_process
+    end
+    
+    def ensure_class_is_defined
+      return if self.class.class_defined?
+      call_js_method(DEFINE_METHOD, self.class.generate_class_code)
+      self.class.class_defined = true
+#    rescue => e
+ #     raise Error, e.message
+    end
+
+    def spawn_process
+      @@tmpdir = Pathname.new(Dir.mktmpdir('nodo'))
+      env = Nodo.env.merge('NODE_PATH' => Nodo.modules_root.to_s)
+      @@node_pid = Process.spawn(env, Nodo.binary, '-e', self.class.generate_core_code, '--', socket_path.to_s)
+      ObjectSpace.define_finalizer(self, self.class.send(:finalize, node_pid, tmpdir))
+    end
+    
+    def wait_for_socket
+      start = Time.now
+      until socket_path.exist?
+        raise TimeoutError, "socket #{socket_path} not found" if Time.now - start > TIMEOUT
+        sleep(0.2)
+      end
+    end
+
+    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
+      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')
+      request.body = JSON.dump(args)
+      client = Client.new("unix://#{socket_path}")
+      response = client.request(request)
+      if response.is_a?(Net::HTTPOK)
+        parse_response(response)
+      else
+        handle_error(response, function)
+      end
+    rescue Errno::EPIPE, IOError
+      # TODO: restart or something? If this happens the process is completely broken
+      raise Error, 'Node process failed'
+    end
+    
+    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')
+      end
+      raise CallError, "Node returned #{response.code}"
+    end
+    
+    def parse_response(response)
+      JSON.parse(response.body.force_encoding('UTF-8'))
+    end
+    
+  end
+end

data/lib/nodo/dependency.rb

@@ -0,0 +1,13 @@
+module Nodo
+  class Dependency
+    attr_reader :name, :package
+    
+    def initialize(name, package)
+      @name, @package = name, package
+    end
+  
+    def to_js
+      "const #{name} = require(#{package.to_json});\n"
+    end
+  end
+end

data/lib/nodo/errors.rb

@@ -0,0 +1,49 @@
+module Nodo
+  class Error < StandardError; end
+  class TimeoutError < Error; end
+  class CallError < Error; end
+  
+  class JavaScriptError < Error
+    attr_reader :attributes
+    
+    def initialize(attributes = {}, function = nil)
+      @attributes = attributes || {}
+      if backtrace = generate_backtrace(attributes['stack'])
+        backtrace.unshift function.source_location if function && function.source_location
+        set_backtrace backtrace
+      end
+      @message = generate_message
+    end
+    
+    def to_s
+      @message
+    end
+    
+    private
+
+    # "filename:lineNo: in `method''' or “filename:lineNo.''
+     
+    def generate_backtrace(stack)
+      backtrace = []
+      if stack and lines = stack.split("\n")
+        lines.shift
+        lines.each do |line|
+          if match = line.match(/\A *at (?<call>.+) \((?<src>.*):(?<line>\d+):(?<column>\d+)\)/)
+            backtrace << "#{match[:src]}:#{match[:line]}:in `#{match[:call]}'"
+          end
+        end
+      end
+      backtrace unless backtrace.empty?
+    end
+    
+    def generate_message
+      message = "#{attributes['message'] || 'Unknown error'}"
+      if loc = attributes['loc']
+        message << loc.inject(' in') { |s, (key, value)| s << " #{key}: #{value}" }
+      end
+      message
+    end
+  end
+  
+  class DependencyError < JavaScriptError; end
+end

data/lib/nodo/function.rb

@@ -0,0 +1,13 @@
+module Nodo
+  class Function
+    attr_reader :name, :code, :source_location
+  
+    def initialize(name, code, source_location)
+      @name, @code, @source_location = name, code, source_location
+    end
+  
+    def to_js
+      "const #{name} = __nodo_klass__.#{name} = (#{code});\n"
+    end
+  end
+end

data/lib/nodo/railtie.rb

@@ -0,0 +1,8 @@
+require 'rails/railtie'
+require 'active_support'
+
+class Nodo::Railtie < Rails::Railtie
+  initializer 'nodo' do |app|
+    Nodo.modules_root = Rails.root.join('vendor', 'node_modules')
+  end
+end

data/lib/nodo/script.rb

@@ -0,0 +1,13 @@
+module Nodo
+  class Script
+    attr_reader :code
+    
+    def initialize(code)
+      @code = code
+    end
+  
+    def to_js
+      "#{code}\n"
+    end
+  end
+end

data/lib/nodo/version.rb

@@ -0,0 +1,3 @@
+module Nodo
+  VERSION = '1.5.0'
+end

data/lib/nodo.rb

@@ -0,0 +1,24 @@
+require 'pathname'
+require 'json'
+require 'fileutils'
+require 'tmpdir'
+
+module Nodo
+  class << self
+    attr_accessor :modules_root, :env, :binary
+  end
+  self.modules_root = './node_modules'
+  self.env = {}
+  self.binary = 'node'
+end
+
+require_relative 'nodo/version'
+require_relative 'nodo/errors'
+require_relative 'nodo/dependency'
+require_relative 'nodo/function'
+require_relative 'nodo/script'
+require_relative 'nodo/constant'
+require_relative 'nodo/client'
+require_relative 'nodo/core'
+
+require_relative 'nodo/railtie' if defined?(Rails)

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: nodo
+version: !ruby/object:Gem::Version
+  version: 1.5.0
+platform: ruby
+authors:
+- Matthias Grosser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-10-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fast Ruby bridge to run JavaScript inside a Node process
+email:
+- mtgrosser@gmx.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/nodo.rb
+- lib/nodo/client.rb
+- lib/nodo/constant.rb
+- lib/nodo/core.rb
+- lib/nodo/dependency.rb
+- lib/nodo/errors.rb
+- lib/nodo/function.rb
+- lib/nodo/railtie.rb
+- lib/nodo/script.rb
+- lib/nodo/version.rb
+homepage: https://github.com/mtgrosser/nodo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Call Node.js from Ruby
+test_files: []