opal 1.2.0 → 1.3.0.alpha1

data/tasks/linting.rake

@@ -1,42 +1,52 @@
 import 'tasks/building.rake'
-desc "Build *corelib* and *stdlib* and lint the result"
-task :jshint do
-  dir = 'tmp/lint'
-  puts
-  puts "= Checking distributed files..."
-  unless ENV['SKIP_BUILD']
+
+
+namespace :lint do
+  desc "Build *corelib* and *stdlib* and lint the result"
+  task :eslint do
+    require 'json'
+    require 'pathname'
+
+    result_path = "tmp/lint/result.json"
+    dir = ENV['DIR'] ||= 'tmp/lint'
+    ENV['FORMATS'] = 'js,map'
     rm_rf dir if File.exist? dir
-    ENV['DIR'] = dir
+
     Rake::Task[:dist].invoke
-  end
 
-  Dir["#{dir}/*.js"].each {|path|
-    # opal-builder and opal-parser take so long travis stalls
-    next if path =~ /.min.js\z|opal-builder|opal-parser/
-
-    sh "yarn -s run jshint --verbose #{path}"
-  }
-  puts
-  puts "= Checking corelib files separately..."
-  js_paths = []
-  Dir['opal/{opal,corelib}/*.rb'].each do |path|
-    js_path = "#{dir}/#{path.tr('/', '-')}.js"
-    Bundler::SharedHelpers.set_bundle_environment
-    File.write js_path, Opal.compile(File.read(path), file: path, dynamic_require_severity: :ignore)
-    js_paths << js_path
-  end
-  js_paths.each do |js_path|
-    sh "yarn -s run jshint --verbose #{js_path}"
+    files = Dir["#{dir}/*.js"]
+    es8, es3 = files.partition { |i| i.include? "await" }
+
+    [es3, es8].each do |files|
+      config = (files == es8) ? ["-c", __dir__+"/../.eslintrc.await.js"] : []
+
+      sh "yarn", "run", "eslint", *config, *files, "--format", "json", "--output-file", result_path do |ok, _|
+        if ok
+          puts "Successful."
+        else
+          sh 'node tasks/linting-parse-eslint-results.js'
+          # results = JSON.parse File.read(result_path), symbolize_names: true
+          # results.each do |data|
+          #   next if data[:messages].empty?
+          #
+          #   relative_path = Pathname(data[:filePath]).relative_path_from(Pathname(dir).expand_path)
+          #   puts "* #{relative_path}"
+          #   data[:messages].each do |message|
+          #     puts "  - #{relative_path}:#{message[:line]}:#{message[:column]}-#{message[:endLine]}:#{message[:endColumn]} #{message[:message]}"
+          #   end
+          # end
+        end
+      end
+    end
   end
-  sh 'yarn -s run jshint --verbose opal/corelib/runtime.js'
 end
 
 require 'rubocop/rake_task'
 desc 'Run RuboCop on lib/, opal/ and stdlib/ directories'
-RuboCop::RakeTask.new(:rubocop) do |task|
+RuboCop::RakeTask.new('lint:rubocop') do |task|
   task.options << '--extra-details'
   task.options << '--display-style-guide'
   task.options << '--parallel'
 end
 
-task :lint => [:jshint, :rubocop]
+task :lint => %w[lint:eslint lint:rubocop]

data/tasks/performance/asciidoctor_test.rb.erb

@@ -0,0 +1,6 @@
+JAVASCRIPT_IO_MODULE="nodejs" if RUBY_ENGINE == 'opal'
+require "asciidoctor"
+puts Asciidoctor.convert(DATA.read)
+
+__END__
+<%= File.read('asciidoctor/benchmark/sample-data/mdbasics.adoc') %>

data/tasks/performance/optimization_status.rb

@@ -0,0 +1,77 @@
+klasses = [
+  Array,
+  Class,
+  # Complex,
+  # Dir,
+  Enumerable,
+  Enumerator,
+  Exception,
+  Hash,
+  # Kernel,
+  Math,
+  Method,
+  Module,
+  Object,
+  Proc,
+  Range,
+  Rational,
+  Regexp,
+  Struct,
+  String,
+  Time
+]
+
+%x{
+  function getOptimizationStatus(fn) {
+    var optstatus = %GetOptimizationStatus(fn);
+
+    return (optstatus & (1 << 6)) ? "[INTERPRETED]" : "[COMPILED]";
+  }
+  
+  function triggerOptAndGetStatus(fn) {
+    // using try/catch to avoid having to call functions properly
+    try {
+      // Fill type-info
+      fn();
+      // 2 calls are needed to go from uninitialized -> pre-monomorphic -> monomorphic
+      fn();
+    }
+    catch (e) {}
+    %OptimizeFunctionOnNextCall(fn);
+    try {
+      fn();
+    }
+    catch (e) {}
+    return getOptimizationStatus(fn);
+  }
+}
+
+optimization_status = Hash[klasses.map do |klass|
+  methods = klass.instance_methods
+  methods -= Object.instance_methods unless klass == Object
+  methods -= [:product, :exit, :exit!, :at_exit]
+  opt_status = Hash[methods.map do |method|
+    method_func = `#{klass.instance_method(method)}.method`
+    [method, `triggerOptAndGetStatus(#{method_func})`]
+  end]
+  by_status_grouped = opt_status.group_by {|method, status| status }
+  as_hash = Hash[by_status_grouped.map do |status, stuff|
+    list = stuff.map {|val| val[0]}
+    [status, list]
+  end]
+  [klass, as_hash]
+end]
+
+puts '----Report----'
+optimization_status.sort_by {|klass,_| klass.name}.each do |klass, statuses|
+  puts "---------------"
+  puts "Class #{klass}:"
+  puts "---------------"
+  statuses.sort_by {|stat,_| stat }.each do |status, methods|
+    methods.sort.each do |m|
+      puts "  #{status} #{m}"
+    end
+  end
+end
+
+puts 'done!'

data/tasks/performance.rake

@@ -0,0 +1,149 @@
+# A set of tasks to track performance regressions by the CI
+
+require 'opal/util'
+
+# Runs a block N times and returns a mean number of seconds it took to run it.
+mean_time = proc do |tries: 31, &block|
+  tries.times.map do
+    t = Time.now
+    block.()
+    Time.now - t
+  end.sort[tries/2]
+end
+
+failed = false
+
+# Mark a failure
+failure = proc do |reason|
+  failed ||= []
+  failed << reason
+end
+
+compare_values = proc do |name, current, previous|
+  current = current.to_f
+  previous = previous.to_f
+
+  change = ((current - previous).to_f / previous) * 100
+
+  puts ("%30s: %.3f -> %.3f (change: %+.2f%%)" % [name, previous, current, change]).gsub('.000','')
+
+  if change > 5.0
+    failure.("#{name} increased by more than 5%")
+  end
+end
+
+ASCIIDOCTOR_REPO_BASE = ENV['ASCIIDOCTOR_REPO_BASE'] || 'https://github.com/asciidoctor'
+
+# Selected asciidoctor versions were working on Aug 19 2021, feel free to update.
+ASCIIDOCTOR_PREPARE = [
+  "bundle",
+  "exec",
+  "bash",
+  "-c",
+  <<~BASH
+    mkdir -p tmp/performance
+    pushd tmp/performance
+    git clone #{ASCIIDOCTOR_REPO_BASE}/asciidoctor >/dev/null 2>&1
+    pushd asciidoctor; git checkout 869e8236 >/dev/null 2>&1; popd
+    git clone #{ASCIIDOCTOR_REPO_BASE}/asciidoctor.js >/dev/null 2>&1
+    pushd asciidoctor.js; git checkout 053fa0d3 >/dev/null 2>&1; popd
+    erb ../../tasks/performance/asciidoctor_test.rb.erb > asciidoctor_test.rb
+    popd
+  BASH
+]
+
+ASCIIDOCTOR_BUILD_OPAL = "bin/opal --no-cache -c " \
+           "-Itmp/performance/asciidoctor/lib " \
+           "-Itmp/performance/asciidoctor.js/packages/core/lib " \
+           "tmp/performance/asciidoctor_test.rb > tmp/performance/asciidoctor_test.js"
+ASCIIDOCTOR_RUN_RUBY = "bundle exec ruby -Itmp/performance/asciidoctor/lib tmp/performance/asciidoctor_test.rb"
+ASCIIDOCTOR_RUN_OPAL = "node tmp/performance/asciidoctor_test.js"
+
+# Generate V8 function optimization status report for corelib methods
+NODE_OPTSTATUS = "env NODE_OPTS=--allow-natives-syntax bin/opal tasks/performance/optimization_status.rb"
+
+performance_stat = ->(name) {
+  stat = {}
+
+  # Run on current
+  puts "\n* Checking optimization status with #{name}..."
+  sh("#{NODE_OPTSTATUS} > tmp/performance/optstatus_#{name}")
+
+  puts "\n* Building AsciiDoctor with #{name}..."
+  stat[:compiler_time] = mean_time.(tries: 3) { sh(ASCIIDOCTOR_BUILD_OPAL) }
+
+  puts "\n* Running AsciiDoctor with #{name}..."
+  stat[:run_time] = mean_time.(tries: 31) { sh("#{ASCIIDOCTOR_RUN_OPAL} > tmp/performance/opal_result_#{name}.html") }
+  stat[:correct] = File.read("tmp/performance/opal_result_#{name}.html") == File.read("tmp/performance/ruby_result.html")
+  stat[:size] = File.size("tmp/performance/asciidoctor_test.js")
+
+  puts "\n* Minifying AsciiDoctor with #{name}..."
+  stat[:min_size] = Opal::Util.uglify(File.read("tmp/performance/asciidoctor_test.js")).bytesize rescue Float::INFINITY
+
+  stat
+}
+
+namespace :performance do
+  task :compare do
+    this_ref = `git describe --tags`.chomp
+    ref = 'master'
+    ref = ENV['GITHUB_BASE_REF'] if ENV['GITHUB_BASE_REF'] && !ENV['GITHUB_BASE_REF'].empty?
+
+    # Prepare
+    puts "\n* Preparing asciidoctor..."
+    sh(*ASCIIDOCTOR_PREPARE)
+
+    puts "\n* Running AsciiDoctor with CRuby..."
+    sh("#{ASCIIDOCTOR_RUN_RUBY} > tmp/performance/ruby_result.html")
+
+    current = performance_stat.(:current)
+
+    # Prepare previous
+    sh("git checkout --recurse-submodules #{ref} && bundle install >/dev/null 2>&1")
+
+    previous = performance_stat.(:previous)
+
+    # Restore current
+    sh("git checkout --recurse-submodules - && bundle install >/dev/null 2>&1")
+
+    # Summary
+    puts "\n=== Summary ==="
+    puts "Summary of performance changes between (previous) #{ref} and (current) #{this_ref}:"
+
+    diff = `diff --report-identical-files -F '^Class' -Naur tmp/performance/optstatus_previous tmp/performance/optstatus_current`
+    diff_lines = diff.split("\n")
+
+    puts
+    puts "Comparison of V8 function optimization status:"
+    puts diff
+
+    if diff_lines.grep(/^-\s+\[COMPILED\]/).count > 0
+      failure.("Some methods are no longer compiled on V8")
+    end
+
+    puts
+    puts "Comparison of the Asciidoctor (a real-life Opal application) compile and run:"
+
+    failure.("Wrong result on the current branch") unless current[:correct]
+    failure.("Wrong result on the previous branch - ignore it") unless previous[:correct]
+
+    compare_values.("Compile time",        current[:compiler_time], previous[:compiler_time])
+    compare_values.("Run time",                 current[:run_time],      previous[:run_time])
+    compare_values.("Bundle size",                  current[:size],          previous[:size])
+    compare_values.("Minified bundle size",     current[:min_size],      previous[:min_size])
+
+    if failed
+      puts "--- Failures ---"
+      failed.each do |f|
+        puts " - #{f}"
+      end
+      puts
+      puts "This run failed - some performance checks did not pass. Don't worry, this is"
+      puts "informative, not fatal. It may be worth to rerun the task, rebase the branch,"
+      puts "or consult those results with a pull request reviewer."
+      fail
+    end
+  end
+end
+
+task :performance => ['performance:compare']

data/tasks/testing.rake

@@ -284,7 +284,7 @@ Use PATTERN environment variable to manually set the glob for specs:
   bundle exec rake mspec_nodejs PATTERN=spec/ruby/core/numeric/**_spec.rb
 DESC
 
-platforms = %w[nodejs server chrome]
+platforms = %w[nodejs server chrome gjs]
 mspec_suites = %w[ruby opal]
 minitest_suites = %w[cruby]
 
@@ -331,6 +331,13 @@ platforms.each do |platform|
           opal/test_openuri.rb
           opal/unsupported_and_bugs.rb
           opal/test_matrix.rb
+          opal/promisev2/test_always.rb
+          opal/promisev2/test_error.rb
+          opal/promisev2/test_rescue.rb
+          opal/promisev2/test_then.rb
+          opal/promisev2/test_trace.rb
+          opal/promisev2/test_value.rb
+          opal/promisev2/test_when.rb
         ]
       end
       Testing::HTTPServer.new.with_server do |session|
@@ -363,6 +370,7 @@ task :minitest_node_nodejs do
     nodejs/test_io.rb
     nodejs/test_opal_builder.rb
     nodejs/test_string.rb
+    nodejs/test_await.rb
   ]
 
   filename = "tmp/minitest_node_nodejs.rb"

data/test/nodejs/test_await.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+# await: true
+
+require "test/unit"
+
+class TestAwait < Test::Unit::TestCase
+  stdheader = <<~RUBY
+    # await: true
+    require "await"
+  RUBY
+
+  tests = {
+    test_await_in_top: [<<~RUBY, 6],
+      #{stdheader}
+      $taval = 5
+      sleep(0.001).__await__
+      $taval = 6
+    RUBY
+    test_await_in_method: [<<~RUBY, 7],
+      #{stdheader}
+      $taval = 5
+      def xx_taim
+        sleep(0.001).__await__
+        $taval = 7
+      end
+      xx_taim.__await__
+    RUBY
+    test_await_in_block: [<<~RUBY, 0],
+      #{stdheader}
+      $taval = 5
+      xx_taib = proc do
+        sleep(0.001).__await__
+        $taval = 0
+      end
+      xx_taib.().__await__
+    RUBY
+    test_await_in_instance_method: [<<~RUBY, 3],
+      #{stdheader}
+      $taval = 5
+      class XXTaiim
+        def xx_taiim
+          sleep(0.001).__await__
+          $taval = 3
+        end
+      end
+      XXTaiim.new.xx_taiim.__await__
+    RUBY
+    test_await_in_class_method: [<<~RUBY, 4],
+      #{stdheader}
+      $taval = 5
+      class XXTaicm
+        def self.xx_taicm
+          sleep(0.001).__await__
+          $taval = 4
+        end
+      end
+      XXTaicm.xx_taicm.__await__
+    RUBY
+    test_await_on_promise: [<<~RUBY, 8],
+      #{stdheader}
+      $taval = PromiseV2.value(8).__await__
+    RUBY
+    test_await_in_while: [<<~RUBY, 9],
+      #{stdheader}
+      $taval = 5
+      begin
+        sleep(0.001).__await__
+        $taval = 9
+      end while false
+    RUBY
+    test_await_in_while_expr: [<<~RUBY, -9],
+      #{stdheader}
+      $taval = 5
+      x = if true
+        begin
+          sleep(0.001).__await__
+          $taval = -9
+        end while false
+      end
+    RUBY
+    test_await_in_case: [<<~RUBY, 88],
+      #{stdheader}
+      $taval = 5
+      case true
+      when true
+        sleep(0.001).__await__
+        $taval = 88
+      end
+    RUBY
+    test_await_in_case_expr: [<<~RUBY, 99],
+      #{stdheader}
+      $taval = 5
+      x = case true
+      when true
+        sleep(0.001).__await__
+        $taval = 99
+      end
+    RUBY
+    test_await_in_rescue: [<<~RUBY, 10],
+      #{stdheader}
+      $taval = 5
+      begin
+        sleep(0.001).__await__
+        nomethoderror
+      rescue
+        sleep(0.001).__await__
+        $taval = 10
+      end
+    RUBY
+    test_await_in_ensure: [<<~RUBY, 11],
+      #{stdheader}
+      $taval = 5
+      begin
+        sleep(0.001).__await__
+        nomethoderror
+      rescue
+        sleep(0.001).__await__
+      ensure
+        sleep(0.001).__await__
+        $taval = 11
+      end
+    RUBY
+    test_await_in_ensure_expr: [<<~RUBY, -11],
+      #{stdheader}
+      $taval = 5
+      x = begin
+        sleep(0.001).__await__
+        nomethoderror
+      rescue
+        sleep(0.001).__await__
+      ensure
+        sleep(0.001).__await__
+        $taval = -11
+      end
+    RUBY
+    test_await_in_module: [<<~RUBY, 12],
+      #{stdheader}
+      $taval = 5
+      module XYTaim
+        sleep(0.001).__await__
+        $taval = 12
+      end
+    RUBY
+    test_await_in_class: [<<~RUBY, 13],
+      #{stdheader}
+      $taval = 5
+      class XYTaic
+        sleep(0.001).__await__
+        $taval = 13
+      end
+    RUBY
+    test_await_in_and: [<<~RUBY, 14],
+      #{stdheader}
+      ($taval = 5) && (PromiseV2.value(4).__await__) && ($taval = 14)
+    RUBY
+    test_await_in_plus: [<<~RUBY, 15],
+      #{stdheader}
+      $taval = 5
+      $taval = PromiseV2.value(5).__await__ + 10
+    RUBY
+  }
+
+  tests.each do |name,(code,expect)|
+    define_method name do
+      eval(code).__await__
+      assert_equal(expect, $taval)
+    end
+  end
+end

data/test/opal/promisev2/test_error.rb

@@ -3,14 +3,20 @@ require 'promise/v2'
 
 class TestPromiseError < Test::Unit::TestCase
   def test_rejects_the_promise_with_the_given_error
-    assert_equal(PromiseV2.error(23).error, 23)
+    prom = PromiseV2.error(23)
+    assert_equal(prom.error, 23)
+    prom.rescue{} # Needed, otherwise we have an uncaught exception
   end
 
   def test_marks_the_promise_as_realized
-    assert_equal(PromiseV2.error(23).realized?, true)
+    prom = PromiseV2.error(23)
+    assert_equal(prom.realized?, true)
+    prom.rescue{} # Needed, otherwise we have an uncaught exception
   end
 
   def test_marks_the_promise_as_rejected
-    assert_equal(PromiseV2.error(23).rejected?, true)
+    prom = PromiseV2.error(23)
+    assert_equal(prom.rejected?, true)
+    prom.rescue{}
   end
 end

data/test/opal/unsupported_and_bugs.rb

@@ -37,3 +37,8 @@ class TestCall
   unsupported :test_safe_call_block_call_brace
   unsupported :test_safe_call_block_call_command
 end
+
+class TestBenchmark
+  # sleep is unsupported if not awaited
+  unsupported :test_realtime_output
+end

data/vendored-minitest/minitest/benchmark.rb

@@ -1,3 +1,5 @@
+# await: *await*
+
 require 'minitest/unit'
 require 'minitest/spec'
 
@@ -88,10 +90,10 @@ module Minitest
 
       times = []
 
-      range.each do |x|
+      range.each_await do |x|
         GC.start
         t0 = Time.now
-        instance_exec(x, &work)
+        instance_exec(x, &work).await
         t = Time.now - t0
 
         io.print "\t%9.6f" % t
@@ -132,7 +134,7 @@ module Minitest
         [a, b, rr]
       end
 
-      assert_performance validation, &work
+      assert_performance(validation, &work).await
     end
 
     ##
@@ -152,7 +154,7 @@ module Minitest
     #   end
 
     def assert_performance_exponential threshold = 0.99, &work
-      assert_performance validation_for_fit(:exponential, threshold), &work
+      assert_performance(validation_for_fit(:exponential, threshold), &work).await
     end
 
     ##
@@ -172,7 +174,7 @@ module Minitest
     #   end
 
     def assert_performance_logarithmic threshold = 0.99, &work
-      assert_performance validation_for_fit(:logarithmic, threshold), &work
+      assert_performance(validation_for_fit(:logarithmic, threshold), &work).await
     end
 
     ##
@@ -192,7 +194,7 @@ module Minitest
     #   end
 
     def assert_performance_linear threshold = 0.99, &work
-      assert_performance validation_for_fit(:linear, threshold), &work
+      assert_performance(validation_for_fit(:linear, threshold), &work).await
     end
 
     ##
@@ -212,7 +214,7 @@ module Minitest
     #   end
 
     def assert_performance_power threshold = 0.99, &work
-      assert_performance validation_for_fit(:power, threshold), &work
+      assert_performance(validation_for_fit(:power, threshold), &work).await
     end
 
     ##

data/vendored-minitest/minitest/test.rb

@@ -1,3 +1,5 @@
+# await: *await*
+
 require "minitest" unless defined? Minitest::Runnable
 
 module Minitest
@@ -105,16 +107,16 @@ module Minitest
           capture_exceptions do
             before_setup; setup; after_setup
 
-            self.send self.name
-          end
+            self.send(self.name).await
+          end.await
 
-          TEARDOWN_METHODS.each do |hook|
+          TEARDOWN_METHODS.each_await do |hook|
             capture_exceptions do
-              self.send hook
-            end
-          end
-        end
-      end
+              self.send(hook).await
+            end.await
+          end.await
+        end.await
+      end.await
 
       self # per contract
     end
@@ -202,7 +204,7 @@ module Minitest
     end # LifecycleHooks
 
     def capture_exceptions # :nodoc:
-      yield
+      yield.await
     rescue *PASSTHROUGH_EXCEPTIONS
       raise
     rescue Assertion => e
@@ -253,7 +255,7 @@ module Minitest
     def time_it # :nodoc:
       t0 = Time.now
 
-      yield
+      yield.await
     ensure
       self.time = Time.now - t0
     end
@@ -273,7 +275,7 @@ module Minitest
         warn "\nCurrent: %s#%s %.2fs" % [self.class, self.name, Time.now - t0]
       end
 
-      self.class.on_signal "INFO", handler, &block
+      self.class.on_signal("INFO", handler, &block).await
     end
 
     include LifecycleHooks
@@ -282,4 +284,4 @@ module Minitest
   end # Test
 end
 
-require "minitest/unit" unless defined?(MiniTest) # compatibility layer only
+# require "minitest/unit" unless defined?(MiniTest) # compatibility layer only