opal 0.5.5 → 0.6.0

data/stdlib/native.rb

@@ -2,7 +2,7 @@ module Native
   def self.is_a?(object, klass)
     %x{
       try {
-        return #{object} instanceof #{Native.try_convert(klass)};
+        return #{object} instanceof #{try_convert(klass)};
       }
       catch (e) {
         return false;
@@ -33,7 +33,7 @@ module Native
         return #{value.to_n};
       }
       else {
-        #{raise ArgumentError, "the passed value isn't a native"};
+        #{raise ArgumentError, "#{value.inspect} isn't native"};
       }
     }
   end
@@ -42,31 +42,24 @@ module Native
     %x{
       var prop = #{obj}[#{key}];
 
-      if (prop == null) {
-        return nil;
-      }
-      else if (prop instanceof Function) {
-        if (block !== nil) {
-          args.push(block);
-        }
+      if (prop instanceof Function) {
+        var converted = new Array(args.length);
 
-        args = #{args.map {|value|
-          native = try_convert(value)
+        for (var i = 0, length = args.length; i < length; i++) {
+          var item = args[i],
+              conv = #{try_convert(`item`)};
 
-          if nil === native
-            value
-          else
-            native
-          end
-        }};
+          converted[i] = conv === nil ? item : conv;
+        }
 
-        return #{Native(`prop.apply(#{obj}, #{args})`)};
-      }
-      else if (#{native?(`prop`)}) {
-        return #{Native(`prop`)};
+        if (block !== nil) {
+          converted.push(block);
+        }
+
+        return #{Native(`prop.apply(#{obj}, converted)`)};
       }
       else {
-        return prop;
+        return #{Native(`prop`)};
       }
     }
   end
@@ -101,7 +94,7 @@ module Native
 
   def initialize(native)
     unless Kernel.native?(native)
-      Kernel.raise ArgumentError, "the passed value isn't native"
+      Kernel.raise ArgumentError, "#{native.inspect} isn't native"
     end
 
     @native = native
@@ -156,7 +149,7 @@ class Native::Object < BasicObject
   end
 
   def has_key?(name)
-    `#@native.hasOwnProperty(#{name})`
+    `$opal.hasOwnProperty.call(#@native, #{name})`
   end
 
   alias key? has_key?
@@ -200,6 +193,26 @@ class Native::Object < BasicObject
     end
   end
 
+  def merge!(other)
+    %x{
+      var other = #{Native.convert(other)};
+
+      for (var prop in other) {
+        #@native[prop] = other[prop];
+      }
+    }
+
+    self
+  end
+
+  def respond_to?(name, include_all = false)
+    Kernel.instance_method(:respond_to?).bind(self).call(name, include_all)
+  end
+
+  def respond_to_missing?(name)
+    `$opal.hasOwnProperty.call(#@native, #{name})`
+  end
+
   def method_missing(mid, *args, &block)
     %x{
       if (mid.charAt(mid.length - 1) === '=') {
@@ -216,13 +229,13 @@ class Native::Object < BasicObject
   end
 
   def is_a?(klass)
-    klass == Native
+    `$opal.is_a(self, klass)`
   end
 
   alias kind_of? is_a?
 
   def instance_of?(klass)
-    klass == Native
+    `self._klass === klass`
   end
 
   def class
@@ -233,10 +246,6 @@ class Native::Object < BasicObject
     Native::Array.new(@native, options, &block).to_a
   end
 
-  def to_ary(options = {}, &block)
-    Native::Array.new(@native, options, &block)
-  end
-
   def inspect
     "#<Native:#{`String(#@native)`}>"
   end
@@ -322,9 +331,7 @@ class Native::Array
     `#@native[#@length]`
   end
 
-  def to_ary
-    self
-  end
+  alias to_ary to_a
 
   def inspect
     to_a.inspect

data/stdlib/opal-parser.rb

@@ -11,12 +11,15 @@ module Kernel
 end
 
 %x{
-  Opal.compile = function(str) {
-    return Opal.Opal.$compile(str);
+  Opal.compile = function(str, options) {
+    if (options) {
+      options = Opal.hash(options);
+    }
+    return Opal.Opal.$compile(str, options);
   };
 
-  Opal.eval = function(str) {
-    return eval(Opal.compile(str));
+  Opal.eval = function(str, options) {
+   return eval(Opal.compile(str, options));
   };
 
   function run_ruby_scripts() {

data/stdlib/promise.rb

@@ -0,0 +1,292 @@
+class Promise
+  def self.value(value)
+    new.resolve(value)
+  end
+
+  def self.error(value)
+    new.reject(value)
+  end
+
+  def self.when(*promises)
+    When.new(promises)
+  end
+
+  attr_reader :value, :error, :prev, :next
+
+  def initialize(success = nil, failure = nil)
+    @success = success
+    @failure = failure
+
+    @realized  = nil
+    @exception = false
+    @value     = nil
+    @error     = nil
+    @delayed   = nil
+
+    @prev = nil
+    @next = nil
+  end
+
+  def act?
+    @success != nil
+  end
+
+  def exception?
+    @exception
+  end
+
+  def realized?
+    @realized != nil
+  end
+
+  def resolved?
+    @realized == :resolve
+  end
+
+  def rejected?
+    @realized == :reject
+  end
+
+  def ^(promise)
+    promise << self
+    self    >> promise
+
+    promise
+  end
+
+  def <<(promise)
+    @prev = promise
+
+    self
+  end
+
+  def >>(promise)
+    @next = promise
+
+    if exception?
+      promise.reject(@delayed)
+    elsif resolved?
+      promise.resolve(@delayed || value)
+    elsif rejected? && (!@failure || Promise === (@delayed || @error))
+      promise.reject(@delayed || error)
+    end
+
+    self
+  end
+
+  def resolve(value)
+    if realized?
+      raise ArgumentError, 'the promise has already been realized'
+    end
+
+    if Promise === value
+      value << @prev
+
+      return value ^ self
+    end
+
+    @realized = :resolve
+    @value    = value
+
+    begin
+      if @success
+        value = @success.call(value)
+      end
+
+      resolve!(value)
+    rescue Exception => e
+      exception!(e)
+    end
+
+    self
+  end
+
+  def resolve!(value)
+    if @next
+      @next.resolve(value)
+    else
+      @delayed = value
+    end
+  end
+
+  def reject(value)
+    if realized?
+      raise ArgumentError, 'the promise has already been realized'
+    end
+
+    if Promise === value
+      value << @prev
+
+      return value ^ self
+    end
+
+    @realized = :reject
+    @error    = value
+
+    begin
+      if @failure
+        value = @failure.call(value)
+
+        if Promise === value
+          reject!(value)
+        end
+      else
+        reject!(value)
+      end
+    rescue Exception => e
+      exception!(e)
+    end
+
+    self
+  end
+
+  def reject!(value)
+    if @next
+      @next.reject(value)
+    else
+      @delayed = value
+    end
+  end
+
+  def exception!(error)
+    @exception = true
+
+    reject!(error)
+  end
+
+  def then(&block)
+    self ^ Promise.new(block)
+  end
+
+  alias do then
+
+  def fail(&block)
+    self ^ Promise.new(nil, block)
+  end
+
+  alias rescue fail
+  alias catch fail
+
+  def always(&block)
+    self ^ Promise.new(block, block)
+  end
+
+  alias finally always
+  alias ensure always
+
+  def trace(&block)
+    self ^ Trace.new(block)
+  end
+
+  def inspect
+    result = "#<#{self.class}(#{object_id})"
+
+    if @next
+      result += " >> #{@next.inspect}"
+    end
+
+    if realized?
+      result += ": #{(@value || @error).inspect}>"
+    else
+      result += ">"
+    end
+
+    result
+  end
+
+  class Trace < self
+    def self.it(promise)
+      unless promise.realized?
+        raise ArgumentError, "the promise hasn't been realized"
+      end
+
+      current = promise.act? ? [promise.value] : []
+
+      if prev = promise.prev
+        current.concat(it(prev))
+      else
+        current
+      end
+    end
+
+    def initialize(block)
+      super -> {
+        block.call(*Trace.it(self).reverse)
+      }
+    end
+  end
+
+  class When < self
+    def initialize(promises = [])
+      super()
+
+      @wait = []
+
+      promises.each {|promise|
+        wait promise
+      }
+    end
+
+    def each(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      self.then {|values|
+        values.each(&block)
+      }
+    end
+
+    def collect(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      self.then {|values|
+        When.new(values.map(&block))
+      }
+    end
+
+    def inject(*args, &block)
+      self.then {|values|
+        values.reduce(*args, &block)
+      }
+    end
+
+    alias map collect
+
+    alias reduce inject
+
+    def wait(promise)
+      unless Promise === promise
+        promise = Promise.value(promise)
+      end
+
+      if promise.act?
+        promise = promise.then
+      end
+
+      @wait << promise
+
+      promise.always {
+        try if @next
+      }
+
+      self
+    end
+
+    alias and wait
+
+    def >>(*)
+      super.tap {
+        try
+      }
+    end
+
+    def try
+      if @wait.all?(&:realized?)
+        if promise = @wait.find(&:rejected?)
+          reject(promise.error)
+        else
+          resolve(@wait.map(&:value))
+        end
+      end
+    end
+  end
+end