opal 1.1.0 → 1.2.0

data/stdlib/securerandom.rb

@@ -1,44 +1,64 @@
 module SecureRandom
-  def self.hex(count = nil)
-    count ||= 16
-    count = count.to_int unless `typeof count === "number"`
-    raise ArgumentError, 'count of hex numbers must be positive' if count < 0
-    %x{
-      count = Math.floor(count);
-      var repeat = Math.floor(count / 6),
-          remain = count % 6,
-          remain_total = remain * 2,
-          string = '',
-          temp;
-      for (var i = 0; i < repeat; i++) {
-        // parseInt('ff'.repeat(6), 16) == 281474976710655
-        temp = Math.floor(Math.random() * 281474976710655).toString(16);
-        if (temp.length < 12) {
-          // account for leading zeros gone missing
-          temp = '0'.repeat(12 - temp.length) + temp;
-        }
-        string = string + temp;
-      }
-      if (remain > 0) {
-        temp = Math.floor(Math.random()*parseInt('ff'.repeat(remain), 16)).toString(16);
-        if (temp.length < remain_total) {
-          // account for leading zeros gone missing
-          temp = '0'.repeat(remain_total - temp.length) + temp;
+  extend Random::Formatter
+
+  %x{
+    var gen_random_bytes;
+
+    if ((Opal.global.crypto   && Opal.global.crypto.getRandomValues) ||
+        (Opal.global.msCrypto && Opal.global.msCrypto.getRandomValues)) {
+      // This method is available in all non-ancient web browsers.
+
+      var crypto = Opal.global.crypto || Opal.global.msCrypto;
+      gen_random_bytes = function(count) {
+        var storage = new Uint8Array(count);
+        crypto.getRandomValues(storage);
+        return storage;
+      };
+    }
+    else if (Opal.global.crypto && Opal.global.crypto.randomBytes) {
+      // This method is available in Node.js
+
+      gen_random_bytes = function(count) {
+        return Opal.global.crypto.randomBytes(count);
+      };
+    }
+    else {
+      // Let's dangerously polyfill this interface with our MersenneTwister
+      // xor native JS Math.random xor something about current time...
+      // That's hardly secure, but the following warning should provide a person
+      // deploying the code a good idea on what he should do to make his deployment
+      // actually secure.
+      // It's possible to interface other libraries by adding an else if above if
+      // that's really desired.
+
+      #{warn 'Can\'t get a Crypto.getRandomValues interface or Crypto.randomBytes.' \
+             'The random values generated with SecureRandom won\'t be ' \
+             'cryptographically secure'}
+
+      gen_random_bytes = function(count) {
+        var storage = new Uint8Array(count);
+        for (var i = 0; i < count; i++) {
+          storage[i] = #{rand(0xff)} ^ Math.floor(Math.random() * 256);
+          storage[i] ^= +(new Date())>>#{rand(0xff)}&0xff;
         }
-        string = string + temp;
+        return storage;
       }
-      return string;
     }
-  end
+  }
 
-  def self.uuid
-    'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.gsub(/[xy]/) do |ch,|
-      %x{
-        var r = Math.random() * 16 | 0,
-            v = ch == "x" ? r : (r & 3 | 8);
+  def self.bytes(bytes = nil)
+    gen_random(bytes)
+  end
 
-        return v.toString(16);
+  def self.gen_random(count = nil)
+    count = Random._verify_count(count)
+    out = ''
+    %x{
+      var bytes = gen_random_bytes(#{count});
+      for (var i = 0; i < #{count}; i++) {
+        out += String.fromCharCode(bytes[i]);
       }
-    end
+    }
+    out.encode('ASCII-8BIT')
   end
 end

data/tasks/releasing.rake

@@ -49,7 +49,7 @@ CHANGELOG_HEADING = <<~MARKDOWN
   - **Security** to invite users to upgrade in case of vulnerabilities.
 MARKDOWN
 
-desc "Update CHANGELOG.md usign info from published GitHub releases (the first unreleased section is preserved)"
+desc "Update CHANGELOG.md using info from published GitHub releases (the first unreleased section is preserved)"
 task :changelog do
   changelog_path    = "#{__dir__}/../CHANGELOG.md"
   unreleased_path   = "#{__dir__}/../UNRELEASED.md"

data/tasks/testing.rake

@@ -113,6 +113,7 @@ module Testing
 
         require 'spec_helper'
         require 'opal/full'
+        require 'securerandom'
         #{enter_benchmarking_mode}
 
         #{filter_requires}
@@ -354,13 +355,14 @@ task :minitest_node_nodejs do
   files = %w[
     nodejs
     opal-parser
-    nodejs/test_file.rb
     nodejs/test_dir.rb
     nodejs/test_env.rb
-    nodejs/test_io.rb
     nodejs/test_error.rb
+    nodejs/test_file.rb
     nodejs/test_file_encoding.rb
+    nodejs/test_io.rb
     nodejs/test_opal_builder.rb
+    nodejs/test_string.rb
   ]
 
   filename = "tmp/minitest_node_nodejs.rb"
@@ -369,8 +371,9 @@ task :minitest_node_nodejs do
   stubs = "-soptparse -sio/console -stimeout -smutex_m -srubygems -stempfile -smonitor"
   includes = "-Itest -Ilib -Ivendored-minitest"
 
+  use_strict_opt = ENV['USE_STRICT'] ? ' --use-strict' : ''
   sh "ruby -rbundler/setup "\
-     "exe/opal #{includes} #{stubs} -R#{platform} -Dwarning -A --enable-source-location #{filename}"
+     "exe/opal #{includes} #{stubs} -R#{platform} -Dwarning -A --enable-source-location#{use_strict_opt} #{filename}"
 end
 
 desc 'Run smoke tests with opal-rspec to see if something is broken'
@@ -464,4 +467,3 @@ task :test_all => [:rspec, :mspec, :minitest]
 task(:cruby_tests) { warn "The task 'cruby_tests' has been renamed to 'minitest_cruby_nodejs'."; exit 1 }
 task(:test_cruby)  { warn "The task 'test_cruby' has been renamed to 'minitest_cruby_nodejs'."; exit 1 }
 task(:test_nodejs) { warn "The task 'test_nodejs' has been renamed to 'minitest_node_nodejs'."; exit 1 }
-

data/test/nodejs/test_string.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require 'nodejs'
+
+class TestString < Test::Unit::TestCase
+  def test_should_get_bytes
+    assert_equal('foo'.bytesize, 3)
+    assert_equal('foo'.each_byte.to_a, [102, 111, 111])
+    assert_equal('foo'.bytes, [102, 111, 111])
+    assert_equal('foo'.bytes, [102, 111, 111])
+  end
+
+  def test_frozen
+    # Commented out examples somehow work in the strict mode,
+    # but otherwise they don't. I have unfortunately no idea
+    # on where it's mangled, but then I don't see it really
+    # as a really harmful thing.
+
+    #assert_equal((-'x').frozen?, true)
+    assert_equal((+'x').frozen?, false)
+    #assert_equal((-+-'x').frozen?, true)
+    assert_equal((+-+'x').frozen?, false)
+    #assert_equal((`'x'`).frozen?, true)
+    assert_equal((+`'x'`).frozen?, false)
+  end
+end

data/test/opal/promisev2/test_always.rb

@@ -0,0 +1,63 @@
+require 'test/unit'
+require 'promise/v2'
+
+class TestPromiseAlways < Test::Unit::TestCase
+  def test_calls_the_block_when_it_was_resolved
+    x = 42
+    PromiseV2.value(23)
+      .then { |v| x = v }
+      .always { |v| x = 2 }
+      .then { assert_equal(x, 2) }
+  end
+
+  def test_calls_the_block_when_it_was_rejected
+    x = 42
+    PromiseV2.error(23)
+      .rescue { |v| x = v }
+      .always { |v| x = 2 }
+      .always { assert_equal(x, 2) }
+  end
+
+  def test_acts_as_resolved
+    x = 42
+    PromiseV2.error(23)
+      .rescue { |v| x = v }
+      .always { x = 2 }
+      .then { x = 3 }
+      .always { assert_equal(x, 3) }
+  end
+
+  def test_can_be_called_multiple_times_on_resolved_promises
+    p = PromiseV2.value(2)
+    x = 1
+    ps = []
+    ps << p.then { x += 1 }
+    ps << p.fail { x += 2 }
+    ps << p.always { x += 3 }
+
+    PromiseV2.when(ps).always do
+      assert_equal(x, 5)
+    end
+  end
+
+  def test_can_be_called_multiple_times_on_rejected_promises
+    p = PromiseV2.error(2)
+    x = 1
+    ps = []
+    ps << p.then { x += 1 }.fail{}
+    ps << p.fail { x += 2 }
+    ps << p.always { x += 3 }.fail{}
+
+    PromiseV2.when(ps).then do
+      assert_equal(x, 6)
+    end
+  end
+
+  def test_raises_with_alwaysB_if_a_promise_has_already_been_chained
+    p = PromiseV2.new
+
+    p.then! {}
+
+    assert_raise(ArgumentError) { p.always! {} }
+  end
+end

data/test/opal/promisev2/test_error.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'promise/v2'
+
+class TestPromiseError < Test::Unit::TestCase
+  def test_rejects_the_promise_with_the_given_error
+    assert_equal(PromiseV2.error(23).error, 23)
+  end
+
+  def test_marks_the_promise_as_realized
+    assert_equal(PromiseV2.error(23).realized?, true)
+  end
+
+  def test_marks_the_promise_as_rejected
+    assert_equal(PromiseV2.error(23).rejected?, true)
+  end
+end

data/test/opal/promisev2/test_rescue.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+require 'promise/v2'
+
+class TestPromiseRescue < Test::Unit::TestCase
+  def test_calls_the_block_when_the_promise_has_already_been_rejected
+    x = 42
+    PromiseV2.error(23)
+      .rescue { |v| x = v }
+      .always { assert_equal(x, 23) }
+  end
+
+  def test_calls_the_block_when_the_promise_is_rejected
+    a = PromiseV2.new
+    x = 42
+
+    pr = a.rescue { |v| x = v }
+    a.reject(23)
+
+    pr.always { assert_equal(x, 23) }
+  end
+
+  def test_does_not_call_then_blocks_when_the_promise_is_rejected
+    x = 42
+    y = 23
+
+    PromiseV2.error(23).then { y = 42 }.rescue { |v| x = v }.always do
+      assert_equal(x, 23)
+      assert_equal(y, 23)
+    end
+  end
+
+  def test_does_not_call_subsequent_rescue_blocks
+    x = 42
+    PromiseV2.error(23).rescue { |v| x = v }.rescue { x = 42 }.always do
+      assert_equal(x, 23)
+    end
+  end
+
+  def test_can_be_called_multiple_times_on_the_same_promise
+    p = PromiseV2.error(2)
+    x = 1
+
+    ps = []
+
+    ps << p.then { x += 1 }.rescue{}
+    ps << p.rescue { x += 3 }
+    ps << p.rescue { x += 3 }
+
+    PromiseV2.when(ps).always { assert_equal(x, 7) }
+  end
+
+  def test_raises_with_rescueB_if_a_promise_has_already_been_chained
+    p = PromiseV2.new
+
+    p.then! {}
+
+    assert_raise(ArgumentError) { p.rescue! {} }
+  end
+end

data/test/opal/promisev2/test_then.rb

@@ -0,0 +1,90 @@
+require 'test/unit'
+require 'promise/v2'
+
+class TestPromiseThen < Test::Unit::TestCase
+  def test_calls_the_block_when_the_promise_has_already_been_resolved
+    x = 42
+    PromiseV2.value(23)
+      .then { |v| x = v }
+      .always { assert_equal(x, 23) }
+  end
+
+  def test_calls_the_block_when_the_promise_is_resolved
+    a = PromiseV2.new
+    x = 42
+
+    p = a.then { |v| x = v }
+    a.resolve(23)
+
+    p.always { assert_equal(x, 23) }
+  end
+
+  def test_works_with_multiple_chains
+    x = 42
+    PromiseV2.value(2)
+      .then { |v| v * 2 }
+      .then { |v| v * 4 }
+      .then { |v| x = v }
+      .always { assert_equal(x, 16) }
+  end
+
+  def test_works_when_a_block_returns_a_promise
+    a = PromiseV2.new
+    b = PromiseV2.new
+
+    x = 42
+    p = a.then { b }.then { |v| x = v }
+
+    a.resolve(42)
+    b.resolve(23)
+
+    p.always { assert_equal(x, 23) }
+  end
+
+  def test_sends_raised_exceptions_as_rejections
+    x = nil
+
+    PromiseV2.value(2)
+      .then { raise "hue" }
+      .rescue { |v| x = v }
+      .always { assert_equal(x.class, RuntimeError) }
+  end
+
+  def test_sends_raised_exceptions_inside_rescue_blocks_as_next_errors
+    x = nil
+
+    PromiseV2.value(2)
+      .then { raise "hue" }
+      .rescue { raise "omg" }
+      .rescue { |v| x = v }
+      .always { assert_equal(x.class, RuntimeError) }
+  end
+
+  def test_allows_then_to_be_called_multiple_times
+    pr = PromiseV2.value(2)
+    x = 1
+
+    ps = []
+
+    ps << pr.then { x += 1 }
+    ps << pr.then { x += 1 }
+
+    PromiseV2.when(ps).always { assert_equal(x, 3) }
+  end
+
+  def test_raises_with_thenB_if_a_promise_has_already_been_chained
+    pr = PromiseV2.new
+
+    pr.then! {}
+
+    assert_raise(ArgumentError) { pr.then! {} }
+  end
+
+  def test_should_pass_a_delayed_falsy_value
+    pr = PromiseV2.new.resolve(5).then { nil }
+
+    pr.always do |value|
+      assert_equal(value, nil)
+    end
+  end
+end

data/test/opal/promisev2/test_trace.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+require 'promise/v2'
+
+class TestPromiseTrace < Test::Unit::TestCase
+  def test_calls_the_block_with_all_the_previous_results
+    x = 42
+
+    PromiseV2.value(1)
+      .then { 2 }
+      .then { 3 }
+      .trace {|a, b, c| x = a + b + c }
+      .always { assert_equal(x, 6) }
+  end
+
+  def test_calls_the_then_after_the_trace
+    x = 42
+
+    PromiseV2.value(1)
+      .then { 2 }
+      .then { 3 }
+      .trace { |a, b, c| a + b + c }
+      .then { |v| x = v }
+      .always { assert_equal(x, 6) }
+  end
+
+  def test_includes_the_first_value
+    x = 42
+
+    PromiseV2.value(1)
+      .trace { |a| x = a }
+      .always { assert_equal(x, 1) }
+  end
+
+  def test_works_after_a_when
+    x = 42
+
+    PromiseV2.value(1).then {
+      PromiseV2.when PromiseV2.value(2), PromiseV2.value(3)
+    }.trace {|a, b|
+      #x = a + b[0] + b[1]
+      x = "#{a},#{b}"
+    }.always { assert_equal(x, "1,native") } # 6
+  end
+
+  def test_raises_with_traceB_if_a_promise_has_already_been_chained
+    p = PromiseV2.new
+
+    p.then! {}
+
+    assert_raise(ArgumentError) { p.trace! {} }
+  end
+end