execjs-fastnode 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 13794e0f836dc1cc7c7eb16a23391df25a556e99
+  data.tar.gz: 66e77b96d13a3bd2be1fd42e249f89e9c832aafb
+SHA512:
+  metadata.gz: 017acad49287c35d0cf4c573939ddbdad3af1e55413d041ec024a71d76b7444286fa9794515fa18b395934e7f75e033100b393b52d3ade132b2e9ec1c85f8b0e
+  data.tar.gz: af736abba04aeb15cae84a798f2556d9ebb052ae12c76329de34e2c3f65073c26bec5f4e9616a0420b8cb3cd109ffe6e73c0b8e2560f01bcdc15a26084d13f8f

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "execjs"]
+	path = execjs
+	url = https://github.com/rails/execjs

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+cache: bundler
+sudo: false
+before_script:
+  - node --version
+matrix:
+  include:
+    - rvm: 2.0.0
+    - rvm: 2.1
+    - rvm: 2.2
+    - rvm: 2.3.1
+    - rvm: jruby-19mode
+    - os: osx

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+
+gem 'therubyracer'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 John Hawthorn
+
+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,98 @@
+# ExecJS FastNode
+
+## What's this?
+
+An alternative implementation of ExecJS's Node.js integration. This aims to speed up sprockets compilation without needing to embed a javascript interpreter inside of ruby like [therubyracer](cowboyd/therubyracer).
+
+## How much faster is it?
+
+Much.
+
+```
+$ rake bench
+...
+                               user     system      total        real
+Node.js (V8) fast   0.000000   0.000000   0.000000 (  0.069723)
+therubyracer (V8)   0.020000   0.000000   0.020000 (  0.018010)
+Node.js (V8)        0.000000   0.010000   1.470000 (  1.487579)
+```
+
+Okay, so it's not as fast as `therubyracer`, but it's 20x faster than the standard ExecJS Node.js implementation.
+
+The benchmark measures the time to compile the javascript CoffeeScript compiler and then eval a small snippet 10 times.
+
+## How?
+
+The existing ExecJS runtime has to run a new Node.js process each time any JS is to be run. This means that if you are loading up the CoffeeScript compiler in order to compile some sprockets assets, it needs to reload the node executable and the entire coffeescript compiler for each file it is compiling.
+
+This implementation avoids this by starting an always running Node.js process connected by pipes to STDIN and STDOUT. The JS to execute is piped into the process and the results are recieved from its output. Isolation between different ExecJS contexts is achieved through Node's [vm.Script](https://nodejs.org/api/vm.html).
+
+| Old | New |
+| --- | --- |
+| ![](docs/example_old.png) | ![](docs/example_new.png) |
+
+## Is this production ready?
+
+Maybe? It needs more testing to be labeled as such. If you encounter any troubles please [file an issue](https://github.com/jhawthorn/execjs-fastnode/issues/new).
+
+Currently minimal effort is made to handle catastrophic errors: Node.js crashing, running out of memory, being killed. All of which result in `Errno::EPIPE: Broken pipe` for future ExecJS calls.
+
+It's probably fine for development.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'execjs-fastnode'
+```
+
+And then `bundle install`. You know the drill.
+
+You can verify that this runtime is being autodetected and used by checking `ExecJS.runtime` in a console.
+
+You can force a certain runtime to be used using `EXECJS_RUNTIME=FastNode`
+
+```
+$ EXECJS_RUNTIME=FastNode bin/console
+> ExecJS.runtime
+=> #<ExecJS::FastNode::ExternalPipedRuntime:0x005599c0d38740 @name="Node.js (V8) fast"...
+
+$ EXECJS_RUNTIME=Node bin/console
+> ExecJS.runtime
+=> #<ExecJS::ExternalRuntime:0x00559c440347c0 @name="Node.js (V8)" ...
+```
+
+## Why not upstream this to execjs?
+
+I'd like to, but it will take time. The goal of this endeavour is to give users a fast ExecJS runtime without needing any additional dependencies, just a Node.js installation. However most users don't (and shouldn't have to) think about ExecJS and need it to Just Work. This is a pretty significant change and it probably won't "Just Work" right now, and more time is needed to tell if it can.
+
+I have sent a pull request upstream to [use vm.runInContext](https://github.com/rails/execjs/pull/55), which would be the first step to merging this upstream.
+
+## Why not just use therubyracer?
+
+Maybe you should, if you need the speed.
+
+Heroku [recommends againts it](https://devcenter.heroku.com/articles/rails-asset-pipeline#therubyracer) as do various stack overflow answers with vague mentions of high memory usage.
+I haven't seen any benchmarks or bug reports that demonstrate this, so I consider these claims somewhat suspect.
+
+[mini_racer](https://github.com/discourse/mini_racer) is another option.
+
+The ExecJS Node runtime has its benefits as well. It should works on jRuby and other non-MRI runtimes.
+If this were merged upstream it would give developers fast javascript execution without needing an extra gem or configuration, just a working `node` somewhere in `$PATH`.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jhawthorn/execjs-fastnode.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :bench do
+  sh 'ruby -Ilib -r./test/shim test/bench_execjs.rb'
+end
+
+task :test do
+  ENV["EXECJS_RUNTIME"] = 'FastNode'
+end
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/shim.rb', 'test/**/*_test.rb', 'test/test_execjs.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "execjs/fastnode"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/docs/example_new.mscgen

@@ -0,0 +1,21 @@
+msc {
+  hscale = "1";
+
+  ruby,node;
+
+  node=>node [ label = "start" ] ;
+  ruby=>ruby [ label = "c = ExecJS.compile(...)" ];
+  ruby->node [ label = "CoffeeScript source code" ] ;
+  node=>node [ label = "Evaluate CoffeeScript source" ] ;
+||| ;
+  ruby=>ruby [ label = "c.call('CoffeeScript', 'compile', ...)" ];
+  ruby->node [ label = "CoffeeScript.compile('(x) -> x * x')" ] ;
+  node=>node [ label = "CoffeeScript.compile(...)" ] ;
+  node->ruby [ label = "\"(function(x){ return x * x })\"" ] ;
+||| ;
+  ruby=>ruby [ label = "c.call('CoffeeScript', 'compile', ...)" ];
+  ruby->node [ label = "CoffeeScript.compile('(x) -> x * 2')" ] ;
+  node=>node [ label = "CoffeeScript.compile(...)" ] ;
+  node->ruby [ label = "\"(function(x){ return x * 2 })\"" ] ;
+}
+

data/docs/example_old.mscgen

@@ -0,0 +1,25 @@
+msc {
+  hscale = "1";
+
+  ruby,node;
+
+  ruby=>ruby [ label = "c = ExecJS.compile(...)" ];
+  ruby=>ruby [ label = "c.call('CoffeeScript', 'compile', ...)" ];
+  node=>node [ label = "start" ] ;
+  ruby->node [ label = "CoffeeScript source code" ] ;
+  ruby->node [ label = "CoffeeScript.compile('(x) -> x * x')" ] ;
+  node=>node [ label = "Evaluate CoffeeScript source" ] ;
+  node=>node [ label = "CoffeeScript.compile(...)" ] ;
+  node->ruby [ label = "\"(function(x){ return x * x })\"" ] ;
+  node=>node [ label = "exit" ] ;
+||| ;
+  ruby=>ruby [ label = "c.call('CoffeeScript', 'compile', ...)" ];
+  node=>node [ label = "start" ] ;
+  ruby->node [ label = "CoffeeScript source code" ] ;
+  ruby->node [ label = "CoffeeScript.compile('(x) -> x * 2')" ] ;
+  node=>node [ label = "Evaluate CoffeeScript source" ] ;
+  node=>node [ label = "CoffeeScript.compile(...)" ] ;
+  node->ruby [ label = "\"(function(x){ return x * 2 })\"" ] ;
+  node=>node [ label = "exit" ] ;
+}
+

data/execjs-fastnode.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'execjs/fastnode/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "execjs-fastnode"
+  spec.version       = ExecJS::FastNode::VERSION
+  spec.authors       = ["John Hawthorn"]
+  spec.email         = ["john.hawthorn@gmail.com"]
+
+  spec.summary       = %q{A faster implementation of ExecJS's node runtime}
+  spec.description   = %q{An ExecJS node runtime which uses pipes to avoid repeated startup costs}
+  spec.homepage      = "https://github.com/jhawthorn/execjs-fastnode"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "execjs", "~> 2.0"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/lib/execjs/fastnode.rb

@@ -0,0 +1,8 @@
+require "execjs/fastnode/version"
+
+# Insert our new runtime into the list
+require "execjs/fastnode/runtimes"
+
+# Re-detect runtime
+require 'execjs'
+ExecJS.runtime = ExecJS::Runtimes.autodetect

data/lib/execjs/fastnode/command.rb

@@ -0,0 +1,47 @@
+module ExecJS
+  module FastNode
+    class Command
+      def initialize(command)
+        @command = command
+      end
+
+      def to_cmd
+        which
+      end
+
+      private
+
+      def locate_executable(command)
+        commands = Array(command)
+        if ExecJS.windows? && File.extname(command) == ""
+          ENV['PATHEXT'].split(File::PATH_SEPARATOR).each { |p|
+            commands << (command + p)
+          }
+        end
+
+        commands.find { |cmd|
+          if File.executable? cmd
+            cmd
+          else
+            path = ENV['PATH'].split(File::PATH_SEPARATOR).find { |p|
+              full_path = File.join(p, cmd)
+              File.executable?(full_path) && File.file?(full_path)
+            }
+            path && File.expand_path(cmd, path)
+          end
+        }
+      end
+
+      def which
+        Array(@command).find do |name|
+          name, args = name.split(/\s+/, 2)
+          path = locate_executable(name)
+
+          next unless path
+
+          args ? "#{path} #{args}" : path
+        end
+      end
+    end
+  end
+end

data/lib/execjs/fastnode/external_piped_runtime.rb

@@ -0,0 +1,155 @@
+require "tmpdir"
+require 'json'
+require "open3"
+require "thread"
+require "execjs/runtime"
+require "execjs/fastnode/command"
+
+module ExecJS
+  module FastNode
+    class ExternalPipedRuntime < ExecJS::Runtime
+      class VM
+        attr_reader :stdin, :stdout
+
+        def initialize(options)
+          @mutex = Mutex.new
+          @stdin = @stdout = @wait_thr = nil
+          @options = options
+        end
+
+        def started?
+          !!@stdin
+        end
+
+        def self.finalize(stdin)
+          proc { stdin.puts('{"cmd": "exit", "arguments": [0]}') }
+        end
+
+        def exec(context, source)
+          command("exec", {context: context, source: source})
+        end
+
+        def delete_context(context)
+          command("deleteContext", context)
+        end
+
+        def start
+          return if started?
+          @mutex.synchronize do
+            # will double check started? with the lock held
+            start_without_synchronization
+          end
+        end
+
+        private
+
+        def start_without_synchronization
+          return if started?
+          @stdin, @stdout, @wait_thr = Open3.popen2(@options[:binary], @options[:runner_path])
+          ObjectSpace.define_finalizer(self, self.class.finalize(@stdin))
+        end
+
+        def command(cmd, *arguments)
+          start
+          @mutex.synchronize do
+            @stdin.puts(::JSON.generate({cmd: cmd, args: arguments}))
+            result = ::JSON.parse(@stdout.gets, create_additions: false)
+          end
+        end
+      end
+
+      class Context < Runtime::Context
+        def initialize(runtime, source = "", options = {})
+          @runtime = runtime
+          @uuid = SecureRandom.uuid
+
+          ObjectSpace.define_finalizer(self, self.class.finalize(@runtime, @uuid))
+
+          source = encode(source)
+
+          raw_exec(source)
+        end
+
+        def self.finalize(runtime, uuid)
+          proc { runtime.vm.delete_context(uuid) }
+        end
+
+        def eval(source, options = {})
+          if /\S/ =~ source
+            raw_exec("(#{source})")
+          end
+        end
+
+        def exec(source, options = {})
+          raw_exec("(function(){#{source}})()")
+        end
+
+        def raw_exec(source, options = {})
+          source = encode(source)
+
+          result = @runtime.vm.exec(@uuid, source)
+          extract_result(result)
+        end
+
+        def call(identifier, *args)
+          eval "#{identifier}.apply(this, #{::JSON.generate(args)})"
+        end
+
+        protected
+
+        def extract_result(output)
+          status, value, stack = output
+          if status == "ok"
+            value
+          else
+            stack ||= ""
+            stack = stack.split("\n").map do |line|
+              line.sub(" at ", "").strip
+            end
+            stack.reject! { |line| ["eval code", "eval@[native code]"].include?(line) }
+            stack.shift unless stack[0].to_s.include?("(execjs)")
+            error_class = value =~ /SyntaxError:/ ? RuntimeError : ProgramError
+            error = error_class.new(value)
+            error.set_backtrace(stack + caller)
+            raise error
+          end
+        end
+      end
+
+      attr_reader :name, :vm
+
+      def initialize(options)
+        @name        = options[:name]
+        @command     = Command.new(options[:command])
+        @runner_path = options[:runner_path]
+        @encoding    = options[:encoding]
+        @deprecated  = !!options[:deprecated]
+        @binary      = nil
+
+        @popen_options = {}
+        @popen_options[:external_encoding] = @encoding if @encoding
+        @popen_options[:internal_encoding] = ::Encoding.default_internal || 'UTF-8'
+      end
+
+      def vm
+        @vm ||= VM.new(
+          binary: @binary,
+          runner_path: @runner_path
+        )
+      end
+
+      def available?
+        binary ? true : false
+      end
+
+      def deprecated?
+        @deprecated
+      end
+
+      private
+      def binary
+        @binary ||= @command.to_cmd
+      end
+    end
+  end
+end

data/lib/execjs/fastnode/node_piped_runner.js

@@ -0,0 +1,72 @@
+(function(){
+  var stdin = process.stdin
+  var stdout = process.stdout
+  var buf = ""
+
+  stdin.setEncoding('utf8')
+
+  var vm = require('vm');
+  var contexts = {};
+
+  function getContext(uuid) {
+    return contexts[uuid] || (contexts[uuid] = vm.createContext())
+  }
+
+  var commands = {
+    deleteContext: function(uuid) {
+      delete contexts[uuid];
+      return 1;
+    },
+    exit: function(code) {
+      process.exit(code)
+    },
+    exec: function execJS(input) {
+      var context = getContext(input.context);
+      var source = input.source;
+      try {
+        var program = function(){
+          return vm.runInContext(source, context, "(execjs)");
+        }
+        result = program();
+        if (typeof result == 'undefined' && result !== null) {
+          return ['ok'];
+        } else {
+          try {
+            return ['ok', result];
+          } catch (err) {
+            return ['err', '' + err, err.stack];
+          }
+        }
+      } catch (err) {
+        return ['err', '' + err, err.stack];
+      }
+    }
+  }
+
+  function processLine(line){
+    var input = JSON.parse(line)
+    var result = commands[input.cmd].apply(null, input.args)
+
+    var outputJSON = JSON.stringify(result)
+    stdout.write(outputJSON)
+    stdout.write('\n')
+  }
+
+  function processBuffer(){
+    if(buf.indexOf('\n') >= 0){
+      var lines = buf.split('\n')
+      for(var i = 0; i < lines.length - 1; i++) {
+        processLine(lines[i]);
+      }
+      buf = lines[lines.length - 1]
+    }
+  }
+
+  process.stdin.on('readable', function(){
+    var chunk = process.stdin.read();
+    if (chunk !== null) {
+      buf += chunk
+      processBuffer()
+    }
+  });
+})();

data/lib/execjs/fastnode/runtimes.rb

@@ -0,0 +1,18 @@
+require "execjs/fastnode/version"
+require "execjs/fastnode/external_piped_runtime"
+require "execjs/runtimes"
+
+module ExecJS
+  module Runtimes
+    # re-opening the runtimes class
+    FastNode = FastNode::ExternalPipedRuntime.new(
+      name:        "Node.js (V8) fast",
+      command:     ["nodejs", "node"],
+      runner_path: File.expand_path('../../fastnode/node_piped_runner.js', __FILE__),
+      encoding:    'UTF-8'
+    )
+
+    # Place FastNode runtime first
+    runtimes.unshift(FastNode)
+  end
+end

data/lib/execjs/fastnode/version.rb

@@ -0,0 +1,5 @@
+module ExecJS
+  module FastNode
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: execjs-fastnode
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- John Hawthorn
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-10-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: execjs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: An ExecJS node runtime which uses pipes to avoid repeated startup costs
+email:
+- john.hawthorn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitmodules"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- docs/example_new.mscgen
+- docs/example_new.png
+- docs/example_old.mscgen
+- docs/example_old.png
+- execjs-fastnode.gemspec
+- lib/execjs/fastnode.rb
+- lib/execjs/fastnode/command.rb
+- lib/execjs/fastnode/external_piped_runtime.rb
+- lib/execjs/fastnode/node_piped_runner.js
+- lib/execjs/fastnode/runtimes.rb
+- lib/execjs/fastnode/version.rb
+homepage: https://github.com/jhawthorn/execjs-fastnode
+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: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A faster implementation of ExecJS's node runtime
+test_files: []