opal 1.4.1 → 1.5.0.rc1

data/lib/opal/rewriters/base.rb

@@ -51,7 +51,6 @@ module Opal
       end
 
       alias on_iter       process_regular_node
-      alias on_top        process_regular_node
       alias on_zsuper     process_regular_node
       alias on_jscall     on_send
       alias on_jsattr     process_regular_node
@@ -124,6 +123,18 @@ module Opal
         error.location = current_node.loc if current_node
         raise error
       end
+
+      def on_top(node)
+        node = process_regular_node(node)
+        node.meta[:dynamic_cache_result] = true if @dynamic_cache_result
+        node
+      end
+
+      # Called when a given transformation is deemed to be dynamic, so
+      # that cache is conditionally disabled for a given file.
+      def dynamic!
+        @dynamic_cache_result = true
+      end
     end
   end
 end

data/lib/opal/rewriters/rubyspec/filters_rewriter.rb

@@ -36,6 +36,7 @@ module Opal
         _recvr, method_name, *args = *node
 
         if rubyspec_dsl?(method_name)
+          dynamic!
           spec_name, _ = *args.first
           begin
             @specs_stack.push(spec_name)

data/lib/opal/version.rb

@@ -3,5 +3,5 @@
 module Opal
   # WHEN RELEASING:
   # Remember to update RUBY_ENGINE_VERSION in opal/corelib/constants.rb too!
-  VERSION = '1.4.1'
+  VERSION = '1.5.0.rc1'
 end

data/opal/corelib/array.rb

@@ -441,20 +441,18 @@ class ::Array < `Array`
   end
 
   def []=(index, value, extra = undefined)
+    data = nil
     %x{
       var i, size = self.length;
-    }
 
-    if ::Range === index
-      data = if ::Array === value
-               value.to_a
-             elsif value.respond_to? :to_ary
-               value.to_ary.to_a
-             else
-               [value]
-             end
+      if (index.$$is_range) {
+        if (value.$$is_array)
+          data = #{value.to_a};
+        else if (#{value.respond_to? :to_ary})
+          data = #{value.to_ary.to_a};
+        else
+          data = [value];
 
-      %x{
         var exclude = index.excl,
             from    = index.begin === nil ? 0 : $coerce_to(index.begin, Opal.Integer, 'to_int'),
             to      = index.end === nil ? -1 : $coerce_to(index.end, Opal.Integer, 'to_int');
@@ -489,24 +487,21 @@ class ::Array < `Array`
         }
 
         return value;
-      }
-    else
-      if `extra === undefined`
-        length = 1
-      else
-        length = value
-        value  = extra
-
-        data = if ::Array === value
-                 value.to_a
-               elsif value.respond_to? :to_ary
-                 value.to_ary.to_a
-               else
-                 [value]
-               end
-      end
+      } else {
+        if (extra === undefined) {
+          #{length = 1}
+        } else {
+          length = value;
+          value  = extra;
+
+          if (value.$$is_array)
+            data = #{value.to_a};
+          else if (#{value.respond_to? :to_ary})
+            data = #{value.to_ary.to_a};
+          else
+            data = [value];
+        }
 
-      %x{
         var old;
 
         index  = $coerce_to(index, #{::Integer}, 'to_int');
@@ -540,7 +535,7 @@ class ::Array < `Array`
 
         return value;
       }
-    end
+    }
   end
 
   def any?(pattern = undefined, &block)

data/opal/corelib/binding.rb

@@ -1,8 +1,9 @@
 class ::Binding
   # @private
-  def initialize(jseval, scope_variables, receiver, source_location)
+  def initialize(jseval, scope_variables = [], receiver = undefined, source_location = nil)
     @jseval, @scope_variables, @receiver, @source_location = \
       jseval, scope_variables, receiver, source_location
+    receiver = js_eval('self') unless `typeof receiver !== undefined`
   end
 
   def js_eval(*args)
@@ -20,7 +21,10 @@ class ::Binding
   end
 
   def local_variable_set(symbol, value)
-    js_eval(symbol, value)
+    `Opal.Binding.tmp_value = value`
+    js_eval("#{symbol} = Opal.Binding.tmp_value")
+    `delete Opal.Binding.tmp_value`
+    value
   end
 
   def local_variables
@@ -46,5 +50,11 @@ module ::Kernel
   end
 end
 
-TOPLEVEL_BINDING = binding
-`#{TOPLEVEL_BINDING}.source_location = ["<main>", 0]`
+TOPLEVEL_BINDING = ::Binding.new(
+  %x{
+    function(js) {
+      return (new Function("self", "return " + js))(self);
+    }
+  },
+  [], self, ['<main>', 0]
+)

data/opal/corelib/constants.rb

@@ -1,9 +1,9 @@
 ::RUBY_PLATFORM       = 'opal'
 ::RUBY_ENGINE         = 'opal'
 ::RUBY_VERSION        = '3.1.0'
-::RUBY_ENGINE_VERSION = '1.4.1'
-::RUBY_RELEASE_DATE   = '2022-01-12'
+::RUBY_ENGINE_VERSION = '1.5.0.rc1'
+::RUBY_RELEASE_DATE   = '2022-04-06'
 ::RUBY_PATCHLEVEL     = 0
 ::RUBY_REVISION       = '0'
-::RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2021 Adam Beynon and the Opal contributors'
+::RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2022 Adam Beynon and the Opal contributors'
 ::RUBY_DESCRIPTION    = "opal #{::RUBY_ENGINE_VERSION} (#{::RUBY_RELEASE_DATE} revision #{::RUBY_REVISION})"

data/opal/corelib/hash.rb

@@ -423,7 +423,7 @@ class ::Hash
     return enum_for(:each) { size } unless block
 
     %x{
-      for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
+      for (var i = 0, keys = self.$$keys.slice(), length = keys.length, key, value; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
@@ -444,7 +444,7 @@ class ::Hash
     return enum_for(:each_key) { size } unless block
 
     %x{
-      for (var i = 0, keys = self.$$keys, length = keys.length, key; i < length; i++) {
+      for (var i = 0, keys = self.$$keys.slice(), length = keys.length, key; i < length; i++) {
         key = keys[i];
 
         block(key.$$is_string ? key : key.key);

data/opal/corelib/irb.rb

@@ -0,0 +1,192 @@
+# Debug is a helper module that allows us to conduct some debugging on
+# a live codebase. It goes with an assumption, that opal-parser or
+# opal-replutils will not be loaded, in which case we will do what we can
+# to provision it.
+
+module Opal
+  module IRB
+    def self.ensure_loaded(library)
+      return if `Opal.loaded_features`.include? library
+
+      version = if RUBY_ENGINE_VERSION.include? 'dev'
+                  'master'
+                else
+                  RUBY_ENGINE_VERSION
+                end
+
+      url = "https://cdn.opalrb.com/opal/#{version}/#{library}.js"
+
+      %x{
+        var libcode;
+
+        if (typeof XMLHttpRequest !== 'undefined') { // Browser
+          var r = new XMLHttpRequest();
+          r.open("GET", url, false);
+          r.send('');
+          libcode = r.responseText;
+        }
+        else {
+          #{::Kernel.raise "You need to provision #{library} yourself in this environment"}
+        }
+
+        (new Function('Opal', libcode))(Opal);
+
+        Opal.require(library);
+      }
+
+      ::Kernel.raise "Could not load #{library} for some reason" unless `Opal.loaded_features`.include? library
+    end
+
+    singleton_class.attr_accessor :output
+
+    def self.prepare_console(&block)
+      self.output = ''
+
+      original = {
+        $stdout => ->(i) { $stdout = i },
+        $stderr => ->(i) { $stderr = i },
+      }
+
+      # Prepare a better prompt experience for a browser
+      if browser?
+        original.each do |pipe, pipe_setter|
+          new_pipe = pipe.dup
+          new_pipe.write_proc = proc do |str|
+            self.output += str
+            self.output = output.split("\n").last(30).join("\n")
+            self.output += "\n" if str.end_with? "\n"
+
+            pipe.write_proc.call(str)
+          end
+          new_pipe.tty = false
+          pipe_setter.call(new_pipe)
+        end
+
+        original_read_proc = $stdin.read_proc
+        $stdin.read_proc = `function(s) { var p = prompt(#{output}); if (p !== null) return p + "\n"; return nil; }`
+      end
+
+      yield
+    ensure
+      original.each do |pipe, pipe_setter|
+        pipe_setter.call(pipe)
+      end
+      $stdin.read_proc = original_read_proc
+      self.output = ''
+    end
+
+    def self.browser?
+      `typeof(document) !== 'undefined' && typeof(prompt) !== 'undefined'`
+    end
+
+    LINEBREAKS = [
+      'unexpected token $end',
+      'unterminated string meets end of file'
+    ].freeze
+
+    class Silencer
+      def initialize
+        @stderr = $stderr
+      end
+
+      def silence
+        @collector = ::StringIO.new
+        $stderr = @collector
+        yield
+      ensure
+        $stderr = @stderr
+      end
+
+      def warnings
+        @collector.string
+      end
+    end
+  end
+end
+
+class ::Binding
+  def irb
+    ::Opal::IRB.ensure_loaded('opal-replutils')
+
+    silencer = ::Opal::IRB::Silencer.new
+
+    ::Opal::IRB.prepare_console do
+      loop do
+        print '>> '
+        line = gets
+        break unless line
+        code = ''
+
+        puts line if ::Opal::IRB.browser?
+
+        if line.start_with? 'ls '
+          code = line[3..-1]
+          mode = :ls
+        elsif line == "ls\n"
+          code = 'self'
+          mode = :ls
+        elsif line.start_with? 'show '
+          code = line[5..-1]
+          mode = :show
+        else
+          code = line
+          mode = :inspect
+        end
+
+        js_code = nil
+
+        begin
+          silencer.silence do
+            js_code = `Opal.compile(code, {irb: true})`
+          end
+        rescue SyntaxError => e
+          if ::Opal::IRB::LINEBREAKS.include?(e.message)
+            print '.. '
+            line = gets
+            return unless line
+            puts line if ::Opal::IRB.browser?
+            code += line
+            retry
+          elsif silencer.warnings.empty?
+            warn e.full_message
+          else
+            # Most likely a parser error
+            warn silencer.warnings
+          end
+        end
+
+        if mode == :show
+          puts js_code
+          return
+        end
+
+        puts ::REPLUtils.eval_and_print(js_code, mode, false, self)
+      end
+    end
+  end
+end
+
+%x{
+  // Run in WebTools console with: Opal.irb(c => eval(c))
+  Opal.irb = function(fun) {
+    #{::Binding.new(`fun`).irb}
+  }
+
+  Opal.load_parser = function() {
+    Opal.Opal.IRB.$ensure_loaded('opal-parser');
+  }
+
+  if (typeof Opal.eval === 'undefined') {
+    Opal.eval = function(str) {
+      Opal.load_parser();
+      return Opal.eval(str);
+    }
+  }
+
+  if (typeof Opal.compile === 'undefined') {
+    Opal.compile = function(str, options) {
+      Opal.load_parser();
+      return Opal.compile(str, options);
+    }
+  }
+}

data/opal/corelib/math/polyfills.rb

@@ -0,0 +1,127 @@
+# Polyfills for browsers in the age of IE11
+
+unless defined?(`Math.acosh`)
+  %x{
+    Math.acosh = function(x) {
+      return Math.log(x + Math.sqrt(x * x - 1));
+    }
+  }
+end
+
+unless defined?(`Math.asinh`)
+  %x{
+    Math.asinh = function(x) {
+      return Math.log(x + Math.sqrt(x * x + 1))
+    }
+  }
+end
+
+unless defined?(`Math.atanh`)
+  %x{
+    Math.atanh = function(x) {
+      return 0.5 * Math.log((1 + x) / (1 - x));
+    }
+  }
+end
+
+unless defined?(`Math.cbrt`)
+  %x{
+    Math.cbrt = function(x) {
+      if (x == 0) {
+        return 0;
+      }
+
+      if (x < 0) {
+        return -Math.cbrt(-x);
+      }
+
+      var r  = x,
+          ex = 0;
+
+      while (r < 0.125) {
+        r *= 8;
+        ex--;
+      }
+
+      while (r > 1.0) {
+        r *= 0.125;
+        ex++;
+      }
+
+      r = (-0.46946116 * r + 1.072302) * r + 0.3812513;
+
+      while (ex < 0) {
+        r *= 0.5;
+        ex++;
+      }
+
+      while (ex > 0) {
+        r *= 2;
+        ex--;
+      }
+
+      r = (2.0 / 3.0) * r + (1.0 / 3.0) * x / (r * r);
+      r = (2.0 / 3.0) * r + (1.0 / 3.0) * x / (r * r);
+      r = (2.0 / 3.0) * r + (1.0 / 3.0) * x / (r * r);
+      r = (2.0 / 3.0) * r + (1.0 / 3.0) * x / (r * r);
+
+      return r;
+    }
+  }
+end
+
+unless defined?(`Math.cosh`)
+  %x{
+    Math.cosh = function(x) {
+      return (Math.exp(x) + Math.exp(-x)) / 2;
+    }
+  }
+end
+
+unless defined?(`Math.hypot`)
+  %x{
+    Math.hypot = function(x, y) {
+      return Math.sqrt(x * x + y * y)
+    }
+  }
+end
+
+unless defined?(`Math.log2`)
+  %x{
+    Math.log2 = function(x) {
+      return Math.log(x) / Math.LN2;
+    }
+  }
+end
+
+unless defined?(`Math.log10`)
+  %x{
+    Math.log10 = function(x) {
+      return Math.log(x) / Math.LN10;
+    }
+  }
+end
+
+unless defined?(`Math.sinh`)
+  %x{
+    Math.sinh = function(x) {
+      return (Math.exp(x) - Math.exp(-x)) / 2;
+    }
+  }
+end
+
+unless defined?(`Math.tanh`)
+  %x{
+    Math.tanh = function(x) {
+      if (x == Infinity) {
+        return 1;
+      }
+      else if (x == -Infinity) {
+        return -1;
+      }
+      else {
+        return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x));
+      }
+    }
+  }
+end