opal-wedge 0.9.0.dev

data/opal/corelib/enumerator.rb

@@ -0,0 +1,426 @@
+require 'corelib/enumerable'
+
+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(*args, &block)
+    return self if block.nil? && args.empty?
+
+    args = @args + args
+
+    return self.class.new(@object, @method, *args) if block.nil?
+
+    @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){self.size} unless block
+
+    %x{
+      var result, index = offset;
+
+      self.$each.$$p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = block(param, index);
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
+        }
+
+        index++;
+
+        return value;
+      }
+
+      self.$each();
+
+      if (result !== undefined) {
+        return result;
+      }
+
+      return self.object;
+    }
+  end
+
+  alias with_object each_with_object
+
+  def inspect
+    result = "#<#{self.class}: #{@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}: #{@enumerator.inspect}>"
+    end
+  end
+end

data/opal/corelib/error.rb

@@ -0,0 +1,77 @@
+class Exception
+  attr_reader :message
+
+  def self.new(message = 'Exception')
+    %x{
+      var err = new self.$$alloc(message);
+
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(err);
+      }
+
+      err.name = self.$$name;
+      err.$initialize(message);
+      return err;
+    }
+  end
+
+  def initialize(message)
+    `self.message = message`
+  end
+
+  def backtrace
+    %x{
+      var backtrace = self.stack;
+
+      if (typeof(backtrace) === 'string') {
+        return backtrace.split("\n").slice(0, 15);
+      }
+      else if (backtrace) {
+        return backtrace.slice(0, 15);
+      }
+
+      return [];
+    }
+  end
+
+  def inspect
+    "#<#{self.class}: '#@message'>"
+  end
+
+  alias to_s message
+end
+
+# keep the indentation, it makes the exception hierarchy clear
+class ScriptError       < Exception; end
+class SyntaxError         < ScriptError; end
+class LoadError           < ScriptError; end
+class NotImplementedError < ScriptError; end
+
+class SystemExit        < Exception; end
+class NoMemoryError     < Exception; end
+class SignalException   < Exception; end
+class Interrupt         < Exception; end
+class SecurityError     < Exception; end
+
+class StandardError     < Exception; end
+class NameError           < StandardError; end
+class NoMethodError         < NameError; end
+class RuntimeError        < StandardError; end
+class LocalJumpError      < StandardError; end
+class TypeError           < StandardError; end
+class ArgumentError       < StandardError; end
+class IndexError          < StandardError; end
+class StopIteration         < IndexError; end
+class KeyError              < IndexError; end
+class RangeError          < StandardError; end
+class FloatDomainError      < RangeError; end
+class IOError             < StandardError; end
+class SystemCallError     < StandardError; end
+
+module Errno
+  class EINVAL              < SystemCallError
+    def self.new
+      super('Invalid argument')
+    end
+  end
+end