opal 0.8.1 → 0.9.0.beta1

data/opal/corelib/proc.rb

@@ -1,4 +1,4 @@
-class Proc
+class Proc < `Function`
   `def.$$is_proc = true`
   `def.$$is_lambda = false`
 
@@ -34,6 +34,8 @@ class Proc
   end
 
   alias [] call
+  alias === call
+  alias yield call
 
   def to_proc
     self
@@ -47,6 +49,84 @@ class Proc
 
   # FIXME: this should support the various splats and optional arguments
   def arity
+    `if (self.$$is_curried) { return -1; }`
+    `if (self.$$arity) { return self.$$arity }`
     `self.length`
   end
+
+  def source_location
+    `if (self.$$is_curried) { return nil; }`
+    nil
+  end
+
+  def binding
+    `if (self.$$is_curried) { #{raise ArgumentError, "Can't create Binding"} }`
+    nil
+  end
+
+  def parameters
+    `if (self.$$is_curried) { return #{[[:rest]]}; }`
+    nil
+  end
+
+  def curry(arity = undefined)
+    %x{
+      if (arity === undefined) {
+        arity = self.length;
+      }
+      else {
+        arity = #{Opal.coerce_to!(arity, Integer, :to_int)};
+        if (self.$$is_lambda && arity !== self.length) {
+          #{raise ArgumentError, "wrong number of arguments (#{`arity`} for #{`self.length`})"}
+        }
+      }
+
+      function curried () {
+        var args = $slice.call(arguments),
+            length = args.length,
+            result;
+
+        if (length > arity && self.$$is_lambda && !self.$$is_curried) {
+          #{raise ArgumentError, "wrong number of arguments (#{`length`} for #{`arity`})"}
+        }
+
+        if (length >= arity) {
+          return self.$call.apply(self, args);
+        }
+
+        result = function () {
+          return curried.apply(null,
+            args.concat($slice.call(arguments)));
+        }
+        result.$$is_lambda = self.$$is_lambda;
+        result.$$is_curried = true;
+
+        return result;
+      };
+
+      curried.$$is_lambda = self.$$is_lambda;
+      curried.$$is_curried = true;
+      return curried;
+    }
+  end
+
+  def dup
+    %x{
+      var original_proc = self.$$original_proc || self,
+          proc = function () {
+            return original_proc.apply(this, arguments);
+          };
+
+      for (var prop in self) {
+        if (self.hasOwnProperty(prop)) {
+          proc[prop] = self[prop];
+        }
+      }
+
+      return proc;
+    }
+  end
+
+  alias clone dup
+
 end

data/opal/corelib/process.rb

@@ -0,0 +1,27 @@
+class Process
+  CLOCK_REALTIME  = 0
+  CLOCK_MONOTONIC = 1
+
+  def self.pid
+    0
+  end
+
+  def self.times
+    t = Time.now.to_f
+    Benchmark::Tms.new(t, t, t, t, t)
+  end
+
+  def self.clock_gettime(clock_id, unit = nil)
+    Time.now.to_f
+  end
+end
+
+class Signal
+  def self.trap(*)
+  end
+end
+
+class GC
+  def self.start
+  end
+end

data/opal/corelib/rational.rb

@@ -1,3 +1,361 @@
+require 'corelib/numeric'
+
 class Rational < Numeric
+  def self.reduce(num, den)
+    num = num.to_i
+    den = den.to_i
+
+    if den == 0
+      raise ZeroDivisionError, "divided by 0"
+    elsif den < 0
+      num = -num
+      den = -den
+    elsif den == 1
+      return new(num, den)
+    end
+
+    gcd = num.gcd(den)
+
+    new(num / gcd, den / gcd)
+  end
+
+  def self.convert(num, den)
+    if num.nil? || den.nil?
+      raise TypeError, "cannot convert nil into Rational"
+    end
+
+    if Integer === num && Integer === den
+      return reduce(num, den)
+    end
+
+    if Float === num || String === num || Complex === num
+      num = num.to_r
+    end
+
+    if Float === den || String === den || Complex === den
+      den = den.to_r
+    end
+
+    if den.equal?(1) && !(Integer === num)
+      Opal.coerce_to!(num, Rational, :to_r)
+    elsif Numeric === num && Numeric === den
+      num / den
+    else
+      reduce(num, den)
+    end
+  end
+
+  attr_reader :numerator, :denominator
+
+  def initialize(num, den)
+    @num = num
+    @den = den
+  end
+
+  def numerator
+    @num
+  end
+
+  def denominator
+    @den
+  end
+
+  def coerce(other)
+    case other
+    when Rational
+      [other, self]
+
+    when Integer
+      [other.to_r, self]
+
+    when Float
+      [other, to_f]
+    end
+  end
+
+  def ==(other)
+    case other
+    when Rational
+      @num == other.numerator && @den == other.denominator
+
+    when Integer
+      @num == other && @den == 1
+
+    when Float
+      to_f == other
+
+    else
+      other == self
+    end
+  end
+
+  def <=>(other)
+    case other
+    when Rational
+      @num * other.denominator - @den * other.numerator <=> 0
+
+    when Integer
+      @num - @den * other <=> 0
+
+    when Float
+      to_f <=> other
+
+    else
+      __coerced__ :<=>, other
+    end
+  end
+
+  def +(other)
+    case other
+    when Rational
+      num = @num * other.denominator + @den * other.numerator
+      den = @den * other.denominator
+
+      Rational(num, den)
+
+    when Integer
+      Rational(@num + other * @den, @den)
+
+    when Float
+      to_f + other
+
+    else
+      __coerced__ :+, other
+    end
+  end
+
+  def -(other)
+    case other
+    when Rational
+      num = @num * other.denominator - @den * other.numerator
+      den = @den * other.denominator
+
+      Rational(num, den)
+
+    when Integer
+      Rational(@num - other * @den, @den)
+
+    when Float
+      to_f - other
+
+    else
+      __coerced__ :-, other
+    end
+  end
+
+  def *(other)
+    case other
+    when Rational
+      num = @num * other.numerator
+      den = @den * other.denominator
+
+      Rational(num, den)
+
+    when Integer
+      Rational(@num * other, @den)
+
+    when Float
+      to_f * other
+
+    else
+      __coerced__ :*, other
+    end
+  end
+
+  def /(other)
+    case other
+    when Rational
+      num = @num * other.denominator
+      den = @den * other.numerator
+
+      Rational(num, den)
+
+    when Integer
+      if other == 0
+        to_f / 0.0
+      else
+        Rational(@num, @den * other)
+      end
+
+    when Float
+      to_f / other
+
+    else
+      __coerced__ :/, other
+    end
+  end
+
+  def **(other)
+    case other
+    when Integer
+      if self == 0 && other < 0
+        return Float::INFINITY
+      elsif other > 0
+        Rational(@num ** other, @den ** other)
+      elsif other < 0
+        Rational(@den ** -other, @num ** -other)
+      else
+        Rational(1, 1)
+      end
+
+    when Float
+      to_f ** other
+
+    when Rational
+      if other == 0
+        Rational(1, 1)
+      elsif other.denominator == 1
+        if other < 0
+          Rational(@den ** other.numerator.abs, @num ** other.numerator.abs)
+        else
+          Rational(@num ** other.numerator, @den ** other.numerator)
+        end
+      elsif self == 0 && other < 0
+        raise ZeroDivisionError, "divided by 0"
+      else
+        to_f ** other
+      end
+
+    else
+      __coerced__ :**, other
+    end
+  end
+
+  def abs
+    Rational(@num.abs, @den.abs)
+  end
+
+  def ceil(precision = 0)
+    if precision == 0
+      (-(-@num / @den)).ceil
+    else
+      with_precision(:ceil, precision)
+    end
+  end
+
+  alias divide /
+
+  def floor(precision = 0)
+    if precision == 0
+      (-(-@num / @den)).floor
+    else
+      with_precision(:floor, precision)
+    end
+  end
+
+  def hash
+    "Rational:#@num:#@den"
+  end
+
+  def inspect
+    "(#{to_s})"
+  end
+
+  alias quo /
+
+  def rationalize(eps = undefined)
+    %x{
+      if (arguments.length > 1) {
+        #{raise ArgumentError, "wrong number of arguments (#{`arguments.length`} for 0..1)"};
+      }
+
+      if (eps == null) {
+        return self;
+      }
+
+      var e = #{eps.abs},
+          a = #{self - `e`},
+          b = #{self + `e`};
+
+      var p0 = 0,
+          p1 = 1,
+          q0 = 1,
+          q1 = 0,
+          p2, q2;
+
+      var c, k, t;
+
+      while (true) {
+        c = #{`a`.ceil};
+
+        if (#{`c` <= `b`}) {
+          break;
+        }
+
+        k  = c - 1;
+        p2 = k * p1 + p0;
+        q2 = k * q1 + q0;
+        t  = #{1 / (`b` - `k`)};
+        b  = #{1 / (`a` - `k`)};
+        a  = t;
+
+        p0 = p1;
+        q0 = q1;
+        p1 = p2;
+        q1 = q2;
+      }
+
+      return #{Rational(`c * p1 + p0`, `c * q1 + q0`)};
+    }
+  end
+
+  def round(precision = 0)
+    return with_precision(:round, precision) unless precision == 0
+    return 0 if @num == 0
+    return @num if @den == 1
+
+    num = @num.abs * 2 + @den
+    den = @den * 2
+
+    approx = (num / den).truncate
+
+    if @num < 0
+      -approx
+    else
+      approx
+    end
+  end
+
+  def to_f
+    @num / @den
+  end
+
+  def to_i
+    truncate
+  end
+
+  def to_r
+    self
+  end
+
+  def to_s
+    "#@num/#@den"
+  end
+
+  def truncate(precision = 0)
+    if precision == 0
+      @num < 0 ? ceil : floor
+    else
+      with_precision(:truncate, precision)
+    end
+  end
+
+  def with_precision(method, precision)
+    raise TypeError, "not an Integer" unless Integer === precision
+
+    p = 10 ** precision
+    s = self * p
+
+    if precision < 1
+      (s.send(method) / p).to_i
+    else
+      Rational(s.send(method), p)
+    end
+  end
+end
 
+module Kernel
+  def Rational(numerator, denominator = 1)
+    Rational.convert(numerator, denominator)
+  end
 end