dienashorner 0.1.1

data/lib/nashorn/error.rb

@@ -0,0 +1,105 @@
+module Nashorn
+
+  class JSError < StandardError
+
+    def initialize(native)
+      @native = native # might be a NativeException wrapping a Java Throwable
+      if ( value = self.value(true) ) != nil
+        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
+        else
+          super value
+        end
+      else
+        super cause ? cause.message : @native
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}: #{message}>"
+    end
+
+    def message; super.to_s end
+
+    # Returns the (nested) cause of this error if any.
+    def cause
+      return @cause if defined?(@cause)
+
+      if @native.respond_to?(:cause) && @native.cause
+        @cause = @native.cause
+      else
+        @native.is_a?(JS::NashornException) ? @native : nil
+      end
+    end
+
+    # Attempts to unwrap the (native) JavaScript/Java exception.
+    def unwrap
+      return @unwrap if defined?(@unwrap)
+      cause = self.cause
+      if cause && cause.is_a?(JS::NashornException)
+        e = cause.getCause
+        if e && e.is_a?(Java::OrgJrubyExceptions::RaiseException)
+          @unwrap = e.getException
+        else
+          @unwrap = e
+        end
+      else
+        @unwrap = nil
+      end
+    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
+    end
+    alias_method :thrown, :value
+
+    # The backtrace is constructed using #javascript_backtrace + the Ruby part.
+    def backtrace
+      if js_backtrace = javascript_backtrace
+        js_backtrace.push(*super)
+      else
+        super
+      end
+    end
+
+    # Returns the JavaScript back-trace part for this error (the script stack).
+    def javascript_backtrace(raw_elements = false)
+      return nil unless cause.is_a?(JS::NashornException)
+      JS::NashornException.getScriptFrames(cause).map do |element|
+        raw_elements ? element : element.to_s # ScriptStackElement
+      end
+    end
+
+    # jdk.nashorn.internal.runtime::ECMAException < NashornException has these :
+
+    def file_name
+      cause.respond_to?(:getFileName) ? cause.getFileName : nil
+    end
+
+    def line_number
+      cause.respond_to?(:getLineNumber) ? cause.getLineNumber : nil
+    end
+
+    def column_number
+      cause.respond_to?(:getColumnNumber) ? cause.getColumnNumber : nil
+    end
+
+    private
+
+    def get_thrown
+      if ( cause = self.cause ) && cause.respond_to?(:thrown)
+        cause.thrown  # e.g. NashornException.getThrown
+      else
+        nil
+      end
+    end
+
+  end
+
+end

data/lib/nashorn/ext.rb

@@ -0,0 +1,201 @@
+module Nashorn
+  module JS
+
+    JSObject.module_eval do
+
+      def [](key)
+        Nashorn.to_rb key.is_a?(Fixnum) ? getSlot(key) : getMember(key.to_s)
+      end
+
+      def []=(key, value)
+        js_val = Nashorn.to_js value
+        key.is_a?(Fixnum) ? setSlot(key, js_val) : setMember(key.to_s, js_val)
+        js_val
+      end
+
+      def has_key?(key); hasMember(key) end
+      alias_method :key?, :has_key?
+      alias_method :include?, :has_key?
+
+      def has_value?(val); raw_values.include?(val) end
+      alias_method :value?, :has_value?
+
+      def delete(key); removeMember(key) end
+
+      def length; keySet.size end
+      alias_method :size, :length
+
+      # enumerate the key value pairs contained in this javascript object. e.g.
+      #
+      #     eval_js("{foo: 'bar', baz: 'bang'}").each do |key,value|
+      #       puts "#{key} -> #{value} "
+      #     end
+      #
+      # outputs foo -> bar baz -> bang
+      #
+      def each
+        each_raw { |key, val| yield key, Nashorn.to_rb(val) }
+      end
+      alias_method :each_pair, :each
+
+      def each_key
+        each_raw { |key, val| yield key }
+      end
+
+      def each_value
+        each_raw { |key, val| yield Nashorn.to_rb(val) }
+      end
+
+      def each_raw
+        for id in keySet do
+          yield id, getMember(id)
+        end
+      end
+
+      def keys
+        keySet.to_a
+      end
+
+      def values
+        raw_values.map { |val| Nashorn.to_rb(val) }
+      end
+
+      # Converts the native object to a hash. This isn't really a stretch since it's
+      # pretty much a hash in the first place.
+      def to_h
+        hash = {}
+        each do |key, val|
+          hash[key] = val.is_a?(JSObject) && ! val.equal?(self) ? val.to_h : val
+        end
+        hash
+      end
+
+    #  def ==(other)
+    #    equivalentValues(other) == true # JS ==
+    #  end
+    #
+    #  def eql?(other)
+    #    self.class == other.class && self.==(other)
+    #  end
+
+      # Convert this javascript object into a json string.
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      # Delegate methods to JS object if possible when called from Ruby.
+      def method_missing(name, *args)
+        name_str = name.to_s
+        if name_str.end_with?('=') && args.size == 1 # writer -> JS put
+          self[ name_str[0...-1] ] = args[0]
+        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)
+            else
+              if args.size > 0
+                raise ArgumentError, "can't call '#{name_str}' with args: #{args.inspect} as it's a property"
+              end
+              Nashorn.to_rb property
+            end
+          else
+            super
+          end
+        end
+      end
+
+      # function :
+
+      # alias_method :__call__, :call
+
+      # make JavaScript functions callable Ruby style e.g. `fn.call('42')`
+      #
+      # NOTE: That invoking #call does not have the same semantics as
+      # 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)
+      rescue JS::NashornException => e
+        raise Nashorn::JSError.new(e)
+      end
+
+      # apply a function with the given context and (optional) arguments
+      # e.g. `fn.apply(obj, 1, 2)`
+      #
+      # 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)
+      rescue JS::NashornException => e
+        raise Nashorn::JSError.new(e)
+      end
+      alias_method :methodcall, :apply # V8::Function compatibility
+
+    end
+
+    AbstractJSObject.module_eval do
+      alias_method :raw_values, :values
+      alias_method :__call__, :call
+    end
+
+    ScriptObjectMirror.module_eval do # implements java.util.Map
+
+      # @private NOTE: duplicated from JSObject
+      def [](key)
+        Nashorn.to_rb key.is_a?(Fixnum) ? getSlot(key) : getMember(key.to_s)
+      end
+
+      # @private NOTE: duplicated from JSObject
+      def []=(key, value)
+        js_val = Nashorn.to_js value
+        key.is_a?(Fixnum) ? setSlot(key, js_val) : setMember(key.to_s, js_val)
+        js_val
+      end
+
+      # @private NOTE: duplicated from JSObject
+      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
+
+#      def callMember(this, *args)
+#        this = nil
+#        Nashorn.to_rb __call__ this, Nashorn.args_to_js(args)
+#      rescue JS::NashornException => e
+#        raise Nashorn::JSError.new(e)
+#      end
+
+      #def to_s
+      #  toString
+      #end
+
+      #def inspect
+      #  id_hash = Java::JavaLang::System.identityHashCode(self)
+      #  "<##{self.class.name}:0x#{Java::JavaLang::Integer.toHexString(id_hash)} #{to_s}>"
+      #end
+
+    end
+
+    NashornException.class_eval do
+      alias_method :value, :thrown
+    end
+
+  end
+end

data/lib/nashorn/rhino/less.rb

@@ -0,0 +1,84 @@
+begin
+  require 'nashorn/rhino'
+rescue LoadError => e
+  warn "[WARNING] Please install gem 'dienashorner' to use Less under JRuby."
+  raise e
+end
+
+require 'less/java_script'
+
+module Less
+  module JavaScript
+    class NashornContext
+
+      def self.instance
+        return new # NOTE: for Rhino a context should be kept open per thread !
+      end
+
+      def initialize(globals = nil)
+        @context = Nashorn::Context.new :java => true
+        #if @context.respond_to?(:version)
+        #  @context.version = '1.8'
+        #  apply_1_8_compatibility! if @context.version.to_s != '1.8'
+        #else
+        #  apply_1_8_compatibility!
+        #end
+        globals.each { |key, val| @context[key] = val } if globals
+      end
+
+      def unwrap
+        @context
+      end
+
+      def exec(&block)
+        @context.open(&block)
+      rescue Nashorn::JSError => e
+        handle_js_error(e)
+      end
+
+      def eval(source, options = nil)
+        source = source.encode('UTF-8') if source.respond_to?(:encode)
+        @context.eval("(#{source})")
+      rescue Nashorn::JSError => e
+        handle_js_error(e)
+      end
+
+      def call(properties, *args)
+        args.last.is_a?(::Hash) ? args.pop : {} # extract_option!
+        @context.eval(properties).call(*args)
+      rescue Nashorn::JSError => e
+        handle_js_error(e)
+      end
+
+      def method_missing(symbol, *args)
+        if @context.respond_to?(symbol)
+          @context.send(symbol, *args)
+        else
+          super
+        end
+      end
+
+      private
+
+      def handle_js_error(e)
+
+        raise e # TODO NOT IMPLEMENTED
+
+        #if e.value && ( e.value['message'] || e.value['type'].is_a?(String) )
+        #  raise Less::ParseError.new(e, e.value) # LessError
+        #end
+        #if e.unwrap.to_s =~ /missing opening `\(`/
+        #  raise Less::ParseError.new(e.unwrap.to_s)
+        #end
+        #if e.message && e.message[0, 12] == "Syntax Error"
+        #  raise Less::ParseError.new(e)
+        #else
+        #  raise Less::Error.new(e)
+        #end
+      end
+
+    end
+  end
+end
+
+Less::JavaScript.context_wrapper = Less::JavaScript::NashornContext

data/lib/nashorn/rhino.rb

@@ -0,0 +1,34 @@
+require 'nashorn'
+require 'nashorn/context'
+
+module Nashorn
+  module Ruby
+    Scriptable.module_eval do
+
+      def get(name, scope = nil)
+        getMember(name)
+      end
+
+      def has(name, scope = nil)
+        hasMember(name)
+      end
+
+      def put(name, value, scope = nil)
+        setMember(name, value)
+      end
+
+    end
+  end
+  module JS
+    Scriptable = JSObject
+    JavaScriptException = NashornException
+    RhinoException = NashornException
+  end
+end
+
+if Object.const_defined?(:Rhino)
+  warn "therubyrhino seems to be loaded, Nashorn won't emulate Rhino"
+else
+  $LOADED_FEATURES << 'rhino'
+  Rhino = Nashorn # the-borg!
+end

data/lib/nashorn/ruby/access.rb

@@ -0,0 +1,68 @@
+module Nashorn
+  module Ruby
+
+    autoload :DefaultAccess, 'nashorn/ruby/default_access'
+    autoload :AttributeAccess, 'nashorn/ruby/attribute_access'
+
+    class AccessBase
+
+      def has(object, name)
+        # try [](name) method :
+        if object.respond_to?(:'[]') && object.method(:'[]').arity == 1
+          unless internal?(name)
+            value = object.[](name) { return true }
+            return true unless value.nil?
+          end
+        end
+        yield
+      end
+
+      def get(object, name)
+        # try [](name) method :
+        if object.respond_to?(:'[]') && object.method(:'[]').arity == 1
+          value = begin
+            object[name]
+          rescue LocalJumpError
+            nil
+          end unless internal?(name)
+          return Nashorn.to_js(value) unless value.nil?
+        end
+        yield
+      end
+
+      def set(object, name, value)
+        # try []=(name, value) method :
+        if object.respond_to?(:'[]=') && object.method(:'[]=').arity == 2
+          rb_value = Nashorn.to_rb(value)
+          begin
+            return object[name] = rb_value
+          rescue LocalJumpError
+          end unless internal?(name)
+        end
+        yield
+      end
+
+      def has_slot(object, index, &block)
+        has(object, index, &block)
+      end
+
+      def get_slot(object, index, &block)
+        get(object, index, &block)
+      end
+
+      def set_slot(object, index, value, &block)
+        set(object, index, value, &block)
+      end
+
+      private
+
+      UNDERSCORES = '__'.freeze
+
+      def internal?(name) # e.g. '__iterator__', '__proto__'
+        name.is_a?(String) && name.start_with?(UNDERSCORES) && name.end_with?(UNDERSCORES)
+      end
+
+    end
+
+  end
+end

data/lib/nashorn/ruby/attribute_access.rb

@@ -0,0 +1,41 @@
+module Nashorn
+  module Ruby
+    class AttributeAccess < AccessBase
+
+      def has(object, name)
+        if object.respond_to?(name.to_s) ||
+           object.respond_to?(:"#{name}=") # might have a writer but no reader
+          return true
+        end
+        super
+      end
+
+      def get(object, name)
+        name_sym = name.to_s.to_sym
+        if object.respond_to?(name_sym)
+          method = object.method(name_sym)
+          if method.arity == 0 && # check if it is an attr_reader
+            ( object.respond_to?(:"#{name}=") ||
+                object.instance_variables.find { |var| var.to_sym == :"@#{name}" } )
+            return Nashorn.to_js(method.call)
+          else
+            return Function.wrap(method.unbind)
+          end
+        elsif object.respond_to?(:"#{name}=")
+          return nil # it does have the property but is non readable
+        end
+        super
+      end
+
+      def set(object, name, value)
+        if object.respond_to?(set_name = :"#{name}=")
+          rb_value = Nashorn.to_rb(value)
+          return object.send(set_name, rb_value)
+        end
+        super
+      end
+      alias_method :put, :set
+
+    end
+  end
+end

data/lib/nashorn/ruby/default_access.rb

@@ -0,0 +1,37 @@
+module Nashorn
+  module Ruby
+    class DefaultAccess < AccessBase
+
+      def has(object, name)
+        if object.respond_to?(name.to_s) ||
+           object.respond_to?(:"#{name}=")
+          return true
+        end
+        super
+      end
+
+      def get(object, name)
+        if object.respond_to?(name_s = name.to_s)
+          method = object.method(name_s)
+          if method.arity == 0
+            return Nashorn.to_js(method.call)
+          else
+            return Function.wrap(method.unbind)
+          end
+        elsif object.respond_to?(:"#{name}=")
+          return nil
+        end
+        super
+      end
+
+      def set(object, name, value)
+        if object.respond_to?(set_name = :"#{name}=")
+          return object.send(set_name, Nashorn.to_rb(value))
+        end
+        super
+      end
+      alias_method :put, :set
+
+    end
+  end
+end