mdarray-sol 0.1.0-java

data/test/jx/test_proxy_array.rb

@@ -0,0 +1,239 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# 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 'rubygems'
+require "test/unit"
+require 'shoulda'
+
+require '../../config' if @platform == nil
+require 'mdarray-sol'
+
+
+class MDArraySolTest < Test::Unit::TestCase
+
+  context "B environment" do
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    setup do 
+
+    end
+        
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+    
+    should "proxy flat ruby array" do
+
+      a1 = [1, 2, 3]
+      a2 = [4, 5]
+      
+      # p1 and p2 are proxy elements for arrays a1 and a2.  They will work as array
+      # in ruby
+      p1 = B.proxy(a1)
+      p2 = B.proxy(a2)
+
+      assert_equal(1, p1[0])
+      assert_equal(5, p2[1])
+
+      # call method concat
+      assert_equal([1, 2, 3, 4, 5], p1.concat(p2))
+
+      # ... and method fetch
+      assert_equal(4, p1.fetch(3))
+      assert_equal("ooops", p1.fetch(100, "ooops"))
+
+      # ... and each
+      puts "should print values from 1 to 5 as ruby output"
+      p1.each { |d| p d }
+
+      # Now lets see p1 and p2 in javascript
+      B.p1, B.p2 = p1, p2
+      
+      B.eval(<<-EOT)
+        var assert = chai.assert;
+        // Check that proxied arrays share the same data as the original ruby arrays
+        assert.equal(2, p1[1]);
+        assert.equal(5, p1[4]);
+        assert.equal(5, p2[1]);
+        assert.equal(5, p1.length);
+
+        // should also allow negative indices for array access
+        assert.equal(5, p1[-1]);
+        assert.equal(2, p1[-4]);
+
+      EOT
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "proxy nested ruby arrays" do
+
+      a1 = [1, 2, 3]
+      a3 = [[1, 2], [3, 4], [5, 6, [7, [8, 9]]]]
+
+      B.p1 = B.proxy(a1)
+      B.p3 = B.proxy(a3)
+
+      B.eval(<<-EOT)
+        var assert = chai.assert;
+
+        // access each element of the array and call to_s on them.  Note that calling
+        // to_s requires '()', otherwise a function is returned
+        console.log("should print the array elements of: [[1, 2], [3, 4], [5, 6, [7, [8, 9]]]]");
+        p3.each(function(x) { console.log(x.to_s()); })      
+                
+      EOT
+
+      # Note that inspect with 'p' shows IRBObjects
+      puts "This is an inspection of the array.  Note that there are Sol::IRBObject"
+      puts "Sol::IRBObjects are ruby objects packaged for use in javascript"
+      p a1
+
+      # ... but puts makes the elements look like normal array elements
+      puts "But a normal puts will show the array as a normal array"
+      puts a1
+      
+    end
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "proxy nested arrays and hashes" do
+
+      a1 = [{name: "John", "age" => 25}, {name: "Mary", "age" => 30},
+            {name: "Paul", "age" => 18}, {name: "Anton", "age" => 45}]
+
+      B.data = B.proxy(a1)
+
+      B.eval(<<-EOT)
+        var assert = chai.assert;
+
+        assert.equal("John", data[0].fetch("name"));
+        assert.equal(25, data[0].age);
+        assert.equal("Anton", data[3].fetch("name"));
+        assert.equal(18, data[2].age);
+      EOT
+
+    end
+        
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "Allow access directly from a js file" do
+      
+      B.data = [1, 2, 3, 4]
+      B.d2 = [10, 20, 30, 40, 50, 60]
+      
+      # load a javascript file to test arrays.  assert clauses in the javascript file
+      # will not be shown as tests, unfortunately.
+      B.load("test_ruby_array.js")
+      
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "allow array updates" do
+
+      a1 = [1, 2, 3]
+
+      # B.p1 is a javascript object that proxies the a1 ruby array
+      B.p1 = B.proxy(a1)
+
+      assert_equal(1, B.p1[0])
+
+      # assing a value to an array index
+      B.p1[3] = 4
+      assert_equal(4, B.p1[3])
+
+      B.eval(<<-EOT)
+        var assert = chai.assert;
+        assert.equal(4, p1[3]);
+        p1[5] = 5
+        console.log(p1.to_s());        
+      EOT
+      
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "call ruby methods passing javascript functions as blocks" do
+
+      a1 = [1, 2, 3, 4, 5]
+
+      B.p1 = B.proxy(a1)
+      
+      B.eval(<<-EOT)
+
+        var assert = chai.assert;
+        // call ruby functions on the array, including functions that require a block
+        // or have names that do not exist in javascript
+        console.log("should output values 1 to 5 in javascript output");
+        p1.each(function(x) { console.log(x); });
+
+      EOT
+      
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "call ruby methods with invalid javascript names" do
+
+      a1 = [1, 2, 3]
+      a2 = [4, 5]
+      
+      # p1 and p2 are proxy elements for arrays a1 and a2.  They will work as array
+      # in ruby
+      B.p1 = B.proxy(a1)
+      B.p2 = B.proxy(a2)
+      
+      B.eval(<<-EOT)
+        var assert = chai.assert;
+
+        p1.concat(p2);
+        console.log(p1.to_s());
+
+        // Concate two arrays going element by element.  Better use ruby´s concat
+        // method... just an example of using a function as block for the each
+        // method and the use of a method with a name not valid in javascript
+        p2.each(function(x) { p1.send("<<", x); });
+        console.log(p1.to_s());
+
+      EOT
+      
+    end
+
+  end
+
+end

data/test/jx/test_proxy_hash.rb

@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# 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 'rubygems'
+require "test/unit"
+require 'shoulda'
+
+require '../../config' if @platform == nil
+require 'mdarray-sol'
+
+
+class MDArraySolTest < Test::Unit::TestCase
+
+  context "B environment" do
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    setup do 
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "proxy a Ruby hash" do
+
+      # Hash with symbols and strings as keys
+      a = {:a=> 1, "b"=> 2, "c"=> 3, :d=> {:e=> 4, :f=> 5, "g"=> {"h"=> 6, "i"=>7}},
+           "j"=> [1, 2, [3, [4, 5]]]}
+      
+      # hash with symbols and Strings as keys
+      b = {"x"=> 100, "y"=> 200, "c"=> 300, d: 400}
+      
+      # Ruby hash proxies javascript 'data'
+      B.data = B.proxy(a)
+      B.d2 = B.proxy(b)
+      
+      B.eval(<<-EOT)
+
+        var assert = chai.assert;
+
+        // When the key is a ruby symbol, in javascript we need to use the 'fetch' method
+        assert.equal(1, data.fetch("a"));
+        // When the key is a String then '[]' can be used
+        assert.equal(2, data["b"]);
+        // Can also use '.' notation to reach a String key
+        assert.equal(2, data.b);
+        // However symbol keys cannot be reached with '.' notation
+        assert.equal(null, data.a);
+        // Somo more examples
+        assert.equal(3, data["c"]);
+        assert.equal(100, d2["x"]);
+
+        // access deep data 
+        assert.equal(4, data.fetch("d").fetch("e"));
+        assert.equal(7, data.fetch("d").g.i);
+        assert.equal(1, data.j[0]);
+        assert.equal(4, data.j[2][1][0]);
+
+      EOT
+      
+    end
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+    
+    should "allow adding key, value data to a proxied ruby hash" do
+      
+      # New Ruby hash
+      hh = {a: 1, b: 2}
+
+      # Pack a Ruby hash into javascript hh variable.  We could also use B.proxy(hh)
+      # instead of B.pack(hh).  Method pack return a java object and not a Ruby object.
+      # This is ok here since the value is 'injected' into javascript.  Method proxy
+      # return a Ruby object.  Using proxy is less efficient than pack.
+      B.hh = B.pack(hh)
+      
+      # Retrieve the value of a key.  Keys in Javascript cannot be symbol, they have to
+      # be strings.  Sol automatically converts strings to symbols and vice-versa.
+      B.eval(<<-EOT)
+        var h1 = hh.fetch("a");
+        var h2 = hh.fetch("b");
+      EOT
+
+      assert_equal(1, B.h1)
+      assert_equal(2, B.h2)
+
+      # assign values to new keys.
+      B.hh["c"] = 3
+
+      # Not however that we cannot add a Symbol as key when going through a javascript
+      # variable (hh in B)
+      assert_raise (RuntimeError) { B.hh[:d] = 4 }
+
+      # But, of course, we can still add symbols directly in the Ruby hash.  Doing this
+      # way is more efficient than going through javascript.
+      hh[:d] = 4
+
+      # method 'store' converts a string key into a symbol key
+      B.hh.store("f", 6)
+
+      B.eval(<<-EOT)
+        hh["e"] = 5;
+        // add a value to the hash from this javascript
+        hh.store("g", 7);
+        console.log(hh.to_s());
+      EOT
+
+      # Both B.hh (javascript) and hh (ruby) hashes share the same backstore
+      assert_equal(5, hh["e"])
+      assert_equal(6, hh[:f])
+      assert_equal(1, B.hh.fetch("a"))
+      
+    end
+
+  end
+
+end
+
+
+=begin      
+      # load a javascript file to test hash usage from javascript.  assert clauses in the
+      # javascript file will not be computed on test statistics, unfortunately.
+      B.load("test_ruby_hash.js")
+
+      # key :j was added in the javascript file
+      # assert_equal("[:b, :c, :d, :j]", a.keys.to_s)
+      assert_equal("Hello from js", a["j"])
+
+      # add new (key, value) to hash
+      a["k"] = "new val"
+
+      # this new (key, value) pair is available to 'data' in javascript
+      B.eval(<<-EOT)
+        assert.equal("new val", data.k);
+        // data.each_pair (function(param) { console.log(param[1]); } )
+      EOT
+=end

data/test/jx/test_proxy_lambda.rb

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# 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 'rubygems'
+require "test/unit"
+require 'shoulda'
+
+require '../../config' if @platform == nil
+require 'mdarray-sol'
+
+
+class MDArraySolTest < Test::Unit::TestCase
+
+  context "B environment" do
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    setup do 
+
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+=begin    
+    should "proxy Ruby lambdas" do
+      
+      B.eval(<<-EOT)
+        //console.log(block.run("call", 100));
+        //function bk(x) { return block.run("call", x); }
+        //console.log(bk(500));
+        
+        // function text(func) { return func.call(this, 5, 6); };
+        function text(x, y, func) { return func.call(this, x, y); };
+
+      EOT
+
+      p B.text(5, 6) { |x, y| x + y}
+      
+    end
+=end    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    should "allow access to 'this'" do
+
+      blk = Proc.new { |x, y| @this + x + y }
+      B.sol_cb = Sol::Callback.new(blk)
+
+      B.eval(<<-EOT)
+        sol_cb.set_this(100);
+        console.log(sol_cb.run("any", 10, 20))
+      EOT
+      
+    end
+
+  end
+  
+end