opal 0.3.11 → 0.3.15

data/runtime/corelib/basic_object.rb

@@ -0,0 +1,66 @@
+class BasicObject
+  def initialize(*)
+  end
+
+  def ==(other)
+    `this === other`
+  end
+
+  def __send__(symbol, *args, &block)
+    %x{
+      var meth = this[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__");
+      }
+    }
+  end
+
+  alias send __send__
+  
+  alias eql? ==
+  alias equal? ==
+
+  def instance_eval(string = nil, &block)
+    %x{
+      if (block === nil) {
+        raise(RubyArgError, 'block not supplied');
+      }
+
+      return block.call(this, null, this);
+    }
+  end
+
+  def instance_exec(*args, &block)
+    %x{
+      if (block === nil) {
+        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})`
+  end
+
+  def singleton_method_added(symbol)
+    nil
+  end
+
+  def singleton_method_removed(symbol)
+    nil
+  end
+
+  def singleton_method_undefined(symbol)
+    nil
+  end
+end

data/runtime/corelib/boolean.rb

@@ -0,0 +1,44 @@
+class Boolean
+  def &(other)
+    `this.valueOf() ? (other !== false && other !== nil) : false`
+  end
+
+  def |(other)
+    `this.valueOf() ? true : (other !== false && other !== nil)`
+  end
+
+  def ^(other)
+    `this.valueOf() ? (other === false || other === nil) : (other !== false && other !== nil)`
+  end
+
+  def ==(other)
+    `this.valueOf() === other.valueOf()`
+  end
+
+  def class
+    `this.valueOf() ? #{TrueClass} : #{FalseClass}`
+  end
+
+  def to_native
+    `this.valueOf()`
+  end
+
+  def to_s
+    `this.valueOf() ? '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/runtime/corelib/class.rb

@@ -0,0 +1,43 @@
+class Class
+  def self.new(sup = Object, &block)
+    %x{
+      var klass             = boot_class(sup);
+          klass.__classid__ = "AnonClass";
+
+      make_metaclass(klass, sup.$klass);
+
+      #{sup.inherited `klass`};
+
+      return block !== nil ? block.call(klass, null) : 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/runtime/corelib/comparable.rb

@@ -0,0 +1,25 @@
+module Comparable
+  def < (other)
+    (self <=> other) == -1
+  end
+
+  def <= (other)
+    (self <=> other) <= 0
+  end
+
+  def == (other)
+    (self <=> other) == 0
+  end
+
+  def > (other)
+    (self <=> other) == 1
+  end
+
+  def >= (other)
+    (self <=> other) >= 0
+  end
+
+  def between? (min, max)
+    self > min && self < max
+  end
+end

data/runtime/corelib/complex.rb

@@ -0,0 +1,2 @@
+class Complex
+end

data/runtime/corelib/dir.rb

@@ -0,0 +1,29 @@
+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
+end

data/runtime/corelib/enumerable.rb

@@ -0,0 +1,316 @@
+module Enumerable
+  def all?(&block)
+    %x{
+      var result = true;
+
+      if (block !== nil) {
+        this.m$each(function (iter, obj) {
+          var value;
+
+          if ((value = $yield.call($context, null, obj)) === $breaker) {
+            return $breaker.$v;
+          }
+
+          if (value === false || value === nil) {
+            result      = false;
+            $breaker.$v = nil;
+
+            return $breaker;
+          }
+        });
+      }
+      else {
+        this.m$each(function (iter, obj) {
+          if (obj === false || obj === nil) {
+            result      = false;
+            $breaker.$v = nil;
+
+            return $breaker;
+          }
+        });
+      }
+
+      return result;
+    }
+  end
+
+  def any?(&block)
+    %x{
+      var result = false, proc;
+
+      if (block !== nil) {
+        this.m$each(function (iter, obj) {
+          var value;
+
+          if ((value = $yield.call($context, null, obj)) === $breaker) {
+            return $breaker.$v;
+          }
+
+          if (value !== false && value !== nil) {
+            result      = true;
+            $breaker.$v = nil;
+
+            return $breaker;
+          }
+        });
+      }
+      else {
+        this.m$each(function (iter, obj) {
+          if (obj !== false && obj !== nil) {
+            result      = true;
+            $breaker.$v = nil;
+
+            return $breaker;
+          }
+        });
+      }
+
+      return result;
+    }
+  end
+
+  def collect(&block)
+    return enum_for :collect unless block_given?
+
+    %x{
+      var result = [];
+
+      this.m$each(function () {
+        var obj = $slice.call(arguments, 1),
+            value;
+
+        if ((value = $yield.apply($context, [null].concat(obj))) === $breaker) {
+          return $breaker.$v;
+        }
+
+        result.push(value);
+      });
+
+      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 (iter, obj) { return #{`obj` == `object`}; };
+        }
+      }
+
+      this.m$each(function (iter, obj) {
+        var value;
+
+        if ((value = $yield.call($context, null, obj)) === $breaker) {
+          return $breaker.$v;
+        }
+
+        if (value !== false && value !== nil) {
+          result++;
+        }
+      });
+
+      return result;
+    }
+  end
+
+  def detect(ifnone = undefined, &block)
+    return enum_for :detect, ifnone unless block
+
+    %x{
+      var result = nil;
+
+      this.m$each(function(iter, obj) {
+        var value;
+
+        if ((value = $yield.call($context, null, obj)) === $breaker) {
+          return $breaker.$v;
+        }
+
+        if (value !== false && value !== nil) {
+          result      = obj;
+          $breaker.$v = nil;
+
+          return $breaker;
+        }
+      });
+
+      if (result !== nil) {
+        return result;
+      }
+
+      if (#{Opal.function?(ifnone)}) {
+        return ifnone.m$call(null);
+      }
+
+      return ifnone === undefined ? nil : ifnone;
+    }
+  end
+
+  def drop(number)
+    raise NotImplementedError
+
+    %x{
+      var result  = [],
+          current = 0;
+
+      this.m$each(function(iter, obj) {
+        if (number < current) {
+          result.push(e);
+        }
+
+        current++;
+      });
+
+      return result;
+    }
+  end
+
+  def drop_while(&block)
+    return enum_for :drop_while unless block
+
+    %x{
+      var result = [];
+
+      this.m$each(function (iter, obj) {
+        var value;
+
+        if ((value = $yield.call($context, null, obj)) === $breaker) {
+          return $breaker.$v;
+        }
+
+        if (value !== false && value !== nil) {
+          result.push(obj);
+        }
+        else {
+          return $breaker;
+        }
+      });
+
+      return result;
+    }
+  end
+
+  def each_with_index(&block)
+    return enum_for :each_with_index unless block
+
+    %x{
+      var index = 0;
+
+      this.m$each(function (iter, obj) {
+        var value;
+
+        if ((value = $yield.call($context, null, obj, index)) === $breaker) {
+          return $breaker.$v;
+        }
+
+        index++;
+      });
+
+      return nil;
+    }
+  end
+
+  def entries
+    %x{
+      var result = [];
+
+      this.m$each(function (iter, obj) { return result.push(obj); })
+
+      return result;
+    }
+  end
+
+  alias_method :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.m$eq$(object); };
+      }
+
+      var result = nil;
+
+      this.m$each_with_index(function(iter, obj, index) {
+        var value;
+
+        if ((value = $yield.call($context, null, obj)) === $breaker) {
+          return $breaker.$v;
+        }
+
+        if (value !== false && value !== nil) {
+          result     = obj;
+          breaker.$v = index;
+
+          return $breaker;
+        }
+      });
+
+      return result;
+    }
+  end
+
+  def first(number = undefined)
+    %x{
+      var result = [],
+          current = 0;
+
+      if (number === undefined) {
+        this.m$each(function (iter, obj) { result = obj; return $breaker; });
+      }
+      else {
+        this.m$each(function (iter, obj) {
+          if (number < current) {
+            return $breaker;
+          }
+
+          result.push(obj);
+
+          current++;
+        });
+      }
+
+      return result;
+    }
+  end
+
+  def grep(pattern, &block)
+    %x{
+      var result = [];
+
+      if (block !== nil) {
+        this.m$each(function (iter, obj) {
+          var value = pattern.m$eqq$(obj);
+
+          if (value !== false && value !== nil) {
+            if ((value = $yield.call($context, null, obj)) === $breaker) {
+              return $breaker.$v;
+            }
+
+            result.push(obj);
+          }
+        });
+      }
+      else {
+        this.m$each(function (iter, obj) {
+          var value = pattern.m$eqq$(obj);
+
+          if (value !== false && value !== nil) {
+            ary.push(obj);
+          }
+        });
+      }
+
+      return result;
+    }
+  end
+
+  alias_method :to_a, :entries
+end