opal 0.3.11 → 0.3.15

data/runtime/corelib/io.rb

@@ -0,0 +1,44 @@
+class IO
+  def puts(*args)
+    return flush if args.empty?
+
+    args.each do |a|
+      write a.to_s
+      flush
+    end
+  end
+
+  def print(*args)
+    args.each { |a| write a.to_s }
+
+    nil
+  end
+
+  def write()
+    # erm..
+  end
+
+  def flush
+    self
+  end
+end
+
+STDOUT = $stdout = IO.new
+
+class << $stdout
+  # private variable used to buffer stdout until flush
+  `var stdout_buffer = [];`
+
+  def write(str)
+    `stdout_buffer.push(str);`
+
+    nil
+  end
+
+  def flush
+    `console.log(stdout_buffer.join(''));`
+    `stdout_buffer = [];`
+
+    nil
+  end
+end

data/runtime/corelib/kernel.rb

@@ -0,0 +1,237 @@
+module Kernel
+  def =~(obj)
+    false
+  end
+
+  def ===(other)
+    `this == other`
+  end
+
+  def Object (object)
+    Opal.native?(object) ? Native::Object.new(object) : object
+  end
+
+  def Array(object)
+    return [] unless object
+
+    unless Opal.native?(object)
+      return object.to_ary if object.respond_to? :to_ary
+      return object.to_a   if object.respond_to? :to_a
+    end
+
+    %x{
+      var length = object.length || 0,
+          result = new Array(length);
+
+      while (length--) {
+        result[length] = object[length];
+      }
+
+      return result;
+    }
+  end
+
+  def at_exit(&block)
+    %x{
+      if (block === nil) {
+        raise(RubyArgError, 'called without a block');
+      }
+
+      end_procs.push(block);
+
+      return block;
+    }
+  end
+
+  def class
+    `class_real(this.$klass)`
+  end
+
+  def define_singleton_method(&body)
+    %x{
+      if (body === nil) {
+        raise(RubyLocalJumpError, 'no block given');
+      }
+
+      $opal.ds(this, name, body);
+
+      return this;
+    }
+  end
+
+  def equal?(other)
+    `this === other`
+  end
+
+  def extend(*mods)
+    %x{
+      for (var i = 0, length = mods.length; i < length; i++) {
+        include_module(singleton_class(this), mods[i]);
+      }
+
+      return this;
+    }
+  end
+
+  def hash
+    `this.$id`
+  end
+
+  def inspect
+    to_s
+  end
+
+  def instance_of?(klass)
+    `this.$klass === klass`
+  end
+
+  def instance_variable_defined?(name)
+    `this.hasOwnProperty(name.substr(1));`
+  end
+
+  def instance_variable_get(name)
+    %x{
+      var ivar = this[name.substr(1)];
+
+      return ivar == undefined ? nil : ivar;
+    }
+  end
+
+  def instance_variable_set(name, value)
+    `this[name.substr(1)] = value`
+  end
+
+  def instance_variables
+    %x{
+      var result = [];
+
+      for (var name in this) {
+        result.push(name);
+      }
+
+      return result;
+    }
+  end
+
+  def is_a?(klass)
+    %x{
+      var search = this.$klass;
+
+      while (search) {
+        if (search === klass) {
+          return true;
+        }
+
+        search = search.$s;
+      }
+
+      return false;
+    }
+  end
+
+  alias_method :kind_of?, :is_a?
+
+  def lambda(&block)
+    block
+  end
+
+  def loop(&block)
+    return enum_for :loop unless block_given?
+
+    %x{
+      while (true) {
+        if ($yield.call($context, null) === breaker) {
+          return breaker.$v;
+        }
+      }
+
+      return this;
+    }
+  end
+
+  def nil?
+    false
+  end
+
+  def object_id
+    `this.$id || (this.$id = unique_id++)`
+  end
+
+  def print(*strs)
+    $stdout.print *strs
+  end
+
+  def proc(&block)
+    block
+  end
+
+  def puts(*strs)
+    $stdout.puts *strs
+  end
+
+  def raise(exception, string = undefined)
+    %x{
+      if (#{Opal.string?(exception)}) {
+        exception = #{`RubyRuntimeError`.new `exception`};
+      }
+      else if (#{!exception.is_a? `RubyException`}) {
+        exception = #{`exception`.new string};
+      }
+
+      throw exception;
+    }
+  end
+
+  def rand(max = undefined)
+    `max === undefined ? Math.random() : Math.floor(Math.random() * max)`
+  end
+
+  def require(path)
+    %x{
+      var resolved = find_lib(path);
+
+      if (!resolved) {
+        raise(RubyLoadError, 'no such file to load -- ' + path);
+      }
+
+      if (LOADER_CACHE[resolved]) {
+        return false;
+      }
+
+      LOADER_CACHE[resolved] = true;
+      $opal.FILE = resolved;
+      FACTORIES[resolved].call(top_self, resolved, $opal);
+
+      return true;
+    }
+  end
+
+  def respond_to?(name)
+    %x{
+      var meth = this[mid_to_jsid(name)];
+      return !!meth;
+    }
+  end
+
+  def singleton_class
+    `singleton_class(this)`
+  end
+
+  def tap(&block)
+    %x{
+      if (block === nil) {
+        raise(RubyLocalJumpError, 'no block given');
+      }
+
+      if ($yield.call($context, null, this) === breaker) {
+        return breaker.$v;
+      }
+
+      return this;
+    }
+  end
+
+  def to_s
+    `inspect_object(this)`
+  end
+end

data/runtime/corelib/load_order

@@ -0,0 +1,29 @@
+alpha
+module
+class
+kernel
+basic_object
+object
+top_self
+boolean
+nil_class
+native
+enumerable
+comparable
+enumerator
+array
+hash
+string
+numeric
+rational
+complex
+proc
+range
+error
+regexp
+match_data
+struct
+time
+io
+file
+dir

data/runtime/corelib/match_data.rb

@@ -0,0 +1,37 @@
+class MatchData
+  def [](index)
+    %x{
+      var length = this.$data.length;
+
+      if (index < 0) {
+        index += length;
+      }
+
+      if (index >= length || index < 0) {
+        return nil;
+      }
+
+      return this.$data[index];
+    }
+  end
+
+  def length
+    `this.$data.length`
+  end
+
+  def inspect
+    "#<MatchData #{self[0].inspect}>"
+  end
+
+  alias_method :size, :length
+
+  def to_a
+    `[].slice.call(this.$data, 0)`
+  end
+
+  alias to_native to_a
+
+  def to_s
+    `this.$data[0]`
+  end
+end

data/runtime/corelib/module.rb

@@ -0,0 +1,171 @@
+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(mod)
+    `include_module(mod, this)`
+
+    self
+  end
+
+  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_accessor_bridge(target, *attrs)
+    %x{
+      for (var i = 0, length = attrs.length; i < length; i++) {
+        define_attr_bridge(this, target, 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_reader_bridge(target, *attrs)
+    %x{
+      for (var i = 0, length = attrs.length; i < length; i++) {
+        define_attr_bridge(this, target, 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_reader_bridge(target, *attrs)
+    %x{
+      for (var i = 0, length = attrs.length; i < length; i++) {
+        define_attr_bridge(this, target, attrs[i], false, true);
+      }
+
+      return nil;
+    }
+  end
+
+  def attr(name, setter = false)
+    `define_attr(this, name, true, setter)`
+
+    self
+  end
+
+  def attr_bridge(target, name, setter = false)
+    `define_attr_bridge(this, target, 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);
+      this.$methods.push(name);
+
+      return nil;
+    }
+  end
+
+  def define_method_bridge(object, name, ali = nil)
+    %x{
+      define_method_bridge(this, object, mid_to_jsid(#{ali || name}), name);
+      this.$methods.push(name);
+
+      return nil;
+    }
+  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
+
+  def instance_methods
+    `this.$methods`
+  end
+
+  def included(mod)
+    nil
+  end
+
+  def module_eval(&block)
+    %x{
+      if (block === nil) {
+        raise(RubyLocalJumpError, 'no block given');
+      }
+
+      return block.call(this, null);
+    }
+  end
+
+  alias_method :class_eval, :module_eval
+
+  def name
+    `this.__classid__`
+  end
+
+  alias_method :public_instance_methods, :instance_methods
+
+  alias_method :to_s, :name
+end