opal 1.2.0 → 1.3.0.alpha1

data/stdlib/opal/replutils.rb

@@ -0,0 +1,271 @@
+require 'pp'
+require 'stringio'
+
+
+module REPLUtils
+  module_function
+
+  def ls(object, colorize)
+    methods = imethods = object.methods
+    ancestors = object.class.ancestors
+    constants = []
+    ivs = object.instance_variables
+    cvs = []
+
+    if [Class, Module].include? object.class
+      imethods = object.instance_methods
+      ancestors = object.ancestors
+      constants = object.constants
+      cvs = object.class_variables
+    end
+
+    if colorize
+      blue      = ->(i) { "\e[1;34m#{i}\e[0m" }
+      dark_blue = ->(i) { "\e[34m#{i}\e[0m" }
+    else
+      blue = dark_blue = ->(i) { i }
+    end
+
+    out = ''
+    out = "#{blue['class variables']}: #{cvs.map { |i| dark_blue[i] }.sort.join('  ')}\n" + out unless cvs.empty?
+    out = "#{blue['instance variables']}: #{ivs.map { |i| dark_blue[i] }.sort.join('  ')}\n" + out unless ivs.empty?
+    ancestors.each do |a|
+      im = a.instance_methods(false)
+      meths = (im & imethods)
+      methods -= meths
+      imethods -= meths
+      next if meths.empty? || [Object, BasicObject, Kernel, PP::ObjectMixin].include?(a)
+      out = "#{blue["#{a.name}#methods"]}: #{meths.sort.join('  ')}\n" + out
+    end
+    methods &= object.methods(false)
+    out = "#{blue['self.methods']}: #{methods.sort.join('  ')}\n" + out unless methods.empty?
+    out = "#{blue['constants']}: #{constants.map { |i| dark_blue[i] }.sort.join('  ')}\n" + out unless constants.empty?
+    out
+  end
+
+  def eval_and_print(func, mode, colorize)
+    printer = if colorize
+                ->(i) { ColorPrinter.default(i) }
+              else
+                ->(i) { out = []; PP.pp(i, out); out.join }
+              end
+
+    %x{
+      var $_result = eval(func);
+
+      if (mode == 'silent') return nil;
+
+      if (typeof $_result === 'null') {
+        return "=> null";
+      }
+      else if (typeof $_result === 'undefined') {
+        return "=> undefined";
+      }
+      else if (typeof $_result.$$class === 'undefined') {
+        try {
+          var json = JSON.stringify($_result, null, 2);
+          if (!colorize) json = #{ColorPrinter.colorize(`json`)}
+          return "=> " + $_result.toString() + " => " + json;
+        }
+        catch(e) {
+          return "=> " + $_result.toString();
+        }
+      }
+      else {
+        if (mode == 'ls') {
+          return #{ls(`$_result`, colorize)};
+        }
+        else {
+          var pretty = #{printer.call(`$_result`)};
+          // Is it multiline? If yes, add a linebreak
+          if (pretty.match(/\n.*?\n/)) pretty = "\n" + pretty;
+          return "=> " + pretty;
+        }
+      }
+    }
+  rescue Exception => e # rubocop:disable Lint/RescueException
+    e.full_message(highlight: true)
+  end
+
+  def js_repl
+    while (line = gets)
+      input = JSON.parse(line)
+
+      out = eval_and_print(input[:code], input[:mode], input[:colors])
+      puts out if out
+      puts '<<<ready>>>'
+    end
+  end
+
+  # Slightly based on Pry's implementation
+  class ColorPrinter < ::PP
+    # Taken from CodeRay
+    TOKEN_COLORS = {
+      debug: "\e[1;37;44m",
+
+      annotation: "\e[34m",
+      attribute_name: "\e[35m",
+      attribute_value: "\e[31m",
+      binary: {
+        self: "\e[31m",
+        char: "\e[1;31m",
+        delimiter: "\e[1;31m",
+      },
+      char: {
+        self: "\e[35m",
+        delimiter: "\e[1;35m"
+      },
+      class: "\e[1;35;4m",
+      class_variable: "\e[36m",
+      color: "\e[32m",
+      comment: {
+        self: "\e[1;30m",
+        char: "\e[37m",
+        delimiter: "\e[37m",
+      },
+      constant: "\e[1;34;4m",
+      decorator: "\e[35m",
+      definition: "\e[1;33m",
+      directive: "\e[33m",
+      docstring: "\e[31m",
+      doctype: "\e[1;34m",
+      done: "\e[1;30;2m",
+      entity: "\e[31m",
+      error: "\e[1;37;41m",
+      exception: "\e[1;31m",
+      float: "\e[1;35m",
+      function: "\e[1;34m",
+      global_variable: "\e[1;32m",
+      hex: "\e[1;36m",
+      id: "\e[1;34m",
+      include: "\e[31m",
+      integer: "\e[1;34m",
+      imaginary: "\e[1;34m",
+      important: "\e[1;31m",
+      key: {
+        self: "\e[35m",
+        char: "\e[1;35m",
+        delimiter: "\e[1;35m",
+      },
+      keyword: "\e[32m",
+      label: "\e[1;33m",
+      local_variable: "\e[33m",
+      namespace: "\e[1;35m",
+      octal: "\e[1;34m",
+      predefined: "\e[36m",
+      predefined_constant: "\e[1;36m",
+      predefined_type: "\e[1;32m",
+      preprocessor: "\e[1;36m",
+      pseudo_class: "\e[1;34m",
+      regexp: {
+        self: "\e[35m",
+        delimiter: "\e[1;35m",
+        modifier: "\e[35m",
+        char: "\e[1;35m",
+      },
+      reserved: "\e[32m",
+      shell: {
+        self: "\e[33m",
+        char: "\e[1;33m",
+        delimiter: "\e[1;33m",
+        escape: "\e[1;33m",
+      },
+      string: {
+        self: "\e[31m",
+        modifier: "\e[1;31m",
+        char: "\e[1;35m",
+        delimiter: "\e[1;31m",
+        escape: "\e[1;31m",
+      },
+      symbol: {
+        self: "\e[33m",
+        delimiter: "\e[1;33m",
+      },
+      tag: "\e[32m",
+      type: "\e[1;34m",
+      value: "\e[36m",
+      variable: "\e[34m",
+
+      insert: {
+        self: "\e[42m",
+        insert: "\e[1;32;42m",
+        eyecatcher: "\e[102m",
+      },
+      delete: {
+        self: "\e[41m",
+        delete: "\e[1;31;41m",
+        eyecatcher: "\e[101m",
+      },
+      change: {
+        self: "\e[44m",
+        change: "\e[37;44m",
+      },
+      head: {
+        self: "\e[45m",
+        filename: "\e[37;45m"
+      },
+    }
+
+    TOKEN_COLORS[:keyword] = TOKEN_COLORS[:reserved]
+    TOKEN_COLORS[:method] = TOKEN_COLORS[:function]
+    TOKEN_COLORS[:escape] = TOKEN_COLORS[:delimiter]
+
+    def self.default(obj, width = 79)
+      pager = StringIO.new
+      pp(obj, pager, width)
+      pager.string
+    end
+
+    def self.pp(obj, output = $DEFAULT_OUTPUT, max_width = 79)
+      queue = ColorPrinter.new(output, max_width, "\n")
+      queue.guard_inspect_key { queue.pp(obj) }
+      queue.flush
+      output << "\n"
+    end
+
+    def text(str, max_width = str.length)
+      super(ColorPrinter.colorize(str), max_width)
+    end
+
+    def self.token(string, *name)
+      TOKEN_COLORS.dig(*name) + string + "\e[0m"
+    end
+
+    NUMBER = '[+-]?[0-9.]+(?:e[+-][0-9]+|i)?'
+    REGEXP = '/.*?/[iesu]*'
+    TOKEN_REGEXP = /(\s+|=>|[@$:]?[a-z]\w+|[A-Z]\w+|#{NUMBER}|#{REGEXP}|".*?"|#<.*?[> ]|.)/
+
+    def self.tokenize(str)
+      str.scan(TOKEN_REGEXP).map(&:first)
+    end
+
+    def self.colorize(str)
+      tokens = tokenize(str)
+
+      tokens.map do |tok|
+        case tok
+        when /^[0-9+-]/
+          if /[.e]/ =~ tok
+            token(tok, :float)
+          else
+            token(tok, :integer)
+          end
+        when /^"/
+          token(tok, :string, :self)
+        when /^:/
+          token(tok, :symbol, :self)
+        when /^[A-Z]/
+          token(tok, :constant)
+        when /^#</, '=', '>'
+          token(tok, :keyword)
+        when /^\/./
+          token(tok, :regexp, :self)
+        when 'true', 'false', 'nil'
+          token(tok, :predefined_constant)
+        else
+          tok
+        end
+      end.join
+    end
+  end
+end

data/stdlib/opal-parser.rb

@@ -6,16 +6,20 @@ require 'opal/erb'
 require 'opal/version'
 
 module Kernel
-  def eval(str)
+  def eval(str, binding = nil, file = nil, line = nil)
     str = Opal.coerce_to!(str, String, :to_str)
-    default_eval_options = { file: '(eval)', eval: true }
+    default_eval_options = { file: file || '(eval)', eval: true }
     compiling_options = __OPAL_COMPILER_CONFIG__.merge(default_eval_options)
-    code = Opal.compile str, compiling_options
-    %x{
-      return (function(self) {
-        return eval(#{code});
-      })(self)
-    }
+    code = `Opal.compile(str, compiling_options)`
+    if binding
+      binding.js_eval(code)
+    else
+      %x{
+        return (function(self) {
+          return eval(#{code});
+        })(self)
+      }
+    end
   end
 
   def require_remote(url)
@@ -30,10 +34,19 @@ end
 
 %x{
   Opal.compile = function(str, options) {
-    if (options) {
-      options = Opal.hash(options);
+    try {
+      str = #{Opal.coerce_to!(`str`, String, :to_str)}
+      if (options) options = Opal.hash(options);
+      return Opal.Opal.$compile(str, options);
+    }
+    catch (e) {
+      if (e.$$class === Opal.Opal.SyntaxError) {
+        var err = Opal.SyntaxError.$new(e.message);
+        err.$set_backtrace(e.$backtrace());
+        throw(err);
+      }
+      else { throw e; }
     }
-    return Opal.Opal.$compile(str, options);
   };
 
   Opal['eval'] = function(str, options) {

data/stdlib/opal-platform.rb

@@ -1,7 +1,11 @@
+`/* global Java, GjsFileImporter */`
+
 browser         = `typeof(document) !== "undefined"`
 node            = `typeof(process) !== "undefined" && process.versions && process.versions.node`
 nashorn         = `typeof(Java) !== "undefined" && Java.type`
 headless_chrome = `typeof(navigator) !== "undefined" && /\bHeadlessChrome\//.test(navigator.userAgent)`
+gjs             = `typeof(window) !== "undefined" && typeof(GjsFileImporter) !== 'undefined'`
+opalminiracer   = `typeof(opalminiracer) !== 'undefined'`
 
 OPAL_PLATFORM = if nashorn
                   'nashorn'
@@ -9,5 +13,9 @@ OPAL_PLATFORM = if nashorn
                   'nodejs'
                 elsif headless_chrome
                   'headless-chrome'
+                elsif gjs
+                  'gjs'
+                elsif opalminiracer
+                  'opal-miniracer'
                 else # possibly browser, which is the primary target
                 end

data/stdlib/promise/v2.rb

@@ -98,10 +98,12 @@
 #     end
 #
 
-warn 'PromiseV2 is a technology preview, which means it may change its behavior ' \
-     'in the future until this warning is removed. If you are interested in this part, ' \
-     'please make sure you track the async/await/promises tag on Opal issues: ' \
-     'https://github.com/opal/opal/issues?q=label%3Aasync%2Fawait%2Fpromises'
+if `Opal.config.experimental_features_severity == 'warning'`
+  warn 'PromiseV2 is a technology preview, which means it may change its behavior ' \
+      'in the future until this warning is removed. If you are interested in this part, ' \
+      'please make sure you track the async/await/promises tag on Opal issues: ' \
+      'https://github.com/opal/opal/issues?q=label%3Aasync%2Fawait%2Fpromises'
+end
 
 class PromiseV2 < `Promise`
   class << self
@@ -360,6 +362,16 @@ class PromiseV2 < `Promise`
     yield self if block_given?
   end
 
+  alias to_v2 itself
+
+  def to_v1
+    v1 = PromiseV1.new
+
+    self.then { |i| v1.resolve(i) }.rescue { |i| v1.reject(i) }
+
+    v1
+  end
+
   alias to_n itself
 
   def inspect

data/stdlib/promise.rb

@@ -337,6 +337,18 @@ class Promise
     result
   end
 
+  alias to_v1 itself
+
+  def to_v2
+    v2 = PromiseV2.new
+
+    self.then { |i| v2.resolve(i) }.rescue { |i| v2.reject(i) }
+
+    v2
+  end
+
+  alias to_n to_v2
+
   class Trace < self
     def self.it(promise)
       current = []
@@ -444,3 +456,5 @@ class Promise
     end
   end
 end
+
+PromiseV1 = Promise

data/stdlib/stringio.rb

@@ -1,7 +1,4 @@
 class StringIO < IO
-  include IO::Readable
-  include IO::Writable
-
   def self.open(string = "", mode = nil, &block)
     io  = new(string, mode)
     res = block.call(io)
@@ -14,13 +11,9 @@ class StringIO < IO
 
   def initialize(string = "", mode = 'rw')
     @string   = string
-    @position = string.length
+    @position = 0
 
-    if mode.include?('r') and not mode.include?('w')
-      @closed = :write
-    elsif mode.include?('w') and not mode.include?('r')
-      @closed = :read
-    end
+    super(nil, mode)
   end
 
   def eof?
@@ -32,6 +25,9 @@ class StringIO < IO
   alias eof eof?
 
   def seek(pos, whence = IO::SEEK_SET)
+    # Let's reset the read buffer, because it will be most likely wrong
+    @read_buffer = ''
+
     case whence
     when IO::SEEK_SET
       raise Errno::EINVAL unless pos >= 0
@@ -68,70 +64,12 @@ class StringIO < IO
     seek 0
   end
 
-  def each_byte(&block)
-    return enum_for :each_byte unless block
-
-    check_readable
-
-    i = @position
-    until eof?
-      block.call(@string[i].ord)
-      i += 1
-    end
-
-    self
-  end
-
-  def each_char(&block)
-    return enum_for :each_char unless block
-
-    check_readable
-
-    i = @position
-    until eof?
-      block.call(@string[i])
-      i += 1
-    end
-
-    self
-  end
-
-  def each(separator = $/)
-    return enum_for :each_line unless block_given?
-    check_readable
-    chomp_lines = false
-    if ::Hash === separator
-      separator = (chomp_lines = separator[:chomp]) ? /\r?\n/ : $/
-    elsif separator
-      separator = separator.to_str
-    else
-      separator = `undefined`
-    end
-    %x{
-      var str = self.string, stringLength = str.length;
-      if (self.position < stringLength) str = str.substr(self.position);
-      if (separator) {
-        var chomped = #{`str`.chomp}, trailing = str.length !== chomped.length, splitted = chomped.split(separator);
-        for (var i = 0, len = splitted.length; i < len; i++) {
-          var line = chomp_lines ? splitted[i] : (i < len - 1 || trailing ? splitted[i] + separator : splitted[i]);
-          #{yield `line`};
-        }
-      } else if (separator === undefined) {
-        #{yield `str`};
-      } else {
-        var m, re = /(.+(?:\n\n|$))\n*/g;
-        while ((m = re.exec(str))) #{yield `m[1]`};
-      }
-      self.position = stringLength;
-    }
-    self
-  end
-
-  alias each_line each
-
   def write(string)
     check_writable
 
+    # Let's reset the read buffer, because it will be most likely wrong
+    @read_buffer = ''
+
     string = String(string)
 
     if @string.length == @position
@@ -154,6 +92,7 @@ class StringIO < IO
     string = if length
       str = @string[@position, length]
       @position += length
+      @position = @string.length if @position > @string.length
       str
     else
       str = @string[@position .. -1]
@@ -168,47 +107,11 @@ class StringIO < IO
     end
   end
 
-  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 closed_read?
-    @closed == :read || @closed == :both
-  end
-
-  def closed_write?
-    @closed == :write || @closed == :both
-  end
+  def sysread(length)
+    check_readable
 
-  def check_writable
-    if closed_write?
-      raise IOError, "not opened for writing"
-    end
+    read(length)
   end
 
-  def check_readable
-    if closed_read?
-      raise IOError, "not opened for reading"
-    end
-  end
+  alias readpartial read
 end

data/stdlib/thread.rb

@@ -111,6 +111,35 @@ class Thread
       @storage.each(&block)
     end
   end
+
+  class Backtrace
+    class Location
+      def initialize(str)
+        @str = str
+
+        str =~ /^(.*?):(\d+):(\d+):in `(.*?)'$/
+        @path = Regexp.last_match(1)
+        @label = Regexp.last_match(4)
+        @lineno = Regexp.last_match(2).to_i
+
+        @label =~ /(\w+)$/
+        @base_label = Regexp.last_match(1) || @label
+      end
+
+      def to_s
+        @str
+      end
+
+      def inspect
+        @str.inspect
+      end
+
+      attr_reader :base_label, :label, :lineno, :path
+
+      # TODO: Make it somehow provide the absolute path.
+      alias absolute_path path
+    end
+  end
 end
 
 Queue = Thread::Queue

data/tasks/building.rake

@@ -4,11 +4,13 @@ desc <<-DESC
 Build *corelib* and *stdlib* to "build/"
 
 You can restrict the file list with the FILES env var (comma separated)
-and the destination dir with the DIR env var.
+and the destination dir with the DIR env var, FORMATS to select output formats.
 
 Example: rake dist DIR=/tmp/foo FILES='opal.rb,base64.rb'
 Example: rake dist DIR=cdn/opal/#{Opal::VERSION}
 Example: rake dist DIR=cdn/opal/master
+Example: rake dist DIR=cdn/opal/master FORMATS=js,min,gz
+Example: rake dist DIR=cdn/opal/master FORMATS=js,map
 DESC
 task :dist do
   require 'opal/util'
@@ -22,6 +24,7 @@ task :dist do
   build_dir = ENV['DIR'] || 'build'
   files     = ENV['FILES'] ? ENV['FILES'].split(',') :
               Dir['{opal,stdlib}/*.rb'].map { |lib| File.basename(lib, '.rb') }
+  formats = (ENV['FORMATS'] || 'js,min,gz').split(',')
 
   mkdir_p build_dir unless File.directory? build_dir
   width = files.map(&:size).max
@@ -34,9 +37,12 @@ task :dist do
 
       # Set requirable to true, unless building opal. This allows opal to be auto-loaded.
       requirable = (lib != 'opal')
-      src = Opal::Builder.build(lib, requirable: requirable).to_s
-      min = Opal::Util.uglify src
-      gzp = Opal::Util.gzip min
+      builder = Opal::Builder.build(lib, requirable: requirable)
+
+      src = builder.to_s if (formats & %w[js min gz]).any?
+      src << ";" << builder.source_map.to_data_uri_comment if (formats & %w[map]).any?
+      min = Opal::Util.uglify src if (formats & %w[min gz]).any?
+      gzp = Opal::Util.gzip min if (formats & %w[gz]).any?
 
       File.open("#{build_dir}/#{lib}.js", 'w+')        { |f| f << src }
       File.open("#{build_dir}/#{lib}.min.js", 'w+')    { |f| f << min } if min

data/tasks/linting-parse-eslint-results.js

@@ -0,0 +1,39 @@
+const SourceMapConsumer = require('source-map').SourceMapConsumer
+const path = require('path')
+const fs = require('fs')
+const root = `${__dirname}/..`
+const results = JSON.parse(fs.readFileSync(`${root}/tmp/lint/result.json`, 'utf8'))
+const bufferFrom = require('buffer-from');
+const puts = (string = '') => process.stdout.write(`${string}\n`)
+const retrieveSourceMapURL = (fileData) => {
+  var re = /(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/mg;
+  var matches = fileData.match(re);
+  return matches[matches.length - 1];
+}
+
+let count = 0
+
+results.forEach(
+  ({filePath, messages}) => {
+    if (messages.length === 0) {return}
+
+    const sourceMappingURL = retrieveSourceMapURL(fs.readFileSync(filePath, 'utf8'))
+    const rawData = sourceMappingURL.split(',', 2)[1]
+    const sourceMapData = bufferFrom(rawData, "base64").toString();
+    const consumer = new SourceMapConsumer(sourceMapData);
+
+    messages.forEach((error) => {
+      const original = consumer.originalPositionFor({ line: error.line, column: error.column })
+      count++
+
+      puts()
+      puts(`* ${error.message}`)
+      if (error.ruleId) puts(`  - Read more: https://eslint.org/docs/rules/${error.ruleId}`)
+      ;(error.suggestions || []).forEach((suggestion) => puts(`  - Suggestion: ${suggestion.desc}`))
+      puts(`  - Compiled: ${path.relative(root, filePath)}:${error.line}:${error.column}`)
+      puts(`  - Original: ${original.source}:${original.line}:${original.column}`)
+    })
+  }
+)
+
+puts(`\nFailed with ${count} error${count === 1 ? '' : 's'}.`)