Nōdo – Call Node.js from Ruby

Nōdo is a powerful library that enables seamless interaction between Ruby and JavaScript. It allows Ruby applications to invoke JavaScript functions executed in a dedicated Node.js process, providing a highly efficient way to leverage JavaScript's capabilities directly from Ruby code. The name "ノード" translates to "node" in Japanese, emphasizing the integration of these two powerful programming languages.

Key Features of Nōdo

• Long-Running Node Process: Nōdo dispatches JavaScript function calls to a single long-running Node process, significantly enhancing performance compared to traditional process evaluation methods.
• Namespaced Environment: JavaScript code is executed in a namespaced environment. This means initialized objects are retained across function calls, avoiding the need for repetitive initialization.
• IPC via UNIX Sockets: Communication between Ruby and Node.js occurs via UNIX sockets, which enhances performance and reduces latency.

How to Define and Use JavaScript Functions

In Nōdo, JavaScript functions can be defined directly within Ruby classes, appearing similar to Ruby methods. For example:

class Foo < Nodo::Core
  function :say_hi, <<~JS
    (name) => {
      return `Hello ${name}!`;
    }
  JS
end

foo = Foo.new
foo.say_hi('Nodo')
=> "Hello Nodo!"

Support for Async Functions

Nōdo natively supports async functions, facilitating asynchronous operations while maintaining a synchronous Ruby call structure.

class SyncFoo < Nodo::Core
  function :do_something, <<~JS
    async () => { return await asyncFunc(); }
  JS
end

Utilizing npm Modules

By installing npm modules in the node_modules directory, users can easily integrate third-party libraries into their Ruby projects. For instance:

class Bar < Nodo::Core
  require :uuid
  function :v4, <<~JS
    () => {
      return uuid.v4();
    }
  JS
end

bar = Bar.new
bar.v4
=> "b305f5c4-db9a-4504-b0c3-4e097a5ec8b9"

Advanced Features

• Dynamic ESM Imports: Load ES modules dynamically within your functions using the nodo.import() method.
• Deferred Function Definitions: Nōdo allows the deferral of function definitions until the first instance is created, enabling runtime evaluations of conditions.
• Execution Timeout Management: Set a global or per-function timeout, ensuring that long-running JavaScript operations do not block Ruby processes indefinitely.

Integration in Rails Applications

For Rails developers, Nōdo provides features to manage node dependencies effectively, keeping them organized within the application's vendor directory.

Debugging and Logging

Nōdo includes built-in support for detailed logging and debugging, allowing developers to track JavaScript errors and custom debug messages easily.

Evaluation Context

Evaluate JavaScript code within the Ruby context, enabling access to functions and constants defined in the Ruby classes.

foo.evaluate('3 + 5')
=> 8

Conclusion

Nōdo serves as a bridge between Ruby and JavaScript, empowering developers to harness the strengths of both languages seamlessly. It is a valuable tool for applications requiring interactive performance and efficient interlanguage operations.