ruby-await-nodejs 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b011818d77969f2e0efdfdf27dee659cfa4d7d896f34181178c260135053ac81
+  data.tar.gz: 32aa42178b25ef2d007d36bc1521bbfa9c3ae889fbb35391df9c7e4ca09fde35
+SHA512:
+  metadata.gz: 3f5ae612ab8609130e3733c2bcfe66926f36daaaa1f023578f487d84b11a078f45681190e5b9431299b133e8a9ae2cd04f07cc54f34f42945c95e9a81c11f8c6
+  data.tar.gz: 2af21e88750990aaaa2aad0b4c85325e3aadb4253dbf54a41da3d97eae94517f2dc5c7175eb0d848e2dce0905abb4031b044ac69537cd97890b7221e019f50d2

data/.circleci/config.yml

@@ -0,0 +1,17 @@
+version: 2
+template:
+  docker: &docker
+    - image: cimg/ruby:2.6.5-node
+jobs:
+  test:
+    docker: *docker
+    steps:
+      - checkout
+      - run: gem install bundler:1.16.1
+      - run: bundle
+      - run: bundle exec rspec spec/
+workflows:
+  version: 2
+  test:
+    jobs:
+      - test

data/.gitignore

@@ -0,0 +1,2 @@
+tags
+.byebug_history

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+
+ruby ">= 2.6.5"
+
+# Specify your gem's dependencies in mavenlink-js.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    ruby-await-nodejs (0.0.4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (11.1.3)
+    diff-lcs (1.3)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.2)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug (~> 11.1.3)
+  rspec
+  ruby-await-nodejs!
+
+RUBY VERSION
+   ruby 3.1.2p20
+
+BUNDLED WITH
+   1.16.1

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Mavenlink, Inc.
+
+MIT License
+
+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,91 @@
+# Introduction
+
+This was inspired by https://github.com/mavenlink/alaska
+Unfortunately, alaska was designed to run every new script in a new
+sandbox, thus things like require won't work. So we don't have access to
+all the power offered by nodejs
+
+Out of our need to call javascript in a rapid fashion from javascript
+with minimal setup, we decided to rewrite alaska into ruby-await-node
+with the goal of efficiently execute sophisticated javascript code from
+ruby.
+
+The key to the performance is to launch a nodejs webserver, then use
+such webserver to dangerously eval any given javascript part.
+
+It's risky, we know. But with great power come great responsibility. You
+should be using this if you want to leverage the expertise of javascript
+where ruby fall short
+
+# TODO For ruby-await-node
+
+- [x] Execute any javascript from ruby
+- [x] Pass all test
+- [x] Execute await/async method
+
+# Getting Started
+
+```ruby
+gem 'ruby-await-node'
+```
+
+Or if you want to run the latest version
+
+```ruby
+gem 'ruby-await-node', :git => 'git@github.com:remitano/ruby-await-node.git'
+```
+
+Then to invoke some javascript
+
+```ruby
+runtime = RubyAwaitNode::Runtime.new(debug: true)
+context = RubyAwaitNode::Context.new(runtime)
+entry_path = File.expand_path("entry.js", __dir__)
+context.eval("global.actor = require(#{entry_path.to_json})")
+result = context.eval("actor.method()")
+```
+
+Your entry.js may look like this:
+```javascript
+const moment = require("moment")
+module.exports = {
+  method: function() {
+    return something;
+  },
+
+  asyncMethod: async function() {
+    await operation;
+    return something;
+  }
+}
+```
+
+Under the hood ruby-await-node will automatically wait for async method
+to complete
+
+## Examples
+
+### Load a javascript file
+```
+context.load(File.expand_path("entry.js", __dir__))
+```
+
+*Warning*: always pass the absolute path
+### Simple execution
+```
+context.eval("1.0 + 2.0")
+context.eval("global.a = 1.0")
+```
+
+### Calling function with arguments
+```
+context.call("(function(b) { return global.a * b })", 5)
+```
+
+This will be equivalent to execute this in nodejs
+```
+(function(b) { return a * b }).apply(this, [5])
+```
+
+### Other examples
+Look into spec/ for other potential examples

data/lib/ruby-await-nodejs/context.rb

@@ -0,0 +1,83 @@
+require 'net/http'
+require 'socket'
+require 'tempfile'
+require 'json'
+require_relative "exception"
+
+module RubyAwaitNodejs
+  class Context
+    # runtime is an instance of RubyAwaitNodejs
+    # src is the js code to be eval()'d in the nodejs context
+    def initialize(runtime, src = "", options = {})
+      @runtime = runtime
+      @execution_timeout = options[:execution_timeout] || 60 # seconds
+
+      # compile context source, in most cases
+      # this is something like the CoffeeScript compiler
+      # or the SASS compiler
+      eval(src)
+    end
+
+    def eval(src)
+      if /\S/ =~ src #IMPORTANT! /\S/ =~ "()" => 0
+        exec(src)
+      end
+    end
+
+    def load(path)
+      exec("require(#{path.to_json})")
+    end
+
+    def exec(src)
+      return "" unless src.length > 0
+
+      src = src.encode('UTF-8', :undef => :replace, :replace => '')
+      src = compile_source(src)
+
+      # src is either an empty object
+      # OR a valid JSON string in the form
+      #   ['ok', 'result-of-coffeescript-or-sass-compiler']
+      # OR if an error occured
+      #   ['err', 'some sort of error to be presented to the developer as a sprockets error']
+      #
+      status, value = src.empty? ? [] : ::JSON.parse(src, create_additions: false)
+      if status == "ok"
+        value
+      elsif value =~ /SyntaxError:/
+        raise RuntimeError, value
+      else
+        raise ProgramError, value
+      end
+    end
+
+    def call(identifier, *args)
+      eval "#{identifier}.apply(this, #{::JSON.generate(args)})"
+    end
+
+    private
+
+    def compile_source(contents)
+      sock = Net::BufferedIO.new(
+        @runtime.provision_socket,
+        read_timeout: @execution_timeout,
+        write_timeout: @execution_timeout,
+        continue_timeout: @execution_timeout
+      )
+      request = Net::HTTP::Post.new("/")
+      request['Connection'] = 'close'
+      request['Content-Type'] = 'application/x-www-form-urlencoded'
+      # This Host header to make sure NodeJS does not throw ClientError, since change from version 23.x with new HTTP parser
+      request['Host'] = 'localhost'
+      request.body = contents
+      request.exec(sock, "1.1", "/")
+
+      begin
+        response = Net::HTTPResponse.read_new(sock)
+      end while response.kind_of?(Net::HTTPContinue)
+
+      response.reading_body(sock, request.response_body_permitted?) { }
+      sock.close
+      response.body
+    end
+  end
+end

data/lib/ruby-await-nodejs/exception.rb

@@ -0,0 +1,4 @@
+module RubyAwaitNodejs
+  class RuntimeError < StandardError; end
+  class ProgramError < StandardError; end
+end

data/lib/ruby-await-nodejs/runtime.rb

@@ -0,0 +1,105 @@
+require 'tempfile'
+
+require_relative 'context'
+
+module RubyAwaitNodejs
+  class Runtime
+    attr_accessor :debug, :nodejs_cmd, :port, :pid, :semaphore
+
+    def initialize(opts = {})
+      srand
+
+      @debug = opts[:debug]
+      @nodejs_cmd = "node"
+      @pid = nil
+      @semaphore = Mutex.new
+    end
+
+    def name
+      "RubyAwaitNodejs"
+    end
+
+    def available?
+      ENV["PATH"].split(":").detect do |path|
+        %w{
+          nodejs
+          node
+        }.detect do |node|
+          File.exist?(File.join(path, node)) || File.symlink?(File.join(path, node))
+        end
+      end
+    end
+
+    def deprecated?
+      false
+    end
+
+    def context_class
+      RubyAwaitNodejs::Context
+    end
+
+    #NOTE: this should be thread-safe
+    def provision_socket
+      ensure_startup unless @pid
+
+      wait_socket = nil
+      checks = 0
+      max_retries = 12
+
+      while checks < max_retries
+        begin
+          checks += 1
+          wait_socket = UNIXSocket.new(@port)
+          break
+        rescue Errno::ENOENT, Errno::ECONNREFUSED, Errno::ENOTDIR
+          wait_socket = nil
+          sleep 0.5
+        end
+      end
+
+      if checks >= max_retries
+        ensure_shutdown
+        raise RuntimeError, "unable to connect to ruby-await-nodejs.js server"
+      end
+
+      wait_socket
+    end
+
+    private
+
+    def ensure_startup
+      @semaphore.synchronize {
+        return if @pid
+
+        @port = begin
+          tmpfile = Tempfile.new("ruby-await-nodejs")
+          path = tmpfile.path
+          tmpfile.close
+          tmpfile.unlink
+          path
+        end
+
+        ruby_await_nodejs_js_path = File.join(File.dirname(File.expand_path(__FILE__)), '../../ruby-await-nodejs.js')
+        command_options = [ruby_await_nodejs_js_path, "--debug #{!!@debug}"] # --other --command-line --options --go --here
+
+        @initialize_pid = Process.pid
+        @pid = Process.spawn({"PORT" => @port.to_s}, @nodejs_cmd, *command_options, {:err => :out})
+
+        at_exit do
+          ensure_shutdown
+        end
+      }
+    end
+
+    def ensure_shutdown
+      return unless @pid
+      return unless Process.pid == @initialize_pid
+
+      Process.kill("TERM", @pid) rescue Errno::ECHILD
+      Process.wait(@pid) rescue Errno::ECHILD
+
+      @port = nil
+      @pid = nil
+    end
+  end
+end

data/lib/ruby-await-nodejs/version.rb

@@ -0,0 +1,3 @@
+module RubyAwaitNodejs
+  VERSION = "0.0.4"
+end

data/lib/ruby-await-nodejs.rb

@@ -0,0 +1,2 @@
+require 'ruby-await-nodejs/version'
+require 'ruby-await-nodejs/runtime'

data/ruby-await-nodejs.gemspec

@@ -0,0 +1,18 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby-await-nodejs/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'ruby-await-nodejs'
+  s.version     = RubyAwaitNodejs::VERSION
+  s.summary     = "Efficiently execute js from ruby by keeping a long run nodejs process"
+  s.description = "Efficiently execute js from ruby by keeping a long run nodejs process"
+  s.authors     = ["Phuong Nguyen", "Jon Bardin", "Stephen Grider", "Ville Lautanala", "Giovanni Bonetti"]
+  s.email       = 'phuongnd08@gmail.com'
+  s.files       = `git ls-files -z`.split("\x0")
+  s.homepage    = "https://github.com/remitano/ruby-await-nodejs"
+  s.license     = 'MIT'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'byebug', '~> 11.1.3'
+end

data/ruby-await-nodejs.js

@@ -0,0 +1,69 @@
+const http = require("http");
+
+const debugOpt = "--debug true";
+let debug = false;
+
+process.argv.forEach((val, index, array) => {
+  if (debugOpt === val) {
+    debug = true;
+  }
+});
+
+const webPrint = (res, respBody) => {
+  res.writeHead(200, { Connection: "keep-alive" });
+  res.write(respBody);
+  res.end();
+};
+
+const webPrintResult = (res, result) => {
+  webPrint(res, JSON.stringify(["ok", result]));
+};
+
+const webPrintError = (res, error) => {
+  webPrint(res, JSON.stringify(["err", error.toString()]));
+};
+
+function isPromise(value) {
+  return Boolean(value && typeof value.then === "function");
+}
+
+const server = http.createServer((req, res) => {
+  let contents = "";
+
+  req.on("data", (dataIn) => {
+    contents += dataIn;
+  });
+
+  req.on("end", () => {
+    try {
+      const result = eval(contents);
+      if (typeof result == "undefined" && result !== null) {
+        webPrintResult(res, null);
+      } else if (isPromise(result)) {
+        result
+          .then((value) => {
+            webPrintResult(res, value);
+          })
+          .catch((err) => {
+            webPrintError(res, err);
+          });
+      } else {
+        try {
+          webPrintResult(res, result);
+        } catch (err) {
+          webPrintError(res, err);
+        }
+      }
+    } catch (err) {
+      webPrintError(res, err);
+    }
+  });
+});
+
+const port = process.env.PORT || 3001;
+server.listen(port);
+
+if (debug) {
+  console.log("Listening on port:", port);
+  console.error("RubyAwaitNode.js started.  Piping coffee to warmer climates.");
+}

data/spec/fork_test_harness.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require 'byebug'
+require 'ruby-await-nodejs'
+
+ruby_await_node_runtime  = RubyAwaitNodejs::Runtime.new(:debug => false)
+context = RubyAwaitNodejs::Context.new(ruby_await_node_runtime)
+context.eval("global.a = 2.0")
+
+fork_count = 4
+
+pids = (0...fork_count).map do |i|
+  fork do
+    sleep i * 0.1 # simulate different process exit at different time to expose premature shutdown of shared nodejs process
+    result = context.call("(function(b) { return (global.a * b); })", i)
+    exit result #use the exit code to communicate the calculation result
+  end
+end
+
+exit_statuses = pids.map { |pid| Process.wait2(pid) }
+
+results = []
+
+exit_statuses.each do |pid, status|
+  results << status.exitstatus
+end
+
+# http://www.wolframalpha.com/input/?i=3rd+trianglur+number
+sum = results.compact.inject(0) { |result, element| result + element }
+
+if (sum) == 12
+  exit 0
+else
+  exit 1
+end

data/spec/ruby_await_node_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe RubyAwaitNodejs do
+  def return_42
+    "(function() { var f = 42; return 42;})()"
+  end
+
+  def await_return_42
+    "(async function() { var f = 42; await new Promise(resolve => setTimeout(resolve, 1000)); return 42;})()"
+  end
+
+  def create_ruby_await_node_runtime
+    RubyAwaitNodejs::Runtime.new(:debug => false)
+  end
+
+  def create_ruby_await_node_context(timeout: nil)
+    RubyAwaitNodejs::Context.new(create_ruby_await_node_runtime, "", { execution_timeout: timeout })
+  end
+
+  context "simple javascript" do
+    it "returns desired value" do
+      js_result = create_ruby_await_node_context.eval(return_42)
+      expect(js_result).to eq 42
+    end
+  end
+
+  context "await javascript" do
+    it "return desired value" do
+      js_result = create_ruby_await_node_context.eval(await_return_42)
+      expect(js_result).to eq 42
+    end
+
+    it "will raise error if the execution_timeout is less than actual execution time" do
+      expect do
+        create_ruby_await_node_context(timeout: 0.05).eval(await_return_42)
+      end.to raise_error(Net::ReadTimeout)
+    end
+  end
+
+  describe "load an entry file" do
+    it "loads correctly" do
+      path = File.expand_path("sample_entry.js", __dir__)
+      context = create_ruby_await_node_context
+      context.load(path)
+      js_result = context.eval("global.entryName")
+      expect(js_result).to eq "sample"
+    end
+  end
+
+  it "raises an RubyAwaitNodejs::ProgramError on error" do
+    expect {
+      create_ruby_await_node_context.eval("(function() { throw new Error('foo\\nbar', 0, 'test.js'); })()")
+    }.to raise_error(RubyAwaitNodejs::ProgramError)
+  end
+
+  it "requires js to be in a self-executing function" do
+    js_result = -1
+
+    expect {
+      js_result = create_ruby_await_node_context.eval("return true;")
+    }.to raise_error(RubyAwaitNodejs::RuntimeError)
+
+    expect(js_result).to eq(-1)
+  end
+
+  it "safely allows subsequent #eval calls after runtime error" do
+    js_result = create_ruby_await_node_context.eval(return_42)
+    expect(js_result).to eq 42
+
+    expect {
+      js_result = create_ruby_await_node_context.eval("return true;")
+    }.to raise_error(RubyAwaitNodejs::RuntimeError)
+
+    js_result = create_ruby_await_node_context.eval(return_42)
+    expect(js_result).to eq 42
+  end
+
+  it "should be thread safe when sharing context between threads" do
+    thread_count = 128
+    threads = []
+    semaphore = Mutex.new
+    results = []
+
+    context = create_ruby_await_node_context
+    context.eval("global.a = 1.0;")
+
+    thread_count.times { |index|
+      threads << Thread.new {
+        result = context.call("(function(b) { return (global.a * b); })", index)
+        semaphore.synchronize {
+          results << result
+        }
+      }
+    }
+
+    threads.each { |t| t.join }
+
+    sum = results.inject(0) { |result, element| result + element }
+
+    expect(sum).to eq(8128) # http://www.wolframalpha.com/input/?i=127th+trianglur+number
+  end
+
+  it "should be thread safe when creating new contexts in threads" do
+    thread_count = 128
+    threads = []
+    semaphore = Mutex.new
+    results = []
+
+    thread_count.times { |index|
+      threads << Thread.new {
+        context = create_ruby_await_node_context
+        context.eval("global.a = 2.0;") # this asserts that the context is shared
+        result = context.call("(function(b) { return (a * b); })", index)
+        semaphore.synchronize {
+          results << result
+        }
+      }
+    }
+
+    threads.each { |t| t.join }
+
+    sum = results.inject(0) { |result, element| result + element }
+
+    expect(sum).to eq(8128 * 2) # http://www.wolframalpha.com/input/?i=127th+trianglur+number
+  end
+
+  it "should not break if exception occurs in thread" do
+    context_a = create_ruby_await_node_context
+
+    g_err_a = nil
+    g_err_b = nil
+
+    make_program_error_thread = Thread.new {
+      begin
+        _b = context_a.call("(function() { asd() })")
+      rescue => err_a
+        g_err_a = err_a
+      end
+    }
+
+    context_b = create_ruby_await_node_context
+
+    begin
+      _c = context_b.call("(function() { asd) })")
+    rescue => err_b
+      g_err_b = err_b
+    end
+
+    make_program_error_thread.join
+
+    expect(g_err_a).to be_kind_of(RubyAwaitNodejs::ProgramError)
+    expect(g_err_b).to be_kind_of(RubyAwaitNodejs::RuntimeError)
+  end
+
+  it "should work when the context is shared between forked processes" do
+    fork_test_harness_pid = Process.spawn("bundle exec ruby spec/fork_test_harness.rb")
+    exit_pid, exit_status = Process.wait2(fork_test_harness_pid)
+
+    expect(exit_pid).to eq(fork_test_harness_pid)
+    expect(exit_status).to eq(0)
+  end
+end

data/spec/sample_entry.js

@@ -0,0 +1 @@
+global.entryName = "sample"

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'byebug'
+require 'ruby-await-nodejs'

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: ruby-await-nodejs
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Phuong Nguyen
+- Jon Bardin
+- Stephen Grider
+- Ville Lautanala
+- Giovanni Bonetti
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: 11.1.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 11.1.3
+description: Efficiently execute js from ruby by keeping a long run nodejs process
+email: phuongnd08@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/ruby-await-nodejs.rb
+- lib/ruby-await-nodejs/context.rb
+- lib/ruby-await-nodejs/exception.rb
+- lib/ruby-await-nodejs/runtime.rb
+- lib/ruby-await-nodejs/version.rb
+- ruby-await-nodejs.gemspec
+- ruby-await-nodejs.js
+- spec/fork_test_harness.rb
+- spec/ruby_await_node_spec.rb
+- spec/sample_entry.js
+- spec/spec_helper.rb
+homepage: https://github.com/remitano/ruby-await-nodejs
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Efficiently execute js from ruby by keeping a long run nodejs process
+test_files: []