opal 0.8.1 → 0.9.0.beta1

data/opal/corelib/basic_object.rb

@@ -6,6 +6,10 @@ class BasicObject
     `self === other`
   end
 
+  def eql?(other)
+    self == other
+  end
+
   def __id__
     `self.$$id || (self.$$id = Opal.uid())`
   end
@@ -34,7 +38,10 @@ class BasicObject
     false
   end
 
-  alias eql? ==
+  def !=(other)
+    !(self == other)
+  end
+
   alias equal? ==
 
   def instance_eval(&block)
@@ -45,7 +52,22 @@ class BasicObject
           result;
 
       block.$$s = null;
-      result = block.call(self, self);
+      
+      // need to pass $$eval so that method definitions know if this is being done on a class/module. Cannot be compiler driven since
+      // send(:instance_eval) needs to work
+      if (self.$$is_class || self.$$is_module) {
+        self.$$eval = true;
+        try {          
+          result = block.call(self, self);
+        }
+        finally {
+          self.$$eval = false;
+        }
+      }
+      else {
+        result = block.call(self, self);
+      }
+      
       block.$$s = old;
 
       return result;
@@ -58,15 +80,37 @@ class BasicObject
     %x{
       var block_self = block.$$s,
           result;
-
+          
       block.$$s = null;
-      result = block.apply(self, args);
+      
+      if (self.$$is_class || self.$$is_module) {
+        self.$$eval = true;
+        try {        
+          result = block.apply(self, args);
+        }
+        finally {
+          self.$$eval = false;
+        }        
+      }
+      else {
+        result = block.apply(self, args);
+      }
+
       block.$$s = block_self;
 
       return result;
     }
   end
 
+  def singleton_method_added(*)
+  end
+
+  def singleton_method_removed(*)
+  end
+
+  def singleton_method_undefined(*)
+  end
+
   def method_missing(symbol, *args, &block)
     Kernel.raise NoMethodError, `self.$inspect && !self.$inspect.$$stub` ?
       "undefined method `#{symbol}' for #{inspect}:#{`self.$$class`}" :

data/opal/corelib/boolean.rb

@@ -1,14 +1,12 @@
-class Boolean
+class Boolean < `Boolean`
   `def.$$is_boolean = true`
+  `def.$$meta = #{self}`
 
   def __id__
     `self.valueOf() ? 2 : 0`
   end
-  alias object_id __id__
 
-  class << self
-    undef_method :new
-  end
+  alias object_id __id__
 
   def !
     `self != true`
@@ -31,12 +29,23 @@ class Boolean
   end
 
   alias equal? ==
+  alias eql? ==
 
-  alias singleton_class class
+  def singleton_class
+    Boolean
+  end
 
   def to_s
     `(self == true) ? 'true' : 'false'`
   end
+
+  def dup
+    raise TypeError, "can't dup #{self.class}"
+  end
+
+  def clone
+    raise TypeError, "can't clone #{self.class}"
+  end
 end
 
 TrueClass  = Boolean

data/opal/corelib/class.rb

@@ -3,14 +3,15 @@ require 'corelib/module'
 class Class
   def self.new(sup = Object, &block)
     %x{
-      if (!sup.$$is_class || sup.$$is_mod) {
+      if (!sup.$$is_class) {
         #{raise TypeError, "superclass must be a Class"};
       }
 
       function AnonClass(){};
-      var klass      = Opal.boot(sup, AnonClass)
-      klass.$$name   = nil;
-      klass.$$parent = sup;
+      var klass        = Opal.boot(sup, AnonClass)
+      klass.$$name     = nil;
+      klass.$$parent   = sup;
+      klass.$$is_class = true;
 
       // inherit scope from parent
       Opal.create_scope(sup.$$scope, klass);
@@ -30,7 +31,7 @@ class Class
 
   def allocate
     %x{
-      var obj = new self.$$alloc;
+      var obj = new self.$$alloc();
       obj.$$id = Opal.uid();
       return obj;
     }

data/opal/corelib/comparable.rb

@@ -10,6 +10,18 @@ module Comparable
   def ==(other)
     return true if equal?(other)
 
+    %x{
+      if (self["$<=>"] == Opal.Kernel["$<=>"]) {
+        return false;
+      }
+
+      // check for infinite recursion
+      if (self.$$comparable) {
+        delete self.$$comparable;
+        return false;
+      }
+    }
+
     return false unless cmp = (self <=> other)
 
     return `#{Comparable.normalize(cmp)} == 0`

data/opal/corelib/complex.rb

@@ -1,3 +1,285 @@
+require 'corelib/numeric'
+
 class Complex < Numeric
+  def self.rect(real, imag = 0)
+    unless Numeric === real && real.real? && Numeric === imag && imag.real?
+      raise TypeError, 'not a real'
+    end
+
+    new(real, imag)
+  end
+
+  class << self
+    alias rectangular rect
+  end
+
+  def self.polar(r, theta = 0)
+    unless Numeric === r && r.real? && Numeric === theta && theta.real?
+      raise TypeError, 'not a real'
+    end
+
+    new(r * Math.cos(theta), r * Math.sin(theta))
+  end
+
+  attr_reader :real, :imag
+
+  def initialize(real, imag = 0)
+    @real = real
+    @imag = imag
+  end
+
+  def coerce(other)
+    if Complex === other
+      [other, self]
+    elsif Numeric === other && other.real?
+      [Complex.new(other, 0), self]
+    else
+      raise TypeError, "#{other.class} can't be coerced into Complex"
+    end
+  end
+
+  def ==(other)
+    if Complex === other
+      @real == other.real && @imag == other.imag
+    elsif Numeric === other && other.real?
+      @real == other && @imag == 0
+    else
+      other == self
+    end
+  end
+
+  def -@
+    Complex(-@real, -@imag)
+  end
+
+  def +(other)
+    if Complex === other
+      Complex(@real + other.real, @imag + other.imag)
+    elsif Numeric === other && other.real?
+      Complex(@real + other, @imag)
+    else
+      __coerced__ :+, other
+    end
+  end
+
+  def -(other)
+    if Complex === other
+      Complex(@real - other.real, @imag - other.imag)
+    elsif Numeric === other && other.real?
+      Complex(@real - other, @imag)
+    else
+      __coerced__ :-, other
+    end
+  end
+
+  def *(other)
+    if Complex === other
+      Complex(@real * other.real - @imag * other.imag,
+              @real * other.imag + @imag * other.real)
+    elsif Numeric === other && other.real?
+      Complex(@real * other, @imag * other)
+    else
+      __coerced__ :*, other
+    end
+  end
+
+  def /(other)
+    if Complex === other
+      if (Number === @real && @real.nan?) || (Number === @imag && @imag.nan?) ||
+         (Number === other.real && other.real.nan?) || (Number === other.imag && other.imag.nan?)
+        Complex.new(Float::NAN, Float::NAN)
+      else
+        self * other.conj / other.abs2
+      end
+    elsif Numeric === other && other.real?
+      Complex(@real.quo(other), @imag.quo(other))
+    else
+      __coerced__ :/, other
+    end
+  end
+
+  def **(other)
+    if other == 0
+      return Complex.new(1, 0)
+    end
+
+    if Complex === other
+      r, theta = polar
+      ore      = other.real
+      oim      = other.imag
+      nr       = Math.exp(ore * Math.log(r) - oim * theta)
+      ntheta   = theta * ore + oim * Math.log(r)
+
+      Complex.polar(nr, ntheta)
+    elsif Integer === other
+      if other > 0
+        x = self
+        z = x
+        n = other - 1
+
+        while n != 0
+          while (div, mod = n.divmod(2); mod == 0)
+            x = Complex(x.real * x.real - x.imag * x.imag, 2 * x.real * x.imag)
+            n = div
+          end
+
+          z *= x
+          n -= 1
+        end
+
+        z
+      else
+        (Rational.new(1, 1) / self) ** -other
+      end
+    elsif Float === other || Rational === other
+      r, theta = polar
+
+      Complex.polar(r ** other, theta * other)
+    else
+      __coerced__ :**, other
+    end
+  end
+
+  def abs
+    Math.hypot(@real, @imag)
+  end
+
+  def abs2
+    @real * @real + @imag * @imag
+  end
+
+  def angle
+    Math.atan2(@imag, @real)
+  end
+
+  alias arg angle
+
+  def conj
+    Complex(@real, -@imag)
+  end
+
+  alias conjugate conj
+
+  def denominator
+    @real.denominator.lcm(@imag.denominator)
+  end
+
+  alias divide /
+
+  def eql?(other)
+    Complex === other && @real.class == @imag.class && self == other
+  end
+
+  def fdiv(other)
+    unless Numeric === other
+      raise TypeError, "#{other.class} can't be coerced into Complex"
+    end
+
+    self / other
+  end
+
+  def hash
+    "Complex:#@real:#@imag"
+  end
+
+  alias imaginary imag
+
+  def inspect
+    "(#{to_s})"
+  end
+
+  alias magnitude abs
+
+  def numerator
+    d = denominator
+
+    Complex(@real.numerator * (d / @real.denominator),
+            @imag.numerator * (d / @imag.denominator))
+  end
+
+  alias phase arg
+
+  def polar
+    [abs, arg]
+  end
+
+  alias quo /
+
+  def rationalize(eps = undefined)
+    %x{
+      if (arguments.length > 1) {
+        #{raise ArgumentError, "wrong number of arguments (#{`arguments.length`} for 0..1)"};
+      }
+    }
+
+    if @imag != 0
+      raise RangeError, "can't' convert #{self} into Rational"
+    end
+
+    real.rationalize(eps)
+  end
+
+  def real?
+    false
+  end
+
+  def rect
+    [@real, @imag]
+  end
+
+  alias rectangular rect
+
+  def to_f
+    unless @imag == 0
+      raise RangeError, "can't convert #{self} into Float"
+    end
+
+    @real.to_f
+  end
+
+  def to_i
+    unless @imag == 0
+      raise RangeError, "can't convert #{self} into Integer"
+    end
+
+    @real.to_i
+  end
+
+  def to_r
+    unless @imag == 0
+      raise RangeError, "can't convert #{self} into Rational"
+    end
+
+    @real.to_r
+  end
+
+  def to_s
+    result = @real.inspect
+
+    if (Number === @imag && @imag.nan?) || @imag.positive?
+      result += ?+
+    else
+      result += ?-
+    end
+
+    result += @imag.abs.inspect
+
+    if Number === @imag && (@imag.nan? || @imag.infinite?)
+      result += ?*
+    end
+
+    result + ?i
+  end
+
+  I = new(0, 1)
+end
 
+module Kernel
+  def Complex(real, imag = nil)
+    if imag
+      Complex.new(real, imag)
+    else
+      Complex.new(real, 0)
+    end
+  end
 end