opal 1.2.0 → 1.3.0.alpha1

data/lib/opal/repl.rb

@@ -2,17 +2,18 @@
 
 require 'opal'
 require 'securerandom'
+require 'stringio'
+require 'fileutils'
 
 module Opal
   class REPL
     HISTORY_PATH = File.expand_path('~/.opal-repl-history')
 
+    attr_accessor :colorize
+
     def initialize
-      begin
-        require 'mini_racer'
-      rescue LoadError
-        abort 'opal-repl depends on mini_racer gem, which is not currently installed'
-      end
+      @argv = []
+      @colorize = true
 
       begin
         require 'readline'
@@ -20,80 +21,154 @@ module Opal
         abort 'opal-repl depends on readline, which is not currently available'
       end
 
-      MiniRacer::Platform.set_flags! :harmony
-
+      begin
+        FileUtils.touch(HISTORY_PATH)
+      rescue
+        nil
+      end
       @history = File.exist?(HISTORY_PATH)
     end
 
-    def run(filename = nil)
+    def run(argv = [])
+      @argv = argv
+
+      savepoint = save_tty
       load_opal
-      load_file(filename) if filename
       load_history
       run_input_loop
     ensure
       dump_history
-    end
-
-    def load_file(filename)
-      raise "file does not exist: #{filename}" unless File.exist? filename
-      eval_ruby File.read(filename)
-    end
-
-    # A polyfill so that SecureRandom works in repl correctly.
-    def random_bytes(bytes)
-      ::SecureRandom.bytes(bytes).split('').map(&:ord)
+      restore_tty(savepoint)
     end
 
     def load_opal
-      v8.attach('console.log', method(:puts).to_proc)
-      v8.attach('console.warn', method(:warn).to_proc)
-      v8.attach('crypto.randomBytes', method(:random_bytes).to_proc)
-      v8.eval Opal::Builder.new.build('opal').to_s
-      v8.attach('Opal.exit', method(:exit).to_proc)
-    end
-
-    def run_line(line)
-      result = eval_ruby(line)
-      puts "=> #{result}"
+      runner = @argv.reject { |i| i == '--repl' }
+      runner += ['-e', 'require "opal/repl_js"']
+      runner = %w[bundle exec opal] + runner
+
+      @pipe = IO.popen(runner, 'r+',
+        # What I try to achieve here: let the runner ignore
+        # interrupts. Those should be handled by a supervisor.
+        pgroup: true,
+        new_pgroup: true,
+      )
     end
 
     def run_input_loop
-      # on SIGINT lets just return from the loop..
-      previous_trap = trap('SIGINT') { return }
-
       while (line = readline)
-        run_line(line)
+        eval_ruby(line)
       end
-
+    rescue Interrupt
+      @incomplete = nil
+      retry
     ensure
-      trap('SIGINT', previous_trap || 'DEFAULT')
+      finish
     end
 
-    private
+    def finish
+      @pipe.close
+    rescue
+      nil
+    end
 
     def eval_ruby(code)
       builder = Opal::Builder.new
-      builder.build_str(code, '(irb)', irb: true, const_missing: true)
-      builder.processed[0...-1].each { |js_code| eval_js js_code.to_s }
+      silencer = Silencer.new
+
+      code = "#{@incomplete}#{code}"
+      if code.start_with? 'ls '
+        eval_code = code[3..-1]
+        mode = :ls
+      elsif code == 'ls'
+        eval_code = 'self'
+        mode = :ls
+      elsif code.start_with? 'show '
+        eval_code = code[5..-1]
+        mode = :show
+      else
+        eval_code = code
+        mode = :inspect
+      end
+
+      begin
+        silencer.silence do
+          builder.build_str(eval_code, '(irb)', irb: true, const_missing: true)
+        end
+        @incomplete = nil
+      rescue Opal::SyntaxError => e
+        if LINEBREAKS.include?(e.message)
+          @incomplete = "#{code}\n"
+        else
+          @incomplete = nil
+          if silencer.warnings.empty?
+            warn e.full_message
+          else
+            # Most likely a parser error
+            warn silencer.warnings
+          end
+        end
+        return
+      end
+      builder.processed[0...-1].each { |js_code| eval_js(:silent, js_code.to_s) }
       last_processed_file = builder.processed.last.to_s
-      eval_js <<-JS
-        var $_result = #{last_processed_file};
-        $_result.$inspect()
-      JS
-    rescue => e
-      puts "#{e.message}\n\t#{e.backtrace.join("\n\t")}"
+
+      if mode == :show
+        puts last_processed_file
+        return
+      end
+
+      eval_js(mode, last_processed_file)
+    rescue Interrupt, SystemExit => e
+      raise e
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      puts e.full_message(highlight: true)
     end
 
-    def eval_js(code)
-      v8.eval(code)
+    private
+
+    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
 
-    def v8
-      @v8 ||= MiniRacer::Context.new
+    def eval_js(mode, code)
+      obj = { mode: mode, code: code, colors: colorize }.to_json
+      @pipe.puts obj
+      while (line = @pipe.readline)
+        break if line.chomp == '<<<ready>>>'
+        puts line
+      end
+    rescue Interrupt => e
+      # A child stopped responding... let's create a new one
+      warn "* Killing #{@pipe.pid}"
+      Process.kill('-KILL', @pipe.pid)
+      load_opal
+      raise e
+    rescue EOFError, Errno::EPIPE
+      exit $?.exitstatus
     end
 
     def readline
-      Readline.readline '>> ', true
+      prompt = @incomplete ? '.. ' : '>> '
+      Readline.readline prompt, true
     end
 
     def load_history
@@ -106,5 +181,18 @@ module Opal
       length = Readline::HISTORY.size > 1000 ? 1000 : Readline::HISTORY.size
       File.write(HISTORY_PATH, Readline::HISTORY.to_a[-length..-1].join("\n"))
     end
+
+    # How do we support Win32?
+    def save_tty
+      %x{stty -g}.chomp
+    rescue
+      nil
+    end
+
+    def restore_tty(savepoint)
+      system('stty', savepoint)
+    rescue
+      nil
+    end
   end
 end

data/lib/opal/rewriters/binary_operator_assignment.rb

@@ -16,11 +16,11 @@ module Opal
       end
 
       GET_SET = ->(get_type, set_type) {
-        ->(lhs, operation, rhs) {
-          get_node = lhs.updated(get_type)               # lhs
-          set_node = s(:send, get_node, operation, rhs)  # lhs + rhs
+        ->(node, lhs, operation, rhs) {
+          get_node = lhs.updated(get_type) # lhs
+          set_node = node.updated(:send, [get_node, operation, rhs]) # lhs + rhs
 
-          lhs.updated(set_type, [*lhs, set_node])        # lhs = lhs + rhs
+          lhs.updated(set_type, [*lhs, set_node]) # lhs = lhs + rhs
         }
       }
 
@@ -48,7 +48,7 @@ module Opal
       # Produces `recvr.meth = recvr.meth + rhs`
       # (lhs is a recvr.meth, op is :+)
       class SendHandler < self
-        def self.call(lhs, operation, rhs)
+        def self.call(node, lhs, operation, rhs)
           recvr, reader_method, *args = *lhs
 
           # If recvr is a complex expression it must be cached.
@@ -62,11 +62,11 @@ module Opal
           writer_method = :"#{reader_method}="
 
           call_reader = lhs.updated(:send, [recvr, reader_method, *args])          # $tmp.meth
-          call_op = s(:send, call_reader, operation, rhs)                          # $tmp.meth + rhs
+          call_op = node.updated(:send, [call_reader, operation, rhs])             # $tmp.meth + rhs
           call_writer = lhs.updated(:send, [recvr, writer_method, *args, call_op]) # $tmp.meth = $tmp.meth + rhs
 
           if cache_recvr
-            s(:begin, cache_recvr, call_writer)
+            node.updated(:begin, [cache_recvr, call_writer])
           else
             call_writer
           end
@@ -78,7 +78,7 @@ module Opal
       #   NOTE: Later output of this handler gets post-processed by this rewriter again
       #   using SendHandler to `recvr.nil? ? nil : (recvr.meth = recvr.meth + rhs)`
       class ConditionalSendHandler < self
-        def self.call(lhs, operation, rhs)
+        def self.call(node, lhs, operation, rhs)
           recvr, meth, *args = *lhs
 
           recvr_tmp = new_temp
@@ -87,7 +87,7 @@ module Opal
 
           recvr_is_nil = s(:send, recvr, :nil?)                   # recvr.nil?
           plain_send = lhs.updated(:send, [recvr, meth, *args])   # recvr.meth
-          plain_op_asgn = s(:op_asgn, plain_send, operation, rhs) # recvr.meth += rhs
+          plain_op_asgn = node.updated(:op_asgn, [plain_send, operation, rhs]) # recvr.meth += rhs
 
           s(:begin,
             cache_recvr,
@@ -116,7 +116,7 @@ module Opal
 
         result = HANDLERS
                  .fetch(lhs.type) { error "cannot handle LHS type: #{lhs.type}" }
-                 .call(lhs, op, rhs)
+                 .call(node, lhs, op, rhs)
 
         process(result)
       end

data/lib/opal/rewriters/block_to_iter.rb

@@ -6,11 +6,11 @@ module Opal
   module Rewriters
     class BlockToIter < Base
       def on_block(node)
-        recvr, args, body = *super
+        recvr, args, body = *node
         iter_node = s(:iter, args, body)
-        recvr.updated(
+        process recvr.updated(
           nil,
-          recvr.children + [iter_node],
+          (recvr.children + [iter_node]),
         )
       end
     end

data/lib/opal/rewriters/for_rewriter.rb

@@ -52,7 +52,7 @@ module Opal
         loop_variable_assignment = case loop_variable.type
                                    when :mlhs # multiple left-hand statement like in "for i,j in [[1, 2], [3, 4]]"
                                      # i, j = __jstmp
-                                     s(:masgn, loop_variable, get_tmp_loop_variable)
+                                     loop_variable.updated(:masgn, [loop_variable, get_tmp_loop_variable])
                                    else # single argument like "for i in (0..3)"
                                      # i = __jstmp
                                      loop_variable << get_tmp_loop_variable
@@ -60,13 +60,13 @@ module Opal
 
         loop_body = prepend_to_body(loop_body, loop_variable_assignment)
 
-        node = s(:send, iterating_value, :each,          # (0..3).each {
-          s(:iter, s(:args, s(:arg, tmp_loop_variable)), #                |__jstmp|
-            process(loop_body)
-          )
-        )                                                #                          i = __jstmp; j = i + 1 }
+        node = node.updated(:send, [iterating_value, :each,                                    # (0..3).each {
+                                    node.updated(:iter, [s(:args, s(:arg, tmp_loop_variable)), #                |__jstmp|
+                                                         process(loop_body)]                   #                          i = __jstmp; j = i + 1 }
+                                    )]
+        )
 
-        s(:begin, *outer_assigns, node)
+        node.updated(:begin, [*outer_assigns, node])
       end
 
       class LocalVariableAssigns < Base

data/lib/opal/rewriters/js_reserved_words.rb

@@ -86,9 +86,9 @@ module Opal
         super(node)
       end
 
-      # Restarg is a special case
-      # because it may have no name
-      # def m(*); end
+      # Restarg and kwrestarg are special cases
+      # because they may have no name
+      # def m(*, **); end
       def on_restarg(node)
         name, _ = *node
 
@@ -99,6 +99,8 @@ module Opal
         node
       end
 
+      alias on_kwrestarg on_restarg
+
       def on_argument(node)
         node = super(node)
         name, value = *node

data/lib/opal/source_map/file.rb

@@ -7,11 +7,12 @@ class Opal::SourceMap::File
   attr_reader :file
   attr_reader :source
 
-  def initialize(fragments, file, source)
+  def initialize(fragments, file, source, generated_code = nil)
     @fragments = fragments
     @file = file
     @source = source
     @names_map = Hash.new { |hash, name| hash[name] = hash.size }
+    @generated_code = generated_code
     @absolute_mappings = nil
   end
 
@@ -98,8 +99,10 @@ class Opal::SourceMap::File
   #    field, in which case the whole value is represented.
   def segment_from_fragment(fragment, generated_column)
     source_index     = 0                          # always 0, we're dealing with a single file
-    original_line    = fragment.line - 1          # fragments have 1-based lines
-    original_column  = fragment.column            # fragments have 0-based columns
+    original_line    = (fragment.line || 0) - 1   # fragments have 1-based lines
+    original_line    = 0 if original_line < 0     # line 0 (-1) for fragments in source maps will crash
+                                                  # browsers devtools and the webpack build process
+    original_column  = fragment.column || 0       # fragments have 0-based columns
 
     if fragment.source_map_name
       map_name_index = (@names_map[fragment.source_map_name.to_s] ||= @names_map.size)
@@ -162,7 +165,7 @@ class Opal::SourceMap::File
         generated_column = 0
         segments = []
         raw_segments.each do |(generated_code, fragment)|
-          if fragment.line && fragment.column
+          unless fragment.is_a?(Opal::Fragment) && fragment.skip_source_map?
             segments << segment_from_fragment(fragment, generated_column)
           end
           generated_column += generated_code.size

data/lib/opal/source_map/map.rb

@@ -5,11 +5,11 @@ require 'json'
 
 module Opal::SourceMap::Map
   def to_h
-    map
+    @to_h || map
   end
 
   def to_json
-    map.to_json
+    to_h.to_json
   end
 
   def as_json(*)
@@ -17,10 +17,24 @@ module Opal::SourceMap::Map
   end
 
   def to_s
-    map.to_s
+    to_h.to_s
   end
 
   def to_data_uri_comment
     "//# sourceMappingURL=data:application/json;base64,#{Base64.encode64(to_json).delete("\n")}"
   end
+
+  # Marshaling for cache shortpath
+  def cache
+    @to_h ||= map
+    self
+  end
+
+  def marshal_dump
+    [to_h, generated_code]
+  end
+
+  def marshal_load(value)
+    @to_h, @generated_code = value
+  end
 end

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.2.0'
+  VERSION = '1.3.0.alpha1'
 end

data/opal/corelib/array.rb

@@ -647,8 +647,8 @@ class Array < `Array`
     self
   end
 
-  def count(object = nil, &block)
-    if object || block
+  def count(object = undefined, &block)
+    if `object !== undefined` || block
       super
     else
       size

data/opal/corelib/binding.rb

@@ -0,0 +1,46 @@
+class Binding
+  # @private
+  def initialize(jseval, scope_variables, receiver, source_location)
+    @jseval, @scope_variables, @receiver, @source_location = \
+      jseval, scope_variables, receiver, source_location
+  end
+
+  def js_eval(*args)
+    @jseval.call(*args)
+  end
+
+  def local_variable_get(symbol)
+    js_eval(symbol)
+  rescue Exception
+    raise NameError, "local variable `#{symbol}' is not defined for #{inspect}"
+  end
+
+  def local_variable_set(symbol, value)
+    js_eval(symbol, value)
+  end
+
+  def local_variables
+    @scope_variables
+  end
+
+  def local_variable_defined?(value)
+    @scope_variables.include?(value)
+  end
+
+  def eval(str, file = nil, line = nil)
+    return receiver if str == 'self'
+
+    Kernel.eval(str, self, file, line)
+  end
+
+  attr_reader :receiver, :source_location
+end
+
+module Kernel
+  def binding
+    raise "Opal doesn't support dynamic calls to binding"
+  end
+end
+
+TOPLEVEL_BINDING = binding
+`#{TOPLEVEL_BINDING}.source_location = ["<main>", 0]`

data/opal/corelib/boolean.rb

@@ -1,6 +1,31 @@
 class Boolean < `Boolean`
   `Opal.defineProperty(self.$$prototype, '$$is_boolean', true)`
-  `Opal.defineProperty(self.$$prototype, '$$meta', #{self})`
+
+  %x{
+    var properties = ['$$class', '$$meta'];
+
+    for (var i = 0; i < properties.length; i++) {
+      Object.defineProperty(self.$$prototype, properties[i], {
+        configurable: true,
+        enumerable: false,
+        get: function() {
+          return this == true  ? Opal.TrueClass :
+                 this == false ? Opal.FalseClass :
+                                 Opal.Boolean;
+        }
+      });
+    }
+
+    Object.defineProperty(self.$$prototype, "$$id", {
+      configurable: true,
+      enumerable: false,
+      get: function() {
+        return this == true  ? 2 :
+               this == false ? 0 :
+                               nil;
+      }
+    });
+  }
 
   class << self
     def allocate
@@ -40,13 +65,15 @@ class Boolean < `Boolean`
   alias eql? ==
 
   def singleton_class
-    Boolean
+    `self.$$meta`
   end
 
   def to_s
     `(self == true) ? 'true' : 'false'`
   end
 
+  alias inspect to_s
+
   def dup
     self
   end
@@ -54,10 +81,33 @@ class Boolean < `Boolean`
   def clone(freeze: true)
     self
   end
+
+  # See: https://github.com/opal/opal/issues/2230
+  #
+  # This is a hack that allows you to add methods to TrueClass and FalseClass.
+  # Do note, that while true and false have a correct $$class (it's either
+  # TrueClass or FalseClass), their prototype is `Boolean.$$prototype`, which
+  # basically means that when calling `true.something` we actually call
+  # `Boolean#something` instead of `TrueClass#something`. So using
+  # method_missing we dispatch it to `TrueClass/FalseClass#something` correctly.
+  #
+  # The downside is that a correct implementation would also allow us to override
+  # the methods defined on Boolean, but our implementation doesn't allow that,
+  # unless you define them on Boolean and not on TrueClass/FalseClass.
+  def method_missing(method, *args, &block)
+    `var body = self.$$class.$$prototype['$' + #{method}]`
+    super unless `typeof body !== 'undefined' && !body.$$stub`
+    `Opal.send(self, body, #{args}, #{block})`
+  end
+
+  def respond_to_missing?(method, _include_all = false)
+    `var body = self.$$class.$$prototype['$' + #{method}]`
+    `typeof body !== 'undefined' && !body.$$stub`
+  end
 end
 
-TrueClass  = Boolean
-FalseClass = Boolean
+class TrueClass < Boolean; end
+class FalseClass < Boolean; end
 
 TRUE  = true
 FALSE = false

data/opal/corelib/class.rb

@@ -60,4 +60,6 @@ class Class
       return #{super()};
     }
   end
+
+  alias inspect to_s
 end

data/opal/corelib/constants.rb

@@ -1,8 +1,8 @@
 RUBY_PLATFORM       = 'opal'
 RUBY_ENGINE         = 'opal'
 RUBY_VERSION        = '3.0.2'
-RUBY_ENGINE_VERSION = '1.2.0'
-RUBY_RELEASE_DATE   = '2021-07-28'
+RUBY_ENGINE_VERSION = '1.3.0.alpha1'
+RUBY_RELEASE_DATE   = '2021-09-29'
 RUBY_PATCHLEVEL     = 0
 RUBY_REVISION       = '0'
 RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2021 Adam Beynon and the Opal contributors'