opal 0.4.4 → 0.5.0

data/corelib/enumerator.rb

@@ -1,17 +1,41 @@
 class Enumerator
   include Enumerable
 
-  def initialize(obj, method = :each, *args)
-    @object = obj
-    @method = method
-    @args   = args
+  class Yielder
+    def initialize(enumerator, block, to)
+      @enumerator = enumerator
+      @block      = block
+      @to         = to
+    end
+
+    def yield(*values)
+      @to.call(*values)
+    end
+
+    alias << yield
+
+    def call
+      @block.call(self)
+    end
+  end
+
+  def initialize(obj = nil, method = :each, *args, &block)
+    if block
+      @block = block
+    else
+      @object = obj
+      @method = method
+      @args   = args
+    end
   end
 
   def each(&block)
     return enum_for :each unless block_given?
 
-    @object.__send__(@method, *@args) do |*e|
-      block.call(*e)
+    if @block
+      Yielder.new(self, @block, block).call
+    else
+      @object.__send__(@method, *@args, &block)
     end
   end
 
@@ -25,6 +49,7 @@ class Enumerator
 
   def rewind
     @cache = nil
+
     self
   end
 end

data/corelib/error.rb

@@ -4,15 +4,15 @@ class Exception
   def self.new(message = '')
     %x{
       var err = new Error(message);
-      err._klass = #{self};
-      err.name = #{self}._name;
+      err._klass = self;
+      err.name = self._name;
       return err;
     }
   end
 
   def backtrace
     %x{
-      var backtrace = #{self}.stack;
+      var backtrace = self.stack;
 
       if (typeof(backtrace) === 'string') {
         return backtrace.split("\\n").slice(0, 15);
@@ -32,7 +32,9 @@ class Exception
   alias to_s message
 end
 
+# keep the indentation, it makes the exception hierarchy clear
 class StandardError < Exception; end
+  class SystemCallError < StandardError; end
   class NameError < StandardError; end
     class NoMethodError < NameError; end
   class RuntimeError < StandardError; end
@@ -43,6 +45,7 @@ class StandardError < Exception; end
     class StopIteration < IndexError; end
     class KeyError < IndexError; end
   class RangeError < StandardError; end
+    class FloatDomainError < RangeError; end
   class IOError < StandardError; end
 
 class ScriptError < Exception; end
@@ -50,3 +53,11 @@ class ScriptError < Exception; end
   class NotImplementedError < ScriptError; end
 
 class SystemExit < Exception; end
+
+module Errno
+  class EINVAL < SystemCallError
+    def self.new
+      super('Invalid argument')
+    end
+  end
+end

data/corelib/hash.rb

@@ -8,21 +8,35 @@ class Hash
       }
 
       var hash   = new Hash._alloc,
-          args   = $slice.call(arguments),
           keys   = [],
           assocs = {};
 
       hash.map   = assocs;
       hash.keys  = keys;
 
-      for (var i = 0, length = args.length, key; i < length; i++) {
-        var key = args[i], obj = args[++i];
+      if (arguments.length == 1 && arguments[0]._isArray) {
+        var args = arguments[0];
 
-        if (assocs[key] == null) {
-          keys.push(key);
+        for (var i = 0, length = args.length; i < length; i++) {
+          var key = args[i][0], obj = args[i][1];
+
+          if (assocs[key] == null) {
+            keys.push(key);
+          }
+
+          assocs[key] = obj;
         }
+      }
+      else {
+        for (var i = 0, length = arguments.length, key; i < length; i++) {
+          var key = arguments[i], obj = arguments[++i];
 
-        assocs[key] = obj;
+          if (assocs[key] == null) {
+            keys.push(key);
+          }
+
+          assocs[key] = obj;
+        }
       }
 
       return hash;
@@ -50,7 +64,7 @@ class Hash
 
   def self.allocate
     %x{
-      var hash = new #{self}._alloc;
+      var hash = new self._alloc;
       hash.map = {};
       hash.keys = [];
       return hash;
@@ -61,7 +75,7 @@ class Hash
     %x{
       if (defaults != null) {
         if (defaults.constructor == Object) {
-          var map = #{self}.map, keys = #{self}.keys;
+          var map = self.map, keys = self.keys;
 
           for (var key in defaults) {
             keys.push(key);
@@ -69,20 +83,20 @@ class Hash
           }
         }
         else {
-          #{self}.none = defaults;
+          self.none = defaults;
         }
       }
       else if (block !== nil) {
-          #{self}.proc = block;
+          self.proc = block;
       }
 
-      return #{self};
+      return self;
     }
   end
 
   def ==(other)
     %x{
-      if (#{self} === other) {
+      if (self === other) {
         return true;
       }
 
@@ -90,15 +104,15 @@ class Hash
         return false;
       }
 
-      if (#{self}.keys.length !== other.keys.length) {
+      if (self.keys.length !== other.keys.length) {
         return false;
       }
 
-      var map  = #{self}.map,
+      var map  = self.map,
           map2 = other.map;
 
-      for (var i = 0, length = #{self}.keys.length; i < length; i++) {
-        var key = #{self}.keys[i], obj = map[key], obj2 = map2[key];
+      for (var i = 0, length = self.keys.length; i < length; i++) {
+        var key = self.keys[i], obj = map[key], obj2 = map2[key];
 
         if (#{`obj` != `obj2`}) {
           return false;
@@ -111,28 +125,28 @@ class Hash
 
   def [](key)
     %x{
-      var bucket = #{self}.map[key];
+      var map = self.map;
 
-      if (bucket != null) {
-        return bucket;
+      if ($hasOwn.call(map, key)) {
+        return map[key];
       }
 
-      var proc = #{@proc};
+      var proc = #@proc;
 
       if (proc !== nil) {
         return #{ `proc`.call self, key };
       }
 
-      return #{@none};
+      return #@none;
     }
   end
 
   def []=(key, value)
     %x{
-      var map = #{self}.map;
+      var map = self.map;
 
       if (!$hasOwn.call(map, key)) {
-        #{self}.keys.push(key);
+        self.keys.push(key);
       }
 
       map[key] = value;
@@ -143,13 +157,13 @@ class Hash
 
   def assoc(object)
     %x{
-      var keys = #{self}.keys, key;
+      var keys = self.keys, key;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         key = keys[i];
 
         if (#{`key` == object}) {
-          return [key, #{self}.map[key]];
+          return [key, self.map[key]];
         }
       }
 
@@ -159,22 +173,25 @@ class Hash
 
   def clear
     %x{
-      #{self}.map = {};
-      #{self}.keys = [];
-      return #{self};
+      self.map = {};
+      self.keys = [];
+      return self;
     }
   end
 
   def clone
     %x{
-      var result = $hash(),
-          map    = #{self}.map,
+      var result = new self._klass._alloc();
+
+      result.map = {}; result.keys = [];
+
+      var map    = self.map,
           map2   = result.map,
           keys2  = result.keys;
 
-      for (var i = 0, length = #{self}.keys.length; i < length; i++) {
-        keys2.push(#{self}.keys[i]);
-        map2[#{self}.keys[i]] = map[#{self}.keys[i]];
+      for (var i = 0, length = self.keys.length; i < length; i++) {
+        keys2.push(self.keys[i]);
+        map2[self.keys[i]] = map[self.keys[i]];
       }
 
       return result;
@@ -199,11 +216,11 @@ class Hash
 
   def delete(key)
     %x{
-      var map  = #{self}.map, result = map[key];
+      var map  = self.map, result = map[key];
 
       if (result != null) {
         delete map[key];
-        #{self}.keys.$delete(key);
+        self.keys.$delete(key);
 
         return result;
       }
@@ -216,7 +233,7 @@ class Hash
     return enum_for :delete_if unless block
 
     %x{
-      var map = #{self}.map, keys = #{self}.keys, value;
+      var map = self.map, keys = self.keys, value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key];
@@ -234,7 +251,7 @@ class Hash
         }
       }
 
-      return #{self};
+      return self;
     }
   end
 
@@ -244,15 +261,19 @@ class Hash
     return enum_for :each unless block
 
     %x{
-      var map = #{self}.map, keys = #{self}.keys;
+      var map  = self.map,
+          keys = self.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i];
+        var key   = keys[i],
+            value = $opal.$yield1(block, [key, map[key]]);
 
-        #{yield [`key`, `map[key]`]};
+        if (value === $breaker) {
+          return $breaker.$v;
+        }
       }
 
-      return #{self};
+      return self;
     }
   end
 
@@ -260,7 +281,7 @@ class Hash
     return enum_for :each_key unless block
 
     %x{
-      var keys = #{self}.keys;
+      var keys = self.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i];
@@ -270,7 +291,7 @@ class Hash
         }
       }
 
-      return #{self};
+      return self;
     }
   end
 
@@ -280,7 +301,7 @@ class Hash
     return enum_for :each_value unless block
 
     %x{
-      var map = #{self}.map, keys = #{self}.keys;
+      var map = self.map, keys = self.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         if (block(map[keys[i]]) === $breaker) {
@@ -288,19 +309,19 @@ class Hash
         }
       }
 
-      return #{self};
+      return self;
     }
   end
 
   def empty?
-    `#{self}.keys.length === 0`
+    `self.keys.length === 0`
   end
 
   alias eql? ==
 
   def fetch(key, defaults = undefined, &block)
     %x{
-      var value = #{self}.map[key];
+      var value = self.map[key];
 
       if (value != null) {
         return value;
@@ -326,7 +347,7 @@ class Hash
 
   def flatten(level=undefined)
     %x{
-      var map = #{self}.map, keys = #{self}.keys, result = [];
+      var map = self.map, keys = self.keys, result = [];
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], value = map[key];
@@ -351,13 +372,13 @@ class Hash
   end
 
   def has_key?(key)
-    `#{self}.map[key] != null`
+    `$hasOwn.call(self.map, key)`
   end
 
   def has_value?(value)
     %x{
-      for (var assoc in #{self}.map) {
-        if (#{`#{self}.map[assoc]` == value}) {
+      for (var assoc in self.map) {
+        if (#{`self.map[assoc]` == value}) {
           return true;
         }
       }
@@ -367,19 +388,19 @@ class Hash
   end
 
   def hash
-    `#{self}._id`
+    `self._id`
   end
 
   alias include? has_key?
 
   def index(object)
     %x{
-      var map = #{self}.map, keys = #{self}.keys;
+      var map = self.map, keys = self.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i];
 
-        if (#{object == `map[key]`}) {
+        if (#{`map[key]` == object}) {
           return key;
         }
       }
@@ -390,7 +411,7 @@ class Hash
 
   def indexes(*keys)
     %x{
-      var result = [], map = #{self}.map, val;
+      var result = [], map = self.map, val;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], val = map[key];
@@ -399,7 +420,7 @@ class Hash
           result.push(val);
         }
         else {
-          result.push(#{self}.none);
+          result.push(self.none);
         }
       }
 
@@ -411,12 +432,12 @@ class Hash
 
   def inspect
     %x{
-      var inspect = [], keys = #{self}.keys, map = #{self}.map;
+      var inspect = [], keys = self.keys, map = self.map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], val = map[key];
 
-        if (val === #{self}) {
+        if (val === self) {
           inspect.push(#{`key`.inspect} + '=>' + '{...}');
         } else {
           inspect.push(#{`key`.inspect} + '=>' + #{`map[key]`.inspect});
@@ -429,7 +450,7 @@ class Hash
 
   def invert
     %x{
-      var result = $hash(), keys = #{self}.keys, map = #{self}.map,
+      var result = $hash(), keys = self.keys, map = self.map,
           keys2 = result.keys, map2 = result.map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
@@ -447,7 +468,7 @@ class Hash
     return enum_for :keep_if unless block
 
     %x{
-      var map = #{self}.map, keys = #{self}.keys, value;
+      var map = self.map, keys = self.keys, value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key];
@@ -465,7 +486,7 @@ class Hash
         }
       }
 
-      return #{self};
+      return self;
     }
   end
 
@@ -474,22 +495,18 @@ class Hash
   alias key? has_key?
 
   def keys
-    %x{
-      return #{self}.keys.slice(0);
-    }
+    `self.keys.slice(0)`
   end
 
   def length
-    %x{
-      return #{self}.keys.length;
-    }
+    `self.keys.length`
   end
 
   alias member? has_key?
 
   def merge(other, &block)
     %x{
-      var keys = #{self}.keys, map = #{self}.map,
+      var keys = self.keys, map = self.map,
           result = $hash(), keys2 = result.keys, map2 = result.map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
@@ -532,7 +549,7 @@ class Hash
 
   def merge!(other, &block)
     %x{
-      var keys = #{self}.keys, map = #{self}.map,
+      var keys = self.keys, map = self.map,
           keys2 = other.keys, map2 = other.map;
 
       if (block === nil) {
@@ -560,13 +577,13 @@ class Hash
         }
       }
 
-      return #{self};
+      return self;
     }
   end
 
   def rassoc(object)
     %x{
-      var keys = #{self}.keys, map = #{self}.map;
+      var keys = self.keys, map = self.map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key];
@@ -584,7 +601,7 @@ class Hash
     return enum_for :reject unless block
 
     %x{
-      var keys = #{self}.keys, map = #{self}.map,
+      var keys = self.keys, map = self.map,
           result = $hash(), map2 = result.map, keys2 = result.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
@@ -606,7 +623,7 @@ class Hash
 
   def replace(other)
     %x{
-      var map = #{self}.map = {}, keys = #{self}.keys = [];
+      var map = self.map = {}, keys = self.keys = [];
 
       for (var i = 0, length = other.keys.length; i < length; i++) {
         var key = other.keys[i];
@@ -614,7 +631,7 @@ class Hash
         map[key] = other.map[key];
       }
 
-      return #{self};
+      return self;
     }
   end
 
@@ -622,7 +639,7 @@ class Hash
     return enum_for :select unless block
 
     %x{
-      var keys = #{self}.keys, map = #{self}.map,
+      var keys = self.keys, map = self.map,
           result = $hash(), map2 = result.map, keys2 = result.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
@@ -646,7 +663,7 @@ class Hash
     return enum_for :select! unless block
 
     %x{
-      var map = #{self}.map, keys = #{self}.keys, value, result = nil;
+      var map = self.map, keys = self.keys, value, result = nil;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key];
@@ -661,7 +678,7 @@ class Hash
 
           length--;
           i--;
-          result = #{self}
+          result = self
         }
       }
 
@@ -671,7 +688,7 @@ class Hash
 
   def shift
     %x{
-      var keys = #{self}.keys, map = #{self}.map;
+      var keys = self.keys, map = self.map;
 
       if (keys.length) {
         var key = keys[0], obj = map[key];
@@ -688,9 +705,11 @@ class Hash
 
   alias size length
 
+  alias_method :store, :[]=
+
   def to_a
     %x{
-      var keys = #{self}.keys, map = #{self}.map, result = [];
+      var keys = self.keys, map = self.map, result = [];
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i];
@@ -707,12 +726,17 @@ class Hash
 
   def to_n
     %x{
-      var result = {}, keys = #{self}.keys, map = #{self}.map, bucket, value;
+      var result = {},
+          keys   = self.keys,
+          map    = self.map,
+          bucket,
+          value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i], obj = map[key];
+        var key = keys[i],
+            obj = map[key];
 
-        if (obj.$to_n) {
+        if (#{`obj`.respond_to? :to_n}) {
           result[key] = #{`obj`.to_n};
         }
         else {
@@ -728,26 +752,13 @@ class Hash
 
   alias update merge!
 
-  def value?(value)
-    %x{
-      var map = #{self}.map;
-
-      for (var assoc in map) {
-        var v = map[assoc];
-        if (#{`v` == value}) {
-          return true;
-        }
-      }
-
-      return false;
-    }
-  end
+  alias value? has_value?
 
   alias values_at indexes
 
   def values
     %x{
-      var map    = #{self}.map,
+      var map    = self.map,
           result = [];
 
       for (var key in map) {