opal 0.3.11 → 0.3.15

data/runtime/corelib/native.rb

@@ -0,0 +1,50 @@
+module Native
+  class Object
+    include Native
+
+    def [](name)
+      `#@native[name]`
+    end
+
+    def []=(name, value)
+      `#@native[name] = value`
+    end
+
+    def nil?
+      `#@native === null || #@native === undefined`
+    end
+
+    def method_missing(name, *args)
+      return super unless Opal.function? `#@native[name]`
+
+      __native_send__ name, *args
+    end
+  end
+
+  def self.included (klass)
+    class << klass
+      def from_native (object)
+        instance = allocate
+        instance.instance_variable_set :@native, object
+
+        instance
+      end
+    end
+  end
+
+  def initialize(native)
+    @native = native
+  end
+
+  def to_native
+    @native
+  end
+
+  def native_send(name, *args)
+    return method_missing(name, *args) unless Opal.function? `#@native[name]`
+
+    `#@native[name].apply(#@native, args)`
+  end
+
+  alias_method :__native_send__, :native_send
+end

data/runtime/corelib/nil_class.rb

@@ -0,0 +1,47 @@
+class NilClass
+  def &(other)
+    false
+  end
+
+  def |(other)
+    `other !== false && other !== nil`
+  end
+
+  def ^(other)
+    `other !== false && other !== nil`
+  end
+
+  def ==(other)
+    `this === other`
+  end
+
+  def inspect
+    'nil'
+  end
+
+  def nil?
+    true
+  end
+
+  def to_a
+    []
+  end
+
+  def to_i
+    0
+  end
+
+  def to_f
+    0.0
+  end
+
+  def to_native
+    `var result; return result;`
+  end
+
+  def to_s
+    ''
+  end
+end
+
+NIL = nil

data/runtime/corelib/numeric.rb

@@ -0,0 +1,219 @@
+class Numeric
+  def +(other)
+    `this + other`
+  end
+
+  def -(other)
+    `this - other`
+  end
+
+  def *(other)
+    `this * other`
+  end
+
+  def /(other)
+    `this / other`
+  end
+
+  def %(other)
+    `this % other`
+  end
+
+  def &(other)
+    `this & other`
+  end
+
+  def |(other)
+    `this | other`
+  end
+
+  def ^(other)
+    `this ^ other`
+  end
+
+  def <(other)
+    `this < other`
+  end
+
+  def <=(other)
+    `this <= other`
+  end
+
+  def >(other)
+    `this > other`
+  end
+
+  def >=(other)
+    `this >= other`
+  end
+
+  def <<(count)
+    `this << count`
+  end
+
+  def >>(count)
+    `this >> count`
+  end
+
+  def +@
+    `+this`
+  end
+
+  def -@
+    `-this`
+  end
+
+  def ~
+    `~this`
+  end
+
+  def **(other)
+    `Math.pow(this, other)`
+  end
+
+  def ==(other)
+    `this.valueOf() === other.valueOf()`
+  end
+
+  def <=>(other)
+    %x{
+      if (#{!Opal.number?(other)}) {
+        return nil;
+      }
+
+      return this < other ? -1 : (this > other ? 1 : 0);
+    }
+  end
+
+  def abs
+    `Math.abs(this)`
+  end
+
+  def ceil
+    `Math.ceil(this)`
+  end
+
+  def downto(finish, &block)
+    return enum_for :downto, finish unless block_given?
+
+    %x{
+      for (var i = this; i >= finish; i--) {
+        if ($yield.call($context, null, i) === $breaker) {
+          return $breaker.$v;
+        }
+      }
+
+      return this;
+    }
+  end
+
+  def even?
+    `this % 2 === 0`
+  end
+
+  def floor
+    `Math.floor(this)`
+  end
+
+  def hash
+    `this.toString()`
+  end
+
+  def integer?
+    `this % 1 === 0`
+  end
+
+  alias_method :magnitude, :abs
+
+  alias_method :modulo, :%
+
+  def next
+    `this + 1`
+  end
+
+  def nonzero?
+    `this.valueOf() === 0 ? nil : this`
+  end
+
+  def odd?
+    `this % 2 !== 0`
+  end
+
+  def pred
+    `this - 1`
+  end
+
+  alias_method :succ, :next
+
+  def times(&block)
+    return enum_for :times unless block
+
+    %x{
+      for (var i = 0; i <= this; i++) {
+        if ($yield.call($context, null, i) === $breaker) {
+          return $breaker.$v;
+        }
+      }
+
+      return this;
+    }
+  end
+
+  def to_f
+    `parseFloat(this)`
+  end
+
+  def to_i
+    `parseInt(this)`
+  end
+
+  def to_native
+    `this.valueOf()`
+  end
+
+  def to_s(base = 10)
+    `this.toString(base)`
+  end
+
+  def upto(finish, &block)
+    return enum_for :upto, finish unless block_given?
+
+    %x{
+      for (var i = 0; i <= finish; i++) {
+        if ($yield.call($context, null, i) === $breaker) {
+          return $breaker.$v;
+        }
+      }
+
+      return this;
+    }
+  end
+
+  def zero?
+    `this.valueOf() === 0`
+  end
+end
+
+class Integer
+  def self.===(obj)
+    %x{
+      if (#{!Opal.number?(obj)}) {
+        return false;
+      }
+
+      return other % 1 === 0;
+    }
+  end
+end
+
+class Float
+  def self.===(obj)
+    %x{
+      if (#{!Opal.number?(obj)}) {
+        return false;
+      }
+
+      return obj % 1 !== 0;
+    }
+  end
+end

data/runtime/corelib/object.rb

@@ -0,0 +1,21 @@
+class Object
+  include Kernel
+
+  def methods
+    `this.$klass.$methods`
+  end
+
+  alias_method :private_methods, :methods
+
+  alias_method :protected_methods, :methods
+
+  alias_method :public_methods, :methods
+
+  def singleton_methods
+    raise NotImplementedError, 'Object#singleton_methods not yet implemented'
+  end
+
+  def to_native
+    raise TypeError, 'no specialized #to_native has been implemented'
+  end
+end

data/runtime/corelib/proc.rb

@@ -0,0 +1,42 @@
+class Proc
+  def self.new(&block)
+    raise ArgumentError, 'tried to create Proc object without a block' unless block_given?
+
+    block
+  end
+
+  def to_proc
+    self
+  end
+
+  def call(*args)
+    `this.apply(this.$S, $slice.call(arguments))`
+  end
+
+  def to_native
+    %x{
+      return function() {
+        var args = Array.slice.call(arguments);
+            args.unshift(null); // block
+
+        return this.apply(this.$S, args);
+      };
+    }
+  end
+
+  def to_proc
+    self
+  end
+
+  def to_s
+    "#<Proc:0x0000000>"
+  end
+
+  def lambda?
+    `this.$lambda ? true : false`
+  end
+
+  def arity
+    `this.length - 1`
+  end
+end

data/runtime/corelib/range.rb

@@ -0,0 +1,38 @@
+class Range
+  def begin
+    `this.begin`
+  end
+
+  def end
+    `this.end`
+  end
+
+  alias_method :first, :begin
+  alias_method :min, :begin
+
+  alias_method :last, :end
+  alias_method :max, :end
+
+  def initialize(min, max, exclude = false)
+    @begin   = `this.begin   = min`
+    @end     = `this.end     = max`
+    @exclude = `this.exclude = exclude`
+  end
+
+  # FIXME: currently hardcoded to assume range holds numerics
+  def ===(obj)
+    `return obj >= this.begin && obj <= this.end`
+  end
+
+  def exclude_end?
+    `this.exclude`
+  end
+
+  def to_s
+    `this.begin + (this.exclude ? '...' : '..') + this.end`
+  end
+
+  def inspect
+    `this.begin + (this.exclude ? '...' : '..') + this.end`
+  end
+end

data/runtime/corelib/rational.rb

@@ -0,0 +1,16 @@
+class Rational
+  attr_reader :numerator, :denominator
+
+  def initialize (numerator, denominator = 1)
+    @numerator   = numerator
+    @denominator = denominator
+  end
+
+  def to_s
+    "#{numerator}#{"/#{denominator}" if denominator}"
+  end
+
+  def inspect
+    "(#{to_s})"
+  end
+end

data/runtime/corelib/regexp.rb

@@ -0,0 +1,63 @@
+class Regexp
+  def self.escape(string)
+    `string.replace(/([.*+?^=!:${}()|[\]\\/\\])/g, '\\$1')`
+  end
+
+  def self.new(string, options = undefined)
+    `new RegExp(string, options)`
+  end
+
+  def ==(other)
+    `other.constructor == RegExp && this.toString() === other.toString()`
+  end
+
+  def ===(obj)
+    `this.test(obj)`
+  end
+
+  def =~(string)
+    %x{
+      var result        = this.exec(string);
+
+      if (result) {
+        var match = new RubyMatch.$allocator();
+        match.$data = result;
+        #{$~ = `match`};
+      }
+      else {
+        #{$~ = nil};
+      }
+
+      return result ? result.index : nil;
+    }
+  end
+
+  alias_method :eql?, :==
+
+  def inspect
+    `this.toString()`
+  end
+
+  def match(pattern)
+    %x{
+      var result  = this.exec(pattern);
+
+      if (result) {
+        var match   = new RubyMatch.$allocator();
+        match.$data = result;
+        return #{$~ = `match`};
+      }
+      else {
+        return #{$~ = nil};
+      }
+    }
+  end
+
+  def to_native
+    self
+  end
+
+  def to_s
+    `this.source`
+  end
+end