opal-wedge 0.9.0.dev

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

data/stdlib/native.rb

@@ -0,0 +1,530 @@
+module Native
+  def self.is_a?(object, klass)
+    %x{
+      try {
+        return #{object} instanceof #{try_convert(klass)};
+      }
+      catch (e) {
+        return false;
+      }
+    }
+  end
+
+  def self.try_convert(value)
+    %x{
+      if (#{native?(value)}) {
+        return #{value};
+      }
+      else if (#{value.respond_to? :to_n}) {
+        return #{value.to_n};
+      }
+      else {
+        return nil;
+      }
+    }
+  end
+
+  def self.convert(value)
+    %x{
+      if (#{native?(value)}) {
+        return #{value};
+      }
+      else if (#{value.respond_to? :to_n}) {
+        return #{value.to_n};
+      }
+      else {
+        #{raise ArgumentError, "#{value.inspect} isn't native"};
+      }
+    }
+  end
+
+  def self.call(obj, key, *args, &block)
+    %x{
+      var prop = #{obj}[#{key}];
+
+      if (prop instanceof Function) {
+        var converted = new Array(args.length);
+
+        for (var i = 0, length = args.length; i < length; i++) {
+          var item = args[i],
+              conv = #{try_convert(`item`)};
+
+          converted[i] = conv === nil ? item : conv;
+        }
+
+        if (block !== nil) {
+          converted.push(block);
+        }
+
+        return #{Native(`prop.apply(#{obj}, converted)`)};
+      }
+      else {
+        return #{Native(`prop`)};
+      }
+    }
+  end
+
+  module Helpers
+    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
+
+    def native_reader(*names)
+      names.each {|name|
+        define_method name do
+          Native(`#@native[name]`)
+        end
+      }
+    end
+
+    def native_writer(*names)
+      names.each {|name|
+        define_method "#{name}=" do |value|
+          Native(`#@native[name] = value`)
+        end
+      }
+    end
+
+    def native_accessor(*names)
+      native_reader(*names)
+      native_writer(*names)
+    end
+  end
+
+  def self.included(klass)
+    klass.extend Helpers
+  end
+
+  def initialize(native)
+    unless Kernel.native?(native)
+      Kernel.raise ArgumentError, "#{native.inspect} isn't native"
+    end
+
+    @native = native
+  end
+
+  def to_n
+    @native
+  end
+end
+
+module Kernel
+  def native?(value)
+    `value == null || !value.$$class`
+  end
+
+  def Native(obj)
+    if `#{obj} == null`
+      nil
+    elsif native?(obj)
+      Native::Object.new(obj)
+    else
+      obj
+    end
+  end
+
+  alias_method :_Array, :Array
+
+  def Array(object, *args, &block)
+    if native?(object)
+      return Native::Array.new(object, *args, &block).to_a
+    end
+    return _Array(object)
+  end
+end
+
+class Native::Object < BasicObject
+  include ::Native
+
+  def ==(other)
+    `#@native === #{Native.try_convert(other)}`
+  end
+
+  def has_key?(name)
+    `Opal.hasOwnProperty.call(#@native, #{name})`
+  end
+
+  alias key? has_key?
+  alias include? has_key?
+  alias member? has_key?
+
+  def each(*args)
+    if block_given?
+      %x{
+        for (var key in #@native) {
+          #{yield `key`, `#@native[key]`}
+        }
+      }
+
+      self
+    else
+      method_missing(:each, *args)
+    end
+  end
+
+  def [](key)
+    %x{
+      var prop = #@native[key];
+
+      if (prop instanceof Function) {
+        return prop;
+      }
+      else {
+        return #{::Native.call(@native, key)}
+      }
+    }
+  end
+
+  def []=(key, value)
+    native = Native.try_convert(value)
+
+    if `#{native} === nil`
+      `#@native[key] = #{value}`
+    else
+      `#@native[key] = #{native}`
+    end
+  end
+
+  def merge!(other)
+    %x{
+      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) === '=') {
+        return #{self[mid.slice(0, mid.length - 1)] = args[0]};
+      }
+      else {
+        return #{::Native.call(@native, mid, *args, &block)};
+      }
+    }
+  end
+
+  def nil?
+    false
+  end
+
+  def is_a?(klass)
+    `Opal.is_a(self, klass)`
+  end
+
+  alias kind_of? is_a?
+
+  def instance_of?(klass)
+    `self.$$class === klass`
+  end
+
+  def class
+    `self.$$class`
+  end
+
+  def to_a(options = {}, &block)
+    Native::Array.new(@native, options, &block).to_a
+  end
+
+  def inspect
+    "#<Native:#{`String(#@native)`}>"
+  end
+end
+
+class Native::Array
+  include Native
+  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
+
+    %x{
+      for (var i = 0, length = #{length}; i < length; i++) {
+        var value = Opal.yield1(block, #{self[`i`]});
+
+        if (value === $breaker) {
+          return $breaker.$v;
+        }
+      }
+    }
+
+    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}, #{Native.convert(value)})`
+    else
+      `#@native[#{index}] = #{Native.convert(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
+
+class Numeric
+  def to_n
+    `self.valueOf()`
+  end
+end
+
+class Proc
+  def to_n
+    self
+  end
+end
+
+class String
+  def to_n
+    `self.valueOf()`
+  end
+end
+
+class Regexp
+  def to_n
+    `self.valueOf()`
+  end
+end
+
+class MatchData
+  def to_n
+    @matches
+  end
+end
+
+class Struct
+  def initialize(*args)
+    if args.length == 1 && native?(args[0])
+      object = args[0]
+
+      members.each {|name|
+        instance_variable_set "@#{name}", Native(`#{object}[#{name}]`)
+      }
+    else
+      members.each_with_index {|name, index|
+        instance_variable_set "@#{name}", args[index]
+      }
+    end
+  end
+
+  def to_n
+    result = `{}`
+
+    each_pair {|name, value|
+      `#{result}[#{name}] = #{value.to_n}`
+    }
+
+    result
+  end
+end
+
+class Array
+  def to_n
+    %x{
+      var result = [];
+
+      for (var i = 0, length = self.length; i < length; i++) {
+        var obj = self[i];
+
+        if (#{`obj`.respond_to? :to_n}) {
+          result.push(#{`obj`.to_n});
+        }
+        else {
+          result.push(obj);
+        }
+      }
+
+      return result;
+    }
+  end
+end
+
+class Boolean
+  def to_n
+    `self.valueOf()`
+  end
+end
+
+class Time
+  def to_n
+    self
+  end
+end
+
+class NilClass
+  def to_n
+    `null`
+  end
+end
+
+class Hash
+  alias_method :_initialize, :initialize
+
+  def initialize(defaults = undefined, &block)
+    %x{
+      if (defaults !== undefined && defaults.constructor === Object) {
+        var smap = self.smap,
+            keys = self.keys,
+            key, value;
+
+        for (key in defaults) {
+          value = defaults[key];
+
+          if (value && value.constructor === Object) {
+            smap[key] = #{Hash.new(`value`)};
+          }
+          else {
+            smap[key] = #{Native(`value`)};
+          }
+
+          keys.push(key);
+        }
+
+        return self;
+      }
+
+      return #{_initialize(defaults, &block)};
+    }
+  end
+
+  def to_n
+    %x{
+      var result = {},
+          keys = self.keys,
+          smap = self.smap,
+          key, value;
+
+      for (var i = 0, length = keys.length; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          value = smap[key];
+        } else {
+          key = key.key;
+          value = key.value;
+        }
+
+        if (#{`value`.respond_to? :to_n}) {
+          result[key] = #{`value`.to_n};
+        }
+        else {
+          result[key] = value;
+        }
+      }
+
+      return result;
+    }
+  end
+end
+
+class Module
+  def native_module
+    `Opal.global[#{self.name}] = #{self}`
+  end
+end
+
+class Class
+  def native_alias(new_jsid, existing_mid)
+    %x{
+      var aliased = #{self}.$$proto['$' + #{existing_mid}];
+      if (!aliased) {
+        #{raise NameError, "undefined method `#{existing_mid}' for class `#{inspect}'"};
+      }
+      #{self}.$$proto[#{new_jsid}] = aliased;
+    }
+  end
+
+  def native_class
+    native_module
+    `self["new"] = self.$new;`
+  end
+end
+
+# native global
+$$ = $global = Native(`Opal.global`)