mdarray-sol 0.1.0-java

data/lib/jx/hash_handler.js

@@ -0,0 +1,87 @@
+/******************************************************************************************
+* @author Rodrigo Botafogo
+*
+* Copyright © 2016 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+* and distribute this software and its documentation, without fee and without a signed 
+* licensing agreement, is hereby granted, provided that the above copyright notice, this 
+* paragraph and the following two paragraphs appear in all copies, modifications, and 
+* distributions.
+*
+* IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+* INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+* THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+* POSSIBILITY OF SUCH DAMAGE.
+*
+* RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+* SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+* RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+* OR MODIFICATIONS.
+*****************************************************************************************/
+
+/****************************************************************************************
+* Methods to proxy a Ruby Hash
+****************************************************************************************/
+
+function HashHandler(ruby_obj) {
+  RubyHandler.call(this, ruby_obj);
+}
+
+HashHandler.prototype = Object.create(RubyHandler.prototype, {
+  constructor: {
+    configurable: true,
+    enumerable: true,
+    value: HashHandler,
+    writable: true
+  }  
+})
+
+HashHandler.prototype.get = function(target, property) {
+
+  // check to see if 'property' is a hash value
+  if ((res = this.ruby_obj.get_key(property)) != null)
+    return res;
+
+  switch(property) {
+  case "isProxy":
+    return true
+  case "ruby_obj":
+    return this.ruby_obj;
+  }
+
+  if (this.ruby_obj.run("respond_to?", property))
+    return RubyHandler.prototype.get.call(this, target, property);
+}
+
+HashHandler.prototype.set = function(target, property, value, receiver) {
+  if (this.ruby_obj.run("respond_to?", property)) {
+    return RubyHandler.prototype.set.call(this, target, property, value, receiver);
+  } else {
+    return this.ruby_obj.run("[]=", property, value);
+  }
+}
+
+HashHandler.prototype.getOwnPropertyDescriptor = function(target, property) {
+  var res = this.ruby_obj.run("[]", property);
+  return { configurable: true, enumerable:true, value: res };
+}
+
+HashHandler.prototype.ownKeys = function(target) {
+  return this.ruby_obj.run("keys");
+}
+
+/*
+HashHandler.prototype.has = function(target, property) {
+  return this.ruby_obj.run("respond_to?", property)
+}
+
+HashHandler.prototype.isExtensible = function(target) {
+  console.log("Method isExtensible in file hash_handler.js");
+  return false;
+}
+
+HashHandler.prototype.preventExtensions = function(target) {
+  console.log("Method preventExtensions in file hash_handler.js");
+  return true;
+}
+*/

data/lib/jx/irbobject.rb

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# @author Rodrigo Botafogo
+#
+# Copyright © 2016 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation, without fee and without a signed 
+# licensing agreement, is hereby granted, provided that the above copyright notice, this 
+# paragraph and the following two paragraphs appear in all copies, modifications, and 
+# distributions.
+#
+# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+# SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+# OR MODIFICATIONS.
+##########################################################################################
+
+class Sol
+
+  ##########################################################################################
+  # An IRBObject is an "Internal" Ruby Object, i.e., is is created while executing a
+  # callback method that returns a Ruby Object and it stays inside a javascript script.
+  # This happens when a ruby block is passed as argument to a javascript function that
+  # expects a function as parameter. The block is converted to a javascript function
+  # in ruby_rich.rb by the call to:
+  #   // Makes a callback function from a given Ruby block
+  #   this.make_callback = function(blk) {
+  #     return function (...args) { blk.set_this(this); return blk.run("call", ...args); }
+  #   }
+  # When this function is called, blk.run is called, which call Callback.run.  In
+  # Callback.run the arguments are converted to ruby arguments.  If the block returns
+  # a ruby Object, this Object is packed in a IRBObject.
+  ##########################################################################################
+  
+  class IRBObject
+    include Java::ComRbMdarray_sol.RubyCallbackInterface
+
+    attr_reader :jsvalue
+    attr_reader :ruby_obj
+    
+    #------------------------------------------------------------------------------------
+    # Undefine methods so that they are caught by method_missing and send to the
+    # actual object
+    #------------------------------------------------------------------------------------
+
+    undef :instance_variable_defined?
+    undef :instance_variable_get
+    undef :instance_variable_set
+    undef :instance_variables
+    undef :method
+    undef :methods
+    undef :private_methods
+    undef :protected_methods
+    undef :public_method
+    undef :public_methods
+    undef :public_send
+    undef :remove_instance_variable
+    undef :respond_to?
+    undef :respond_to_missing?
+    undef :singleton_methods
+    undef :taint
+    undef :tainted?
+    undef :tap
+    undef :to_enum
+    undef :to_s
+    undef :trust
+    undef :untaint
+    undef :untrust
+    undef :untrusted?    
+    # undef :singleton_method
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def initialize(jsvalue)
+      @jsvalue = jsvalue
+      @run_func = @jsvalue.getProperty("run")
+      @ruby_obj = @jsvalue.asJavaObject().ruby_obj
+    end
+
+    #----------------------------------------------------------------------------------------
+    #
+    #----------------------------------------------------------------------------------------
+
+    def is_instance_of(class_name)
+      B.invoke(@jsvalue, @run_func, "is_instance_of", class_name)
+    end
+
+    #------------------------------------------------------------------------------------
+    # An IRBObject is called with ruby arguments, so it does not need to call any
+    # process_arguments method as it is proxies a Ruby object
+    # TODO: Might actually need to process_args on the argument since we use invoke
+    # BUG!!!
+    #------------------------------------------------------------------------------------
+
+    def method_missing(symbol, *args, &blk)
+      # B.invoke(@jsvalue, @run_func, symbol, *args)
+      @ruby_obj.send(symbol, *args, &blk)
+    end
+    
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def native(*args)
+      p "IRBObject native method.  NOT WORKING YET!!"
+      method = args.shift
+      # other is a ruby object
+      other = args.shift
+    end
+
+  end
+
+end

data/lib/jx/js.rb

@@ -0,0 +1,442 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# @author Rodrigo Botafogo
+#
+# Copyright © 2016 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation, without fee and without a signed 
+# licensing agreement, is hereby granted, provided that the above copyright notice, this 
+# paragraph and the following two paragraphs appear in all copies, modifications, and 
+# distributions.
+#
+# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+# SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+# OR MODIFICATIONS.
+##########################################################################################
+
+require 'benchmark'
+
+require 'json'
+require_relative 'jsobject'
+require_relative 'rbobject'
+require_relative 'irbobject'
+
+class Sol
+  
+  #==========================================================================================
+  # Class to communicate with the embedded browser (jxBrowser), by sending javascript
+  # messages
+  #==========================================================================================
+
+  class Js
+    java_import com.teamdev.jxbrowser.chromium.events.ConsoleListener
+    java_import com.teamdev.jxbrowser.chromium.JSONString
+    
+    #========================================================================================
+    # Class RBListener listen for the Browser console.log messages
+    #========================================================================================
+    
+    class RBListener
+      include ConsoleListener
+      # include DisposeListener
+      
+      def onMessage(event)
+        puts "JS> #{event.getMessage()}"
+      end
+      
+    end
+
+    #========================================================================================
+    # @attr_reader [Browser] jxBrowser instance
+    # @attr_reader identity [jsFunction] A javascript function that implements the identity
+    # function
+    # @attr_reader instanceOf [jsFunction] A javascript function that returns if a JSObject
+    # is an instance of a class
+    #========================================================================================
+    
+    attr_reader :browser
+    attr_accessor :identity
+    attr_accessor :instanceOf
+        
+    #------------------------------------------------------------------------------------
+    # @param browser [Browser] the jxBrowser instance
+    #------------------------------------------------------------------------------------
+
+    def initialize(browser)
+
+      @browser = browser
+
+      # listen for console events
+      @browser.addConsoleListener(RBListener.new)
+      
+    end
+        
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def typeof(object)
+      object.typeof
+    end
+
+    #------------------------------------------------------------------------------------
+    # @return the browser 'window' object
+    #------------------------------------------------------------------------------------
+
+    def window
+      @browser.executeJavaScriptAndReturnValue("window")
+    end
+
+    #------------------------------------------------------------------------------------
+    # @return the browser 'document' object
+    #------------------------------------------------------------------------------------
+
+    def document
+      @browser.executeJavaScriptAndReturnValue("document")
+    end
+
+    #------------------------------------------------------------------------------------
+    # @return the browser JSContext
+    #------------------------------------------------------------------------------------
+
+    def jscontext
+      @browser.getJSContext()
+    end
+    
+    #------------------------------------------------------------------------------------
+    # Calls Chrome printing popup interface
+    #------------------------------------------------------------------------------------
+
+    def print_page
+      @browser.print
+    end
+    
+    #------------------------------------------------------------------------------------
+    # Applies javascript method 'instanceOf' defined in ruby_rich.rb to the given object
+    # and type.  'instanceOf' is a JSFunction.
+    # @param object [JSObject]
+    # @param type [String] the type to check
+    #------------------------------------------------------------------------------------
+
+    def instanceof(object, type)
+      @instanceOf[object, type]
+    end
+    
+    #------------------------------------------------------------------------------------
+    # Applies the javascript 'identity' function to the given value.
+    # @return [JSObject || primitive] a proxy object or a primitive that does not need to
+    # be proxied
+    #------------------------------------------------------------------------------------
+
+    def push(value)
+      @identity[value]
+    end
+    
+    #------------------------------------------------------------------------------------
+    # return [JSObject || primitive] the given property from the 'window' scope
+    #------------------------------------------------------------------------------------
+
+    def pull(name)
+      eval("#{name};")
+    end
+
+    #------------------------------------------------------------------------------------
+    # Proxies a ruby object into a javascript object.  The javascript object captures
+    # all method calls and forwads them to a packed ruby object, by calling method 'run'
+    # on this packed object
+    # @param obj [Object] The ruby object to be proxied
+    # @return [JSObject || RBObject]
+    #------------------------------------------------------------------------------------
+
+    def proxy(obj)
+
+      case obj
+      when TrueClass, FalseClass, Numeric, String, NilClass
+        obj
+      when Java::ComTeamdevJxbrowserChromium::JSValue
+        JSObject.build(obj)
+      when Proc
+        # TODO: Needs to test Proc proxying.  I don´t think the code ever gets here
+        blk2func(obj)
+      when Object
+        # B.obj = Callback.new(obj)
+        B.obj = Callback.build(obj)
+        RBObject.new(jeval("new RubyProxy(obj)"), obj, true)
+      else
+        raise "No method to proxy the given object: #{obj}"
+      end
+      
+    end
+    
+    #----------------------------------------------------------------------------------------
+    # Pack a ruby object for use inside a javascript script.  A packed ruby object is
+    # identical to a proxy object exect by the return value that is a java.JSValue and not
+    # a Sol::xxx object.
+    # @param obj [Object] The ruby object to be packed
+    # @return [java.JSObject] A java.JSObject that that implements the 'run' interface
+    #----------------------------------------------------------------------------------------
+
+    def pack(obj)
+
+      case obj
+      when TrueClass, FalseClass, Numeric, String, NilClass,
+           Java::ComTeamdevJxbrowserChromium::JSValue
+        obj
+      when Proc
+        blk2func(obj).jsvalue
+      when Object
+        B.obj = Callback.build(obj)
+        jeval("new RubyProxy(obj)")
+      else
+        raise "No method to pack the given object: #{obj}"
+      end
+      
+    end
+
+    #------------------------------------------------------------------------------------
+    # Evaluates the javascript script synchronously and then proxies the result in a
+    # Ruby JSObject or RBObject
+    # @param scrpt [String] a javascript script to be executed synchronously
+    # @return [JSObject || RBObject] a JSObject or one of its subclasses
+    #------------------------------------------------------------------------------------
+
+    def eval(scrpt)
+      proxy(@browser.executeJavaScriptAndReturnValue(scrpt))
+    end
+
+    #------------------------------------------------------------------------------------
+    # Evaluates the javascript script synchronously, but does not pack in JSObject. This
+    # method should not be normally called by normal users.  This should be used only in
+    # some special cases, usually developers of this application.
+    # @param scrpt [String] a javascript script to be executed synchronously
+    # @return [java.JSObject] a java.JSObject
+    #------------------------------------------------------------------------------------
+
+    def jeval(scrpt)
+      @browser.executeJavaScriptAndReturnValue(scrpt)
+    end
+
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def eval_obj(jsobject, prop)
+      B.obj = push(jsobject)
+      jeval(<<-EOT)
+         obj.#{prop}
+      EOT
+    end
+    
+    #------------------------------------------------------------------------------------
+    # Invokes the function
+    # @param scope [Java::JSObject] the object that holds the function, i.e., it´s scope
+    # @param function [java JSFunction] the function to be invoked, already in its java
+    # form
+    # @param *args [Args] a list of java arguments to pass to the function
+    # @return jsobject [JSObject] a JSObject or one of its subclasses depending on the
+    # result of the function invokation
+    # TODO: needs implementation/tests to call functions in the scope of a given object.
+    # method_missing in jsobject does create fix the scope, but needs to check if this
+    # also needs to be done in this (invoke) method.
+    #------------------------------------------------------------------------------------
+
+    def invoke(scope, function, *args)
+      args = nil if (args.size == 1 && args[0].nil?)
+      proxy(function.invoke(scope, *(args)))
+    end
+
+    #------------------------------------------------------------------------------------
+    # Duplicates the given Ruby data into a javascript object in the Browser
+    # @param name [Symbol, String] the name of the javascript variable into which to dup
+    # @param data [Object] a Ruby object
+    #------------------------------------------------------------------------------------
+
+    def dup(data)
+      push(JSONString.new(data.to_json))
+    end
+    
+    #------------------------------------------------------------------------------------
+    # Creates a new function in javascript and returns it as a jsfunction
+    # @param symbol [Symbol] the name of the function in javascript namespace.  If not
+    # given, then a temporary name is used just to be able to create the function.
+    # @return [JSFunction] a jsfunction.
+    #------------------------------------------------------------------------------------
+
+    def function(definition)
+      eval("var __tmpvar__ = function #{definition}")
+      eval("__tmpvar__")
+    end
+
+    #------------------------------------------------------------------------------------
+    # TODO: Something is wrong here!!!!  Need to set B.block, but if we pass the B.block
+    # variable to make_callback, the application crashes.
+    #------------------------------------------------------------------------------------
+
+    def blk2func(blk)
+      B.block = Callback.build(blk)
+      B.rr.make_callback(nil)
+    end
+    
+    #------------------------------------------------------------------------------------
+    #
+    #------------------------------------------------------------------------------------
+
+    def method_missing(symbol, *args, &blk)
+
+      # if block is given, then create a javascript function that will call the block
+      # passing the args
+      args.push(blk2func(blk)) if (blk)
+        
+      name = symbol.id2name
+      name.gsub!(/__/,"$")
+
+      if name =~ /(.*)=$/
+        ret = assign_window($1, process_args(args)[0])
+      else
+        if (((ret = pull(name)).is_a? Sol::JSObject) && ret.function?)
+          if (args.size > 0)
+            if (args.size == 1 && args[0].nil?)
+              ret = ret.send
+            else
+              ret = ret.send(*args)
+            end
+          end
+        end
+      end
+      ret
+    end
+#=begin    
+    #------------------------------------------------------------------------------------
+    # Converts Ruby arguments into a javascript objects to run in a javascript
+    # script.  A Sol::JSObject and Sol::RBObject are similar in that they pack a 'native'
+    # object (either java.JSObject or ruby Object).  These objects show up in a ruby
+    # script and when injected in javascript their jsvalue is made available.  An
+    # IRBObject (Internal Ruby Object) appears when a Ruby Callback is executed and
+    # exists for the case that this object transitions between javascript and ends up
+    # in a Ruby script.
+    # @param args [Array] Ruby array with ruby arguments
+    # @return args [Array] Ruby array with ruby arguments converted to javascript
+    # arguments
+    # TODO: Can an IRBObject end up in a javascript script? If so, will it work fine?
+    # TODO: Make tests that allow Proc/block to be injected into javascript
+    #------------------------------------------------------------------------------------
+
+    def process_args(args)
+
+      args.map do |arg|
+        case arg
+        when Sol::IRBObject # Sol::Callback
+          arg
+        when Sol::JSObject, Sol::RBObject
+          arg.jsvalue
+        when Hash, Array
+          pack(arg)
+        when Symbol
+          raise "Ruby Symbols are not supported in jxBrowser.  Converting ':#{arg}' not supported."
+        when Proc
+          p "i´m a proc... not implemented yet"
+          arg
+        else
+          arg
+        end
+      end
+      
+    end
+#=end    
+    #------------------------------------------------------------------------------------
+    # Converts Ruby arguments into a javascript objects to run in a javascript
+    # script.  A Sol::JSObject and Sol::RBObject are similar in that they pack a 'native'
+    # object (either java.JSObject or ruby Object).  These objects show up in a ruby
+    # script and when injected in javascript their jsvalue is made available.  An
+    # IRBObject (Internal Ruby Object) appears when a Ruby Callback is executed and
+    # exists for the case that this object transitions between javascript and ends up
+    # in a Ruby script.
+    # @param args [Array] Ruby array with ruby arguments
+    # @return args [Array] Ruby array with ruby arguments converted to javascript
+    # arguments
+    # TODO: Can an IRBObject end up in a javascript script? If so, will it work fine?
+    # TODO: Make tests that allow Proc/block to be injected into javascript
+    #------------------------------------------------------------------------------------
+
+    def process_args2(args)
+
+      args.map do |arg|
+        case arg
+        when Sol::IRBObject
+          arg.to_java
+        when Sol::JSObject, Sol::RBObject
+          arg.jsvalue.to_java
+        when Hash, Array
+          pack(arg).to_java
+        when Symbol
+          raise "Ruby Symbols are not supported in jxBrowser.  Converting ':#{arg}' not supported."
+        when Proc
+          p "i´m a proc... not implemented yet"
+          arg.to_java
+        else
+          arg.to_java
+        end
+      end
+      
+    end
+
+    #------------------------------------------------------------------------------------
+    # Loads a javascript file relative to the callers directory
+    #------------------------------------------------------------------------------------
+
+    def load(filename)
+
+      file = caller.first.split(/:\d/,2).first
+      dir = File.dirname(File.expand_path(file))
+      
+      scrpt = "" 
+      begin
+        file = File.new("#{dir}/#{filename}", "r") 
+        while (line = file.gets)
+          scrpt << line
+        end
+        file.close
+      rescue => err
+        puts "Exception: #{err}"
+        err
+      end
+
+      @browser.executeJavaScriptAndReturnValue(scrpt)
+      
+    end
+ 
+    #------------------------------------------------------------------------------------
+    # Returns a list of StyleSheet's
+    #------------------------------------------------------------------------------------
+
+    def style_sheets
+      eval(<<-EOT)
+        var __style_sheets__ = document.styleSheets;
+      EOT
+      CSSStyleSheets.new
+    end
+    
+    #------------------------------------------------------------------------------------
+    # Private methods
+    #------------------------------------------------------------------------------------
+
+    private
+    
+    #------------------------------------------------------------------------------------
+    # Assign the data to the given named window property
+    #------------------------------------------------------------------------------------
+
+    def assign_window(property_name, data)
+      window.setProperty(property_name, data)
+    end
+        
+  end
+  
+end