dienashorner 0.1.1

data/spec/nashorn/error_spec.rb

@@ -0,0 +1,199 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+describe Nashorn::JSError do
+
+  it "works as a StandardError with a message being passed" do
+    js_error = Nashorn::JSError.new 'an error message'
+    lambda { js_error.to_s && js_error.inspect }.should_not raise_error
+
+    js_error.cause.should be nil
+    js_error.message.should == 'an error message'
+    js_error.javascript_backtrace.should be nil
+  end
+
+#  it "might wrap a NashornException wrapped in a NativeException like error" do
+#    # JRuby's NativeException.new(Nashorn_e) does not work as it is
+#    # intended to handle Java exceptions ... no new on the Ruby side
+#    native_error_class = Class.new(RuntimeError) do
+#      def initialize(cause); @cause = cause end
+#      def cause; @cause end
+#    end
+#
+#    nashorn_e = javax.script.ScriptException.new("42".to_java)
+#    js_error = Nashorn::JSError.new native_error_class.new(nashorn_e)
+#    lambda { js_error.to_s && js_error.inspect }.should_not raise_error
+#
+#    js_error.cause.should be nashorn_e
+#    js_error.message.should == '42'
+#    js_error.javascript_backtrace.should be nil
+#  end
+
+  it "keeps the thrown javascript object value" do
+    begin
+      Nashorn::Context.eval "throw { foo: 'bar' }"
+    rescue => e
+      e.should be_a(Nashorn::JSError)
+      e.message.should == e.value.to_s
+
+      pending
+
+      puts e.value.inspect
+      puts e.value.class
+      puts e.value.class.included_modules.inspect
+      puts e.value.class.superclass
+      puts e.value.class.superclass.included_modules.inspect
+
+      e.value.should be_a(Nashorn::JS::JSObject)
+      e.value['foo'].should == 'bar'
+    else
+      fail "expected to rescue"
+    end
+  end
+
+  it "keeps the thrown javascript string value" do
+    begin
+      Nashorn::Context.eval "throw 'mehehehe'"
+    rescue => e
+      e.should be_a(Nashorn::JSError)
+      e.value.should == 'mehehehe'
+      e.message.should == e.value.to_s
+    else
+      fail "expected to rescue"
+    end
+  end
+
+  it "contains the native error as the cause 42" do
+    begin
+      Nashorn::Context.eval "throw 42"
+    rescue => e # javax.script.ScriptException
+      e.cause.should_not be nil
+      e.cause.should be_a Java::JdkNashornInternalRuntime::ECMAException
+      e.cause.value.should == 42
+      e.cause.lineNumber.should == 1
+      e.cause.fileName.should == '<eval>'
+    else
+      fail "expected to rescue"
+    end
+  end
+
+  it "has a correct javascript backtrace" do
+    begin
+      Nashorn::Context.eval "throw 42"
+    rescue => e
+      #
+      e.javascript_backtrace.should be_a Enumerable
+      e.javascript_backtrace.size.should >= 1
+      e.javascript_backtrace[0].should =~ /.*?<eval>:1/
+      e.javascript_backtrace(true).should be_a Enumerable
+      e.javascript_backtrace(true).size.should >= 1
+      element = e.javascript_backtrace(true)[0]
+      element.file_name.should == '<eval>'
+      # element.function_name.should be nil
+      element.line_number.should == 1
+    else
+      fail "expected to rescue"
+    end
+  end
+
+  it "contains function name in javascript backtrace" do
+    begin
+      Nashorn::Context.eval "function fortyTwo() { throw 42 }\n fortyTwo()"
+    rescue => e
+      # ["<<eval>>.fortyTwo(<eval>:1)", "<<eval>>.<program>(<eval>:2)"]
+      e.javascript_backtrace.size.should >= 2
+      e.javascript_backtrace[0].should =~ /fortyTwo\(<eval>:1\)/
+      expect( e.javascript_backtrace.find { |trace| trace.index("<eval>:2") } ).to_not be nil
+    else
+      fail "expected to rescue"
+    end
+  end
+
+  it "backtrace starts with the javascript part" do
+    begin
+      Nashorn::Context.eval "throw 42"
+    rescue => e
+      e.backtrace.should be_a Array
+      e.backtrace[0].should =~ /.*?<eval>:1/
+      e.backtrace[1].should_not be nil
+    else
+      fail "expected to rescue"
+    end
+  end
+
+  it "inspect shows the javascript value" do
+    begin
+      Nashorn::Context.eval "throw '42'"
+    rescue => e
+      e.inspect.should == '#<Nashorn::JSError: 42>'
+      e.to_s.should == '42'
+    else
+      fail "expected to rescue"
+    end
+  end
+
+  it "wrapps false value correctly" do
+    begin
+      Nashorn::Context.eval "throw false"
+    rescue => e
+      e.inspect.should == '#<Nashorn::JSError: false>'
+      e.value.should be false
+    else
+      fail "expected to rescue"
+    end
+  end
+
+  it "wrapps null value correctly" do
+    begin
+      Nashorn::Context.eval "throw null"
+    rescue => e
+      e.inspect.should == '#<Nashorn::JSError: null>'
+      e.value.should be nil
+    else
+      fail "expected to rescue"
+    end
+  end
+
+  it "raises correct error from function#apply" do
+    begin
+      context = Nashorn::Context.new
+      context.eval "function foo() { throw 'bar' }"
+      context['foo'].apply(nil)
+    rescue => e
+      e.should be_a Nashorn::JSError
+      e.value.should == 'bar'
+    else
+      fail "expected to rescue"
+    end
+  end
+
+  it "prints info about nested (ruby) error" do
+    context = Nashorn::Context.new
+    klass = Class.new do
+      def hello(arg = 42)
+        raise RuntimeError, 'hello' if arg != 42
+      end
+    end
+    context[:Hello] = klass.new
+    hi = context.eval "( function hi(arg) { Hello.hello(arg); } )"
+    begin
+      hi.call(24)
+    rescue => e
+      e.should be_a Nashorn::JSError
+      e.value.should_not be nil
+      # Java::JdkNashornInternalObjects::NativeTypeError
+      # e.value.should be_a Nashorn::Ruby::Object
+      # e.value(true).should be_a RuntimeError # unwraps ruby object
+      # prints the original message (beyond [ruby RuntimeError]) :
+      e.message.should =~ /TypeError: .* has no such function \"hello\"/
+    else
+      fail "expected to rescue"
+    end
+    #     Nashorn::JSError:
+    #       jdk.nashorn.internal.objects.NativeTypeError@52719fb6
+    #     # <<eval>>.hi(<eval>:1)
+    #     # <jdk/nashorn/internal/scripts/<eval>>.hi(jdk/nashorn/internal/scripts/<eval>:1)
+    #     # ./lib/nashorn/ext.rb:157:in `call'
+    #     # ./spec/nashorn/error_spec.rb:179:in `(root)'
+  end
+
+end

data/spec/nashorn/integration/bar.js

@@ -0,0 +1,11 @@
+//console.log('bar.js 1');
+var util = require('util');
+//console.log('bar.js 2');
+var Bar = {};
+Bar.puts = function (message) {
+    util.puts(message);
+    return message;
+};
+//console.log('bar.js 3');
+exports.Bar = Bar;
+//console.log('bar.js 4');

data/spec/nashorn/integration/foo.js

@@ -0,0 +1,7 @@
+//console.log('foo.js 1');
+var Bar = require('./bar').Bar;
+//console.log('foo.js 2 ' + Bar + " : " + Bar.puts);
+Bar.puts('Hello Bar!');
+//console.log('foo.js 3');
+exports.foo = { 'Bar': Bar };
+//console.log('foo.js 4');

data/spec/nashorn/integration/index.js

@@ -0,0 +1,7 @@
+console.log('./loop');
+require('./loop');
+
+['element1', 'element2'].forEach(function (n) {
+    console.log('require(./loop/' + n + ')');
+    require('./loop/' + n);
+});

data/spec/nashorn/integration/loop/element1.js

@@ -0,0 +1,3 @@
+console.log('loop/element1 1');
+require('../index');
+console.log('loop/element1 2');

data/spec/nashorn/integration/loop/element2.js

@@ -0,0 +1,8 @@
+console.log('loop/element2 1');
+(function (loop) {
+console.log('loop/element2 2');
+loop.fn2 = function (arg1, arg2) {
+    return arg1 + arg2;
+};
+})(require('../loop'));
+console.log('loop/element2 3');

data/spec/nashorn/integration/loop.js

@@ -0,0 +1,3 @@
+Loop = {};
+Loop.toString = function() { return 'Loop'; };
+exports.Loop = Loop;

data/spec/nashorn/integration_spec.rb

@@ -0,0 +1,149 @@
+require 'nashorn'
+require 'nashorn/context'
+require 'pathname'
+require 'stringio'
+
+puts "Nashorn #{Nashorn::VERSION}"
+
+describe 'integration' do
+
+  it "Less.js: loads (less.rb)" do
+    require 'nashorn/rhino/less'
+    require 'less'
+
+    expect( Less.Parser ).to be_a(Nashorn::JS::ScriptObjectMirror)
+    # exposes less.tree e.g. for attaching custom functions
+    Less.tree.functions['foo'] = lambda { |*args| 'bar' }
+  end
+
+  it "CommonJS: require foo" do # CommonJS
+    environment = new_environment(:console => Console)
+    environment.native 'util', Util.new(out = StringIO.new)
+    exports = environment.require 'foo'
+    out.string.should == "Hello Bar!\n"
+
+    exports.should_not be nil
+    exports.foo.should respond_to(:'[]')
+    exports.foo['Bar'].should respond_to(:'[]')
+    exports.foo['Bar'][:puts].should be_a Nashorn::JS::JSObject # Rhino::JS::Function
+  end
+
+  it "CommonJS: require index/loop" do # CommonJS
+    environment = new_environment(:console => Console)
+    environment.require 'index'
+    environment.context['Loop'].should_not be nil
+  end
+
+  private
+
+  def new_environment(globals = {})
+    context = Nashorn::Context.new
+    globals.each { |key, obj| context[key] = obj }
+    path = Pathname(__FILE__).dirname.join('integration')
+    Env.new(context, :path => path.to_s)
+  end
+
+  class Env # a CommonJS like environment (inspired by commonjs.rb)
+
+    attr_reader :context, :modules
+
+    def initialize(context, options = {})
+      @context = context
+      @paths = [ options[:path] ].flatten.map { |path| Pathname(path) }
+      @modules = {}
+    end
+
+    def require(module_id)
+      unless mod = modules[module_id]
+        filepath = find(module_id) or fail LoadError, "no such module '#{module_id}'"
+        js = "( function(module, require, exports) {\n#{File.read(filepath)}\n} )"
+        load = context.eval(js, filepath.expand_path.to_s)
+        modules[module_id] = mod = Module.new(module_id, self)
+        load.call(mod, mod.require_function, mod.exports)
+      end
+      return mod.exports
+    end
+
+    def native(module_id, impl)
+      modules[module_id] = Module::Native.new(impl)
+    end
+
+    def new_object
+      context['Object'].new
+    end
+
+    private
+
+    def find(module_id)
+      if loadpath = @paths.find { |path| path.join("#{module_id}.js").exist? }
+        loadpath.join("#{module_id}.js")
+      end
+    end
+
+    class Module
+
+      attr_reader :id, :exports
+
+      def initialize(id, env)
+        @id, @env = id, env
+        @exports = env.new_object
+        @segments = id.split('/')
+      end
+
+      def require_function
+        @require_function ||= lambda do |*args|
+          this, module_id = *args
+          module_id ||= this #backwards compatibility with TRR < 0.10
+          @env.require(expand(module_id))
+        end
+      end
+
+      private
+
+      def expand(module_id)
+        return module_id unless module_id =~ /(\.|\..)/
+        module_id.split('/').inject(@segments[0..-2]) do |path, element|
+          path.tap do
+            if element == '.'
+              # do nothing
+            elsif element == '..'
+              path.pop
+            else
+              path.push element
+            end
+          end
+        end.join('/')
+      end
+
+      class Native
+
+        def initialize(impl); @impl = impl; end
+        def exports; @impl; end
+
+      end
+
+    end
+
+  end
+
+  class Util
+
+    def initialize(io = STDOUT)
+      @io = io
+    end
+
+    def puts(*args)
+      args.each { |arg| @io.puts(arg) }
+    end
+
+  end
+
+  class Console
+
+    def self.log(*msgs)
+      puts msgs.join(', ')
+    end
+
+  end
+
+end