opal 0.3.43 → 0.3.44

data/opal/opal/enumerable.rb

@@ -442,6 +442,96 @@ module Enumerable
 
   alias map collect
 
+  def max(&block)
+    %x{
+      var proc, result;
+      var arg_error = false;
+      if (block !== nil) {
+        proc = function(obj) {
+          if (result == undefined) {
+            result = obj;
+          }
+          else if ((value = block(obj, result)) === __breaker) {
+            result = __breaker.$v;
+            return __breaker;
+          }
+          else {
+            if (value > 0) {
+              result = obj;
+            }
+            __breaker.$v = nil;
+          }
+        }
+      }
+      else {
+        proc = function(obj) {
+          var modules = obj.$class().$included_modules;
+          if (modules == undefined || modules.length == 0 || modules.indexOf(Opal.Comparable) == -1) {
+            arg_error = true;
+            return __breaker;
+          }
+          if (result == undefined || obj > result) {
+            result = obj;
+          }
+        }
+      }
+
+      #{self}.$each._p = proc;
+      #{self}.$each();
+
+      if (arg_error) {
+        #{raise ArgumentError, "Array#max"};
+      }
+
+      return (result == undefined ? nil : result);
+    }
+  end
+
+  def min(&block)
+    %x{
+      var proc, result;
+      var arg_error = false;
+      if (block !== nil) {
+        proc = function(obj) {
+          if (result == undefined) {
+            result = obj;
+          }
+          else if ((value = block(obj, result)) === __breaker) {
+            result = __breaker.$v;
+            return __breaker;
+          }
+          else {
+            if (value < 0) {
+              result = obj;
+            }
+            __breaker.$v = nil;
+          }
+        }
+      }
+      else {
+        proc = function(obj) {
+          var modules = obj.$class().$included_modules;
+          if (modules == undefined || modules.length == 0 || modules.indexOf(Opal.Comparable) == -1) {
+            arg_error = true;
+            return __breaker;
+          }
+          if (result == undefined || obj < result) {
+            result = obj;
+          }
+        }
+      }
+
+      #{self}.$each._p = proc;
+      #{self}.$each();
+
+      if (arg_error) {
+        #{raise ArgumentError, "Array#min"};
+      }
+
+      return (result == undefined ? nil : result);
+    }
+  end
+
   alias select find_all
 
   alias take first

data/opal/opal/error.rb

@@ -1,4 +1,4 @@
-class Exception < `Error`
+class Exception
   attr_reader :message
 
   def self.new(message = '')

data/opal/opal/hash.rb

@@ -2,7 +2,7 @@ class Hash
   include Enumerable
 
   %x{
-    __hash = Opal.hash = function() {
+    var __hash = Opal.hash = function() {
       var hash   = new Hash,
           args   = __slice.call(arguments),
           keys   = [],
@@ -30,7 +30,7 @@ class Hash
   # compile time, so they are just added here by the constructor
   # function
   %x{
-    __hash2 = Opal.hash2 = function(keys, map) {
+    var __hash2 = Opal.hash2 = function(keys, map) {
       var hash = new Hash;
       hash.keys = keys;
       hash.map = map;

data/opal/opal/kernel.rb

@@ -386,7 +386,7 @@ module Kernel
 
   def singleton_class
     %x{
-      if (#{self}._isClass) {
+      if (typeof(#{self}) === 'function') {
         if (#{self}._singleton) {
           return #{self}._singleton;
         }
@@ -400,7 +400,7 @@ module Kernel
         return meta;
       }
 
-      if (!#{self}._isObject) {
+      if (typeof(#{self}) === 'function') {
         return #{self}._klass;
       }
 
@@ -412,7 +412,7 @@ module Kernel
         var orig_class = #{self}._klass,
             class_id   = "#<Class:#<" + orig_class._name + ":" + orig_class._id + ">>";
 
-        function Singleton() {};
+        var Singleton = function () {};
         var meta = Opal.boot(orig_class, Singleton);
         meta._name = class_id;
 

data/opal/opal/numeric.rb

@@ -1,4 +1,4 @@
-class Numeric < `Number`
+class Numeric
   include Comparable
 
   `def._isNumber = true`

data/opal/opal/proc.rb

@@ -1,4 +1,4 @@
-class Proc < `Function`
+class Proc
   `def._isProc = true`
   `def.is_lambda = true`
 

data/opal/opal/regexp.rb

@@ -1,10 +1,10 @@
-class Regexp < `RegExp`
+class Regexp
   def self.escape(string)
     `string.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\^\\$\\|]/g, '\\\\$&')`
   end
 
-  def self.new(string, options = undefined)
-    `new RegExp(string, options)`
+  def self.new(regexp, options = undefined)
+    `new RegExp(regexp, options)`
   end
 
   def ==(other)
@@ -15,17 +15,23 @@ class Regexp < `RegExp`
 
   def =~(string)
     %x{
-      var result = #{self}.exec(string);
+      var re = #{self};
+      if (re.global) {
+        // should we clear it afterwards too?
+        re.lastIndex = 0;
+      }
+      else {
+        // rewrite regular expression to add the global flag to capture pre/post match
+        re = new RegExp(re.source, 'g' + (re.multiline ? 'm' : '') + (re.ignoreCase ? 'i' : ''));
+      }
 
-      if (result) {
-        result.$to_s    = match_to_s;
-        result.$inspect = match_inspect;
-        result._klass = #{MatchData};
+      var result = re.exec(string);
 
-        #{$~ = `result`};
+      if (result) {
+        #{$~ = MatchData.new(`re`, `result`)};
       }
       else {
-        #{$~ = nil};
+        #{$~ = $` = $' = nil};
       }
 
       return result ? result.index : nil;
@@ -36,37 +42,31 @@ class Regexp < `RegExp`
 
   alias_native :inspect, :toString
 
-  def match(pattern, pos = undefined)
+  def match(string, pos = undefined)
     %x{
-      var result  = #{self}.exec(pattern);
+      var re = #{self};
+      if (re.global) {
+        // should we clear it afterwards too?
+        re.lastIndex = 0;
+      }
+      else {
+        re = new RegExp(re.source, 'g' + (#{self}.multiline ? 'm' : '') + (#{self}.ignoreCase ? 'i' : ''));
+      }
 
-      if (result) {
-        result.$to_s    = match_to_s;
-        result.$inspect = match_inspect;
-        result._klass = #{MatchData};
+      var result = re.exec(string);
 
-        return #{$~ = `result`};
+      if (result) {
+        return #{$~ = MatchData.new(`re`, `result`)};
       }
       else {
-        return #{$~ = nil};
+        return #{$~ = $` = $' = nil};
       }
     }
   end
 
-  def to_s
+  def source
     `#{self}.source`
   end
 
-  %x{
-    function match_to_s() {
-      return this[0];
-    }
-
-    function match_inspect() {
-      return "<#MatchData " + this[0].$inspect() + ">";
-    }
-  }
-end
-
-class MatchData
+  alias to_s source
 end

data/opal/opal/runtime.js

@@ -21,7 +21,7 @@
   TopScope.prototype = Opal;
 
   // To inherit scopes
-  Opal.alloc  = TopScope;
+  Opal.constructor  = TopScope;
 
   // This is a useful reference to global object inside ruby files
   Opal.global = this;
@@ -44,9 +44,40 @@
   // Globals table
   Opal.gvars = {};
 
+  /*
+   * Create a new constants scope for the given class with the given
+   * base. Constants are looked up through their parents, so the base
+   * scope will be the outer scope of the new klass.
+   */
+  function create_scope(base, klass, id) {
+    var const_alloc   = function() {};
+    var const_scope   = const_alloc.prototype = new base.constructor();
+    klass._scope      = const_scope;
+    const_scope.base  = klass;
+    const_scope.constructor = const_alloc;
+
+    if (id) {
+      base[id] = base.constructor[id] = klass;
+    }
+  }
+
+  /*
+    Define a bridged class. Bridged classes will always be in the top level
+    scope, and will always be a subclass of Object.
+  */
+  Opal.bridge = function(name, constructor) {
+    var klass = bridge_class(constructor);
+
+    klass._name = name;
+
+    create_scope(Opal, klass, name);
+
+    return klass;
+  };
+
   Opal.klass = function(base, superklass, id, constructor) {
     var klass;
-    if (base._isObject) {
+    if (typeof(base) !== 'function') {
       base = base._klass;
     }
 
@@ -69,11 +100,7 @@
 
       klass._name = (base === Object ? id : base._name + '::' + id);
 
-      var const_alloc   = function() {};
-      var const_scope   = const_alloc.prototype = new base._scope.alloc();
-      klass._scope      = const_scope;
-      const_scope.base  = klass;
-      const_scope.alloc = const_alloc;
+      create_scope(base._scope, klass);
 
       base[id] = base._scope[id] = klass;
 
@@ -88,7 +115,7 @@
   // Define new module (or return existing module)
   Opal.module = function(base, id, constructor) {
     var klass;
-    if (base._isObject) {
+    if (typeof(base) !== 'function') {
       base = base._klass;
     }
 
@@ -101,12 +128,7 @@
 
       klass.$included_in = [];
 
-      var const_alloc   = function() {};
-      var const_scope   = const_alloc.prototype = new base._scope.alloc();
-      klass._scope      = const_scope;
-      const_scope.alloc = const_alloc;
-
-      base[id] = base._scope[id]    = klass;
+      create_scope(base._scope, klass, id);
     }
 
     return klass;
@@ -129,20 +151,14 @@
     var prototype = constructor.prototype;
 
     prototype.constructor = constructor;
-    prototype._isObject   = true;
     prototype._klass      = constructor;
 
     constructor._inherited    = [];
     constructor._included_in  = [];
-    constructor._isClass      = true;
     constructor._name         = id;
     constructor._super        = superklass;
     constructor._methods      = [];
     constructor._smethods     = [];
-    constructor._isObject     = false;
-
-    constructor._donate = __donate;
-    constructor._defs = __defs;
 
     constructor['$==='] = module_eqq;
     constructor.$to_s = module_to_s;
@@ -166,13 +182,9 @@
 
     constructor._inherited    = [];
     constructor._included_in  = [];
-    constructor._isClass      = true;
     constructor._super        = superklass;
     constructor._methods      = [];
-    constructor._isObject     = false;
     constructor._klass        = Class;
-    constructor._donate       = __donate
-    constructor._defs = __defs;
 
     constructor['$==='] = module_eqq;
     constructor.$to_s = module_to_s;
@@ -201,15 +213,10 @@
 
     constructor._inherited    = [];
     constructor._included_in  = [];
-    constructor._isClass      = true;
     constructor._super        = Object;
     constructor._klass        = Class;
     constructor._methods      = [];
     constructor._smethods     = [];
-    constructor._isObject     = false;
-
-    constructor._donate = function(){};
-    constructor._defs = __defs;
 
     constructor['$==='] = module_eqq;
     constructor.$to_s = module_to_s;
@@ -237,17 +244,106 @@
 
   Opal.puts = function(a) { console.log(a); };
 
-  var mm_mid = '';
+  // Method missing dispatcher
+  Opal.mm = function(mid) {
+    var dispatcher = function() {
+      var args = __slice.call(arguments);
 
-  var method_missing_dispatcher = function() {
-    this.$method_missing._p = method_missing_dispatcher._p;
-    return this.$method_missing.apply(this, [mm_mid].concat(__slice.call(arguments)));
+      if (this.$method_missing) {
+        this.$method_missing._p = dispatcher._p;
+        return this.$method_missing.apply(this, [mid].concat(args));
+      }
+      else {
+        return native_send(this, mid, args);
+      }
+    };
+
+    return dispatcher;
   };
 
-  // Method missing dispatcher
-  Opal.mm = function(mid) {
-    mm_mid = mid;
-    return method_missing_dispatcher;
+  // send a method to a native object
+  var native_send = function(obj, mid, args) {
+    var prop, block = native_send._p;
+    native_send._p = null;
+
+    if (prop = native_methods[mid]) {
+      return prop(obj, args, block);
+    }
+
+    prop = obj[mid];
+
+    if (typeof(prop) === "function") {
+      prop = prop.apply(obj, args.$to_native());
+    }
+    else if (mid.charAt(mid.length - 1) === "=") {
+      prop = mid.slice(0, mid.length - 1);
+      return obj[prop] = args[0];
+    }
+
+    if (prop != null) {
+      return prop;
+    }
+
+    return nil;
+  };
+
+  var native_methods = {
+    "==": function(obj, args) {
+      return obj === args[0];
+    },
+
+    "[]": function(obj, args) {
+      var prop = obj[args[0]];
+
+      if (prop != null) {
+        return prop;
+      }
+
+      return nil;
+    },
+
+    "respond_to?": function(obj, args) {
+      return obj[args[0]] != null;
+    },
+
+    "each": function(obj, args, block) {
+      var prop;
+
+      if (obj.length === +obj.length) {
+        for (var i = 0, len = obj.length; i < len; i++) {
+          prop = obj[i];
+
+          if (prop == null) {
+            prop = nil;
+          }
+
+          block(prop);
+        }
+      }
+      else {
+        for (var key in obj) {
+          prop = obj[key];
+
+          if (prop == null) {
+            prop = nil;
+          }
+
+          block(key, prop);
+        }
+      }
+
+      return obj;
+    },
+
+    "to_a": function(obj, args) {
+      var result = [];
+
+      for (var i = 0, length = obj.length; i < length; i++) {
+        result.push(obj[i]);
+      }
+
+      return result;
+    }
   };
 
   // Const missing dispatcher
@@ -257,7 +353,7 @@
 
   // Arity count error dispatcher
   Opal.ac = function(actual, expected, object, meth) {
-    var inspect = (object._isObject ? object._klass._name + '#' : object._name + '.') + meth;
+    var inspect = ((typeof(object) !== 'function') ? object._klass._name + '#' : object._name + '.') + meth;
     var msg = '[' + inspect + '] wrong number of arguments(' + actual + ' for ' + expected + ')'
     throw Opal.ArgumentError.$new(msg);
   };
@@ -288,17 +384,6 @@
     return recv.$method_missing.apply(recv, [mid].concat(args));
   };
 
-  // Initialization
-  // --------------
-
-  boot_defclass('BasicObject', BasicObject)
-  boot_defclass('Object', Object, BasicObject);
-  boot_defclass('Class', Class, Object);
-
-  Class.prototype = Function.prototype;
-
-  BasicObject._klass = Object._klass = Class._klass = Class;
-
   // Implementation of Class#===
   function module_eqq(object) {
     if (object == null) {
@@ -323,12 +408,14 @@
     return this._name;
   }
 
-  // Donator for all 'normal' classes and modules
-  function __donate(defined, indirect) {
-    var methods = this._methods, included_in = this.$included_in;
+  /**
+   * Donate methods for a class/module
+   */
+  Opal.donate = function(klass, defined, indirect) {
+    var methods = klass._methods, included_in = klass.$included_in;
 
     // if (!indirect) {
-      this._methods = methods.concat(defined);
+      klass._methods = methods.concat(defined);
     // }
 
     if (included_in) {
@@ -338,39 +425,58 @@
 
         for (var j = 0, jj = defined.length; j < jj; j++) {
           var method = defined[j];
-          dest[method] = this.prototype[method];
+          dest[method] = klass.prototype[method];
         }
 
         if (includee.$included_in) {
-          includee._donate(defined, true);
+          Opal.donate(includee, defined, true);
         }
       }
-
     }
-  }
+  };
 
-  // Define a singleton method on a class
-  function __defs(mid, body) {
-    this._smethods.push(mid);
-    this[mid] = body;
+  /*
+    Define a singleton method on the given klass
+
+        Opal.defs(Array, '$foo', function() {})
 
-    var inherited = this._inherited;
+    @param [Function] klass
+    @param [String] mid the method_id
+    @param [Function] body function body
+  */
+  Opal.defs = function(klass, mid, body) {
+    klass._smethods.push(mid);
+    klass[mid] = body;
+
+    var inherited = klass._inherited;
     if (inherited.length) {
       for (var i = 0, length = inherited.length, subclass; i < length; i++) {
         subclass = inherited[i];
         if (!subclass[mid]) {
-          subclass._defs(mid, body);
+          Opal.defs(subclass, mid, body);
         }
       }
     }
-  }
+  };
 
   // Defines methods onto Object (which are then donated to bridged classes)
   Object._defn = function (mid, body) {
     this.prototype[mid] = body;
-    this._donate([mid]);
+    Opal.donate(this, [mid]);
   };
 
+  // Initialization
+  // --------------
+
+  boot_defclass('BasicObject', BasicObject)
+  boot_defclass('Object', Object, BasicObject);
+  boot_defclass('Class', Class, Object);
+
+  Class.prototype = Function.prototype;
+
+  BasicObject._klass = Object._klass = Class._klass = Class;
+
+
   var bridged_classes = Object.$included_in = [];
 
   Opal.base = Object;
@@ -378,10 +484,7 @@
   Opal.Module = Opal.Class;
   Opal.Kernel = Object;
 
-  var class_const_alloc = function(){};
-  var class_const_scope = new TopScope();
-  class_const_scope.alloc = class_const_alloc;
-  Class._scope = class_const_scope;
+  create_scope(Opal, Class);
 
   Object.prototype.toString = function() {
     return this.$to_s();
@@ -394,4 +497,13 @@
   nil.call = nil.apply = function() { throw Opal.LocalJumpError.$new('no block given'); };
 
   Opal.breaker  = new Error('unexpected break');
+
+  Opal.bridge('Array', Array);
+  Opal.bridge('Boolean', Boolean);
+  Opal.bridge('Numeric', Number);
+  Opal.bridge('String', String);
+  Opal.bridge('Proc', Function);
+  Opal.bridge('Exception', Error);
+  Opal.bridge('Regexp', RegExp);
+  Opal.bridge('Time', Date);
 }).call(this);