opal 1.2.0 → 1.3.0.alpha1

data/opal/corelib/error.rb

@@ -1,5 +1,5 @@
 class Exception < `Error`
-  # `var Kernel$raise = #{Kernel}.$raise`
+  `Opal.defineProperty(self.$$prototype, '$$is_exception', true)`
   `var stack_trace_limit`
 
   def self.new(*args)
@@ -8,6 +8,7 @@ class Exception < `Error`
       var error     = new self.$$constructor(message);
       error.name    = self.$$name;
       error.message = message;
+      error.cause   = #{$!};
       Opal.send(error, error.$initialize, args);
 
       // Error.captureStackTrace() will use .name and .toString to build the
@@ -33,6 +34,37 @@ class Exception < `Error`
     `self.message = (args.length > 0) ? args[0] : nil`
   end
 
+  %x{
+    // Convert backtrace from any format to Ruby format
+    function correct_backtrace(backtrace) {
+      var new_bt = [], m;
+
+      for (var i = 0; i < backtrace.length; i++) {
+        var loc = backtrace[i];
+        if (!loc || !loc.$$is_string) {
+          /* Do nothing */
+        }
+        /* Chromium format */
+        else if ((m = loc.match(/^    at (.*?) \((.*?)\)$/))) {
+          new_bt.push(m[2] + ":in `" + m[1] + "'");
+        }
+        else if ((m = loc.match(/^    at (.*?)$/))) {
+          new_bt.push(m[1] + ":in `undefined'");
+        }
+        /* Node format */
+        else if ((m = loc.match(/^  from (.*?)$/))) {
+          new_bt.push(m[1]);
+        }
+        /* Mozilla/Apple format */
+        else if ((m = loc.match(/^(.*?)@(.*?)$/))) {
+          new_bt.push(m[2] + ':in `' + m[1] + "'");
+        }
+      }
+
+      return new_bt;
+    }
+  }
+
   def backtrace
     %x{
       if (self.backtrace) {
@@ -42,17 +74,31 @@ class Exception < `Error`
 
       var backtrace = self.stack;
 
-      if (typeof(backtrace) === 'string') {
-        return backtrace.split("\n").slice(0, 15);
+      if (backtrace.$$is_string) {
+        return self.backtrace = correct_backtrace(backtrace.split("\n").slice(0, 15));
       }
       else if (backtrace) {
-        return backtrace.slice(0, 15);
+        return self.backtrace = correct_backtrace(backtrace.slice(0, 15));
       }
 
       return [];
     }
   end
 
+  def backtrace_locations
+    %x{
+      if (self.backtrace_locations) return self.backtrace_locations;
+      self.backtrace_locations = #{backtrace&.map do |loc|
+        ::Thread::Backtrace::Location.new(loc)
+      end}
+      return self.backtrace_locations;
+    }
+  end
+
+  def cause
+    `self.cause || nil`
+  end
+
   def exception(str = nil)
     %x{
       if (str === nil || self === str) {
@@ -61,7 +107,9 @@ class Exception < `Error`
 
       var cloned = #{clone};
       cloned.message = str;
+      if (self.backtrace) cloned.backtrace = self.backtrace.$dup();
       cloned.stack = self.stack;
+      cloned.cause = self.cause;
       return cloned;
     }
   end
@@ -71,6 +119,37 @@ class Exception < `Error`
     to_s
   end
 
+  def full_message(highlight: $stderr.tty?, order: :top)
+    raise ArgumentError, "expected true or false as highlight: #{highlight}" unless [true, false].include? highlight
+    raise ArgumentError, "expected :top or :bottom as order: #{order}" unless %i[top bottom].include? order
+
+    if highlight
+      bold_underline = "\e[1;4m"
+      bold = "\e[1m"
+      reset = "\e[m"
+    else
+      bold_underline = bold = reset = ''
+    end
+
+    bt = backtrace.dup
+    bt = caller if !bt || bt.empty?
+    first = bt.shift
+
+    msg = "#{first}: "
+    msg += "#{bold}#{to_s} (#{bold_underline}#{self.class}#{reset}#{bold})#{reset}\n"
+
+    msg += bt.map { |loc| "\tfrom #{loc}\n" }.join
+
+    msg += cause.full_message(highlight: highlight) if cause
+
+    if order == :bottom
+      msg = msg.split("\n").reverse.join("\n")
+      msg = "#{bold}Traceback#{reset} (most recent call last):\n" + msg
+    end
+
+    msg
+  end
+
   def inspect
     as_str = to_s
     as_str.empty? ? self.class.to_s : "#<#{self.class.to_s}: #{to_s}>"
@@ -85,7 +164,7 @@ class Exception < `Error`
         self.stack = '';
       } else if (backtrace.$$is_string) {
         self.backtrace = [backtrace];
-        self.stack = backtrace;
+        self.stack = '  from ' + backtrace;
       } else {
         if (backtrace.$$is_array) {
           for (i = 0, ii = backtrace.length; i < ii; i++) {
@@ -103,7 +182,7 @@ class Exception < `Error`
         }
 
         self.backtrace = backtrace;
-        self.stack = backtrace.join('\n');
+        self.stack = #{`backtrace`.map { |i| '  from ' + i }}.join("\n");
       }
 
       return backtrace;
@@ -125,8 +204,9 @@ class NotImplementedError < ScriptError; end
 class SystemExit        < Exception; end
 class NoMemoryError     < Exception; end
 class SignalException   < Exception; end
-class Interrupt         < Exception; end
+class Interrupt           < SignalException; end
 class SecurityError     < Exception; end
+class SystemStackError  < Exception; end
 
 class StandardError     < Exception; end
 class EncodingError       < StandardError; end
@@ -138,13 +218,19 @@ class FrozenError           < RuntimeError; end
 class LocalJumpError      < StandardError; end
 class TypeError           < StandardError; end
 class ArgumentError       < StandardError; end
+class UncaughtThrowError    < ArgumentError; end
 class IndexError          < StandardError; end
 class StopIteration         < IndexError; end
+class ClosedQueueError        < StopIteration; end
 class KeyError              < IndexError; end
 class RangeError          < StandardError; end
 class FloatDomainError      < RangeError; end
 class IOError             < StandardError; end
+class EOFError              < IOError; end
 class SystemCallError     < StandardError; end
+class RegexpError         < StandardError; end
+class ThreadError         < StandardError; end
+class FiberError          < StandardError; end
 
 module Errno
   class EINVAL              < SystemCallError
@@ -157,13 +243,13 @@ module Errno
 end
 
 class UncaughtThrowError < ArgumentError
-  attr_reader :sym, :arg
+  attr_reader :tag, :value
 
-  def initialize(args)
-    @sym = args[0]
-    @arg = args[1] if args.length > 1
+  def initialize(tag, value = nil)
+    @tag = tag
+    @value = value
 
-    super("uncaught throw #{@sym.inspect}")
+    super("uncaught throw #{@tag.inspect}")
   end
 end
 

data/opal/corelib/io.rb

@@ -2,16 +2,30 @@ class IO
   SEEK_SET = 0
   SEEK_CUR = 1
   SEEK_END = 2
+  SEEK_DATA = 3
+  SEEK_HOLE = 4
 
-  def tty?
-    @tty
+  READABLE = 1
+  WRITABLE = 4
+
+  def initialize(fd, flags = 'r')
+    @fd = fd
+    @flags = flags
+    @eof = false
+
+    if flags.include?('r') && !flags.match?(/[wa+]/)
+      @closed = :write
+    elsif flags.match?(/[wa]/) && !flags.match?(/[r+]/)
+      @closed = :read
+    end
   end
 
-  def closed?
-    @closed
+  def tty?
+    `self.tty == true`
   end
 
   attr_accessor :write_proc
+  attr_accessor :read_proc
 
   def write(string)
     `self.write_proc(string)`
@@ -20,63 +34,261 @@ class IO
 
   attr_accessor :sync, :tty
 
+  attr_reader :eof
+  alias eof? eof
+
   def flush
     # noop
   end
 
-  module Writable
-    def <<(string)
-      write(string)
-      self
-    end
+  def <<(string)
+    write(string)
+    self
+  end
 
-    def print(*args)
-      %x{
-        for (var i = 0, ii = args.length; i < ii; i++) {
-          args[i] = #{String(`args[i]`)}
-        }
-        self.$write(args.join(#{$,}));
+  def print(*args)
+    %x{
+      for (var i = 0, ii = args.length; i < ii; i++) {
+        args[i] = #{String(`args[i]`)}
       }
-      nil
-    end
+      self.$write(args.join(#{$,}));
+    }
+    nil
+  end
 
-    def puts(*args)
-      %x{
-        for (var i = 0, ii = args.length; i < ii; i++) {
-          args[i] = #{String(`args[i]`).chomp}
-        }
-        self.$write(args.concat([nil]).join(#{$/}));
+  def puts(*args)
+    %x{
+      for (var i = 0, ii = args.length; i < ii; i++) {
+        args[i] = #{String(`args[i]`).chomp}
       }
-      nil
+      self.$write(args.concat([nil]).join(#{$/}));
+    }
+    nil
+  end
+
+  # Reading
+
+  def getc
+    @read_buffer ||= ''
+    parts = ''
+
+    # Will execure at most twice - one time reading from a buffer
+    # second time
+    begin
+      @read_buffer += parts
+      if @read_buffer != ''
+        ret = @read_buffer[0]
+        @read_buffer = @read_buffer[1..-1]
+        return ret
+      end
+    end while parts = sysread_noraise(1)
+
+    nil
+  end
+
+  def getbyte
+    getc&.ord
+  end
+
+  def readbyte
+    readchar.ord
+  end
+
+  def readchar
+    getc || raise(EOFError, 'end of file reached')
+  end
+
+  def readline(*args)
+    gets(*args) || raise(EOFError, 'end of file reached')
+  end
+
+  def gets(sep = false, limit = nil, opts = {})
+    if `sep.$$is_number` && !limit
+      sep, limit, opts = false, sep, limit
+    end
+    if `sep.$$is_hash` && !limit && opts == {}
+      sep, limit, opts = false, nil, sep
+    elsif `limit.$$is_hash` && opts == {}
+      sep, limit, opts = sep, nil, limit
+    end
+
+    orig_sep = sep
+
+    sep = $/ if sep == false
+    sep = /\r?\n\r?\n/ if sep == ''
+    sep ||= ''
+    sep = sep.to_str unless orig_sep == ''
+
+    # Try to deduce length of a regexp
+    seplen = `orig_sep == '' ? 2 : sep.length`
+
+    sep = / / if sep == ' ' # WTF is this, String#split(" ") matches all whitespaces???
+
+    @read_buffer ||= ''
+    data = ''
+    ret = nil
+
+    begin
+      @read_buffer += data
+      if sep != '' && (`sep.$$is_regexp` ? @read_buffer.match?(sep) : @read_buffer.include?(sep))
+        orig_buffer = @read_buffer
+        ret, @read_buffer = @read_buffer.split(sep, 2)
+        ret += orig_buffer[ret.length, seplen] if ret != orig_buffer
+        break
+      end
+    end while data = sysread_noraise(sep == '' ? 65_536 : 1)
+
+    unless ret
+      ret, @read_buffer = (@read_buffer || ''), ''
+      ret = nil if ret == ''
+    end
+
+    if ret
+      if limit
+        ret = ret[0...limit]
+        @read_buffer = ret[limit..-1] + @read_buffer
+      end
+      ret = ret.sub(/\r?\n\z/, '') if opts[:chomp]
+      ret = ret.sub(/\A[\r\n]+/, '') if orig_sep == ''
     end
+
+    $_ = ret if orig_sep == false
+    ret
   end
 
-  module Readable
-    def readbyte
-      getbyte
+  # This method is to be overloaded, or read_proc can be changed
+  def sysread(integer)
+    `self.read_proc(integer)` || begin
+      @eof = true
+      raise EOFError, 'end of file reached'
     end
+  end
+
+  # @private
+  def sysread_noraise(integer)
+    sysread(integer)
+  rescue EOFError
+    nil
+  end
 
-    def readchar
-      getc
+  def readpartial(integer)
+    @read_buffer ||= ''
+    part = sysread(integer)
+    ret, @read_buffer = @read_buffer + (part || ''), ''
+    ret = nil if ret == ''
+    ret
+  end
+
+  def read(integer = nil)
+    @read_buffer ||= ''
+    parts = ''
+    ret = nil
+
+    begin
+      @read_buffer += parts
+      if integer && @read_buffer.length > integer
+        ret, @read_buffer = @read_buffer[0...integer], @read_buffer[integer..-1]
+        return ret
+      end
+    end while parts = sysread_noraise(integer || 65_536)
+
+    ret, @read_buffer = @read_buffer, ''
+    ret
+  end
+
+  # Eaches
+
+  def readlines(separator = $/)
+    each_line(separator).to_a
+  end
+
+  def each(sep = $/, *args, &block)
+    return enum_for :each, sep, *args unless block_given?
+
+    while (s = gets(sep, *args))
+      yield(s)
+    end
+
+    self
+  end
+
+  alias each_line each
+
+  def each_byte(&block)
+    return enum_for :each_byte unless block_given?
+
+    while (s = getbyte)
+      yield(s)
+    end
+
+    self
+  end
+
+  def each_char(&block)
+    return enum_for :each_char unless block_given?
+
+    while (s = getc)
+      yield(s)
+    end
+
+    self
+  end
+
+  # Closedness
+
+  def close
+    @closed = :both
+  end
+
+  def close_read
+    if @closed == :write
+      @closed = :both
+    else
+      @closed = :read
+    end
+  end
+
+  def close_write
+    if @closed == :read
+      @closed = :both
+    else
+      @closed = :write
     end
+  end
+
+  def closed?
+    @closed == :both
+  end
 
-    def readline(sep = $/)
-      raise NotImplementedError
+  def closed_read?
+    @closed == :read || @closed == :both
+  end
+
+  def closed_write?
+    @closed == :write || @closed == :both
+  end
+
+  # @private
+  def check_writable
+    if closed_write?
+      raise IOError, 'not opened for writing'
     end
+  end
 
-    def readpartial(integer, outbuf = nil)
-      raise NotImplementedError
+  # @private
+  def check_readable
+    if closed_read?
+      raise IOError, 'not opened for reading'
     end
   end
 end
 
-STDERR = $stderr = IO.new
-STDIN  = $stdin  = IO.new
-STDOUT = $stdout = IO.new
+STDIN  = $stdin  = IO.new(0, 'r')
+STDOUT = $stdout = IO.new(1, 'w')
+STDERR = $stderr = IO.new(2, 'w')
 
 `var console = Opal.global.console`
 STDOUT.write_proc = `typeof(process) === 'object' && typeof(process.stdout) === 'object' ? function(s){process.stdout.write(s)} : function(s){console.log(s)}`
 STDERR.write_proc = `typeof(process) === 'object' && typeof(process.stderr) === 'object' ? function(s){process.stderr.write(s)} : function(s){console.warn(s)}`
 
-STDOUT.extend(IO::Writable)
-STDERR.extend(IO::Writable)
+STDIN.read_proc = `function(s) { var p = prompt(); if (p !== null) return p + "\n"; return nil; }`

data/opal/corelib/kernel/format.rb

@@ -66,8 +66,8 @@ module Kernel
 
       function GET_NEXT_ARG() {
         switch (pos_arg_num) {
-        case -1: #{raise ArgumentError, "unnumbered(#{`seq_arg_num`}) mixed with numbered"}
-        case -2: #{raise ArgumentError, "unnumbered(#{`seq_arg_num`}) mixed with named"}
+        case -1: #{raise ArgumentError, "unnumbered(#{`seq_arg_num`}) mixed with numbered"} // raise
+        case -2: #{raise ArgumentError, "unnumbered(#{`seq_arg_num`}) mixed with named"} // raise
         }
         pos_arg_num = seq_arg_num++;
         return GET_NTH_ARG(pos_arg_num - 1);
@@ -135,6 +135,7 @@ module Kernel
         switch (format_string.charAt(i)) {
         case '%':
           begin_slice = i;
+          // no-break
         case '':
         case '\n':
         case '\0':
@@ -240,6 +241,7 @@ module Kernel
               }
               hash_parameter_key += format_string.charAt(i);
             }
+            // raise
 
           case '*':
             i++;
@@ -482,6 +484,7 @@ module Kernel
           case 'A':
             // Not implemented because there are no specs for this field type.
             #{raise NotImplementedError, '`A` and `a` format field types are not implemented in Opal yet'}
+            // raise
 
           case 'c':
             arg = GET_ARG();