opal 1.3.2 → 1.4.0.alpha1

data/opal/corelib/enumerator.rb

@@ -1,9 +1,9 @@
-# helpers: breaker, slice, falsy, truthy, coerce_to
+# helpers: slice, coerce_to
 
 require 'corelib/enumerable'
 
-class Enumerator
-  include Enumerable
+class ::Enumerator
+  include ::Enumerable
 
   `self.$$prototype.$$is_enumerator = true`
 
@@ -15,12 +15,14 @@ class Enumerator
       obj.size   = block;
       obj.method = method;
       obj.args   = args;
+      obj.cursor = 0;
 
       return obj;
     }
   end
 
   def initialize(*, &block)
+    @cursor = 0
     if block
       @object = Generator.new(&block)
       @method = :each
@@ -28,7 +30,7 @@ class Enumerator
       @size   = `arguments[0] || nil`
 
       if @size && !@size.respond_to?(:call)
-        @size = `$coerce_to(#{@size}, #{Integer}, 'to_int')`
+        @size = `$coerce_to(#{@size}, #{::Integer}, 'to_int')`
       end
     else
       @object = `arguments[0]`
@@ -54,7 +56,7 @@ class Enumerator
 
   def with_index(offset = 0, &block)
     offset = if offset
-               `$coerce_to(offset, #{Integer}, 'to_int')`
+               `$coerce_to(offset, #{::Integer}, 'to_int')`
              else
                0
              end
@@ -65,7 +67,7 @@ class Enumerator
       var result, index = offset;
 
       self.$each.$$p = function() {
-        var param = #{Opal.destructure(`arguments`)},
+        var param = #{::Opal.destructure(`arguments`)},
             value = block(param, index);
 
         index++;
@@ -77,8 +79,6 @@ class Enumerator
     }
   end
 
-  alias with_object each_with_object
-
   def each_with_index(&block)
     return enum_for(:each_with_index) { size } unless block_given?
 
@@ -86,312 +86,57 @@ class Enumerator
     @object
   end
 
-  def inspect
-    result = "#<#{self.class}: #{@object.inspect}:#{@method}"
-
-    if @args.any?
-      result += "(#{@args.inspect[Range.new(1, -2)]})"
-    end
+  def rewind
+    @cursor = 0
 
-    result + '>'
+    self
   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});
-
-          Opal.yieldX(#{@block}, args);
-        }
-        catch (e) {
-          if (e === $breaker) {
-            return $breaker.$v;
-          }
-          else {
-            throw e;
-          }
-        }
-      }
-
-      self
-    end
+  def peek_values
+    @values ||= map { |*i| i }
+    ::Kernel.raise ::StopIteration, 'iteration reached an end' if @cursor >= @values.length
+    @values[@cursor]
   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
+  def peek
+    values = peek_values
+    values.length <= 1 ? values[0] : values
   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|
-        object.each(*each_args) do |*args|
-          %x{
-            args.unshift(#{yielder});
-
-            Opal.yieldX(block, args);
-          }
-        end
-      rescue Exception
-        nil
-      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) do |enum, *args|
-        %x{
-          var value = Opal.yieldX(block, args);
-
-          #{enum.yield `value`};
-        }
-      end
-    end
-
-    def collect_concat(&block)
-      unless block
-        raise ArgumentError, 'tried to call lazy map without a block'
-      end
-
-      Lazy.new(self, nil) do |enum, *args|
-        %x{
-          var value = Opal.yieldX(block, args);
-
-          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
-    end
-
-    def drop(n)
-      n = `$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) do |enum, *args|
-        if dropped < n
-          dropped += 1
-        else
-          enum.yield(*args)
-        end
-      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) do |enum, *args|
-        if succeeding
-          %x{
-            var value = Opal.yieldX(block, args);
-
-            if ($falsy(value)) {
-              succeeding = false;
-
-              #{enum.yield(*args)};
-            }
-          }
-        else
-          enum.yield(*args)
-        end
-      end
-    end
-
-    def enum_for(method = :each, *args, &block)
-      self.class.for(self, method, *args, &block)
-    end
-
-    alias filter find_all
-
-    def find_all(&block)
-      unless block
-        raise ArgumentError, 'tried to call lazy select without a block'
-      end
-
-      Lazy.new(self, nil) do |enum, *args|
-        %x{
-          var value = Opal.yieldX(block, args);
-
-          if ($truthy(value)) {
-            #{enum.yield(*args)};
-          }
-        }
-      end
-    end
-
-    alias flat_map collect_concat
-
-    def grep(pattern, &block)
-      if block
-        Lazy.new(self, nil) do |enum, *args|
-          %x{
-            var param = #{Opal.destructure(args)},
-                value = #{pattern === `param`};
-
-            if ($truthy(value)) {
-              value = Opal.yield1(block, param);
-
-              #{enum.yield `Opal.yield1(block, param)`};
-            }
-          }
-        end
-      else
-        Lazy.new(self, nil) do |enum, *args|
-          %x{
-            var param = #{Opal.destructure(args)},
-                value = #{pattern === `param`};
-
-            if ($truthy(value)) {
-              #{enum.yield `param`};
-            }
-          }
-        end
-      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) do |enum, *args|
-        %x{
-          var value = Opal.yieldX(block, args);
-
-          if ($falsy(value)) {
-            #{enum.yield(*args)};
-          }
-        }
-      end
-    end
+  def next_values
+    out = peek_values
+    @cursor += 1
+    out
+  end
 
-    def take(n)
-      n = `$coerce_to(#{n}, #{Integer}, 'to_int')`
+  def next
+    values = next_values
+    values.length <= 1 ? values[0] : values
+  end
 
-      if n < 0
-        raise ArgumentError, 'attempt to take negative size'
-      end
+  def feed(arg)
+    raise NotImplementedError, "Opal doesn't support Enumerator#feed"
+  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) do |enum, *args|
-        if taken < n
-          enum.yield(*args)
-          taken += 1
-        else
-          raise StopLazyError
-        end
-      end
-    end
+  def +(other)
+    ::Enumerator::Chain.new(self, other)
+  end
 
-    def take_while(&block)
-      unless block
-        raise ArgumentError, 'tried to call lazy take_while without a block'
-      end
+  def inspect
+    result = "#<#{self.class}: #{@object.inspect}:#{@method}"
 
-      Lazy.new(self, nil) do |enum, *args|
-        %x{
-          var value = Opal.yieldX(block, args);
-
-          if ($truthy(value)) {
-            #{enum.yield(*args)};
-          }
-          else {
-            #{raise StopLazyError};
-          }
-        }
-      end
+    if @args.any?
+      result += "(#{@args.inspect[::Range.new(1, -2)]})"
     end
 
-    alias to_enum enum_for
-
-    def inspect
-      "#<#{self.class}: #{@enumerator.inspect}>"
-    end
+    result + '>'
   end
 
-  class ArithmeticSequence < self
-    # We need to stub this for the time being
-  end
+  alias with_object each_with_object
+
+  autoload :ArithmeticSequence, 'corelib/enumerator/arithmetic_sequence'
+  autoload :Chain, 'corelib/enumerator/chain'
+  autoload :Generator, 'corelib/enumerator/generator'
+  autoload :Lazy, 'corelib/enumerator/lazy'
+  autoload :Yielder, 'corelib/enumerator/yielder'
 end

data/opal/corelib/error/errno.rb

@@ -0,0 +1,47 @@
+module ::Errno
+  errors = [
+    [:EINVAL, 'Invalid argument', 22],
+    [:EEXIST, 'File exists', 17],
+    [:EISDIR, 'Is a directory', 21],
+    [:EMFILE, 'Too many open files', 24],
+    [:EACCES, 'Permission denied', 13],
+    [:EPERM, 'Operation not permitted', 1],
+    [:ENOENT, 'No such file or directory', 2]
+  ]
+
+  klass = nil
+
+  %x{
+    var i;
+    for (i = 0; i < errors.length; i++) {
+      (function() { // Create a closure
+        var class_name = errors[i][0];
+        var default_message = errors[i][1];
+        var errno = errors[i][2];
+
+        klass = Opal.klass(self, Opal.SystemCallError, class_name);
+        klass.errno = errno;
+
+        #{
+          class << klass
+            def new(name = nil)
+              message = `default_message`
+              message += " - #{name}" if name
+              super(message)
+            end
+          end
+        }
+      })();
+    }
+  }
+end
+
+class ::SystemCallError < ::StandardError
+  def errno
+    self.class.errno
+  end
+
+  class << self
+    attr_reader :errno
+  end
+end

data/opal/corelib/error.rb

@@ -1,5 +1,5 @@
-class Exception < `Error`
-  `Opal.defineProperty(self.$$prototype, '$$is_exception', true)`
+class ::Exception < `Error`
+  `Opal.prop(self.$$prototype, '$$is_exception', true)`
   `var stack_trace_limit`
 
   def self.new(*args)
@@ -119,9 +119,19 @@ class Exception < `Error`
     to_s
   end
 
-  def full_message(highlight: $stderr.tty?, order: :top)
-    raise ArgumentError, "expected true or false as highlight: #{highlight}" unless [true, false].include? highlight
-    raise ArgumentError, "expected :top or :bottom as order: #{order}" unless %i[top bottom].include? order
+  def full_message(kwargs = nil)
+    unless defined? Hash
+      # We are dealing with an unfully loaded Opal library, so we should
+      # do with as little as we can.
+
+      return "#{@message}\n#{`self.stack`}"
+    end
+
+    kwargs = { highlight: $stderr.tty?, order: :top }.merge(kwargs || {})
+    highlight, order = kwargs[:highlight], kwargs[:order]
+
+    ::Kernel.raise ::ArgumentError, "expected true or false as highlight: #{highlight}" unless [true, false].include? highlight
+    ::Kernel.raise ::ArgumentError, "expected :top or :bottom as order: #{order}" unless %i[top bottom].include? order
 
     if highlight
       bold_underline = "\e[1;4m"
@@ -178,7 +188,7 @@ class Exception < `Error`
         }
 
         if (valid === false) {
-          #{raise TypeError, 'backtrace must be Array of String'}
+          #{::Kernel.raise ::TypeError, 'backtrace must be Array of String'}
         }
 
         self.backtrace = backtrace;
@@ -196,53 +206,45 @@ class Exception < `Error`
 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           < SignalException; end
-class SecurityError     < Exception; end
-class SystemStackError  < Exception; end
-
-class StandardError     < Exception; end
-class EncodingError       < StandardError; end
-class ZeroDivisionError   < StandardError; end
-class NameError           < StandardError; end
-class NoMethodError         < NameError; end
-class RuntimeError        < StandardError; end
-class FrozenError           < RuntimeError; end
-class LocalJumpError      < StandardError; end
-class TypeError           < StandardError; end
-class ArgumentError       < StandardError; end
-class UncaughtThrowError    < ArgumentError; end
-class IndexError          < StandardError; end
-class StopIteration         < IndexError; end
-class ClosedQueueError        < StopIteration; end
-class KeyError              < IndexError; end
-class RangeError          < StandardError; end
-class FloatDomainError      < RangeError; end
-class IOError             < StandardError; end
-class EOFError              < IOError; end
-class SystemCallError     < StandardError; end
-class RegexpError         < StandardError; end
-class ThreadError         < StandardError; end
-class FiberError          < StandardError; end
-
-module Errno
-  class EINVAL              < SystemCallError
-    def self.new(name = nil)
-      message = 'Invalid argument'
-      message += " - #{name}" if name
-      super(message)
-    end
-  end
-end
-
-class UncaughtThrowError < ArgumentError
+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           < ::SignalException; end
+class ::SecurityError     < ::Exception; end
+class ::SystemStackError  < ::Exception; end
+
+class ::StandardError     < ::Exception; end
+class ::EncodingError       < ::StandardError; end
+class ::ZeroDivisionError   < ::StandardError; end
+class ::NameError           < ::StandardError; end
+class ::NoMethodError         < ::NameError; end
+class ::RuntimeError        < ::StandardError; end
+class ::FrozenError           < ::RuntimeError; end
+class ::LocalJumpError      < ::StandardError; end
+class ::TypeError           < ::StandardError; end
+class ::ArgumentError       < ::StandardError; end
+class ::UncaughtThrowError    < ::ArgumentError; end
+class ::IndexError          < ::StandardError; end
+class ::StopIteration         < ::IndexError; end
+class ::ClosedQueueError        < ::StopIteration; end
+class ::KeyError              < ::IndexError; end
+class ::RangeError          < ::StandardError; end
+class ::FloatDomainError      < ::RangeError; end
+class ::IOError             < ::StandardError; end
+class ::EOFError              < ::IOError; end
+class ::SystemCallError     < ::StandardError; end
+class ::RegexpError         < ::StandardError; end
+class ::ThreadError         < ::StandardError; end
+class ::FiberError          < ::StandardError; end
+
+::Object.autoload :Errno, 'corelib/error/errno'
+
+class ::UncaughtThrowError < ::ArgumentError
   attr_reader :tag, :value
 
   def initialize(tag, value = nil)
@@ -253,7 +255,7 @@ class UncaughtThrowError < ArgumentError
   end
 end
 
-class NameError
+class ::NameError
   attr_reader :name
 
   def initialize(message, name = nil)
@@ -262,7 +264,7 @@ class NameError
   end
 end
 
-class NoMethodError
+class ::NoMethodError
   attr_reader :args
 
   def initialize(message, name = nil, args = [])
@@ -271,11 +273,11 @@ class NoMethodError
   end
 end
 
-class StopIteration
+class ::StopIteration
   attr_reader :result
 end
 
-class KeyError
+class ::KeyError
   def initialize(message, receiver: nil, key: nil)
     super(message)
     @receiver = receiver
@@ -283,15 +285,15 @@ class KeyError
   end
 
   def receiver
-    @receiver || raise(ArgumentError, 'no receiver is available')
+    @receiver || ::Kernel.raise(::ArgumentError, 'no receiver is available')
   end
 
   def key
-    @key || raise(ArgumentError, 'no key is available')
+    @key || ::Kernel.raise(::ArgumentError, 'no key is available')
   end
 end
 
-module JS
+module ::JS
   class Error
   end
 end