opal-cj 0.7.0.beta1

data/stdlib/json.rb

@@ -0,0 +1,182 @@
+module JSON
+  %x{
+    var $parse  = JSON.parse,
+        $hasOwn = Opal.hasOwnProperty;
+
+    function to_opal(value, options) {
+      switch (typeof value) {
+        case 'string':
+          return value;
+
+        case 'number':
+          return value;
+
+        case 'boolean':
+          return !!value;
+
+        case 'null':
+          return nil;
+
+        case 'object':
+          if (!value) return nil;
+
+          if (value.$$is_array) {
+            var arr = #{`options.array_class`.new};
+
+            for (var i = 0, ii = value.length; i < ii; i++) {
+              #{`arr`.push(`to_opal(value[i], options)`)};
+            }
+
+            return arr;
+          }
+          else {
+            var hash = #{`options.object_class`.new};
+
+            for (var k in value) {
+              if ($hasOwn.call(value, k)) {
+                #{`hash`[`k`] = `to_opal(value[k], options)`};
+              }
+            }
+
+            var klass;
+            if ((klass = #{`hash`[JSON.create_id]}) != nil) {
+              klass = Opal.cget(klass);
+              return #{`klass`.json_create(`hash`)};
+            }
+            else {
+              return hash;
+            }
+          }
+      }
+    };
+  }
+
+  class << self
+    attr_accessor :create_id
+  end
+
+  self.create_id = :json_class
+
+  def self.[](value, options = {})
+    if String === value
+      parse(value, options)
+    else
+      generate(value, options)
+    end
+  end
+
+  def self.parse(source, options = {})
+    from_object(`$parse(source)`, options)
+  end
+
+  def self.parse!(source, options = {})
+    parse(source, options)
+  end
+
+  # Raw js object => opal object
+  def self.from_object(js_object, options = {})
+    options[:object_class] ||= Hash
+    options[:array_class]  ||= Array
+
+    `to_opal(js_object, options.map)`
+  end
+
+  def self.generate(obj, options = {})
+    obj.to_json(options)
+  end
+
+  def self.dump(obj, io = nil, limit = nil)
+    string = generate(obj)
+
+    if io
+      io = io.to_io if io.responds_to? :to_io
+      io.write string
+
+      io
+    else
+      string
+    end
+  end
+end
+
+class Object
+  def to_json
+    to_s.to_json
+  end
+end
+
+# BUG: Enumerable must come before Array, otherwise it overrides #to_json
+#      this is due to how modules are implemented.
+module Enumerable
+  def to_json
+    to_a.to_json
+  end
+end
+
+class Array
+  def to_json
+    %x{
+      var result = [];
+
+      for (var i = 0, length = #{self}.length; i < length; i++) {
+        result.push(#{`self[i]`.to_json});
+      }
+
+      return '[' + result.join(', ') + ']';
+    }
+  end
+end
+
+class Boolean
+  def to_json
+    `(self == true) ? 'true' : 'false'`
+  end
+end
+
+class Hash
+  def to_json
+    %x{
+      var inspect = [], keys = self.keys, map = self.map;
+
+      for (var i = 0, length = keys.length; i < length; i++) {
+        var key = keys[i];
+        inspect.push(#{`key`.to_s.to_json} + ':' + #{`map[key]`.to_json});
+      }
+
+      return '{' + inspect.join(', ') + '}';
+    }
+  end
+end
+
+class NilClass
+  def to_json
+    'null'
+  end
+end
+
+class Numeric
+  def to_json
+    `self.toString()`
+  end
+end
+
+class String
+  alias to_json inspect
+end
+
+class Time
+  def to_json
+    strftime("%FT%T%z").to_json
+  end
+end
+
+class Date
+  def to_json
+    to_s.to_json
+  end
+
+  def as_json
+    to_s
+  end
+end
+

data/stdlib/math.rb

@@ -0,0 +1,370 @@
+module Math
+  class DomainError < StandardError
+    def self.new(method)
+      super "Numerical argument is out of domain - \"#{method}\""
+    end
+  end
+
+  E  = `Math.E`
+  PI = `Math.PI`
+
+  def acos(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      x = #{x.to_f};
+
+      if (x < -1 || x > 1) {
+        #{raise DomainError, :acos};
+      }
+
+      return Math.acos(x);
+    }
+  end
+
+  unless defined?(`Math.acosh`)
+    %x{
+      Math.acosh = function(x) {
+        return Math.log(x + Math.sqrt(x * x - 1));
+      }
+    }
+  end
+
+  def acosh(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      return Math.acosh(#{x.to_f});
+    }
+  end
+
+  def asin(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      x = #{x.to_f};
+
+      if (x < -1 || x > 1) {
+        #{raise DomainError, :asin};
+      }
+
+      return Math.asin(x);
+    }
+  end
+
+  unless defined?(`Math.asinh`)
+    %x{
+      Math.asinh = function(x) {
+        return Math.log(x + Math.sqrt(x * x + 1))
+      }
+    }
+  end
+
+  def asinh(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      return Math.asinh(#{x.to_f});
+    }
+  end
+
+  def atan(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      return Math.atan(#{x.to_f});
+    }
+  end
+
+  def atan2(x, y)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      if (!#{Numeric === y}) {
+        #{raise Opal.type_error(y, Float)};
+      }
+
+      return Math.atan2(#{x.to_f}, #{y.to_f});
+    }
+  end
+
+  unless defined?(`Math.atanh`)
+    %x{
+      Math.atanh = function(x) {
+        return 0.5 * Math.log((1 + x) / (1 - x));
+      }
+    }
+  end
+
+  def atanh(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      x = #{x.to_f};
+
+      if (x < -1 || x > 1) {
+        #{raise DomainError, :atanh};
+      }
+
+      return Math.atanh(x);
+    }
+  end
+
+  # TODO: reimplement this when unavailable
+  def cbrt(x)
+    `Math.cbrt(x)`
+  end
+
+  def cos(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      return Math.cos(#{x.to_f});
+    }
+  end
+
+  unless defined?(`Math.cosh`)
+    %x{
+      Math.cosh = function(x) {
+        return (Math.exp(x) + Math.exp(-x)) / 2;
+      }
+    }
+  end
+
+  def cosh(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      return Math.cosh(#{x.to_f});
+    }
+  end
+
+  def erf(x)
+    raise NotImplementedError
+  end
+
+  def erfc(x)
+    raise NotImplementedError
+  end
+
+  def exp(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      return Math.exp(#{x.to_f});
+    }
+  end
+
+  def frexp(x)
+    raise NotImplementedError
+  end
+
+  def gamma(x)
+    raise NotImplementedError
+  end
+
+  unless defined?(`Math.hypot`)
+    %x{
+      Math.hypot = function(x, y) {
+        return Math.sqrt(x * x + y * y)
+      }
+    }
+  end
+
+  def hypot(x, y)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      if (!#{Numeric === y}) {
+        #{raise Opal.type_error(y, Float)};
+      }
+
+      return Math.hypot(#{x.to_f}, #{y.to_f});
+    }
+  end
+
+  def ldexp(flt, int)
+    raise NotImplementedError
+  end
+
+  def lgamma(x)
+    raise NotImplementedError
+  end
+
+  def log(num, base = E, method = nil)
+    %x{
+      if (!#{Numeric === num}) {
+        #{raise Opal.type_error(num, Float)};
+      }
+
+      if (!#{Numeric === base}) {
+        #{raise Opal.type_error(base, Float)};
+      }
+
+      num  = #{num.to_f};
+      base = #{base.to_f};
+
+      if (num < 0) {
+        #{raise DomainError, method || :log};
+      }
+
+      num = Math.log(num);
+
+      if (base != Math.E) {
+        num /= Math.log(base);
+      }
+
+      return num
+    }
+  end
+
+  if defined?(`Math.log10`)
+    def log10(num)
+      %x{
+        if (!#{Numeric === num}) {
+          #{raise Opal.type_error(num, Float)};
+        }
+
+        num = #{num.to_f};
+
+        if (num < 0) {
+          #{raise DomainError, :log2};
+        }
+
+        return Math.log10(num);
+      }
+    end
+  else
+    def log10(num)
+      log(num, 10, :log10)
+    end
+  end
+
+  if defined?(`Math.log2`)
+    def log2(num)
+      %x{
+        if (!#{Numeric === num}) {
+          #{raise Opal.type_error(num, Float)};
+        }
+
+        num = #{num.to_f};
+
+        if (num < 0) {
+          #{raise DomainError, :log2};
+        }
+
+        return Math.log2(num);
+      }
+    end
+  else
+    def log2(num)
+      log(num, 2, :log2)
+    end
+  end
+
+  def sin(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      return Math.sin(#{x.to_f});
+    }
+  end
+
+  unless defined?(`Math.sinh`)
+    %x{
+      Math.sinh = function(x) {
+        return (Math.exp(x) - Math.exp(-x)) / 2;
+      }
+    }
+  end
+
+  def sinh(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      return Math.sinh(#{x.to_f});
+    }
+  end
+
+  def sqrt(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      x = #{x.to_f};
+
+      if (x < 0) {
+        #{raise DomainError, :log2};
+      }
+
+      return Math.sqrt(x);
+    }
+  end
+
+  def tan(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      return Math.tan(#{x.to_f});
+    }
+  end
+
+  unless defined?(`Math.tanh`)
+    %x{
+      Math.tanh = function(x) {
+        if (x == Infinity) {
+          return 1;
+        }
+        else if (x == -Infinity) {
+          return -1;
+        }
+        else {
+          return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x));
+        }
+      }
+    }
+  end
+
+  def tanh(x)
+    %x{
+      if (!#{Numeric === x}) {
+        #{raise Opal.type_error(x, Float)};
+      }
+
+      return Math.tanh(#{x.to_f});
+    }
+  end
+
+  class << self
+    include Math
+  end
+end