opal 0.5.0 → 0.5.2

data/opal/core/enumerator.rb

@@ -0,0 +1,416 @@
+class Enumerator
+  include Enumerable
+
+  def self.for(object, method = :each, *args, &block)
+    %x{
+      var obj = #{allocate};
+
+      obj.object = object;
+      obj.size   = block;
+      obj.method = method;
+      obj.args   = args;
+
+      return obj;
+    }
+
+  end
+
+  def initialize(*, &block)
+    if block
+      @object = Generator.new(&block)
+      @method = :each
+      @args   = []
+      @size   = `arguments[0] || nil`
+
+      if @size
+        @size = Opal.coerce_to @size, Integer, :to_int
+      end
+    else
+      @object = `arguments[0]`
+      @method = `arguments[1] || "each"`
+      @args   = `$slice.call(arguments, 2)`
+      @size   = nil
+    end
+  end
+
+  def each(&block)
+    return self unless block
+
+    @object.__send__(@method, *@args, &block)
+  end
+
+  def size
+    Proc === @size ? @size.call(*@args) : @size
+  end
+
+  def with_index(offset = 0, &block)
+    if offset
+      offset = Opal.coerce_to offset, Integer, :to_int
+    else
+      offset = 0
+    end
+
+    return enum_for :with_index, offset unless block
+
+    %x{
+      var result
+
+      self.$each._p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = block(param, index);
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
+        }
+
+        index++;
+      }
+
+      self.$each();
+
+      if (result !== undefined) {
+        return result;
+      }
+    }
+  end
+
+  alias with_object each_with_object
+
+  def inspect
+    result = "#<#{self.class.name}: #{@object.inspect}:#{@method}"
+
+    unless @args.empty?
+      result += "(#{@args.inspect[Range.new(1, -2)]})"
+    end
+
+    result + ">"
+  end
+
+  class Generator
+    include Enumerable
+
+    def initialize(&block)
+      raise LocalJumpError, 'no block given' unless block
+
+      @block = block
+    end
+
+    def each(*args, &block)
+      yielder = Yielder.new(&block)
+
+      %x{
+        try {
+          args.unshift(#{yielder});
+
+          if ($opal.$yieldX(#@block, args) === $breaker) {
+            return $breaker.$v;
+          }
+        }
+        catch (e) {
+          if (e === $breaker) {
+            return $breaker.$v;
+          }
+          else {
+            throw e;
+          }
+        }
+      }
+
+      self
+    end
+  end
+
+  class Yielder
+    def initialize(&block)
+      @block = block
+    end
+
+    def yield(*values)
+      %x{
+        var value = $opal.$yieldX(#@block, values);
+
+        if (value === $breaker) {
+          throw $breaker;
+        }
+
+        return value;
+      }
+    end
+
+    def <<(*values)
+      self.yield(*values)
+
+      self
+    end
+  end
+
+  class Lazy < self
+    class StopLazyError < Exception; end
+
+    def initialize(object, size = nil, &block)
+      unless block_given?
+        raise ArgumentError, 'tried to call lazy new without a block'
+      end
+
+      @enumerator = object
+
+      super size do |yielder, *each_args|
+        begin
+          object.each(*each_args) {|*args|
+            %x{
+              args.unshift(#{yielder});
+
+              if ($opal.$yieldX(block, args) === $breaker) {
+                return $breaker;
+              }
+            }
+          }
+        rescue Exception
+          nil
+        end
+      end
+    end
+
+    alias force to_a
+
+    def lazy
+      self
+    end
+
+    def collect(&block)
+      unless block
+        raise ArgumentError, 'tried to call lazy map without a block'
+      end
+
+      Lazy.new(self, enumerator_size) {|enum, *args|
+        %x{
+          var value = $opal.$yieldX(block, args);
+
+          if (value === $breaker) {
+            return $breaker;
+          }
+
+          #{enum.yield `value`};
+        }
+      }
+    end
+
+    def collect_concat(&block)
+      unless block
+        raise ArgumentError, 'tried to call lazy map without a block'
+      end
+
+      Lazy.new(self, nil) {|enum, *args|
+        %x{
+          var value = $opal.$yieldX(block, args);
+
+          if (value === $breaker) {
+            return $breaker;
+          }
+
+          if (#{`value`.respond_to? :force} && #{`value`.respond_to? :each}) {
+            #{`value`.each { |v| enum.yield v }}
+          }
+          else {
+            var array = #{Opal.try_convert `value`, Array, :to_ary};
+
+            if (array === nil) {
+              #{enum.yield `value`};
+            }
+            else {
+              #{`value`.each { |v| enum.yield v }};
+            }
+          }
+        }
+      }
+    end
+
+    def drop(n)
+      n = Opal.coerce_to n, Integer, :to_int
+
+      if n < 0
+        raise ArgumentError, "attempt to drop negative size"
+      end
+
+      current_size = enumerator_size
+      set_size     = if Integer === current_size
+        n < current_size ? n : current_size
+      else
+        current_size
+      end
+
+      dropped = 0
+      Lazy.new(self, set_size) {|enum, *args|
+        if dropped < n
+          dropped += 1
+        else
+          enum.yield(*args)
+        end
+      }
+    end
+
+    def drop_while(&block)
+      unless block
+        raise ArgumentError, 'tried to call lazy drop_while without a block'
+      end
+
+      succeeding = true
+      Lazy.new(self, nil) {|enum, *args|
+        if succeeding
+          %x{
+            var value = $opal.$yieldX(block, args);
+
+            if (value === $breaker) {
+              return $breaker;
+            }
+
+            if (#{Opal.falsy?(`value`)}) {
+              succeeding = false;
+
+              #{enum.yield(*args)};
+            }
+          }
+        else
+          enum.yield(*args)
+        end
+      }
+    end
+
+    def enum_for(method = :each, *args, &block)
+      self.class.for(self, method, *args, &block)
+    end
+
+    def find_all(&block)
+      unless block
+        raise ArgumentError, 'tried to call lazy select without a block'
+      end
+
+      Lazy.new(self, nil) {|enum, *args|
+        %x{
+          var value = $opal.$yieldX(block, args);
+
+          if (value === $breaker) {
+            return $breaker;
+          }
+
+          if (#{Opal.truthy?(`value`)}) {
+            #{enum.yield(*args)};
+          }
+        }
+      }
+    end
+
+    alias flat_map collect_concat
+
+    def grep(pattern, &block)
+      if block
+        Lazy.new(self, nil) {|enum, *args|
+          %x{
+            var param = #{Opal.destructure(args)},
+                value = #{pattern === `param`};
+
+            if (#{Opal.truthy?(`value`)}) {
+              value = $opal.$yield1(block, param);
+
+              if (value === $breaker) {
+                return $breaker;
+              }
+
+              #{enum.yield `$opal.$yield1(block, param)`};
+            }
+          }
+        }
+      else
+        Lazy.new(self, nil) {|enum, *args|
+          %x{
+            var param = #{Opal.destructure(args)},
+                value = #{pattern === `param`};
+
+            if (#{Opal.truthy?(`value`)}) {
+              #{enum.yield `param`};
+            }
+          }
+        }
+      end
+    end
+
+    alias map collect
+
+    alias select find_all
+
+    def reject(&block)
+      unless block
+        raise ArgumentError, 'tried to call lazy reject without a block'
+      end
+
+      Lazy.new(self, nil) {|enum, *args|
+        %x{
+          var value = $opal.$yieldX(block, args);
+
+          if (value === $breaker) {
+            return $breaker;
+          }
+
+          if (#{Opal.falsy?(`value`)}) {
+            #{enum.yield(*args)};
+          }
+        }
+      }
+    end
+
+    def take(n)
+      n = Opal.coerce_to n, Integer, :to_int
+
+      if n < 0
+        raise ArgumentError, "attempt to take negative size"
+      end
+
+      current_size = enumerator_size
+      set_size     = if Integer === current_size
+        n < current_size ? n : current_size
+      else
+        current_size
+      end
+
+      taken = 0
+      Lazy.new(self, set_size) {|enum, *args|
+        if taken < n
+          enum.yield(*args)
+          taken += 1
+        else
+          raise StopLazyError
+        end
+      }
+    end
+
+    def take_while(&block)
+      unless block
+        raise ArgumentError, 'tried to call lazy take_while without a block'
+      end
+
+      Lazy.new(self, nil) {|enum, *args|
+        %x{
+          var value = $opal.$yieldX(block, args);
+
+          if (value === $breaker) {
+            return $breaker;
+          }
+
+          if (#{Opal.truthy?(`value`)}) {
+            #{enum.yield(*args)};
+          }
+          else {
+            #{raise StopLazyError};
+          }
+        }
+      }
+    end
+
+    alias to_enum enum_for
+
+    def inspect
+      "#<#{self.class.name}: #{@enumerator.inspect}>"
+    end
+  end
+end

data/{corelib → opal/core}/hash.rb

@@ -28,8 +28,9 @@ class Hash
         }
       }
       else {
-        for (var i = 0, length = arguments.length, key; i < length; i++) {
-          var key = arguments[i], obj = arguments[++i];
+        for (var i = 0, length = arguments.length; i < length; i++) {
+          var key = arguments[i],
+              obj = arguments[++i];
 
           if (assocs[key] == null) {
             keys.push(key);
@@ -50,8 +51,10 @@ class Hash
   %x{
     var $hash2 = Opal.hash2 = function(keys, map) {
       var hash = new Hash._alloc;
+
       hash.keys = keys;
-      hash.map = map;
+      hash.map  = map;
+
       return hash;
     };
   }
@@ -65,8 +68,10 @@ class Hash
   def self.allocate
     %x{
       var hash = new self._alloc;
-      hash.map = {};
+
+      hash.map  = {};
       hash.keys = [];
+
       return hash;
     }
   end
@@ -74,20 +79,10 @@ class Hash
   def initialize(defaults = undefined, &block)
     %x{
       if (defaults != null) {
-        if (defaults.constructor == Object) {
-          var map = self.map, keys = self.keys;
-
-          for (var key in defaults) {
-            keys.push(key);
-            map[key] = defaults[key];
-          }
-        }
-        else {
-          self.none = defaults;
-        }
+        self.none = defaults;
       }
       else if (block !== nil) {
-          self.proc = block;
+        self.proc = block;
       }
 
       return self;
@@ -181,20 +176,25 @@ class Hash
 
   def clone
     %x{
-      var result = new self._klass._alloc();
-
-      result.map = {}; result.keys = [];
-
-      var map    = self.map,
-          map2   = result.map,
-          keys2  = result.keys;
+      var map  = {},
+          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]];
+        var key   = self.keys[i],
+            value = self.map[key];
+
+        keys.push(key);
+        map[key] = value;
       }
 
-      return result;
+      var hash = new self._klass._alloc();
+
+      hash.map  = map;
+      hash.keys = keys;
+      hash.none = self.none;
+      hash.proc = self.proc;
+
+      return hash;
     }
   end
 
@@ -720,34 +720,24 @@ class Hash
     }
   end
 
-  def to_hash
-    self
-  end
-
-  def to_n
+  def to_h
     %x{
-      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 hash   = new Hash._alloc,
+          cloned = #{clone};
 
-        if (#{`obj`.respond_to? :to_n}) {
-          result[key] = #{`obj`.to_n};
-        }
-        else {
-          result[key] = obj;
-        }
-      }
+      hash.map  = cloned.map;
+      hash.keys = cloned.keys;
+      hash.none = cloned.none;
+      hash.proc = cloned.proc;
 
-      return result;
+      return hash;
     }
   end
 
+  def to_hash
+    self
+  end
+
   alias to_s inspect
 
   alias update merge!