runjs 0.1.0

data/test/javascript_error_test.rb

@@ -0,0 +1,150 @@
+require 'test_helper'
+
+describe 'syntax error' do
+
+  specify 'a JavaScript syntax error raises a CompileError' do
+    assert_raises(RunJS::CompileError) do
+      RunJS.run(']')
+    end
+  end
+
+  specify 'eval with syntax error raises a JavaScriptError' do
+    error = assert_raises(RunJS::JavaScriptError) do
+      RunJS.eval(']')
+    end
+    assert_equal 'SyntaxError', error['name']
+  end
+
+  specify 'throw SyntaxError raises a JavaScriptError' do
+    error = assert_raises(RunJS::JavaScriptError) do
+      RunJS.run('throw new SyntaxError();')
+    end
+    assert_equal 'SyntaxError', error[:name]
+  end
+
+end
+
+describe 'runtime error' do
+
+  describe 'raising a JavaScriptError' do
+
+    specify 'the JavaScript code throws an error' do
+      assert_raises(RunJS::JavaScriptError) do
+        RunJS.run('throw new Error();')
+      end
+    end
+
+    specify 'calling an undefined function' do
+      assert_raises(RunJS::JavaScriptError) do
+        RunJS.call('notAFunction')
+      end
+    end
+
+    specify 'JSON.stringify gets a cyclic structure' do
+      assert_raises(RunJS::JavaScriptError) do
+        RunJS.run('var cycle = {}; cycle.self = cycle; return cycle;')
+      end
+    end
+
+  end
+
+  specify 'the error message' do
+    error = RunJS.run('throw new Error("msg");') rescue $!
+    assert_equal 'Error: msg', error.message
+
+    error = RunJS.run('throw new Error();') rescue $!
+    assert_equal 'Error', error.message
+
+    error = RunJS.run('throw "msg";') rescue $!
+    assert_equal 'msg', error.message
+
+    error = RunJS.run('throw "";') rescue $!
+    assert_equal '', error.message
+
+    error = RunJS.run('throw [];') rescue $!
+    assert_equal '', error.message
+
+    error = RunJS.run('throw 0;') rescue $!
+    assert_equal '0', error.message
+  end
+
+  describe 'the error object' do
+
+    it 'contains the thrown JavaScript object' do
+      error = RunJS.run('throw "msg";') rescue $!
+      assert_equal 'msg', error.error
+
+      error = RunJS.run('throw 0;') rescue $!
+      assert_equal 0, error.error
+
+      error = RunJS.run('throw null;') rescue $!
+      assert_equal nil, error.error
+    end
+
+    it 'captures all the properties of the thrown error object' do
+      error = assert_raises(RunJS::JavaScriptError) do
+        RunJS.run(
+          'var err = new Error("msg");' <<
+          'err.location = { line: 4, column: 8 };' <<
+          'throw err;'
+        )
+      end
+      assert_equal 'Error', error['name']
+      assert_equal 'msg', error['message']
+      assert_equal 4, error['location']['line']
+
+      skip if RunJS.runtime == RunJS::JScript
+      skip if RunJS.runtime == RunJS::TheRubyRhino
+
+      refute_empty error['stack']
+    end
+
+    it 'handles array error objects' do
+      error = RunJS.run('throw [false];') rescue $!
+      assert_equal [false], error.error
+      assert_equal false, error[0]
+    end
+
+    it 'handles error properties that cannot be stringified (cyclic objects)' do
+      error = assert_raises(RunJS::JavaScriptError) do
+        context = RunJS.context('var cycle = {}; cycle.self = cycle;')
+        context.run('throw { name: "Cycle", cycle: cycle };')
+      end
+      assert_equal 'Cycle', error['name']
+      assert_equal '[object Object]', error['cycle']
+    end
+
+    it 'shortens the stack trace produced by SpiderMonkey' do
+      error = RunJS.call('notAFunction', 'x' * 2000) rescue $!
+      if RunJS.runtime == RunJS::SpiderMonkey
+        assert_equal 1005, error.error['stack'].size
+        assert_match 'xxx ... xxx', error['stack']
+      else
+        refute_match ' ... ', error[:stack]
+      end
+    end
+
+  end
+
+end
+
+describe 'accessing the JavaScript source code that caused the error' do
+
+  def runner(js)
+    if RunJS.runtime == RunJS::JScript
+      js = [RunJS::JScript::JSON_JS, js].join("\n")
+    end
+    RunJS::Runtime::RUNNER % js
+  end
+
+  specify 'CompileError#source contains the runner code' do
+    error = assert_raises(RunJS::CompileError) { RunJS.run('(') }
+    assert_equal runner('('), error.source
+  end
+
+  specify 'JavaScriptError#source contains the runner code' do
+    error = assert_raises(RunJS::JavaScriptError) { RunJS.run('foo();') }
+    assert_equal runner('foo();'), error.source
+  end
+
+end

data/test/javascript_test.rb

@@ -0,0 +1,93 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe 'run JavaScript' do
+
+  specify 'call' do
+    assert_equal 5, RunJS.call('Math.sqrt', 25)
+    assert_equal 0, RunJS.call('Date.parse', 'Jan 1 1970 UTC')
+  end
+
+  specify 'apply' do
+    result = RunJS.apply('Array.prototype.concat', '["cat"]', 2, :food => nil)
+    assert_equal ['cat', 2, { 'food' => nil }], result
+
+    skip if RunJS.runtime == RunJS::JScript
+
+    result = RunJS.apply('Array.prototype.slice', 'cat'.to_json)
+    assert_equal ['c', 'a', 't'], result
+  end
+
+  specify 'run' do
+    assert_nil RunJS.run('true;')
+    assert_nil RunJS.run('return undefined;')
+    assert_equal 4, RunJS.run('return 2 + 2;')
+    assert_equal false, RunJS.run('var x = 2, y = 2; return x > y;')
+    assert_equal [1, 'cat'], RunJS.run('return [1].concat("cat");')
+    assert_equal '\\', RunJS.run('return "\\\\";')
+  end
+
+  describe 'eval' do
+
+    specify 'eval' do
+      assert_nil RunJS.eval(nil)
+      assert_nil RunJS.eval('')
+      assert_equal 4, RunJS.eval('2 + 2')
+      assert_equal 4, RunJS.eval('var x = 2, y = 2; x + y')
+      assert_equal ['c', 'a', 't'], RunJS.eval('"cat".split("")')
+    end
+
+    it 'requires parentheses around objects' do
+      assert_equal Hash['one' => 1], RunJS.eval('({ one: 1 })')
+    end
+
+    it 'requires parentheses around anonymous functions' do
+      assert_nil RunJS.eval('(function() {})')
+      assert_nil RunJS.eval('function notAnonymous() {}')
+      assert_nil RunJS.eval('var notAnonymous = function() {}')
+    end
+
+  end
+
+  describe 'context' do
+
+    it 'supports nested context' do
+      js = 'a = {}; a.b = {}; a.b.c = function(d) { return d; }'
+      assert_equal 'nest', RunJS.context(js).call('a.b.c', 'nest')
+    end
+
+    it 'supports many contexts' do
+      heart    = 'function heart(s) { return "♥ " + s + " ♥"; }'
+      upcase   = 'function upcase(s) { return s.toUpperCase(); }'
+      decorate = 'function decorate(s) { return heart(upcase(s)); }'
+      context  = RunJS.context(upcase).context(heart).context(decorate)
+      assert_equal '♥ RUBY ♥', context.call('decorate', 'ruby')
+    end
+
+    specify 'using a runtime instance' do
+      instance = RunJS.runtime.new
+      instance.context('function upcase(s) { return s.toUpperCase(); }')
+      instance.context('function star(s) { return "★" + upcase(s) + "★"; }')
+      assert_equal '★RUBY★', instance.run('return star("ruby");')
+      assert_equal '★RUBY★', instance.apply('star', nil, 'ruby')
+      assert_equal '★RUBY★', instance.call('star', 'ruby')
+      assert_equal '★RUBY★', instance.eval('star("ruby")')
+    end
+
+  end
+
+  it 'does not use strict mode by default' do
+    js = 'aGlobalVariable = true; return aGlobalVariable;'
+    assert_equal true, RunJS.run(js)
+
+    skip if RunJS.runtime == RunJS::JScript
+    skip if RunJS.runtime == RunJS::TheRubyRhino
+
+    error = assert_raises(RunJS::JavaScriptError) do
+      RunJS.run("'use strict'; #{js}")
+    end
+    assert_equal 'ReferenceError', error[:name]
+  end
+
+end

data/test/select_runtime_test.rb

@@ -0,0 +1,103 @@
+require 'test_helper'
+
+describe 'select a runtime' do
+
+  class AvailableRuntime < RunJS::SystemRuntime
+    @cmd = 'ruby'
+  end
+
+  class DeprecatedRuntime < RunJS::SystemRuntime
+    @cmd = 'ruby'
+    @deprecated = true
+  end
+
+  class UnavailableRuntime < RunJS::SystemRuntime
+    @cmd = 'this is not a command'
+  end
+
+  specify 'the runtime is available if @cmd is executable' do
+    assert AvailableRuntime.available?
+    refute UnavailableRuntime.available?
+  end
+
+  specify 'deprecated' do
+    refute AvailableRuntime.deprecated?
+    assert DeprecatedRuntime.deprecated?
+  end
+
+  before { @runtime = RunJS.runtime }
+  after  { RunJS.runtime = @runtime }
+
+  describe 'setting the runtime manually' do
+
+    it 'sets the runtime if it is available' do
+      RunJS.runtime = AvailableRuntime
+      assert_equal AvailableRuntime, RunJS.runtime
+    end
+
+    it 'accepts a deprecated runtime' do
+      RunJS.runtime = DeprecatedRuntime
+      assert_equal DeprecatedRuntime, RunJS.runtime
+    end
+
+    it 'raises RuntimeUnavailable if the runtime is unavailable' do
+      assert_raises(RunJS::RuntimeUnavailable) do
+        RunJS.runtime = UnavailableRuntime
+      end
+      assert_equal @runtime, RunJS.runtime
+    end
+
+  end
+
+  describe 'selecting a runtime automatically' do
+
+    before do
+      @runtimes = RunJS::RUNTIMES.dup
+      @environment = ENV['RUNJS_RUNTIME']
+
+      ENV['RUNJS_RUNTIME'] = nil
+      RunJS.instance_variable_set(:@runtime, nil)
+    end
+
+    after do
+      RunJS::RUNTIMES.replace(@runtimes)
+      ENV['RUNJS_RUNTIME'] = @environment
+    end
+
+    it 'selects the first available runtime' do
+      RunJS::RUNTIMES.replace([UnavailableRuntime, AvailableRuntime] + @runtimes)
+      assert_equal AvailableRuntime, RunJS.runtime
+    end
+
+    it 'will not select a deprecated runtime automatically' do
+      RunJS::RUNTIMES.replace([DeprecatedRuntime])
+      assert_raises(RunJS::RuntimeUnavailable) { RunJS.runtime }
+    end
+
+    it 'raises RuntimeUnavailable if none of the supported runtimes are installed' do
+      RunJS::RUNTIMES.replace([UnavailableRuntime, DeprecatedRuntime])
+      assert_raises(RunJS::RuntimeUnavailable) { RunJS.runtime }
+    end
+
+    describe 'the RUNJS_RUNTIME environment variable' do
+
+      it 'selects the runtime set by the environment' do
+        ENV['RUNJS_RUNTIME'] = 'AvailableRuntime'
+        assert_equal AvailableRuntime, RunJS.runtime
+      end
+
+      it 'will accept a deprecated runtime from the environment' do
+        ENV['RUNJS_RUNTIME'] = 'DeprecatedRuntime'
+        assert_equal DeprecatedRuntime, RunJS.runtime
+      end
+
+      it 'raises RuntimeUnavailable if the runtime is unavailable' do
+        ENV['RUNJS_RUNTIME'] = 'UnavailableRuntime'
+        assert_raises(RunJS::RuntimeUnavailable) { RunJS.runtime }
+      end
+
+    end
+
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,17 @@
+require 'runjs'
+
+def display_banner(width)
+  runtime = RunJS.runtime.class_name rescue ENV['RUNJS_RUNTIME']
+  ruby = defined?(JRUBY_VERSION) ? "JRuby #{JRUBY_VERSION}" :
+                                   "Ruby #{RUBY_VERSION}"
+  puts
+  puts '=' * width
+  puts "#{runtime} - #{ruby}".center(width)
+  puts '=' * width
+  puts
+end
+
+display_banner(40)
+RunJS.runtime rescue abort $!.message  # abort if no runtime is detected
+
+require 'minitest/autorun'

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: runjs
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- AS Harbitz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: coffee-script-source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+- !ruby/object:Gem::Dependency
+  name: therubyracer
+  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: therubyrhino
+  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: 'You can run JavaScript code from Ruby with RunJS. The supported JavaScript
+  engines are: Node, V8, TheRubyRacer, JavaScriptCore and JScript.'
+email: asharbitz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Rakefile
+- runjs.gemspec
+- README.md
+- lib/runjs/encoding.rb
+- lib/runjs/error.rb
+- lib/runjs/os.rb
+- lib/runjs/runtime.rb
+- lib/runjs/runtimes/java_script_core.rb
+- lib/runjs/runtimes/jscript.rb
+- lib/runjs/runtimes/node.rb
+- lib/runjs/runtimes/spider_monkey.rb
+- lib/runjs/runtimes/the_ruby_racer.rb
+- lib/runjs/runtimes/the_ruby_rhino.rb
+- lib/runjs/runtimes/v8.rb
+- lib/runjs/support/runner.js
+- lib/runjs/system_runtime.rb
+- lib/runjs/vendor/json2.js
+- lib/runjs.rb
+- test/coffeescript_test.rb
+- test/encoding_test.rb
+- test/execjs_test.rb
+- test/javascript_error_test.rb
+- test/javascript_test.rb
+- test/select_runtime_test.rb
+- test/test_helper.rb
+homepage: https://github.com/asharbitz/runjs
+licenses:
+- MIT
+metadata: {}
+post_install_message: |2+
+
+  If your version of ruby is older than 1.9, you may need to install json:
+  gem install json || gem install json_pure
+
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Run JavaScript code from Ruby
+test_files:
+- test/coffeescript_test.rb
+- test/encoding_test.rb
+- test/execjs_test.rb
+- test/javascript_error_test.rb
+- test/javascript_test.rb
+- test/select_runtime_test.rb
+- test/test_helper.rb