opal 0.4.4 → 0.5.0

data/corelib/native.rb

@@ -4,7 +4,9 @@ module Kernel
   end
 
   def Native(obj)
-    if native?(obj)
+    if `#{obj} == null`
+      nil
+    elsif native?(obj)
       Native.new(obj)
     else
       obj
@@ -15,9 +17,25 @@ end
 class Native < BasicObject
   module Base
     module Helpers
-      def alias_native(new, old)
-        define_method new do |*args|
-          Native.call(@native, old, *args)
+      def alias_native(new, old = new, options = {})
+        if old.end_with? ?=
+          define_method new do |value|
+            `#@native[#{old[0 .. -2]}] = #{Native.convert(value)}`
+
+            value
+          end
+        else
+          if as = options[:as]
+            define_method new do |*args, &block|
+              if value = Native.call(@native, old, *args, &block)
+                as.new(value.to_n)
+              end
+            end
+          else
+            define_method new do |*args, &block|
+              Native.call(@native, old, *args, &block)
+            end
+          end
         end
       end
     end
@@ -29,8 +47,8 @@ class Native < BasicObject
     end
 
     def initialize(native)
-      unless native?(native)
-        raise ArgumentError, "the passed value isn't native"
+      unless Kernel.native?(native)
+        Kernel.raise ArgumentError, "the passed value isn't native"
       end
 
       @native = native
@@ -41,10 +59,107 @@ class Native < BasicObject
     end
   end
 
+  class Array
+    include Base
+    include Enumerable
+
+    def initialize(native, options = {}, &block)
+      super(native)
+
+      @get    = options[:get] || options[:access]
+      @named  = options[:named]
+      @set    = options[:set] || options[:access]
+      @length = options[:length] || :length
+      @block  = block
+
+      if `#{length} == null`
+        raise ArgumentError, "no length found on the array-like object"
+      end
+    end
+
+    def each(&block)
+      return enum_for :each unless block
+
+      index  = 0
+      length = self.length
+
+      while index < length
+        block.call(self[index])
+
+        index += 1
+      end
+
+      self
+    end
+
+    def [](index)
+      result = case index
+        when String, Symbol
+          @named ? `#@native[#@named](#{index})` : `#@native[#{index}]`
+
+        when Integer
+          @get ? `#@native[#@get](#{index})` : `#@native[#{index}]`
+      end
+
+      if result
+        if @block
+          @block.call(result)
+        else
+          Native(result)
+        end
+      end
+    end
+
+    def []=(index, value)
+      if @set
+        `#@native[#@set](#{index}, #{value})`
+      else
+        `#@native[#{index}] = #{value}`
+      end
+    end
+
+    def last(count = nil)
+      if count
+        index  = length - 1
+        result = []
+
+        while index >= 0
+          result << self[index]
+          index  -= 1
+        end
+
+        result
+      else
+        self[length - 1]
+      end
+    end
+
+    def length
+      `#@native[#@length]`
+    end
+
+    alias to_ary to_a
+
+    def inspect
+      to_a.inspect
+    end
+  end
+
+  def self.is_a?(object, klass)
+    %x{
+      try {
+        return #{object} instanceof #{Native.try_convert(klass)};
+      }
+      catch (e) {
+        return false;
+      }
+    }
+  end
+
   def self.try_convert(value)
     %x{
       if (#{native?(value)}) {
-        return #{value}.valueOf();
+        return #{value};
       }
       else if (#{value.respond_to? :to_n}) {
         return #{value.to_n};
@@ -90,25 +205,29 @@ class Native < BasicObject
 
   include Base
 
-  def nil?
-    `#@native == null`
+  def has_key?(name)
+    `#@native.hasOwnProperty(#{name})`
   end
 
-  def each
-    return Enumerator.new(self, :each) unless block_given?
+  alias key? has_key?
+  alias include? has_key?
+  alias member? has_key?
 
-    %x{
-      for (var key in #@native) {
-        #{yield `key`, `#@native[key]`}
+  def each(*args)
+    if block_given?
+      %x{
+        for (var key in #@native) {
+          #{yield `key`, `#@native[key]`}
+        }
       }
-    }
 
-    self
+      self
+    else
+      method_missing(:each, *args)
+    end
   end
 
   def [](key)
-    raise 'cannot get value from nil native' if nil?
-
     %x{
       var prop = #@native[key];
 
@@ -122,8 +241,6 @@ class Native < BasicObject
   end
 
   def []=(key, value)
-    raise 'cannot set value on nil native' if nil?
-
     native = Native.try_convert(value)
 
     if `#{native} === nil`
@@ -134,8 +251,6 @@ class Native < BasicObject
   end
 
   def method_missing(mid, *args, &block)
-    raise 'cannot call method from nil native' if nil?
-
     %x{
       if (mid.charAt(mid.length - 1) === '=') {
         return #{self[mid.slice(0, mid.length - 1)] = args[0]};
@@ -145,4 +260,11 @@ class Native < BasicObject
       }
     }
   end
+
+  def nil?
+    false
+  end
 end
+
+# native global
+$$ = $global = Native(`Opal.global`)

data/corelib/nil_class.rb

@@ -58,3 +58,5 @@ class NilClass
   end
   alias hash object_id
 end
+
+NIL = nil

data/corelib/numeric.rb

@@ -3,132 +3,293 @@ class Numeric
 
   `def._isNumber = true`
 
+  class << self
+    undef_method :new
+  end
+
+  def coerce(other, type = :operation)
+    %x{
+      if (other._isNumber) {
+        return [self, other];
+      }
+      else {
+        return #{other.coerce(self)};
+      }
+    }
+  rescue
+    case type
+    when :operation
+      raise TypeError, "#{other.class} can't be coerce into Numeric"
+
+    when :comparison
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+  end
+
+  def send_coerced(method, other)
+    type = case method
+      when :+, :-, :*, :/, :%, :&, :|, :^, :**
+        :operation
+
+      when :>, :>=, :<, :<=, :<=>
+        :comparison
+    end
+
+    a, b = coerce(other, type)
+    a.__send__ method, b
+  end
+
   def +(other)
-    `#{self} + other`
+    %x{
+      if (other._isNumber) {
+        return self + other;
+      }
+      else {
+        return #{send_coerced :+, other};
+      }
+    }
   end
 
   def -(other)
-    `#{self} - other`
+    %x{
+      if (other._isNumber) {
+        return self - other;
+      }
+      else {
+        return #{send_coerced :-, other};
+      }
+    }
   end
 
   def *(other)
-    `#{self} * other`
+    %x{
+      if (other._isNumber) {
+        return self * other;
+      }
+      else {
+        return #{send_coerced :*, other};
+      }
+    }
   end
 
   def /(other)
-    `#{self} / other`
+    %x{
+      if (other._isNumber) {
+        return self / other;
+      }
+      else {
+        return #{send_coerced :/, other};
+      }
+    }
   end
 
   def %(other)
-    `#{self} % other`
+    %x{
+      if (other._isNumber) {
+        if (other < 0 || self < 0) {
+          return (self % other + other) % other;
+        }
+        else {
+          return self % other;
+        }
+      }
+      else {
+        return #{send_coerced :%, other};
+      }
+    }
   end
 
   def &(other)
-    `#{self} & other`
+    %x{
+      if (other._isNumber) {
+        return self & other;
+      }
+      else {
+        return #{send_coerced :&, other};
+      }
+    }
   end
 
   def |(other)
-    `#{self} | other`
+    %x{
+      if (other._isNumber) {
+        return self | other;
+      }
+      else {
+        return #{send_coerced :|, other};
+      }
+    }
   end
 
   def ^(other)
-    `#{self} ^ other`
+    %x{
+      if (other._isNumber) {
+        return self ^ other;
+      }
+      else {
+        return #{send_coerced :^, other};
+      }
+    }
   end
 
   def <(other)
-    `#{self} < other`
+    %x{
+      if (other._isNumber) {
+        return self < other;
+      }
+      else {
+        return #{send_coerced :<, other};
+      }
+    }
   end
 
   def <=(other)
-    `#{self} <= other`
+    %x{
+      if (other._isNumber) {
+        return self <= other;
+      }
+      else {
+        return #{send_coerced :<=, other};
+      }
+    }
   end
 
   def >(other)
-    `#{self} > other`
+    %x{
+      if (other._isNumber) {
+        return self > other;
+      }
+      else {
+        return #{send_coerced :>, other};
+      }
+    }
   end
 
   def >=(other)
-    `#{self} >= other`
+    %x{
+      if (other._isNumber) {
+        return self >= other;
+      }
+      else {
+        return #{send_coerced :>=, other};
+      }
+    }
+  end
+
+  def <=>(other)
+    %x{
+      if (other._isNumber) {
+        return self > other ? 1 : (self < other ? -1 : 0);
+      }
+      else {
+        return #{send_coerced :<=>, other};
+      }
+    }
+  rescue ArgumentError
+    nil
   end
 
   def <<(count)
-    `#{self} << count`
+    `self << #{count.to_int}`
   end
 
   def >>(count)
-    `#{self} >> count`
+    `self >> #{count.to_int}`
   end
 
   def +@
-    `+#{self}`
+    `+self`
   end
 
   def -@
-    `-#{self}`
+    `-self`
   end
 
   def ~
-    `~#{self}`
+    `~self`
   end
 
   def **(other)
-    `Math.pow(#{self}, other)`
+    %x{
+      if (other._isNumber) {
+        return Math.pow(self, other);
+      }
+      else {
+        return #{send_coerced :**, other};
+      }
+    }
   end
 
   def ==(other)
-    `!!(other._isNumber) && #{self} == Number(other)`
-  end
-
-  def <=>(other)
     %x{
-      if (typeof(other) !== 'number') {
-        return nil;
+      if (other._isNumber) {
+        return self == Number(other);
+      }
+      else if (#{other.respond_to? :==}) {
+        return #{other == self};
+      }
+      else {
+        return false;
       }
-
-      return #{self} < other ? -1 : (#{self} > other ? 1 : 0);
     }
   end
 
   def abs
-    `Math.abs(#{self})`
+    `Math.abs(self)`
   end
 
   def ceil
-    `Math.ceil(#{self})`
+    `Math.ceil(self)`
   end
 
   def chr
-    `String.fromCharCode(#{self})`
+    `String.fromCharCode(self)`
+  end
+
+  def conj
+    self
   end
 
+  alias conjugate conj
+
   def downto(finish, &block)
+    return enum_for :downto, finish unless block
+
     %x{
-      for (var i = #{self}; i >= finish; i--) {
+      for (var i = self; i >= finish; i--) {
         if (block(i) === $breaker) {
           return $breaker.$v;
         }
       }
-
-      return #{self};
     }
+
+    self
   end
 
   alias eql? ==
+  alias equal? ==
 
   def even?
-    `#{self} % 2 === 0`
+    `self % 2 === 0`
   end
 
   def floor
-    `Math.floor(#{self})`
+    `Math.floor(self)`
   end
 
   def hash
-    `#{self}.toString()`
+    `self.toString()`
   end
 
   def integer?
-    `#{self} % 1 === 0`
+    `self % 1 === 0`
+  end
+
+  def is_a?(klass)
+    return true if klass == Float && Float === self
+    return true if klass == Integer && Integer === self
+
+    super
   end
 
   alias magnitude abs
@@ -136,15 +297,15 @@ class Numeric
   alias modulo %
 
   def next
-    `#{self} + 1`
+    `self + 1`
   end
 
   def nonzero?
-    `#{self} === 0 ? nil : #{self}`
+    `self == 0 ? nil : self`
   end
 
   def odd?
-    `#{self} % 2 !== 0`
+    `self % 2 !== 0`
   end
 
   def ord
@@ -152,42 +313,48 @@ class Numeric
   end
 
   def pred
-    `#{self} - 1`
+    `self - 1`
   end
 
   def step(limit, step = 1, &block)
+    return enum_for :step, limit, step unless block
+
+    raise ArgumentError, 'step cannot be 0' if `step == 0`
+
     %x{
-      var working = #{self};
+      var value = self;
 
       if (step > 0) {
-        while (working <= limit) {
-          block(working);
-          working += step;
+        while (value <= limit) {
+          block(value);
+          value += step;
         }
       }
       else {
-        while (working >= limit) {
-          block(working);
-          working += step;
+        while (value >= limit) {
+          block(value);
+          value += step;
         }
       }
-
-      return #{self};
     }
+
+    self
   end
 
   alias succ next
 
   def times(&block)
+    return enum_for :times unless block
+
     %x{
-      for (var i = 0; i < #{self}; i++) {
+      for (var i = 0; i < self; i++) {
         if (block(i) === $breaker) {
           return $breaker.$v;
         }
       }
-
-      return #{self};
     }
+
+    self
   end
 
   def to_f
@@ -198,48 +365,79 @@ class Numeric
     `parseInt(#{self})`
   end
 
+  alias to_int to_i
+
   def to_s(base = 10)
-    `#{self}.toString()`
+    if base < 2 || base > 36
+      raise ArgumentError, 'base must be between 2 and 36'
+    end
+
+    `self.toString(base)`
+  end
+
+  alias inspect to_s
+
+  def divmod(rhs)
+    q = (self / rhs).floor
+    r = self % rhs
+
+    [q, r]
   end
 
   def to_n
-    `#{self}.valueOf()`
+    `self.valueOf()`
   end
 
   def upto(finish, &block)
-    return enum_for :upto, finish unless block_given?
+    return enum_for :upto, finish unless block
 
     %x{
-      for (var i = #{self}; i <= finish; i++) {
+      for (var i = self; i <= finish; i++) {
         if (block(i) === $breaker) {
           return $breaker.$v;
         }
       }
-
-      return #{self};
     }
+
+    self
   end
 
   def zero?
-    `#{self} == 0`
+    `self == 0`
   end
 
   def size
     # Just a stub, JS is 32bit for bitwise ops though
     4
   end
+
+  def nan?
+    `isNaN(self)`
+  end
+
+  def finite?
+    `self == Infinity || self == -Infinity`
+  end
+
+  def infinite?
+    if `self == Infinity`
+      `+1`
+    elsif `self == -Infinity`
+      `-1`
+    end
+  end
 end
 
 Fixnum = Numeric
 
 class Integer < Numeric
   def self.===(other)
-    other.is_a?(Numeric) && `(other % 1) == 0`
+    `!!(other._isNumber && (other % 1) == 0)`
   end
 end
 
 class Float < Numeric
   def self.===(other)
-    other.is_a?(Numeric) && `(other % 1) != 0`
+    `!!(other._isNumber && (other % 1) != 0)`
   end
 end