dienashorner 0.1.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ca8cc68b27b38c33dbdb7f1e0ac5822305ff736
-  data.tar.gz: aa5411ac802f8ff7e4dac8a88a3772b1eb392f0b
+  metadata.gz: dd7cd7502f49f9a24841e42881064fce73a09df1
+  data.tar.gz: 3b5f2dc911bf0384853232e290f25405a900786c
 SHA512:
-  metadata.gz: 79d0770cf58dfe94314196ed577a06291f61427e200c66ef4cdc066017e093f4bd2f5123ce36f2f4884244820372be08e370c0bd390ec6d0fa3256a6bc389023
-  data.tar.gz: 4b0a046d56d0878788299b90b85a46e46fb4777fc7d5c0ac78270c043c59a6a11949f2f5633db682020fe2639ba2f83fd8748f98684294d6ac28803326eb153a
+  metadata.gz: 514de8502051b964befd3bb7edd902969f9a15251cbb4042a9be361f07b46a451807da9681e9cb574a24451dcaf967d0e6a3473ae9b83d3997899431185865b4
+  data.tar.gz: ff10758e53b1b206bac06d2104a6041b68ce150b4f353e640a96b92fe7fa24a36aaec12dc927208a6433038e84c44f2bdd79b69496b86b755d1d42cf6442e6c9

data/README.md

@@ -1,6 +1,6 @@
 # dia nashorner
 
-Embed the ~~Mozilla Rhino~~ Nashorn JavaScript interpreter into Ruby.
+Embed the ~~Mozilla Rhino~~ [Nashorn][0] JavaScript interpreter into Ruby.
 
 Nashorn JS engine is available with Java 8 installs (try `jjs -v`).
 
@@ -147,11 +147,25 @@ Far from being a drop-in replacement although there's `require 'nashorn/rhino'`.
 will simply need to :`require 'nashorn/rhino/less'` before a `require 'less'`.
 
 
+### ExecJS
+
+dienashorner gem ships with an [ExecJS][3] compatible runtime, its best to load it
+(`require 'nashorn/execjs/load'`) before ExecJS's auto-detection takes place :
+```ruby
+gem 'execjs', require: false
+gem 'dienashorner', platform: :jruby, require: [ 'nashorn/execjs/load', 'execjs' ]
+```
+
+
 ### Nashorn
 
-Nashorn JavaScript runtime is part of OpenJDK http://openjdk.java.net/projects/nashorn/
+Nashorn JavaScript runtime is part of [OpenJDK][4] (available since 8u40).
 
 
 ## Copyright
 
 Copyright (c) 2016 Karol Bucek. Apache License v2 (see LICENSE for details).
+
+[0]: http://www.oracle.com/technetwork/articles/java/jf14-nashorn-2126515.html
+[3]: https://github.com/rails/execjs
+[4]: http://openjdk.java.net/projects/nashorn/

data/lib/nashorn.rb

@@ -15,6 +15,7 @@ module Nashorn
     include_package 'jdk.nashorn.api.scripting'
     # include_package 'jdk.nashorn.internal.runtime'
     ScriptObject = Java::JdkNashornInternalRuntime::ScriptObject rescue nil
+    # Undefined = Java::JdkNashornInternalRuntime::Undefined rescue nil
   end
 
   def eval_js(source, options = {})
@@ -28,6 +29,8 @@ module Nashorn
     alias_method :eval, :eval_js # Nashorn.eval '"4" + 2'
   end
 
+  autoload :Context, 'nashorn/context'
+
 end
 
 require 'nashorn/version'

data/lib/nashorn/convert.rb

@@ -1,11 +1,23 @@
 class << Nashorn
 
+  ScriptObjectMirror = Nashorn::JS::ScriptObjectMirror
+  private_constant :ScriptObjectMirror
+  ScriptObject = Nashorn::JS::ScriptObject
+  private_constant :ScriptObject
+
   def to_rb(object, unmirror = false)
     # ConsString for optimized String + operations :
     return object.toString if object.is_a?(Java::JavaLang::CharSequence)
     return object.unwrap if object.is_a?(Nashorn::RubyObject)
     return object.unwrap if object.is_a?(Nashorn::RubyFunction)
-    return nil if Nashorn::JS::ScriptObjectMirror.isUndefined(object)
+    return nil if ScriptObjectMirror.isUndefined(object)
+    # NOTE: "correct" Nashorn leaking-out internals :
+    if ScriptObject && object.is_a?(ScriptObject)
+      # BUGY: Java::JavaLang::ClassCastException:
+      #   jdk.nashorn.internal.scripts.JO4 cannot be cast to jdk.nashorn.api.scripting.ScriptObjectMirror
+      #   jdk.nashorn.api.scripting.ScriptUtils.wrap(jdk/nashorn/api/scripting/ScriptUtils.java:92)
+      # object = Nashorn::JS::ScriptUtils.wrap(object)
+    end
     return js_mirror_to_rb(object) if unmirror
     object
   end
@@ -32,22 +44,27 @@ class << Nashorn
     args.map { |arg| to_rb(arg) }
   end
 
-  def args_to_js(args)
-    args.map { |arg| to_js(arg) }.to_java
+  def args_to_js(args, to_java = false)
+    args = args.map { |arg| to_js(arg) }
+    to_java ? args.to_java : args
   end
 
-  DEEP_MIRROR = ENV['nashorn.to_rb.unmirror.deep'] &&
-                ENV['nashorn.to_rb.unmirror.deep'].length > 0 &&
-                ENV['nashorn.to_rb.unmirror.deep'] != 'false'
+  DEEP_UNMIRROR = ENV_JAVA['nashorn.to_rb.unmirror.deep'] &&
+                  ENV_JAVA['nashorn.to_rb.unmirror.deep'].length > 0 &&
+                  ENV_JAVA['nashorn.to_rb.unmirror.deep'] != 'false'
 
-  def js_mirror_to_rb(object, deep = DEEP_MIRROR)
-    object = Nashorn::JS::ScriptUtils.unwrap(object)
+  def js_mirror_to_rb(object, deep = DEEP_UNMIRROR)
     if object.is_a?(Nashorn::JS::JSObject)
-      return object.values.to_a if object.isArray
-      return object if object.isFunction
+      if object.isArray
+        return object.raw_values.to_a unless deep
+        object.raw_values.map { |obj| to_rb(obj, true) }
+      end
+      return object if object.isFunction # TODO CallableHash < Hash?
       # Nashorn::JS::ScriptObjectMirror is already a Map but still :
       hash = {}
-      object.keySet.each { |key| hash[key] = to_rb object[key], true }
+      for key in object.keySet
+        hash[key] = deep ? to_rb(object[key], true) : object[key]
+      end
       hash
     else
       object

data/lib/nashorn/error.rb

@@ -8,12 +8,17 @@ module Nashorn
         if value.is_a?(Exception)
           super "#{value.class.name}: #{value.message}"
         elsif value.is_a?(JS::ScriptObject) # && @native.to_s.index('Error:')
-          super @native.message
+          super normalize_message(@native)
         else
           super value
         end
       else
-        super cause ? cause.message : @native
+        if cause = self.cause
+          message = normalize_message(cause)
+        else
+          message = normalize_message(@native)
+        end
+        super message
       end
     end
 
@@ -30,7 +35,7 @@ module Nashorn
       if @native.respond_to?(:cause) && @native.cause
         @cause = @native.cause
       else
-        @native.is_a?(JS::NashornException) ? @native : nil
+        @cause = @native.is_a?(JS::NashornException) ? @native : nil
       end
     end
 
@@ -51,11 +56,20 @@ module Nashorn
     end
 
     # Return the thown (native) JavaScript value.
-    def value(unwrap = false)
-      return @value if defined?(@value) && ! unwrap
-      @value = get_thrown unless defined?(@value)
-      return @value.unwrap if unwrap && @value.respond_to?(:unwrap)
-      @value
+    def value(unwrap = nil) # (unwrap = false)
+      # return @value if defined?(@value) && ! unwrap
+      # @value = get_thrown unless defined?(@value)
+      # return @value.unwrap if unwrap && @value.respond_to?(:unwrap)
+      # @value
+
+      return @value if defined?(@value)
+      
+      if thrown = get_thrown
+        # NOTE: thrown sometimes leaks a Nashorn::JS::ScriptObject
+        @value = Nashorn.to_rb thrown
+      else
+        @value = thrown
+      end
     end
     alias_method :thrown, :value
 
@@ -70,10 +84,19 @@ module Nashorn
 
     # Returns the JavaScript back-trace part for this error (the script stack).
     def javascript_backtrace(raw_elements = false)
+      return @javascript_backtrace if (@javascript_backtrace ||= nil) && ! raw_elements
+
       return nil unless cause.is_a?(JS::NashornException)
-      JS::NashornException.getScriptFrames(cause).map do |element|
-        raw_elements ? element : element.to_s # ScriptStackElement
+
+      return JS::NashornException.getScriptFrames(cause) if raw_elements
+
+      js_backtrace = []
+      js_backtrace << @_trace_trail if defined?(@_trace_trail)
+
+      for element in JS::NashornException.getScriptFrames(cause)
+        js_backtrace << element.to_s # element - ScriptStackElement
       end
+      @javascript_backtrace = js_backtrace
     end
 
     # jdk.nashorn.internal.runtime::ECMAException < NashornException has these :
@@ -90,6 +113,14 @@ module Nashorn
       cause.respond_to?(:getColumnNumber) ? cause.getColumnNumber : nil
     end
 
+    PARSER_EXCEPTION = 'Java::JdkNashornInternalRuntime::ParserException'
+    private_constant :PARSER_EXCEPTION if respond_to?(:private_constant)
+
+    # @private invented for ExceJS
+    def self.parse_error?(error)
+      PARSER_EXCEPTION.eql? error.class.name
+    end
+
     private
 
     def get_thrown
@@ -100,6 +131,18 @@ module Nashorn
       end
     end
 
+    def normalize_message(error)
+      # "<eval>:1:1 Expected an operand but found )\n ())\n^"
+      # extract first trace part of message :
+      message = error.message
+      return message unless JSError.parse_error?(error)
+      if match = message.match(/^(.*?\:\d+\:\d+)\s/)
+        @_trace_trail = match[1]
+        return message[@_trace_trail.length + 1..-1]
+      end
+      message
+    end
+
   end
 
 end

data/lib/nashorn/execjs/load.rb

@@ -0,0 +1,16 @@
+# load ExecJS with an available Nashorn runtime!
+
+require 'execjs/runtimes' # only require 'execjs' triggers auto-detect
+
+module ExecJS
+  if const_defined?(:NashornRuntime)
+    warn "ExecJS::NashornRuntime exists, you probably want to avoid loading #{__FILE__}"
+  end
+
+  require 'nashorn/execjs/runtime'
+
+  unless at = Runtimes.runtimes.find { |runtime| runtime.is_a?(ExecJS::NashornRuntime) }
+    at = Runtimes.runtimes.index(RubyRhino) if const_defined?(:RubyRhino)
+    Runtimes.runtimes.insert (at || 0), ExecJS::NashornRuntime.new
+  end
+end

data/lib/nashorn/execjs/runtime.rb

@@ -0,0 +1,85 @@
+require 'execjs/runtime'
+
+module ExecJS
+  class NashornRuntime < Runtime
+    class Context < Runtime::Context
+
+      def initialize(runtime, source = nil)
+        source = encode(source) if source
+        @nashorn_context = ::Nashorn::Context.new
+        @nashorn_context.eval(source) if source
+      rescue Exception => e
+        raise wrap_error(e)
+      end
+
+      def exec(source, options = nil) # options not used
+        source = encode(source)
+        eval "(function(){#{source}})()", options if /\S/ =~ source
+      end
+
+      def eval(source, options = nil) # options not used
+        source = encode(source)
+        unbox @nashorn_context.eval("(#{source})") if /\S/ =~ source
+      rescue Exception => e
+        raise wrap_error(e)
+      end
+
+      def call(prop, *args)
+        evaled = @nashorn_context.eval(prop)
+        unbox evaled.call(*args)
+      rescue Exception => e
+        raise wrap_error(e)
+      end
+
+      def unbox(value)
+        value = ::Nashorn::to_rb(value, false) # ExecJS likes its own way :
+
+        if value.is_a?(::Nashorn::JS::JSObject)
+          return nil if value.isFunction
+          return value.values.map { |v| unbox(v) } if value.isArray
+          hash = {}; value.each_raw do |key, val|
+            next if val.respond_to?(:isFunction) && val.isFunction
+            hash[key] = unbox(val)
+          end
+          return hash
+        end
+        value
+      end
+
+      def wrap_error(e)
+        return e unless e.is_a?(::Nashorn::JSError)
+
+        error_class = ::Nashorn::JSError.parse_error?(e.cause) ? RuntimeError : ProgramError
+
+        backtrace = e.backtrace
+
+        if js_stack = e.javascript_backtrace
+          backtrace = backtrace - js_stack
+          # ["<<eval>>.<anonymous>(<eval>:1)", "<<eval>>.<program>(<eval>:1)"]
+          js_stack = js_stack.map { |line| line.sub(/\<eval\>\:/, "(execjs):") }
+          backtrace = js_stack + backtrace
+        elsif backtrace
+          backtrace = backtrace.dup; backtrace.unshift('(execjs):1')
+        end
+
+        error = error_class.new e.value ? e.value.to_s : e.message
+        error.set_backtrace(backtrace)
+        error
+      end
+
+    end
+
+    def name
+      'dienashorner (Nashorn)'
+    end
+
+    def available?
+      return false unless defined? JRUBY_VERSION
+      require 'nashorn'
+      true
+    rescue LoadError
+      false
+    end
+
+  end
+end

data/lib/nashorn/ext.rb

@@ -1,6 +1,11 @@
 module Nashorn
   module JS
 
+    AbstractJSObject.module_eval do
+      alias_method :raw_values, :values
+      alias_method :__call__, :call
+    end
+
     JSObject.module_eval do
 
       def [](key)
@@ -91,8 +96,7 @@ module Nashorn
         else
           if hasMember(name_str) && property = getMember(name_str)
             if property.is_a?(JSObject) && property.isFunction
-              js_args = Nashorn.args_to_js(args)
-              Nashorn.to_rb property.__call__(self, js_args)
+              Nashorn.to_rb property.__call__(self, *Nashorn.args_to_js(args))
             else
               if args.size > 0
                 raise ArgumentError, "can't call '#{name_str}' with args: #{args.inspect} as it's a property"
@@ -115,21 +119,7 @@ module Nashorn
       # JavaScript's Function#call but rather as Ruby's Method#call !
       # Use #apply or #bind before calling to achieve the same effect.
       def call(*args)
-        this = nil
-        Nashorn.to_rb __call__ this, Nashorn.args_to_js(args)
-      rescue JS::NashornException => e
-        raise Nashorn::JSError.new(e)
-      end
-
-      # bind a JavaScript function into the given (this) context
-      #def bind(this, *args)
-      #  args = Nashorn.args_to_js(args)
-      #  Rhino::JS::BoundFunction.new(self, Nashorn.to_js(this), args)
-      #end
-
-      # use JavaScript functions constructors from Ruby as `fn.new`
-      def new(*args)
-        newObject Nashorn.args_to_js(args)
+        Nashorn.to_rb __call__ nil, *Nashorn.args_to_js(args) # this = nil
       rescue JS::NashornException => e
         raise Nashorn::JSError.new(e)
       end
@@ -140,20 +130,28 @@ module Nashorn
       # NOTE: That #call from Ruby does not have the same semantics as
       # JavaScript's Function#call but rather as Ruby's Method#call !
       def apply(this, *args)
-        __call__ Nashorn.to_js(this), Nashorn.args_to_js(args)
+        __call__ Nashorn.to_js(this), *Nashorn.args_to_js(args)
       rescue JS::NashornException => e
         raise Nashorn::JSError.new(e)
       end
       alias_method :methodcall, :apply # V8::Function compatibility
 
-    end
+      # bind a JavaScript function into the given (this) context
+      #def bind(this, *args)
+      #  args = Nashorn.args_to_js(args)
+      #  Rhino::JS::BoundFunction.new(self, Nashorn.to_js(this), args)
+      #end
+
+      # use JavaScript functions constructors from Ruby as `fn.new`
+      def new(*args)
+        newObject *Nashorn.args_to_js(args)
+      rescue JS::NashornException => e
+        raise Nashorn::JSError.new(e)
+      end
 
-    AbstractJSObject.module_eval do
-      alias_method :raw_values, :values
-      alias_method :__call__, :call
     end
 
-    ScriptObjectMirror.module_eval do # implements java.util.Map
+    ScriptObjectMirror.class_eval do # implements java.util.Map
 
       # @private NOTE: duplicated from JSObject
       def [](key)
@@ -169,15 +167,32 @@ module Nashorn
 
       # @private NOTE: duplicated from JSObject
       def call(*args)
-        this = nil
-        Nashorn.to_rb __call__ this, Nashorn.args_to_js(args)
+        # Nashorn.to_rb __call__ nil, *Nashorn.args_to_js(args) # this = nil
+
+
+        #if isFunction
+        #  this = Nashorn.to_js args.shift
+        #
+        #  puts "calling this = #{this.inspect} args = #{args.inspect}"
+        #
+        #  result = __call__(this, Nashorn.args_to_js(args))
+        #else
+
+        #puts "calling args = #{args.inspect} Nashorn.args_to_js(args) #{Nashorn.args_to_js(args).inspect}"
+
+        result = __call__ nil, *Nashorn.args_to_js(args)
+
+        #puts "called result = #{result.inspect} #{result.class}"
+
+        Nashorn.to_rb result
+        #end
       rescue JS::NashornException => e
         raise Nashorn::JSError.new(e)
       end
 
 #      def callMember(this, *args)
 #        this = nil
-#        Nashorn.to_rb __call__ this, Nashorn.args_to_js(args)
+#        Nashorn.to_rb __call__ this, *Nashorn.args_to_js(args)
 #      rescue JS::NashornException => e
 #        raise Nashorn::JSError.new(e)
 #      end

data/lib/nashorn/ruby.rb

@@ -269,8 +269,7 @@ module Nashorn
         # Nashorn.to_js(result) # TODO do not convert if java_args ?
       end
 
-      # make sure redefined :call is aliased not the one "inherited" from
-      # JS::BaseFunction#call when invoking __call__ (@see ext.rb)
+      # make sure redefined :call is aliased not the one "inherited" (@see ext.rb)
       alias_method :__call__, :call
 
     end
@@ -331,22 +330,21 @@ module Nashorn
     # @private
     class Exception < JS::NashornException
 
-      def initialize(value)
-        super wrap_value(value)
-      end
-
-      private
+      attr_reader :thrown
 
-      def wrap_value(value)
-        value.is_a?(Object) ? value : Object.wrap(value)
+      def initialize(error)
+        super error.message, error.is_a?(Java::JavaLang::Throwable) ? error : nil
+        @thrown = error
       end
 
+      def getThrown; @thrown end
+
     end
 
     def self.wrap_error(e, backtrace = nil)
-      error = Exception.new(e)
-      error.set_backtrace(backtrace) if backtrace
-      error
+      js_error = Exception.new(e)
+      js_error.set_backtrace(backtrace) if backtrace
+      js_error
     end
 
   end

data/lib/nashorn/version.rb

@@ -1,3 +1,3 @@
 module Nashorn
-  VERSION = '0.1.1'
+  VERSION = '0.2.2'
 end

data/spec/nashorn/access_spec.rb

@@ -32,7 +32,7 @@ describe Nashorn::Ruby::AttributeAccess do
   it "gets methods and instance variables" do
     rb_object = Nashorn::Ruby::Object.wrap Meh.new
 
-    rb_object.get('anAttr0', nil).should be_nil
+    rb_object.get('anAttr0', nil).should be nil
     rb_object.get('the_attr_1', nil).should == 'attr_1'
 
     # rb_object.get('an_attr_2', nil).should be(Rhino::JS::Scriptable::NOT_FOUND) # no reader
@@ -49,23 +49,21 @@ describe Nashorn::Ruby::AttributeAccess do
   it "has methods and instance variables" do
     rb_object = Nashorn::Ruby::Object.wrap Meh.new
 
-    rb_object.has('anAttr0', nil).should be_true
-    rb_object.has('the_attr_1', nil).should be_true
-    rb_object.has('an_attr_2', nil).should be_false # no reader nor writer
+    rb_object.has('anAttr0', nil).should be true
+    rb_object.has('the_attr_1', nil).should be true
+    rb_object.has('an_attr_2', nil).should be false # no reader nor writer
 
     [ 'theMethod0', 'a_method1', 'the_method_2' ].each do |name|
-      rb_object.has(name, nil).should be_true
+      rb_object.has(name, nil).should be true
     end
 
-    rb_object.has('non-existent-method', nil).should be_false
+    rb_object.has('non-existent-method', nil).should be false
   end
 
   it "puts using attr writer" do
-    start = mock('start')
-    start.expects(:put).never
     rb_object = Nashorn::Ruby::Object.wrap Meh.new
 
-    rb_object.put('the_attr_1', start, 42)
+    rb_object.put('the_attr_1', 42)
     rb_object.the_attr_1.should == 42
   end
 

data/spec/nashorn/error_spec.rb

@@ -3,6 +3,8 @@ require File.expand_path('../spec_helper', File.dirname(__FILE__))
 describe Nashorn::JSError do
 
   it "works as a StandardError with a message being passed" do
+    pending 'currently JSError.new always gets a (nashorn) exception'
+
     js_error = Nashorn::JSError.new 'an error message'
     lambda { js_error.to_s && js_error.inspect }.should_not raise_error
 
@@ -11,38 +13,40 @@ describe Nashorn::JSError do
     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 "might wrap a NashornException wrapped in a NativeException like error" do
+    pending 'probably not relevant'
+
+    # 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
+    rescue Nashorn::JSError => e
 
-      pending
+      pending 'CAN NOT WORK-AROUND DUE A NASHORN BUG!'
 
-      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.message.should == e.value.to_s
 
+      # Java::JdkNashornInternalRuntime::ScriptObject leaks out?!
+      #if Nashorn::JS::ScriptObject
+      #  e.value.should be_a(Nashorn::JS::ScriptObject)
+      #else
+      #  e.value.should be_a(Nashorn::JS::JSObject)
+      #end
       e.value.should be_a(Nashorn::JS::JSObject)
       e.value['foo'].should == 'bar'
     else
@@ -158,8 +162,7 @@ describe Nashorn::JSError do
       context = Nashorn::Context.new
       context.eval "function foo() { throw 'bar' }"
       context['foo'].apply(nil)
-    rescue => e
-      e.should be_a Nashorn::JSError
+    rescue Nashorn::JSError => e
       e.value.should == 'bar'
     else
       fail "expected to rescue"
@@ -177,14 +180,13 @@ describe Nashorn::JSError do
     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
+    rescue Nashorn::JSError => e
+      e.thrown.should_not be nil
+      # NOTE: ... or should it be wrapped?
+      e.value.should be_a Nashorn::Ruby::Object if false
+      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\"/
+      e.message.should =~ /hello/
     else
       fail "expected to rescue"
     end

data/spec/nashorn/test_execjs.rb

@@ -0,0 +1,374 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+
+require 'json'
+
+require 'nashorn/execjs/load'
+require 'execjs'
+
+if defined? Minitest::Test
+  Test = Minitest::Test
+elsif defined? MiniTest::Unit::TestCase
+  Test = MiniTest::Unit::TestCase
+end
+
+class TestExecJS < Test
+#  def test_runtime_available
+#    runtime = ExecJS::ExternalRuntime.new(command: "nonexistent")
+#    assert !runtime.available?
+#
+#    runtime = ExecJS::ExternalRuntime.new(command: "ruby")
+#    assert runtime.available?
+#  end
+#
+#  def test_runtime_assignment
+#    original_runtime = ExecJS.runtime
+#    runtime = ExecJS::ExternalRuntime.new(command: "nonexistent")
+#    assert_raises(ExecJS::RuntimeUnavailable) { ExecJS.runtime = runtime }
+#    assert_equal original_runtime, ExecJS.runtime
+#
+#    runtime = ExecJS::ExternalRuntime.new(command: "ruby")
+#    ExecJS.runtime = runtime
+#    assert_equal runtime, ExecJS.runtime
+#  ensure
+#    ExecJS.runtime = original_runtime
+#  end
+
+  def test_context_call
+    context = ExecJS.compile("id = function(v) { return v; }")
+    assert_equal "bar", context.call("id", "bar")
+  end
+
+  def test_nested_context_call
+    context = ExecJS.compile("a = {}; a.b = {}; a.b.id = function(v) { return v; }")
+    assert_equal "bar", context.call("a.b.id", "bar")
+  end
+
+  def test_context_call_missing_function
+    context = ExecJS.compile("")
+    assert_raises ExecJS::ProgramError do
+      context.call("missing")
+    end
+  end
+
+  {
+    "function() {}" => nil,
+    "0" => 0,
+    "null" => nil,
+    "undefined" => nil,
+    "true" => true,
+    "false" => false,
+    "[1, 2]" => [1, 2],
+    "[1, function() {}]" => [1, nil],
+    "'hello'" => "hello",
+    "'red yellow blue'.split(' ')" => ["red", "yellow", "blue"],
+    "{a:1,b:2}" => {"a"=>1,"b"=>2},
+    "{a:true,b:function (){}}" => {"a"=>true},
+    "'café'" => "café",
+    '"☃"' => "☃",
+    '"\u2603"' => "☃",
+    "'\u{1f604}'".encode("UTF-8") => "\u{1f604}".encode("UTF-8"), # Smiling emoji
+    "'\u{1f1fa}\u{1f1f8}'".encode("UTF-8") => "\u{1f1fa}\u{1f1f8}".encode("UTF-8"), # US flag
+    '"\\\\"' => "\\"
+  }.each_with_index do |(input, output), index|
+    define_method("test_exec_string_#{index}") do
+      assert_equal output, ExecJS.exec("return #{input}")
+    end
+
+    define_method("test_eval_string_#{index}") do
+      assert_equal output, ExecJS.eval(input)
+    end
+
+    define_method("test_compile_return_string_#{index}") do
+      context = ExecJS.compile("var a = #{input};")
+      assert_equal output, context.eval("a")
+    end
+
+    define_method("test_compile_call_string_#{index}") do
+      context = ExecJS.compile("function a() { return #{input}; }")
+      assert_equal output, context.call("a")
+    end
+  end
+
+  [
+    nil,
+    true,
+    false,
+    1,
+    3.14,
+    "hello",
+    "\\",
+    "café",
+    "☃",
+    "\u{1f604}".encode("UTF-8"), # Smiling emoji
+    "\u{1f1fa}\u{1f1f8}".encode("UTF-8"), # US flag
+    [1, 2, 3],
+    [1, [2, 3]],
+    [1, [2, [3]]],
+    ["red", "yellow", "blue"],
+    { "a" => 1, "b" => 2},
+    { "a" => 1, "b" => [2, 3]},
+    { "a" => true }
+  ].each_with_index do |value, index|
+    json_value = JSON.generate(value, quirks_mode: true)
+
+    define_method("test_json_value_#{index}") do
+      assert_equal value, JSON.parse(json_value, quirks_mode: true)
+    end
+
+    define_method("test_exec_value_#{index}") do
+      assert_equal value, ExecJS.exec("return #{json_value}")
+    end
+
+    define_method("test_eval_value_#{index}") do
+      assert_equal value, ExecJS.eval("#{json_value}")
+    end
+
+    define_method("test_strinigfy_value_#{index}") do
+      # context = ExecJS.compile("function json(obj) { return obj || JSON.stringify(obj); }")
+      context = ExecJS.compile("function json(obj) { return JSON.stringify(obj); }")
+
+      puts context.inspect; puts "value = #{value.inspect}"
+
+      assert_equal json_value, context.call("json", value)
+    end
+
+    define_method("test_call_value_#{index}") do
+      context = ExecJS.compile("function id(obj) { return obj; }")
+      assert_equal value, context.call("id", value)
+    end
+  end
+
+  def test_eval_blank
+    assert_nil ExecJS.eval("")
+    assert_nil ExecJS.eval(" ")
+    assert_nil ExecJS.eval("  ")
+  end
+
+  def test_exec_return
+    assert_nil ExecJS.exec("return")
+  end
+
+  def test_exec_no_return
+    assert_nil ExecJS.exec("1")
+  end
+
+  def test_encoding
+    utf8 = Encoding.find('UTF-8')
+
+    assert_equal utf8, ExecJS.exec("return 'hello'").encoding
+    assert_equal utf8, ExecJS.eval("'☃'").encoding
+
+    ascii = "'hello'".encode('US-ASCII')
+    result = ExecJS.eval(ascii)
+    assert_equal "hello", result
+    assert_equal utf8, result.encoding
+
+    assert_raises Encoding::UndefinedConversionError do
+      binary = "\xde\xad\xbe\xef".force_encoding("BINARY")
+      ExecJS.eval(binary)
+    end
+  end
+
+  def test_encoding_compile
+    utf8 = Encoding.find('UTF-8')
+
+    context = ExecJS.compile("foo = function(v) { return '¶' + v; }".encode("ISO8859-15"))
+
+    assert_equal utf8, context.exec("return foo('hello')").encoding
+    assert_equal utf8, context.eval("foo('☃')").encoding
+
+    ascii = "foo('hello')".encode('US-ASCII')
+    result = context.eval(ascii)
+    assert_equal "¶hello", result
+    assert_equal utf8, result.encoding
+
+    assert_raises Encoding::UndefinedConversionError do
+      binary = "\xde\xad\xbe\xef".force_encoding("BINARY")
+      context.eval(binary)
+    end
+  end
+
+  def test_surrogate_pairs
+    # Smiling emoji
+    str = "\u{1f604}".encode("UTF-8")
+    assert_equal 2, ExecJS.eval("'#{str}'.length")
+    assert_equal str, ExecJS.eval("'#{str}'")
+
+    # US flag emoji
+    str = "\u{1f1fa}\u{1f1f8}".encode("UTF-8")
+    assert_equal 4, ExecJS.eval("'#{str}'.length")
+    assert_equal str, ExecJS.eval("'#{str}'")
+  end
+
+  def test_compile_anonymous_function
+    context = ExecJS.compile("foo = function() { return \"bar\"; }")
+    assert_equal "bar", context.exec("return foo()")
+    assert_equal "bar", context.eval("foo()")
+    assert_equal "bar", context.call("foo")
+  end
+
+  def test_compile_named_function
+    context = ExecJS.compile("function foo() { return \"bar\"; }")
+    assert_equal "bar", context.exec("return foo()")
+    assert_equal "bar", context.eval("foo()")
+    assert_equal "bar", context.call("foo")
+  end
+
+  def test_this_is_global_scope
+    assert_equal true, ExecJS.eval("this === (function() {return this})()")
+    assert_equal true, ExecJS.exec("return this === (function() {return this})()")
+  end
+
+  def test_browser_self_is_undefined
+    assert ExecJS.eval("typeof self == 'undefined'")
+  end
+
+  def test_node_global_is_undefined
+    assert ExecJS.eval("typeof global == 'undefined'")
+  end
+
+  def test_commonjs_vars_are_undefined
+    assert ExecJS.eval("typeof module == 'undefined'")
+    assert ExecJS.eval("typeof exports == 'undefined'")
+    assert ExecJS.eval("typeof require == 'undefined'")
+  end
+
+  def test_console_is_undefined
+    assert ExecJS.eval("typeof console == 'undefined'")
+  end
+
+  def test_timers_are_undefined
+    assert ExecJS.eval("typeof setTimeout == 'undefined'")
+    assert ExecJS.eval("typeof setInterval == 'undefined'")
+    assert ExecJS.eval("typeof clearTimeout == 'undefined'")
+    assert ExecJS.eval("typeof clearInterval == 'undefined'")
+    assert ExecJS.eval("typeof setImmediate == 'undefined'")
+    assert ExecJS.eval("typeof clearImmediate == 'undefined'")
+  end
+
+  def test_compile_large_scripts
+    body = "var foo = 'bar';\n" * 100_000
+    assert ExecJS.exec("function foo() {\n#{body}\n};\nreturn true")
+  end
+
+  def test_exec_syntax_error
+    begin
+      ExecJS.exec(")")
+      flunk
+    rescue ExecJS::RuntimeError => e
+
+      #puts "\n\nEXEC: " + e.inspect + "\n  #{e.backtrace.join("\n  ")}\n"
+
+      assert e
+      assert e.backtrace[0].include?("(execjs):1"), e.backtrace.join("\n")
+    end
+  end
+
+  def test_eval_syntax_error
+    begin
+      ExecJS.eval(")")
+      flunk
+    rescue ExecJS::RuntimeError => e
+      assert e
+      assert e.backtrace[0].include?("(execjs):1"), e.backtrace.join("\n")
+    end
+  end
+
+  def test_compile_syntax_error
+    begin
+      ExecJS.compile(")")
+      flunk
+    rescue ExecJS::RuntimeError => e
+      assert e
+      assert e.backtrace[0].include?("(execjs):1"), e.backtrace.join("\n")
+    end
+  end
+
+  def test_exec_thrown_error
+    begin
+      ExecJS.exec("throw new Error('hello')")
+      flunk
+    rescue ExecJS::ProgramError => e
+      assert e
+      assert e.backtrace[0].include?("(execjs):1"), e.backtrace.join("\n")
+    end
+  end
+
+  def test_eval_thrown_error
+    begin
+      ExecJS.eval("(function(){ throw new Error('hello') })()")
+      flunk
+    rescue ExecJS::ProgramError => e
+      assert e
+      assert e.backtrace[0].include?("(execjs):1"), e.backtrace.join("\n")
+    end
+  end
+
+  def test_compile_thrown_error
+    begin
+      ExecJS.compile("throw new Error('hello')")
+      flunk
+    rescue ExecJS::ProgramError => e
+      assert e
+      assert e.backtrace[0].include?("(execjs):1"), e.backtrace.join("\n")
+    end
+  end
+
+  def test_exec_thrown_string
+    assert_raises ExecJS::ProgramError do
+      ExecJS.exec("throw 'hello'")
+    end
+  end
+
+  def test_eval_thrown_string
+    assert_raises ExecJS::ProgramError do
+      ExecJS.eval("(function(){ throw 'hello' })()")
+    end
+  end
+
+  def test_compile_thrown_string
+    assert_raises ExecJS::ProgramError do
+      ExecJS.compile("throw 'hello'")
+    end
+  end
+=begin
+  def test_babel
+    skip if ExecJS.runtime.is_a?(ExecJS::RubyRhinoRuntime)
+
+    assert source = File.read(File.expand_path("../fixtures/babel.js", __FILE__))
+    source = <<-JS
+      var self = this;
+      #{source}
+      babel.eval = function(code) {
+        return eval(babel.transform(code)["code"]);
+      }
+    JS
+    context = ExecJS.compile(source)
+    assert_equal 64, context.call("babel.eval", "((x) => x * x)(8)")
+  end
+
+  def test_coffeescript
+    assert source = File.read(File.expand_path("../fixtures/coffee-script.js", __FILE__))
+    context = ExecJS.compile(source)
+    assert_equal 64, context.call("CoffeeScript.eval", "((x) -> x * x)(8)")
+  end
+
+  def test_uglify
+    assert source = File.read(File.expand_path("../fixtures/uglify.js", __FILE__))
+    source = <<-JS
+      #{source}
+
+      function uglify(source) {
+        var ast = UglifyJS.parse(source);
+        var stream = UglifyJS.OutputStream();
+        ast.print(stream);
+        return stream.toString();
+      }
+    JS
+    context = ExecJS.compile(source)
+    assert_equal "function foo(bar){return bar}",
+      context.call("uglify", "function foo(bar) {\n  return bar;\n}")
+  end
+=end
+end

data/spec/nashorn_spec.rb

@@ -4,7 +4,7 @@ describe Nashorn do
 
   it 'allows to eval js on Nashorn' do
     expect( Nashorn.eval '"4" + 2' ).to eql '42'
-    expect( Nashorn.eval_js 'true + 10' ).to eql '11'
+    expect( Nashorn.eval_js 'true + 100' ).to eql 101
   end
 
   class NashornStub

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dienashorner
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Karol Bucek
@@ -58,6 +58,8 @@ files:
 - lib/nashorn/context.rb
 - lib/nashorn/convert.rb
 - lib/nashorn/error.rb
+- lib/nashorn/execjs/load.rb
+- lib/nashorn/execjs/runtime.rb
 - lib/nashorn/ext.rb
 - lib/nashorn/rhino.rb
 - lib/nashorn/rhino/less.rb
@@ -76,6 +78,7 @@ files:
 - spec/nashorn/integration/loop/element2.js
 - spec/nashorn/integration_spec.rb
 - spec/nashorn/ruby_spec.rb
+- spec/nashorn/test_execjs.rb
 - spec/nashorn_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/kares/dienashorner