opal 0.3.15 → 0.3.16

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

@@ -8,21 +8,14 @@ class BasicObject
 
   def __send__(symbol, *args, &block)
     %x{
-      var meth = this[mid_to_jsid(symbol)];
+      var meth = this[mid_to_jsid(symbol)] || $opal.mm(mid_to_jsid(symbol));
 
-      if (meth) {
-        args.unshift(null);
-
-        return meth.apply(this, args);
-      }
-      else {
-        throw new Error("method missing yielder for " + symbol + " in __send__");
-      }
+      return meth.apply(this, args);
     }
   end
 
   alias send __send__
-  
+
   alias eql? ==
   alias equal? ==
 
@@ -32,7 +25,7 @@ class BasicObject
         raise(RubyArgError, 'block not supplied');
       }
 
-      return block.call(this, null, this);
+      return block.call(this, this);
     }
   end
 
@@ -42,25 +35,21 @@ class BasicObject
         raise(RubyArgError, 'block not supplied');
       }
 
-      args.unshift(null);
-
       return block.apply(this, args);
     }
   end
 
   def method_missing(symbol, *args)
-    `raise(RubyNoMethodError, 'undefined method \`' + symbol + '\` for ' + #{inspect})`
+    `throw RubyNoMethodError.$new('undefined method \`' + symbol + '\` for ' + #{inspect});`
+    self
   end
 
   def singleton_method_added(symbol)
-    nil
   end
 
   def singleton_method_removed(symbol)
-    nil
   end
 
   def singleton_method_undefined(symbol)
-    nil
   end
 end

data/core/boolean.rb

@@ -0,0 +1,40 @@
+class Boolean
+  def &(other)
+    `(this == true) ? (other !== false && other !== nil) : false`
+  end
+
+  def |(other)
+    `(this == true) ? true : (other !== false && other !== nil)`
+  end
+
+  def ^(other)
+    `(this == true) ? (other === false || other === nil) : (other !== false && other !== nil)`
+  end
+
+  def ==(other)
+    `(this == true) === other.valueOf()`
+  end
+
+  def class
+    `(this == true) ? #{TrueClass} : #{FalseClass}`
+  end
+
+  def to_s
+    `(this == true) ? 'true' : 'false'`
+  end
+end
+
+class TrueClass
+  def self.===(obj)
+    `obj === true`
+  end
+end
+
+class FalseClass
+  def self.===(obj)
+    `obj === false`
+  end
+end
+
+TRUE  = true
+FALSE = false

data/core/class.rb

@@ -0,0 +1,69 @@
+class Class
+  def self.new(sup = Object, &block)
+    %x{
+      var klass       = boot_class(sup);
+          klass.$name = "AnonClass";
+
+      make_metaclass(klass, sup.$klass);
+
+      #{sup.inherited `klass`};
+
+      return block !== nil ? block.call(klass, null) : klass;
+    }
+  end
+
+  def bridge_class(constructor)
+    %x{
+      var prototype = constructor.prototype,
+          klass     = this;
+
+      klass.$allocator = constructor;
+      klass.$proto     = prototype;
+
+      bridged_classes.push(klass);
+
+      prototype.$klass = klass;
+      prototype.$flags = T_OBJECT;
+
+      var donator = RubyObject.$proto;
+      for (var method in donator) {
+        if (donator.hasOwnProperty(method)) {
+          if (!prototype[method]) {
+            prototype[method] = donator[method];
+          }
+        }
+      }
+
+      return klass;
+    }
+  end
+
+  def allocate
+    `new this.$allocator()`
+  end
+
+  def new(*args, &block)
+    obj = allocate()
+    obj.initialize *args, &block
+    obj
+  end
+
+  def inherited(cls)
+  end
+
+  def superclass
+    %x{
+      var sup = this.$s;
+
+      if (!sup) {
+        if (this === RubyObject) {
+          return nil;
+        }
+
+        raise(RubyRuntimeError, 'uninitialized class');
+      }
+
+      return sup;
+    }
+  end
+end

data/core/debug.js

@@ -0,0 +1,59 @@
+// ..........................................................
+// DEBUG - this is only included in debug mode
+//
+
+// Identify opal as being in debug mode
+opal.debug = true;
+
+// An array of every method send in debug mode
+var debug_stack = [];
+
+opal.send = function(recv, block, jsid) {
+  var args    = $slice.call(arguments, 3),
+      meth    = recv[jsid];
+
+  if (!meth) {
+    args.unshift(jsid_to_mid(jsid));
+    return recv.$method_missing.apply(recv, args);
+  }
+
+  // Always set a block. If a block wasn't given then this is just a
+  // no-op.
+  meth.$P = block;
+
+  // Push this call frame onto debug stack
+  debug_stack.push({
+    recv: recv,
+    jsid: jsid,
+    meth: meth
+  });
+
+  try {
+    var result = meth.apply(recv, args);
+  }
+  catch (err) {
+    if (!err.opal_stack) {
+      err.opal_stack = debug_stack.slice();
+    }
+
+    throw err;
+  }
+  finally {
+    debug_stack.pop();
+  }
+
+  return result;
+};
+
+var release_define_method = define_method;
+
+define_method = opal.defn = function(klass, id, body, file, line) {
+
+  if (!body.$debugFile) {
+    body.$debugFile  = file;
+    body.$debugLine  = line;
+    body.$debugKlass = klass;
+  }
+
+  return release_define_method(klass, id, body);
+};

data/core/debug.rb

@@ -0,0 +1,35 @@
+#############################################################
+# DEBUG - only included in debug mode
+#
+
+class Exception
+  def backtrace
+    %x{
+      var result = [],
+          stack  = this.opal_stack || [],
+          frame,
+          recv,
+          meth;
+
+      for (var i = stack.length - 1; i >= 0; i--) {
+        frame = stack[i];
+        meth  = frame.meth;
+        recv  = frame.recv;
+        klass = meth.$debugKlass;
+
+        if (recv.$flags & T_OBJECT) {
+          recv = class_real(recv.$klass);
+          recv = (recv === klass ? recv.$name : klass.$name + '(' + recv.$name + ')') + '#';
+        }
+        else {
+
+          recv = recv.$name + '.';
+        }
+
+        result.push('from ' + recv + jsid_to_mid(frame.jsid) + ' at ' + meth.$debugFile + ':' + meth.$debugLine);
+      }
+
+      return result;
+    }
+  end
+end

data/core/dir.rb

@@ -0,0 +1,90 @@
+class Dir
+  def self.getwd
+    `FS_CWD`
+  end
+
+  def self.pwd
+    `FS_CWD`
+  end
+
+  def self.[](*globs)
+    %x{
+      var result = [], files = FACTORIES;
+
+      for (var i = 0, ii = globs.length; i < ii; i++) {
+        var glob = globs[i];
+
+        var re = fs_glob_to_regexp(#{ File.expand_path `glob` });
+
+        for (var file in files) {
+          if (re.exec(file)) {
+            result.push(file);
+          }
+        }
+      }
+
+      return result;
+    }
+  end
+
+  %x(
+    function fs_glob_to_regexp(glob) {
+      var parts  = glob.split(''),
+          length = parts.length,
+          result = '';
+
+      var opt_group_stack = 0;
+
+      for (var i = 0; i < length; i++) {
+        var cur = parts[i];
+
+        switch (cur) {
+          case '*':
+            if (parts[i + 1] === '*' && parts[i + 2] === '/') {
+              result += '.*';
+              i += 2;
+            }
+            else {
+              result += '[^/]*';
+            }
+            break;
+
+          case '.':
+            result += '\\\\';
+            result += cur;
+            break;
+
+          case ',':
+            if (opt_group_stack) {
+              result += '|';
+            }
+            else {
+              result += ',';
+            }
+            break;
+
+          case '{':
+            result += '(';
+            opt_group_stack++;
+            break;
+
+          case '}':
+            if (opt_group_stack) {
+            result += ')';
+            opt_group_stack--;
+          }
+          else {
+            result += '}'
+          }
+          break;
+
+        default:
+          result += cur;
+      }
+    }
+
+    return new RegExp('^' + result + '$');
+  }
+
+  )
+end

data/core/enumerable.rb

@@ -0,0 +1,331 @@
+module Enumerable
+  def all?(&block)
+    %x{
+      var result = true;
+
+      this.$each.$P = block !== nil
+        ? function(obj) {
+            var value;
+
+            if ((value = $yield.call($context, obj)) === $breaker) {
+              return $breaker.$v;
+            }
+
+            if (value === false || value === nil) {
+              result      = false;
+              $breaker.$v = nil;
+
+              return $breaker;
+            }
+          }
+        : function(obj) {
+            if (obj === false || obj === nil) {
+              result      = false;
+              $breaker.$v = nil;
+
+              return $breaker;
+            }
+          };
+
+      this.$each();
+
+      return result;
+    }
+  end
+
+  def any?(&block)
+    %x{
+      var result = false;
+
+      this.$each.$P = block !== nil
+        ? function(obj) {
+            var value;
+
+            if ((value = $yield.call($context, obj)) === $breaker) {
+              return $breaker.$v;
+            }
+
+            if (value !== false && value !== nil) {
+              result      = true;
+              $breaker.$v = nil;
+
+              return $breaker;
+            }
+          }
+        : function(obj) {
+            if (obj !== false && obj !== nil) {
+              result      = true;
+              $breaker.$v = nil;
+
+              return $breaker;
+            }
+          };
+
+      this.$each();
+
+      return result;
+    }
+  end
+
+  def collect(&block)
+    return enum_for :collect unless block_given?
+
+    %x{
+      var result = [];
+
+      this.$each.$P = function () {
+        var obj = $slice.call(arguments),
+            value;
+
+        if ((value = $yield.apply($context, obj)) === $breaker) {
+          return $breaker.$v;
+        }
+
+        result.push(value);
+      };
+
+      this.$each();
+
+      return result;
+    }
+  end
+
+  def count(object = undefined, &block)
+    %x{
+      var result = 0;
+
+      if (block === nil) {
+        if (object === undefined) {
+          $yield = function() { return true; };
+        }
+        else {
+          $yield = function(obj) { return #{`obj` == `object`}; };
+        }
+      }
+
+      this.$each.$P = function(obj) {
+        var value;
+
+        if ((value = $yield.call($context, obj)) === $breaker) {
+          return $breaker.$v;
+        }
+
+        if (value !== false && value !== nil) {
+          result++;
+        }
+      };
+
+      this.$each();
+
+      return result;
+    }
+  end
+
+  def detect(ifnone = undefined, &block)
+    return enum_for :detect, ifnone unless block
+
+    %x{
+      var result = nil;
+
+      this.$each.$P = function(obj) {
+        var value;
+
+        if ((value = $yield.call($context, obj)) === $breaker) {
+          return $breaker.$v;
+        }
+
+        if (value !== false && value !== nil) {
+          result      = obj;
+          $breaker.$v = nil;
+
+          return $breaker;
+        }
+      };
+
+      this.$each();
+
+      if (result !== nil) {
+        return result;
+      }
+
+      if (typeof(ifnone) === 'function') {
+        return ifnone.$call();
+      }
+
+      return ifnone === undefined ? nil : ifnone;
+    }
+  end
+
+  def drop(number)
+    raise NotImplementedError
+
+    %x{
+      var result  = [],
+          current = 0;
+
+      this.$each.$P = function(obj) {
+        if (number < current) {
+          result.push(e);
+        }
+
+        current++;
+      };
+
+      this.$each();
+
+      return result;
+    }
+  end
+
+  def drop_while(&block)
+    return enum_for :drop_while unless block
+
+    %x{
+      var result = [];
+
+      this.$each.$P = function(obj) {
+        var value;
+
+        if ((value = $yield.call($context, obj)) === $breaker) {
+          return $breaker.$v;
+        }
+
+        if (value !== false && value !== nil) {
+          result.push(obj);
+        }
+        else {
+          return $breaker;
+        }
+      };
+
+      this.$each();
+
+      return result;
+    }
+  end
+
+  def each_with_index(&block)
+    return enum_for :each_with_index unless block
+
+    %x{
+      var index = 0;
+
+      this.$each.$P = function(obj) {
+        var value;
+
+        if ((value = $yield.call($context, obj, index)) === $breaker) {
+          return $breaker.$v;
+        }
+
+        index++;
+      };
+
+      this.$each();
+
+      return nil;
+    }
+  end
+
+  def entries
+    %x{
+      var result = [];
+
+      this.$each.$P = function(obj) { return result.push(obj); };
+      this.$each();
+
+      return result;
+    }
+  end
+
+  alias find detect
+
+  def find_index(object = undefined, &block)
+    return enum_for :find_index, object unless block
+
+    %x{
+      if (object !== undefined) {
+        $yield = function (iter, obj) { return obj.$eq$(object); };
+      }
+
+      var result = nil;
+
+      this.$each_with_index.$P = function(obj, index) {
+        var value;
+
+        if ((value = $yield.call($context, obj)) === $breaker) {
+          return $breaker.$v;
+        }
+
+        if (value !== false && value !== nil) {
+          result     = obj;
+          breaker.$v = index;
+
+          return $breaker;
+        }
+      };
+
+      this.$each_with_index();
+
+      return result;
+    }
+  end
+
+  def first(number = undefined)
+    %x{
+      var result = [],
+          current = 0;
+
+      this.$each.$P = number === undefined
+        ? function(obj) {
+            result = obj; return $breaker;
+          }
+        : function(obj) {
+            if (number <= current) {
+              return $breaker;
+            }
+
+            result.push(obj);
+
+            current++;
+          };
+
+      this.$each();
+
+      return result;
+    }
+  end
+
+  def grep(pattern, &block)
+    %x{
+      var result = [];
+
+      this.$each.$P = block !== nil
+        ? function(obj) {
+            var value = pattern.$eqq$(obj);
+
+            if (value !== false && value !== nil) {
+              if ((value = $yield.call($context, obj)) === $breaker) {
+                return $breaker.$v;
+              }
+
+              result.push(obj);
+            }
+          }
+        : function(obj) {
+            var value = pattern.$eqq$(obj);
+
+            if (value !== false && value !== nil) {
+              ary.push(obj);
+            }
+          };
+
+      this.$each();
+
+      return result;
+    }
+  end
+
+  alias take first
+
+  alias to_a entries
+end