opal 1.2.0 → 1.3.0.alpha1

data/opal/corelib/kernel.rb

@@ -2,7 +2,7 @@
 
 module Kernel
   def method_missing(symbol, *args, &block)
-    raise NoMethodError.new("undefined method `#{symbol}' for #{inspect}", symbol, args)
+    raise NoMethodError.new("undefined method `#{symbol}' for #{inspect}", symbol, args), nil, caller(1)
   end
 
   def =~(obj)
@@ -94,19 +94,18 @@ module Kernel
 
   def caller(start = 1, length = nil)
     %x{
-      var stack, result
+      var stack, result;
 
-      stack = (new Error().stack || "").split("\n")
-      result = []
+      stack = new Error().$backtrace();
+      result = [];
 
-      // Skip the initial line ("Error:") and Kernel#caller with i=3
-      for (var i = 3, ii = stack.length; i < ii; i++) {
-        if (!stack[i].match("runtime.js")) {
-          result.push(stack[i].replace(/^ *\w+ +/, ''))
-          if (length && result.length == length) break
+      for (var i = #{start} + 1, ii = stack.length; i < ii; i++) {
+        if (!stack[i].match(/runtime\.js/)) {
+          result.push(stack[i]);
         }
       }
-      return result
+      if (length != nil) result = result.slice(0, length);
+      return result;
     }
   end
 
@@ -239,6 +238,10 @@ module Kernel
     self
   end
 
+  def gets(*args)
+    $stdin.gets(*args)
+  end
+
   def hash
     __id__
   end
@@ -247,7 +250,11 @@ module Kernel
   end
 
   def inspect
-    to_s
+    ivs = ''
+    instance_variables.each do |i|
+      ivs += " #{i}=#{instance_variable_get(i)}"
+    end
+    "#<#{self.class}:0x#{__id__.to_s(16)}#{ivs}>"
   end
 
   def instance_of?(klass)
@@ -367,22 +374,26 @@ module Kernel
             base = 2;
             return head;
           }
+          // no-break
         case '0':
         case '0o':
           if (base === 0 || base === 8) {
             base = 8;
             return head;
           }
+          // no-break
         case '0d':
           if (base === 0 || base === 10) {
             base = 10;
             return head;
           }
+          // no-break
         case '0x':
           if (base === 0 || base === 16) {
             base = 16;
             return head;
           }
+          // no-break
         }
         #{raise ArgumentError, "invalid value for Integer(): \"#{value}\""}
       });
@@ -516,11 +527,15 @@ module Kernel
     $stdout.print(*strs)
   end
 
+  def readline(*args)
+    $stdin.readline(*args)
+  end
+
   def warn(*strs, uplevel: nil)
     if uplevel
       uplevel = Opal.coerce_to!(uplevel, Integer, :to_str)
       raise ArgumentError, "negative level (#{uplevel})" if uplevel < 0
-      location = caller(uplevel + 2, 1).first
+      location = caller(uplevel + 1, 1).first&.split(':in `')&.first
       location = "#{location}: " if location
       strs = strs.map { |s| "#{location}warning: #{s}" }
     end
@@ -528,33 +543,38 @@ module Kernel
     $stderr.puts(*strs) unless $VERBOSE.nil? || strs.empty?
   end
 
-  def raise(exception = undefined, string = nil, _backtrace = nil)
+  def raise(exception = undefined, string = nil, backtrace = nil)
     %x{
       if (exception == null && #{$!} !== nil) {
         throw #{$!};
       }
       if (exception == null) {
-        exception = #{RuntimeError.new};
+        exception = #{RuntimeError.new ''};
       }
-      else if (exception.$$is_string) {
-        exception = #{RuntimeError.new exception};
+      else if ($respond_to(exception, '$to_str')) {
+        exception = #{RuntimeError.new exception.to_str};
       }
       // using respond_to? and not an undefined check to avoid method_missing matching as true
-      else if (exception.$$is_class && #{exception.respond_to?(:exception)}) {
+      else if (exception.$$is_class && $respond_to(exception, '$exception')) {
         exception = #{exception.exception string};
       }
-      else if (#{exception.is_a?(Exception)}) {
+      else if (exception.$$is_exception) {
         // exception is fine
       }
       else {
         exception = #{TypeError.new 'exception class/object expected'};
       }
 
+      if (backtrace !== nil) {
+        exception.$set_backtrace(backtrace);
+      }
+
       if (#{$!} !== nil) {
         Opal.exceptions.push(#{$!});
       }
 
       #{$!} = exception;
+      #{$@} = #{`exception`.backtrace};
 
       throw exception;
     }
@@ -687,15 +707,16 @@ module Kernel
     "#<#{self.class}:0x#{__id__.to_s(16)}>"
   end
 
-  def catch(sym)
-    yield
+  def catch(tag = nil)
+    tag ||= Object.new
+    yield(tag)
   rescue UncaughtThrowError => e
-    return e.arg if e.sym == sym
+    return e.value if e.tag == tag
     raise
   end
 
-  def throw(*args)
-    raise UncaughtThrowError, args
+  def throw(tag, obj = nil)
+    raise UncaughtThrowError.new(tag, obj)
   end
 
   # basic implementation of open, delegate to File.open

data/opal/corelib/main.rb

@@ -5,3 +5,8 @@ end
 def self.include(mod)
   Object.include mod
 end
+
+# Compiler overrides this method
+def self.using(mod)
+  raise 'main.using is permitted only at toplevel'
+end

data/opal/corelib/method.rb

@@ -33,6 +33,7 @@ class Method
   end
 
   alias [] call
+  alias === call
 
   def >>(other)
     @method >> other

data/opal/corelib/module.rb

@@ -629,6 +629,8 @@ class Module
     `Opal.Module.$name.call(self)` || "#<#{`self.$$is_module ? 'Module' : 'Class'`}:0x#{__id__.to_s(16)}>"
   end
 
+  alias inspect to_s
+
   def undef_method(*names)
     %x{
       for (var i = 0, length = names.length; i < length; i++) {
@@ -678,4 +680,30 @@ class Module
       }
     }
   end
+
+  def refine(mod, &block)
+    s, m, mod_id = self, nil, nil
+    %x{
+      mod_id = Opal.id(mod);
+      if (typeof self.$$refine_modules === "undefined") {
+        self.$$refine_modules = {};
+      }
+      if (typeof self.$$refine_modules[mod_id] === "undefined") {
+        m = self.$$refine_modules[mod_id] = #{::Module.new};
+      }
+      else {
+        m = self.$$refine_modules[mod_id];
+      }
+    }
+    m.define_singleton_method :inspect do
+      "#<refinement:#{mod.inspect}@#{s.inspect}>"
+    end
+    m.class_exec(&block)
+    m
+  end
+
+  # Compiler overrides this method
+  def using(mod)
+    raise 'Module#using is not permitted in methods'
+  end
 end

data/opal/corelib/number.rb

@@ -711,6 +711,11 @@ class Number < Numeric
       raise ArgumentError, "invalid radix #{base}"
     end
 
+    # Don't lose the negative zero
+    if self == 0 && `1/self === -Infinity`
+      return '-0.0'
+    end
+
     `self.toString(base)`
   end
 
@@ -747,9 +752,15 @@ class Number < Numeric
     end
 
     %x{
+      if (self != parseInt(self)) #{raise NoMethodError, "undefined method `digits' for #{inspect}"}
+
       var value = self, result = [];
 
-      while (value !== 0) {
+      if (self == 0) {
+        return [0];
+      }
+
+      while (value != 0) {
         result.push(value % base);
         value = parseInt(value / base, 10);
       }

data/opal/corelib/random/seedrandom.js.rb

@@ -2,7 +2,7 @@ class Random
   %x{
     var module = { exports: {} };
 
-    /* jshint ignore:start */
+    /* eslint-disable */
     /*
     seedrandom.min.js 2.4.1 (original source: https://github.com/davidbau/seedrandom/blob/2.4.1/seedrandom.min.js)
     How to update:
@@ -12,7 +12,7 @@ class Random
      .. Add a module id for the RequireJS `define` method: https://github.com/Mogztter/seedrandom/commit/e047540c3d81f955cab9a01d17b8141d439fbd7d
     */
     !function(a,b){function c(c,j,k){var n=[];j=1==j?{entropy:!0}:j||{};var s=g(f(j.entropy?[c,i(a)]:null==c?h():c,3),n),t=new d(n),u=function(){for(var a=t.g(m),b=p,c=0;a<q;)a=(a+c)*l,b*=l,c=t.g(1);for(;a>=r;)a/=2,b/=2,c>>>=1;return(a+c)/b};return u.int32=function(){return 0|t.g(4)},u.quick=function(){return t.g(4)/4294967296},u.double=u,g(i(t.S),a),(j.pass||k||function(a,c,d,f){return f&&(f.S&&e(f,t),a.state=function(){return e(t,{})}),d?(b[o]=a,c):a})(u,s,"global"in j?j.global:this==b,j.state)}function d(a){var b,c=a.length,d=this,e=0,f=d.i=d.j=0,g=d.S=[];for(c||(a=[c++]);e<l;)g[e]=e++;for(e=0;e<l;e++)g[e]=g[f=s&f+a[e%c]+(b=g[e])],g[f]=b;(d.g=function(a){for(var b,c=0,e=d.i,f=d.j,g=d.S;a--;)b=g[e=s&e+1],c=c*l+g[s&(g[e]=g[f=s&f+b])+(g[f]=b)];return d.i=e,d.j=f,c})(l)}function e(a,b){return b.i=a.i,b.j=a.j,b.S=a.S.slice(),b}function f(a,b){var c,d=[],e=typeof a;if(b&&"object"==e)for(c in a)if(a.hasOwnProperty(c))try{d.push(f(a[c],b-1))}catch(a){}return d.length?d:"string"==e?a:a+"\0"}function g(a,b){for(var c,d=a+"",e=0;e<d.length;)b[s&e]=s&(c^=19*b[s&e])+d.charCodeAt(e++);return i(b)}function h(){try{if(j)return i(j.randomBytes(l));var b=new Uint8Array(l);return(k.crypto||k.msCrypto).getRandomValues(b),i(b)}catch(b){var c=k.navigator,d=c&&c.plugins;return[+new Date,k,d,k.screen,i(a)]}}function i(a){return String.fromCharCode.apply(0,a)}var j,k=this,l=256,m=6,n=52,o="random",p=b.pow(l,m),q=b.pow(2,n),r=2*q,s=l-1;if(b["seed"+o]=c,g(b.random(),a),"object"==typeof module&&module.exports){module.exports=c;try{j=require("crypto")}catch(a){}}else"function"==typeof define&&define.amd&&define('seekrandom',function(){return c})}([],Math);
-    /* jshint ignore:end */
+    /* eslint-enable */
     var seedrandom = module.exports
     var $seed_generator = new Math.seedrandom('opal', { entropy: true })
   }

data/opal/corelib/regexp.rb

@@ -244,6 +244,20 @@ class Regexp < `RegExp`
     }
   end
 
+  def names
+    source.scan(/\(?<(\w+)>/).map(&:first).uniq
+  end
+
+  def named_captures
+    source.scan(/\(?<(\w+)>/)        # Scan for capture groups
+          .map(&:first)              # Get the first regexp match (\w+)
+          .each_with_index           # Add index to an iterator
+          .group_by(&:first)         # Group by the capture group names
+          .transform_values do |i|   # Convert hash values
+            i.map { |j| j.last + 1 } # Drop the capture group names; increase indexes by 1
+          end
+  end
+
   def ~
     self =~ $_
   end
@@ -304,7 +318,17 @@ class MatchData
   end
 
   def [](*args)
-    @matches[*args]
+    %x{
+      if (args[0].$$is_string) {
+        if (#{!regexp.names.include?(args[0])}) {
+          #{raise IndexError, "undefined group name reference: #{args[0]}"}
+        }
+        return #{named_captures[args[0]]}
+      }
+      else {
+        return #{@matches[*args]}
+      }
+    }
   end
 
   def offset(n)
@@ -350,12 +374,32 @@ class MatchData
     `#{@matches}.slice(1)`
   end
 
+  def named_captures
+    matches = captures
+    regexp.named_captures.transform_values do |i|
+      matches[i.last - 1]
+    end
+  end
+
+  def names
+    regexp.names
+  end
+
   def inspect
     %x{
       var str = "#<MatchData " + #{`#{@matches}[0]`.inspect};
 
-      for (var i = 1, length = #{@matches}.length; i < length; i++) {
-        str += " " + i + ":" + #{`#{@matches}[i]`.inspect};
+      if (#{regexp.names.empty?}) {
+        for (var i = 1, length = #{@matches}.length; i < length; i++) {
+          str += " " + i + ":" + #{`#{@matches}[i]`.inspect};
+        }
+      }
+      else {
+        #{ named_captures.each do |k, v|
+             %x{
+               str += " " + #{k} + ":" + #{v.inspect}
+             }
+           end }
       }
 
       return str + ">";

data/opal/corelib/runtime.js

@@ -65,6 +65,7 @@
   Opal.config = {
     missing_require_severity: 'error',        // error, warning, ignore
     unsupported_features_severity: 'warning', // error, warning, ignore
+    experimental_features_severity: 'warning',// warning, ignore
     enable_stack_trace: true                  // true, false
   };
 
@@ -111,7 +112,14 @@
   // @private
   // Pops an exception from the stack and updates `$!`.
   Opal.pop_exception = function() {
-    Opal.gvars["!"] = Opal.exceptions.pop() || nil;
+    var exception = Opal.exceptions.pop();
+    if (exception) {
+      Opal.gvars["!"] = exception;
+      Opal.gvars["@"] = exception.$backtrace();
+    }
+    else {
+      Opal.gvars["!"] = Opal.gvars["@"] = nil;
+    }
   };
 
   // Inspect any kind of object, including non Ruby ones
@@ -209,6 +217,22 @@
     }
   }
 
+  // TracePoint support
+  // ------------------
+  //
+  // Support for `TracePoint.trace(:class) do ... end`
+  Opal.trace_class = false;
+  Opal.tracers_for_class = [];
+
+  function invoke_tracers_for_class(klass_or_module) {
+    var i, ii, tracer;
+
+    for(i = 0, ii = Opal.tracers_for_class.length; i < ii; i++) {
+      tracer = Opal.tracers_for_class[i];
+      tracer.trace_object = klass_or_module;
+      tracer.block.$call(tracer);
+    }
+  }
 
   // Constants
   // ---------
@@ -565,6 +589,9 @@
         // Make sure existing class has same superclass
         ensureSuperclassMatch(klass, superclass);
       }
+
+      if (Opal.trace_class) { invoke_tracers_for_class(klass); }
+
       return klass;
     }
 
@@ -588,6 +615,8 @@
       Opal.bridge(bridged, klass);
     }
 
+    if (Opal.trace_class) { invoke_tracers_for_class(klass); }
+
     return klass;
   };
 
@@ -665,6 +694,9 @@
     module = find_existing_module(scope, name);
 
     if (module) {
+
+      if (Opal.trace_class) { invoke_tracers_for_class(module); }
+
       return module;
     }
 
@@ -672,6 +704,8 @@
     module = Opal.allocate_module(name);
     Opal.const_set(scope, name, module);
 
+    if (Opal.trace_class) { invoke_tracers_for_class(module); }
+
     return module;
   };
 
@@ -1358,9 +1392,10 @@
   // @return [undefined]
   Opal.add_stubs = function(stubs) {
     var proto = Opal.BasicObject.$$prototype;
+    var stub, existing_method;
 
     for (var i = 0, length = stubs.length; i < length; i++) {
-      var stub = stubs[i], existing_method = proto[stub];
+      stub = stubs[i], existing_method = proto[stub];
 
       if (existing_method == null || existing_method.$$stub) {
         Opal.add_stub_for(proto, stub);
@@ -1375,8 +1410,8 @@
   // @param stub [String] stub name to add (e.g. "$foo")
   // @return [undefined]
   Opal.add_stub_for = function(prototype, stub) {
-    var method_missing_stub = Opal.stub_for(stub);
-    $defineProperty(prototype, stub, method_missing_stub);
+    // Opal.stub_for(stub) is the method_missing_stub
+    $defineProperty(prototype, stub, Opal.stub_for(stub));
   };
 
   // Generate the method_missing stub for a given method name.
@@ -1386,8 +1421,6 @@
   Opal.stub_for = function(method_name) {
 
     function method_missing_stub() {
-      /* jshint validthis: true */
-
       // Copy any given block onto the method_missing dispatcher
       this.$method_missing.$$p = method_missing_stub.$$p;
 
@@ -1443,7 +1476,7 @@
   };
 
   // Super dispatcher
-  Opal.find_super_dispatcher = function(obj, mid, current_func, defcheck, allow_stubs) {
+  Opal.find_super = function(obj, mid, current_func, defcheck, allow_stubs) {
     var jsid = '$' + mid, ancestors, super_method;
 
     if (obj.hasOwnProperty('$$meta')) {
@@ -1477,7 +1510,7 @@
   };
 
   // Iter dispatcher for super in a block
-  Opal.find_iter_super_dispatcher = function(obj, jsid, current_func, defcheck, implicit) {
+  Opal.find_block_super = function(obj, jsid, current_func, defcheck, implicit) {
     var call_jsid = jsid;
 
     if (!current_func) {
@@ -1495,6 +1528,12 @@
     return Opal.find_super_dispatcher(obj, call_jsid, current_func, defcheck);
   };
 
+  // @deprecated
+  Opal.find_super_dispatcher = Opal.find_super;
+
+  // @deprecated
+  Opal.find_iter_super_dispatcher = Opal.find_block_super;
+
   // Used to return as an expression. Sometimes, we can't simply return from
   // a javascript function as if we were a method, as the return is used as
   // an expression, or even inside a block which must "return" to the outer
@@ -1773,6 +1812,44 @@
     return body.apply(recv, args);
   };
 
+  Opal.refined_send = function(refinement_groups, recv, method, args, block) {
+    var i, j, k, ancestors, ancestor, refinements, refinement, refine_modules, refine_module, body;
+
+    if (recv.hasOwnProperty('$$meta')) {
+      ancestors = Opal.ancestors(recv.$$meta);
+    } else {
+      ancestors = Opal.ancestors(recv.$$class);
+    }
+
+    // For all ancestors that there are, starting from the closest to the furthest...
+    for (i = 0; i < ancestors.length; i++) {
+      ancestor = Opal.id(ancestors[i]);
+      // For all refinement groups there are, starting from the closest scope to the furthest...
+      for (j = 0; j < refinement_groups.length; j++) {
+        refinements = refinement_groups[j];
+        // For all refinements there are, starting from the last `using` call to the furthest...
+        for (k = refinements.length - 1; k >= 0; k--) {
+          refinement = refinements[k];
+          if (typeof refinement.$$refine_modules === 'undefined') continue;
+          // A single module being given as an argument of the `using` call contains multiple
+          // refinement modules
+          refine_modules = refinement.$$refine_modules;
+          // Does this module refine a given call for a given ancestor module?
+          if (typeof refine_modules[ancestor] !== 'undefined') {
+            refine_module = refine_modules[ancestor];
+            // Does this module define a method we want to call?
+            if (typeof refine_module.$$prototype['$'+method] !== 'undefined') {
+              body = refine_module.$$prototype['$'+method];
+              return Opal.send2(recv, body, method, args, block);
+            }
+          }
+        }
+      }
+    }
+
+    return Opal.send(recv, method, args, block);
+  };
+
   Opal.lambda = function(block) {
     block.$$is_lambda = true;
     return block;
@@ -1915,9 +1992,16 @@
   Opal.alias = function(obj, name, old) {
     var id     = '$' + name,
         old_id = '$' + old,
-        body   = obj.$$prototype['$' + old],
+        body,
         alias;
 
+    // Aliasing on main means aliasing on Object...
+    if (typeof obj.$$prototype === 'undefined') {
+      obj = Opal.Object;
+    }
+
+    body = obj.$$prototype['$' + old];
+
     // When running inside #instance_eval the alias refers to class methods.
     if (obj.$$eval) {
       return Opal.alias(Opal.get_singleton_class(obj), name, old);
@@ -1982,6 +2066,20 @@
     return obj;
   };
 
+  Opal.alias_gvar = function(new_name, old_name) {
+    Object.defineProperty(Opal.gvars, new_name, {
+      configurable: true,
+      enumerable: true,
+      get: function() {
+        return Opal.gvars[old_name];
+      },
+      set: function(new_value) {
+        Opal.gvars[old_name] = new_value;
+      }
+    });
+    return nil;
+  }
+
   Opal.alias_native = function(obj, name, native_name) {
     var id   = '$' + name,
         body = obj.$$prototype[native_name];
@@ -2085,7 +2183,7 @@
   };
 
   Opal.hash_delete = function(hash, key) {
-    var i, keys = hash.$$keys, length = keys.length, value;
+    var i, keys = hash.$$keys, length = keys.length, value, key_tmp;
 
     if (key.$$is_string) {
       if (typeof key !== "string") key = key.valueOf();
@@ -2095,7 +2193,13 @@
       }
 
       for (i = 0; i < length; i++) {
-        if (keys[i] === key) {
+        key_tmp = keys[i];
+
+        if (key_tmp.$$is_string && typeof key_tmp !== "string") {
+          key_tmp = key_tmp.valueOf();
+        }
+
+        if (key_tmp === key) {
           keys.splice(i, 1);
           break;
         }
@@ -2444,7 +2548,12 @@
     var module = Opal.modules[path];
 
     if (module) {
-      module(Opal);
+      var retval = module(Opal);
+      if (typeof Promise !== 'undefined' && retval instanceof Promise) {
+        // A special case of require having an async top:
+        // We will need to await it.
+        return retval.then(function() { return true; });
+      }
     }
     else {
       var severity = Opal.config.missing_require_severity;
@@ -2523,6 +2632,37 @@
     return Opal.set_encoding(dup, "binary", "internal_encoding");
   }
 
+  Opal.last_promise = null;
+  Opal.promise_unhandled_exception = false;
+
+  // Run a block of code, but if it returns a Promise, don't run the next
+  // one, but queue it.
+  Opal.queue = function(proc) {
+    if (Opal.last_promise) {
+      // The async path is taken only if anything before returned a
+      // Promise(V2).
+      Opal.last_promise = Opal.last_promise.then(function() {
+        if (!Opal.promise_unhandled_exception) return proc(Opal);
+      })['catch'](function(error) {
+        if (Opal.respond_to(error, '$full_message')) {
+          error = error.$full_message();
+        }
+        console.error(error);
+        // Abort further execution
+        Opal.promise_unhandled_exception = true;
+        Opal.exit(1);
+      });
+      return Opal.last_promise;
+    }
+    else {
+      var ret = proc(Opal);
+      if (typeof Promise === 'function' && typeof ret === 'object' && ret instanceof Promise) {
+        Opal.last_promise = ret;
+      }
+      return ret;
+    }
+  }
+
 
   // Initialization
   // --------------