opal-cj 0.7.0.beta1

data/opal/corelib/main.rb

@@ -0,0 +1,7 @@
+def self.to_s
+  'main'
+end
+
+def self.include(mod)
+  Object.include mod
+end

data/opal/corelib/match_data.rb

@@ -0,0 +1,114 @@
+class MatchData
+  attr_reader :post_match, :pre_match, :regexp, :string
+
+  def self.new(regexp, match_groups)
+    data = super(regexp, match_groups)
+
+    $` = data.pre_match
+    $' = data.post_match
+    $~ = data
+
+    data
+  end
+
+  def initialize(regexp, match_groups)
+    @regexp     = regexp
+    @begin      = `match_groups.index`
+    @string     = `match_groups.input`
+    @pre_match  = `#@string.substr(0, regexp.lastIndex - match_groups[0].length)`
+    @post_match = `#@string.substr(regexp.lastIndex)`
+    @matches    = []
+
+    %x{
+      for (var i = 0, length = match_groups.length; i < length; i++) {
+        var group = match_groups[i];
+
+        if (group == null) {
+          #@matches.push(nil);
+        }
+        else {
+          #@matches.push(group);
+        }
+      }
+    }
+  end
+
+  def [](*args)
+    @matches[*args]
+  end
+
+  def ==(other)
+    return false unless MatchData === other
+
+    `self.string == other.string` &&
+    `self.regexp == other.regexp` &&
+    `self.pre_match == other.pre_match` &&
+    `self.post_match == other.post_match` &&
+    `self.begin == other.begin`
+  end
+
+  def begin(pos)
+    if pos != 0 && pos != 1
+      raise ArgumentError, 'MatchData#begin only supports 0th element'
+    end
+
+    @begin
+  end
+
+  def captures
+    `#@matches.slice(1)`
+  end
+
+  def inspect
+    %x{
+      var str = "#<MatchData " + #{`#@matches[0]`.inspect};
+
+      for (var i = 1, length = #@matches.length; i < length; i++) {
+        str += " " + i + ":" + #{`#@matches[i]`.inspect};
+      }
+
+      return str + ">";
+    }
+  end
+
+  def length
+    `#@matches.length`
+  end
+
+  alias size length
+
+  def to_a
+    @matches
+  end
+
+  def to_s
+    `#@matches[0]`
+  end
+
+  def values_at(*indexes)
+    %x{
+      var values       = [],
+          match_length = #@matches.length;
+
+      for (var i = 0, length = indexes.length; i < length; i++) {
+        var pos = indexes[i];
+
+        if (pos >= 0) {
+          values.push(#@matches[pos]);
+        }
+        else {
+          pos += match_length;
+
+          if (pos > 0) {
+            values.push(#@matches[pos]);
+          }
+          else {
+            values.push(nil);
+          }
+        }
+      }
+
+      return values;
+    }
+  end
+end

data/opal/corelib/method.rb

@@ -0,0 +1,58 @@
+class Method
+  attr_reader :owner, :receiver, :name
+
+  def initialize(receiver, method, name)
+    @receiver = receiver
+    @owner    = receiver.class
+    @name     = name
+    @method   = method
+  end
+
+  def arity
+    @method.arity
+  end
+
+  def call(*args, &block)
+    %x{
+      #@method.$$p = block;
+
+      return #@method.apply(#@receiver, args);
+    }
+  end
+
+  alias [] call
+
+  def unbind
+    UnboundMethod.new(@owner, @method, @name)
+  end
+
+  def to_proc
+    @method
+  end
+
+  def inspect
+    "#<Method: #{@obj.class.name}##@name}>"
+  end
+end
+
+class UnboundMethod
+  attr_reader :owner, :name
+
+  def initialize(owner, method, name)
+    @owner  = owner
+    @method = method
+    @name   = name
+  end
+
+  def arity
+    @method.arity
+  end
+
+  def bind(object)
+    Method.new(object, @method, @name)
+  end
+
+  def inspect
+    "#<UnboundMethod: #{@owner.name}##@name>"
+  end
+end

data/opal/corelib/module.rb

@@ -0,0 +1,462 @@
+class Module
+  def self.new(&block)
+    %x{
+      function AnonModule(){}
+      var klass      = Opal.boot(Opal.Module, AnonModule);
+      klass.$$name   = nil;
+      klass.$$class  = Opal.Module;
+      klass.$$dep    = []
+      klass.$$is_mod = true;
+      klass.$$proto  = {};
+
+      // inherit scope from parent
+      $opal.create_scope(Opal.Module.$$scope, klass);
+
+      if (block !== nil) {
+        var block_self = block.$$s;
+        block.$$s = null;
+        block.call(klass);
+        block.$$s = block_self;
+      }
+
+      return klass;
+    }
+  end
+
+  def ===(object)
+    return false if `object == null`
+
+    `$opal.is_a(object, self)`
+  end
+
+  def <(other)
+    %x{
+      var working = self;
+
+      while (working) {
+        if (working === other) {
+          return true;
+        }
+
+        working = working.$$parent;
+      }
+
+      return false;
+    }
+  end
+
+  def alias_method(newname, oldname)
+    %x{
+      self.$$proto['$' + newname] = self.$$proto['$' + oldname];
+
+      if (self.$$methods) {
+        $opal.donate(self, ['$' + newname ])
+      }
+    }
+    self
+  end
+
+  def alias_native(mid, jsid = mid)
+    `self.$$proto['$' + mid] = self.$$proto[jsid]`
+  end
+
+  def ancestors
+    %x{
+      var parent = self,
+          result = [];
+
+      while (parent) {
+        result.push(parent);
+        result = result.concat(parent.$$inc);
+
+        parent = parent.$$super;
+      }
+
+      return result;
+    }
+  end
+
+  def append_features(klass)
+    `Opal.append_features(self, klass)`
+    self
+  end
+
+  def attr_accessor(*names)
+    attr_reader(*names)
+    attr_writer(*names)
+  end
+
+  def attr_reader(*names)
+    %x{
+      var proto = self.$$proto, cls = self;
+      for (var i = 0, length = names.length; i < length; i++) {
+        (function(name) {
+          proto[name] = nil;
+          var func = function() { return this[name] };
+
+          if (cls.$$is_singleton) {
+            proto.constructor.prototype['$' + name] = func;
+          }
+          else {
+            proto['$' + name] = func;
+            $opal.donate(self, ['$' + name ]);
+          }
+        })(names[i]);
+      }
+    }
+
+    nil
+  end
+
+  def attr_writer(*names)
+    %x{
+      var proto = self.$$proto, cls = self;
+      for (var i = 0, length = names.length; i < length; i++) {
+        (function(name) {
+          proto[name] = nil;
+          var func = function(value) { return this[name] = value; };
+
+          if (cls.$$is_singleton) {
+            proto.constructor.prototype['$' + name + '='] = func;
+          }
+          else {
+            proto['$' + name + '='] = func;
+            $opal.donate(self, ['$' + name + '=']);
+          }
+        })(names[i]);
+      }
+    }
+    nil
+  end
+
+  alias attr attr_accessor
+
+  def autoload(const, path)
+    %x{
+      var autoloaders;
+
+      if (!(autoloaders = self.$$autoload)) {
+        autoloaders = self.$$autoload = {};
+      }
+
+      autoloaders[#{const}] = #{path};
+      return nil;
+    }
+  end
+
+  def constants
+    `self.$$scope.constants`
+  end
+
+  # check for constant within current scope
+  # if inherit is true or self is Object, will also check ancestors
+  def const_defined?(name, inherit = true)
+    raise NameError, "wrong constant name #{name}" unless name =~ /^[A-Z]\w*$/
+
+    %x{
+      scopes = [self.$$scope];
+      if (inherit || self === Opal.Object) {
+        var parent = self.$$super;
+        while (parent !== Opal.BasicObject) {
+          scopes.push(parent.$$scope);
+          parent = parent.$$super;
+        }
+      }
+
+      for (var i = 0, len = scopes.length; i < len; i++) {
+        if (scopes[i].hasOwnProperty(name)) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+  end
+
+  def const_get(name, inherit = true)
+    raise NameError, "wrong constant name #{name}" unless name =~ /^[A-Z]\w*$/
+
+    %x{
+      var scopes = [self.$$scope];
+      if (inherit || self == Opal.Object) {
+        var parent = self.$$super;
+        while (parent !== Opal.BasicObject) {
+          scopes.push(parent.$$scope);
+          parent = parent.$$super;
+        }
+      }
+
+      for (var i = 0, len = scopes.length; i < len; i++) {
+        if (scopes[i].hasOwnProperty(name)) {
+          return scopes[i][name];
+        }
+      }
+
+      return #{const_missing name};
+    }
+  end
+
+  def const_missing(const)
+    %x{
+      var autoloader;
+
+      if (self.$$autoload && (autoloader = self.$$autoload[#{const}])) {
+        self.$require(autoloader);
+        return self.$$scope.get(#{const});
+      }
+    }
+
+    name = `self.$$name`
+
+    raise NameError, "uninitialized constant #{name}::#{const}"
+  end
+
+  def const_set(name, value)
+    raise NameError, "wrong constant name #{name}" unless name =~ /^[A-Z]\w*$/
+
+    begin
+      name = name.to_str
+    rescue
+      raise TypeError, 'conversion with #to_str failed'
+    end
+
+    %x{
+      $opal.casgn(self, name, value);
+      return #{value}
+    }
+  end
+
+  def define_method(name, method = undefined, &block)
+    %x{
+      if (method) {
+        block = #{method.to_proc};
+      }
+
+      if (block === nil) {
+        throw new Error("no block given");
+      }
+
+      var jsid    = '$' + name;
+      block.$$jsid = name;
+      block.$$s    = null;
+      block.$$def  = block;
+
+      self.$$proto[jsid] = block;
+      $opal.donate(self, [jsid]);
+
+      return name;
+    }
+  end
+
+  def remove_method(name)
+    %x{
+      var jsid    = '$' + name;
+      var current = self.$$proto[jsid];
+      delete self.$$proto[jsid];
+
+      // Check if we need to reverse $opal.donate
+      // $opal.retire(self, [jsid]);
+      return self;
+    }
+  end
+
+  def include(*mods)
+    %x{
+      for (var i = mods.length - 1; i >= 0; i--) {
+        var mod = mods[i];
+
+        if (mod === self) {
+          continue;
+        }
+
+        #{`mod`.append_features self};
+        #{`mod`.included self};
+      }
+    }
+
+    self
+  end
+
+  def include?(mod)
+    %x{
+      for (var cls = self; cls; cls = cls.parent) {
+        for (var i = 0; i != cls.$$inc.length; i++) {
+          var mod2 = cls.$$inc[i];
+          if (mod === mod2) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+  end
+
+  def instance_method(name)
+    %x{
+      var meth = self.$$proto['$' + name];
+
+      if (!meth || meth.$$stub) {
+        #{raise NameError, "undefined method `#{name}' for class `#{self.name}'"};
+      }
+
+      return #{UnboundMethod.new(self, `meth`, name)};
+    }
+  end
+
+  def instance_methods(include_super = false)
+    %x{
+      var methods = [], proto = self.$$proto;
+
+      for (var prop in self.$$proto) {
+        if (!include_super && !proto.hasOwnProperty(prop)) {
+          continue;
+        }
+
+        if (!include_super && proto[prop].$$donated) {
+          continue;
+        }
+
+        if (prop.charAt(0) === '$') {
+          methods.push(prop.substr(1));
+        }
+      }
+
+      return methods;
+    }
+  end
+
+  def included(mod)
+  end
+
+  def extended(mod)
+  end
+
+  def module_eval(&block)
+    raise ArgumentError, 'no block given' unless block
+
+    %x{
+      var old = block.$$s,
+          result;
+
+      block.$$s = null;
+      result = block.call(self);
+      block.$$s = old;
+
+      return result;
+    }
+  end
+
+  alias class_eval module_eval
+
+  def module_exec(&block)
+    %x{
+      if (block === nil) {
+        throw new Error("no block given");
+      }
+
+      var block_self = block.$$s, result;
+
+      block.$$s = null;
+      result = block.apply(self, $slice.call(arguments));
+      block.$$s = block_self;
+
+      return result;
+    }
+  end
+
+  alias class_exec module_exec
+
+  def method_defined?(method)
+    %x{
+      var body = self.$$proto['$' + method];
+      return (!!body) && !body.$$stub;
+    }
+  end
+
+  def module_function(*methods)
+    %x{
+      for (var i = 0, length = methods.length; i < length; i++) {
+        var meth = methods[i], func = self.$$proto['$' + meth];
+
+        self.constructor.prototype['$' + meth] = func;
+      }
+
+      return self;
+    }
+  end
+
+  def name
+    %x{
+      if (self.$$full_name) {
+        return self.$$full_name;
+      }
+
+      var result = [], base = self;
+
+      while (base) {
+        if (base.$$name === nil) {
+          return result.length === 0 ? nil : result.join('::');
+        }
+
+        result.unshift(base.$$name);
+
+        base = base.$$base_module;
+
+        if (base === $opal.Object) {
+          break;
+        }
+      }
+
+      if (result.length === 0) {
+        return nil;
+      }
+
+      return self.$$full_name = result.join('::');
+    }
+  end
+
+  def public(*)
+  end
+
+  alias private public
+  alias protected public
+  alias nesting public
+
+  def private_class_method(name)
+    `self['$' + name] || nil`
+  end
+  alias public_class_method private_class_method
+
+  def private_method_defined?(obj)
+    false
+  end
+
+  def private_constant(*)
+  end
+
+  alias protected_method_defined? private_method_defined?
+
+  alias public_instance_methods instance_methods
+
+  alias public_method_defined? method_defined?
+
+  def remove_class_variable(*)
+  end
+
+  def remove_const(name)
+    %x{
+      var old = self.$$scope[name];
+      delete self.$$scope[name];
+      return old;
+    }
+  end
+
+  def to_s
+    name.to_s
+  end
+
+  def undef_method(symbol)
+    `$opal.add_stub_for(self.$$proto, "$" + symbol)`
+    self
+  end
+end