opal 0.3.15 → 0.3.16

data/{runtime/corelib → core}/load_order

@@ -7,23 +7,20 @@ object
 top_self
 boolean
 nil_class
-native
 enumerable
-comparable
 enumerator
+comparable
 array
 hash
 string
 numeric
-rational
-complex
 proc
 range
 error
 regexp
 match_data
-struct
 time
+struct
 io
 file
 dir

data/{runtime/corelib → core}/match_data.rb

@@ -23,14 +23,12 @@ class MatchData
     "#<MatchData #{self[0].inspect}>"
   end
 
-  alias_method :size, :length
+  alias size length
 
   def to_a
-    `[].slice.call(this.$data, 0)`
+    `$slice.call(this.$data)`
   end
 
-  alias to_native to_a
-
   def to_s
     `this.$data[0]`
   end

data/core/module.rb

@@ -0,0 +1,204 @@
+class Module
+  def ===(object)
+    object.kind_of? self
+  end
+
+  def alias_method(newname, oldname)
+    `$opal.alias(this, newname, oldname)`
+
+    self
+  end
+
+  def ancestors
+    %x{
+      var parent = this,
+          result = [];
+
+      while (parent) {
+        if (!(parent.$flags & FL_SINGLETON)) {
+          result.push(parent);
+        }
+
+        parent = parent.$s;
+      }
+
+      return result;
+    }
+  end
+
+  def append_features(klass)
+    %x{
+      var module = this;
+
+      if (!klass.$included_modules) {
+        klass.$included_modules = [];
+      }
+
+      if (klass.$included_modules.indexOf(module) != -1) {
+        return;
+      }
+
+      klass.$included_modules.push(module);
+
+      if (!module.$included_in) {
+        module.$included_in = [];
+      }
+
+      module.$included_in.push(klass);
+
+      var donator   = module.$allocator.prototype,
+          prototype = klass.$proto,
+          methods   = [];
+
+      for (var method in donator) {
+        if (hasOwnProperty.call(donator, method)) {
+          if (!prototype.hasOwnProperty(method)) {
+            prototype[method] = donator[method];
+            methods.push(method);
+          }
+        }
+      }
+
+      if (klass.$included_in) {
+        klass.$donate(methods);
+      }
+    }
+
+    self
+  end
+
+  # Private helper function to define attributes
+  %x{
+    function define_attr(klass, name, getter, setter) {
+      if (getter) {
+        define_method(klass, mid_to_jsid(name), function() {
+          var res = this[name];
+
+          return res == null ? nil : res;
+        });
+      }
+
+      if (setter) {
+        define_method(klass, mid_to_jsid(name + '='), function(block, val) {
+          return this[name] = val;
+        });
+      }
+    }
+  }
+
+  def attr_accessor(*attrs)
+    %x{
+      for (var i = 0, length = attrs.length; i < length; i++) {
+        define_attr(this, attrs[i], true, true);
+      }
+
+      return nil;
+    }
+  end
+
+  def attr_reader(*attrs)
+    %x{
+      for (var i = 0, length = attrs.length; i < length; i++) {
+        define_attr(this, attrs[i], true, false);
+      }
+
+      return nil;
+    }
+  end
+
+  def attr_writer(*attrs)
+    %x{
+      for (var i = 0, length = attrs.length; i < length; i++) {
+        define_attr(this, attrs[i], false, true);
+      }
+
+      return nil;
+    }
+  end
+
+  def attr(name, setter = false)
+    `define_attr(this, name, true, setter)`
+
+    self
+  end
+
+  def define_method(name, &body)
+    %x{
+      if (body === nil) {
+        raise(RubyLocalJumpError, 'no block given');
+      }
+
+      define_method(this, mid_to_jsid(name), body);
+
+      return nil;
+    }
+  end
+
+  # FIXME: this could do with a better name
+  def donate(methods)
+    %x{
+      var included_in = this.$included_in, includee, method, table = this.$proto, dest;
+
+      if (included_in) {
+        for (var i = 0, length = included_in.length; i < length; i++) {
+          includee = included_in[i];
+          dest = includee.$proto;
+          for (var j = 0, jj = methods.length; j < jj; j++) {
+            method = methods[j];
+            // if (!dest[method]) {
+              dest[method] = table[method];
+            // }
+          }
+          // if our includee is itself included in another module/class then it
+          // should also donate its new methods
+          if (includee.$included_in) {
+            includee.$donate(methods);
+          }
+        }
+      }
+    }
+  end
+
+  def include(*mods)
+    %x{
+      var i = mods.length - 1, mod;
+      while (i >= 0) {
+        #{mod = `mods[i]`};
+        #{mod.append_features self};
+        #{mod.included self};
+
+        i--;
+      }
+
+      return this;
+    }
+  end
+
+  # FIXME
+  def instance_methods
+    []
+  end
+
+  def included(mod)
+  end
+
+  def module_eval(&block)
+    %x{
+      if (block === nil) {
+        raise(RubyLocalJumpError, 'no block given');
+      }
+
+      return block.call(this, null);
+    }
+  end
+
+  alias class_eval module_eval
+
+  def name
+    `this.$name`
+  end
+
+  alias public_instance_methods instance_methods
+
+  alias to_s name
+end

data/{runtime/corelib → core}/nil_class.rb

@@ -31,13 +31,7 @@ class NilClass
     0
   end
 
-  def to_f
-    0.0
-  end
-
-  def to_native
-    `var result; return result;`
-  end
+  alias to_f to_i
 
   def to_s
     ''

data/{runtime/corelib → core}/numeric.rb

@@ -77,7 +77,7 @@ class Numeric
 
   def <=>(other)
     %x{
-      if (#{!Opal.number?(other)}) {
+      if (typeof(other) !== 'number') {
         return nil;
       }
 
@@ -98,7 +98,7 @@ class Numeric
 
     %x{
       for (var i = this; i >= finish; i--) {
-        if ($yield.call($context, null, i) === $breaker) {
+        if ($yield.call($context, i) === $breaker) {
           return $breaker.$v;
         }
       }
@@ -123,9 +123,9 @@ class Numeric
     `this % 1 === 0`
   end
 
-  alias_method :magnitude, :abs
+  alias magnitude abs
 
-  alias_method :modulo, :%
+  alias modulo %
 
   def next
     `this + 1`
@@ -143,14 +143,14 @@ class Numeric
     `this - 1`
   end
 
-  alias_method :succ, :next
+  alias 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) {
+        if ($yield.call($context, i) === $breaker) {
           return $breaker.$v;
         }
       }
@@ -167,10 +167,6 @@ class Numeric
     `parseInt(this)`
   end
 
-  def to_native
-    `this.valueOf()`
-  end
-
   def to_s(base = 10)
     `this.toString(base)`
   end
@@ -180,7 +176,7 @@ class Numeric
 
     %x{
       for (var i = 0; i <= finish; i++) {
-        if ($yield.call($context, null, i) === $breaker) {
+        if ($yield.call($context, i) === $breaker) {
           return $breaker.$v;
         }
       }
@@ -197,7 +193,7 @@ end
 class Integer
   def self.===(obj)
     %x{
-      if (#{!Opal.number?(obj)}) {
+      if (typeof(obj) !== 'number') {
         return false;
       }
 
@@ -209,7 +205,7 @@ end
 class Float
   def self.===(obj)
     %x{
-      if (#{!Opal.number?(obj)}) {
+      if (typeof(obj) !== 'number') {
         return false;
       }
 

data/core/object.rb

@@ -0,0 +1,17 @@
+class Object
+  include Kernel
+
+  # FIXME
+  def methods
+    []
+  end
+
+  alias private_methods methods
+  alias protected_methods methods
+  alias public_methods methods
+
+  # FIXME
+  def singleton_methods
+    []
+  end
+end

data/{runtime/corelib → core}/proc.rb

@@ -10,18 +10,7 @@ class Proc
   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);
-      };
-    }
+    `this.apply(this.$S, args)`
   end
 
   def to_proc
@@ -33,7 +22,7 @@ class Proc
   end
 
   def lambda?
-    `this.$lambda ? true : false`
+    `!!this.$lambda`
   end
 
   def arity

data/{runtime/corelib → core}/range.rb

@@ -1,3 +1,15 @@
+# Helper function on runtime for creating range literals
+%x{
+  $opal.range = function(beg, end, exc) {
+    var range         = new RubyRange.$allocator();
+        range.begin   = beg;
+        range.end     = end;
+        range.exclude = exc;
+
+    return range;
+  };
+}
+
 class Range
   def begin
     `this.begin`
@@ -7,16 +19,16 @@ class Range
     `this.end`
   end
 
-  alias_method :first, :begin
-  alias_method :min, :begin
+  alias first begin
+  alias min begin
 
-  alias_method :last, :end
-  alias_method :max, :end
+  alias last end
+  alias max end
 
   def initialize(min, max, exclude = false)
-    @begin   = `this.begin   = min`
-    @end     = `this.end     = max`
-    @exclude = `this.exclude = exclude`
+    @begin   = min
+    @end     = max
+    @exclude = exclude
   end
 
   # FIXME: currently hardcoded to assume range holds numerics

data/{runtime/corelib → core}/regexp.rb

@@ -17,7 +17,7 @@ class Regexp
 
   def =~(string)
     %x{
-      var result        = this.exec(string);
+      var result = this.exec(string);
 
       if (result) {
         var match = new RubyMatch.$allocator();
@@ -32,7 +32,7 @@ class Regexp
     }
   end
 
-  alias_method :eql?, :==
+  alias eql? ==
 
   def inspect
     `this.toString()`
@@ -53,10 +53,6 @@ class Regexp
     }
   end
 
-  def to_native
-    self
-  end
-
   def to_s
     `this.source`
   end