opal 0.10.0 → 0.11.0

data/opal/corelib/method.rb

@@ -1,9 +1,9 @@
 class Method
   attr_reader :owner, :receiver, :name
 
-  def initialize(receiver, method, name)
+  def initialize(receiver, owner, method, name)
     @receiver = receiver
-    @owner    = receiver.class
+    @owner    = owner
     @name     = name
     @method   = method
   end
@@ -16,6 +16,14 @@ class Method
     `#{@method}.$$parameters`
   end
 
+  def source_location
+    `#{@method}.$$source_location` || ['(eval)', 0]
+  end
+
+  def comments
+    `#{@method}.$$comments` || []
+  end
+
   def call(*args, &block)
     %x{
       #@method.$$p = block;
@@ -27,12 +35,12 @@ class Method
   alias [] call
 
   def unbind
-    UnboundMethod.new(@owner, @method, @name)
+    UnboundMethod.new(@receiver.class, @owner, @method, @name)
   end
 
   def to_proc
     %x{
-      var proc = function () { return self.$call.apply(self, $slice.call(arguments)); };
+      var proc = self.$call.bind(self);
       proc.$$unbound = #@method;
       proc.$$is_lambda = true;
       return proc;
@@ -40,14 +48,15 @@ class Method
   end
 
   def inspect
-    "#<Method: #{@receiver.class}##@name>"
+    "#<#{self.class}: #{@receiver.class}##{@name} (defined in #{@owner} in #{source_location.join(':')})>"
   end
 end
 
 class UnboundMethod
-  attr_reader :owner, :name
+  attr_reader :source, :owner, :name
 
-  def initialize(owner, method, name)
+  def initialize(source, owner, method, name)
+    @source = source
     @owner  = owner
     @method = method
     @name   = name
@@ -61,15 +70,26 @@ class UnboundMethod
     `#{@method}.$$parameters`
   end
 
+  def source_location
+    `#{@method}.$$source_location` || ['(eval)', 0]
+  end
+
+  def comments
+    `#{@method}.$$comments` || []
+  end
+
   def bind(object)
-    # TODO: re-enable when Module#< is fixed
-    # unless object.class <= @owner
-    #   raise TypeError, "can't bind singleton method to a different class"
-    # end
-    Method.new(object, @method, @name)
+    %x{
+      if (#{@owner}.$$is_module || Opal.is_a(#{object}, #{@owner})) {
+        return #{Method.new(object, @owner, @method, @name)};
+      }
+      else {
+        #{raise TypeError, "can't bind singleton method to a different class (expected #{object}.kind_of?(#{@owner} to be true)"};
+      }
+    }
   end
 
   def inspect
-    "#<UnboundMethod: #{@owner.name}##@name>"
+    "#<#{self.class}: #{@source}##{@name} (defined in #{@owner} in #{source_location.join(':')})>"
   end
 end

data/opal/corelib/module.rb

@@ -3,8 +3,7 @@ class Module
     %x{
       var module;
 
-      module = Opal.module_allocate();
-      Opal.create_scope(Opal.Module.$$scope, module, null);
+      module = Opal.module_allocate(self);
       return module;
     }
   end
@@ -98,8 +97,8 @@ class Module
     `Opal.ancestors(self)`
   end
 
-  def append_features(klass)
-    `Opal.append_features(self, klass)`
+  def append_features(includer)
+    `Opal.append_features(self, includer)`
     self
   end
 
@@ -187,38 +186,79 @@ class Module
 
   def autoload(const, path)
     %x{
-      var autoloaders;
-
-      if (!(autoloaders = self.$$autoload)) {
-        autoloaders = self.$$autoload = {};
-      }
-
-      autoloaders[#{const}] = #{path};
+      if (self.$$autoload == null) self.$$autoload = {};
+      Opal.const_cache_version++;
+      self.$$autoload[#{const}] = #{path};
       return nil;
     }
   end
 
+  def class_variables
+    `Object.keys(Opal.class_variables(self))`
+  end
+
   def class_variable_get(name)
-    name = Opal.coerce_to!(name, String, :to_str)
-    raise NameError.new('class vars should start with @@', name) if `name.length < 3 || name.slice(0,2) !== '@@'`
+    name = Opal.class_variable_name!(name)
     %x{
-      var value = Opal.cvars[name.slice(2)];
-      #{raise NameError.new('uninitialized class variable @@a in', name) if `value == null`}
+      var value = Opal.class_variables(self)[name];
+      if (value == null) {
+        #{raise NameError.new("uninitialized class variable #{name} in #{self}", name)}
+      }
       return value;
     }
   end
 
   def class_variable_set(name, value)
-    name = Opal.coerce_to!(name, String, :to_str)
-    raise NameError if `name.length < 3 || name.slice(0,2) !== '@@'`
+    name = Opal.class_variable_name!(name)
+
+    `Opal.class_variable_set(self, name, value)`
+  end
+
+  def class_variable_defined?(name)
+    name = Opal.class_variable_name!(name)
+
+    `Opal.class_variables(self).hasOwnProperty(name)`
+  end
+
+  def remove_class_variable(name)
+    name = Opal.class_variable_name!(name)
+
     %x{
-      Opal.cvars[name.slice(2)] = value;
-      return value;
+      if (Opal.hasOwnProperty.call(self.$$cvars, name)) {
+        var value = self.$$cvars[name];
+        delete self.$$cvars[name];
+        return value;
+      } else {
+        #{raise NameError.new("cannot remove #{name} for #{self}")}
+      }
     }
   end
 
-  def constants
-    `self.$$scope.constants.slice(0)`
+  def constants(inherit=true)
+    `Opal.constants(self, inherit)`
+  end
+
+  def self.constants(inherit=undefined)
+    %x{
+      if (inherit == null) {
+        var nesting = (self.$$nesting || []).concat(Opal.Object),
+            constant, constants = {},
+            i, ii;
+
+        for(i = 0, ii = nesting.length; i < ii; i++) {
+          for (constant in nesting[i].$$const) {
+            constants[constant] = true;
+          }
+        }
+        return Object.keys(constants);
+      } else {
+        return Opal.constants(self, inherit)
+      }
+    }
+  end
+
+  def self.nesting
+    `self.$$nesting || []`
   end
 
   # check for constant within current scope
@@ -229,20 +269,21 @@ class Module
     raise NameError.new("wrong constant name #{name}", name) unless name =~ Opal::CONST_NAME_REGEXP
 
     %x{
-      var scopes = [self.$$scope];
-
-      if (inherit || self === Opal.Object) {
-        var parent = self.$$super;
+      var module, modules = [self], module_constants, i, ii;
 
-        while (parent !== Opal.BasicObject) {
-          scopes.push(parent.$$scope);
+      // Add up ancestors if inherit is true
+      if (inherit) {
+        modules = modules.concat(Opal.ancestors(self));
 
-          parent = parent.$$super;
+        // Add Object's ancestors if it's a module – modules have no ancestors otherwise
+        if (self.$$is_module) {
+          modules = modules.concat([Opal.Object]).concat(Opal.ancestors(Opal.Object));
         }
       }
 
-      for (var i = 0, length = scopes.length; i < length; i++) {
-        if (scopes[i].hasOwnProperty(name)) {
+      for (i = 0, ii = modules.length; i < ii; i++) {
+        module = modules[i];
+        if (module.$$const[name] != null) {
           return true;
         }
       }
@@ -267,25 +308,11 @@ class Module
     raise NameError.new("wrong constant name #{name}", name) unless name =~ Opal::CONST_NAME_REGEXP
 
     %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;
-        }
+      if (inherit) {
+        return Opal.const_get_relative([self], name);
+      } else {
+        return Opal.const_get_local(self, name);
       }
-
-      for (var i = 0, length = scopes.length; i < length; i++) {
-        if (scopes[i].hasOwnProperty(name)) {
-          return scopes[i][name];
-        }
-      }
-
-      return #{const_missing name};
     }
   end
 
@@ -314,11 +341,14 @@ class Module
       raise NameError.new("wrong constant name #{name}", name)
     end
 
-    `Opal.casgn(self, name, value)`
+    `Opal.const_set(self, name, value)`
 
     value
   end
 
+  def public_constant(const_name)
+  end
+
   def define_method(name, method = undefined, &block)
     if `method === undefined && block === nil`
       raise ArgumentError, "tried to create a Proc object without a block"
@@ -374,10 +404,6 @@ class Module
       for (var i = mods.length - 1; i >= 0; i--) {
         var mod = mods[i];
 
-        if (mod === self) {
-          continue;
-        }
-
         if (!mod.$$is_module) {
           #{raise TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
         }
@@ -397,7 +423,7 @@ class Module
       var module_chain = function(klass) {
         var included = [];
 
-        for (var i = 0; i != klass.$$inc.length; i++) {
+        for (var i = 0, ii = klass.$$inc.length; i < ii; i++) {
           var mod_or_class = klass.$$inc[i];
           included.push(mod_or_class);
           included = included.concat(module_chain(mod_or_class));
@@ -410,9 +436,9 @@ class Module
 
       // need superclass's modules
       if (self.$$is_class) {
-          for (var cls = self; cls; cls = cls.$$super) {
-            results = results.concat(module_chain(cls));
-          }
+        for (var cls = self; cls; cls = cls.$$super) {
+          results = results.concat(module_chain(cls));
+        }
       }
 
       return results;
@@ -421,14 +447,19 @@ class Module
 
   def include?(mod)
     %x{
-      for (var cls = self; cls; cls = cls.$$super) {
-        for (var i = 0; i != cls.$$inc.length; i++) {
-          var mod2 = cls.$$inc[i];
-          if (mod === mod2) {
-            return true;
-          }
+      if (!mod.$$is_module) {
+        #{raise TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
+      }
+
+      var i, ii, mod2, ancestors = Opal.ancestors(self);
+
+      for (i = 0, ii = ancestors.length; i < ii; i++) {
+        mod2 = ancestors[i];
+        if (mod2 === mod && mod2 !== self) {
+          return true;
         }
       }
+
       return false;
     }
   end
@@ -441,30 +472,33 @@ class Module
         #{raise NameError.new("undefined method `#{name}' for class `#{self.name}'", name)};
       }
 
-      return #{UnboundMethod.new(self, `meth`, name)};
+      return #{UnboundMethod.new(self, `meth.$$owner || #{self}`, `meth`, name)};
     }
   end
 
   def instance_methods(include_super = true)
     %x{
-      var methods = [],
+      var value,
+          methods = [],
           proto   = self.$$proto;
 
       for (var prop in proto) {
-        if (prop.charAt(0) !== '$') {
+        if (prop.charAt(0) !== '$' || prop.charAt(1) === '$') {
           continue;
         }
 
-        if (typeof(proto[prop]) !== "function") {
+        value = proto[prop];
+
+        if (typeof(value) !== "function") {
           continue;
         }
 
-        if (proto[prop].$$stub) {
+        if (value.$$stub) {
           continue;
         }
 
         if (!self.$$is_module) {
-          if (self !== Opal.BasicObject && proto[prop] === Opal.BasicObject.$$proto[prop]) {
+          if (self !== Opal.BasicObject && value === Opal.BasicObject.$$proto[prop]) {
             continue;
           }
 
@@ -472,7 +506,7 @@ class Module
             continue;
           }
 
-          if (!include_super && proto[prop].$$donated) {
+          if (!include_super && value.$$donated) {
             continue;
           }
         }
@@ -515,7 +549,8 @@ class Module
         }
       end
     elsif args.size > 0
-      Kernel.raise ArgumentError, "wrong number of arguments (#{args.size} for 0)"
+      Kernel.raise ArgumentError, "wrong number of arguments (#{args.size} for 0)"+
+        "\n\n  NOTE:If you want to enable passing a String argument please add \"require 'opal-parser'\" to your script\n"
     end
 
     %x{
@@ -585,9 +620,8 @@ class Module
       var result = [], base = self;
 
       while (base) {
-        if (base.$$name === nil) {
-          return result.length === 0 ? nil : result.join('::');
-        }
+        // Give up if any of the ancestors is unnamed
+        if (base.$$name === nil || base.$$name == null) return nil;
 
         result.unshift(base.$$name);
 
@@ -606,15 +640,8 @@ class Module
     }
   end
 
-  def remove_class_variable(*)
-  end
-
   def remove_const(name)
-    %x{
-      var old = self.$$scope[name];
-      delete self.$$scope[name];
-      return old;
-    }
+    `Opal.const_remove(self, name)`
   end
 
   def to_s
@@ -645,4 +672,29 @@ class Module
       return result;
     }
   end
+
+  def dup
+    copy = super
+    copy.copy_class_variables(self)
+    copy.copy_constants(self)
+    copy
+  end
+
+  def copy_class_variables(other)
+    %x{
+      for (var name in other.$$cvars) {
+        self.$$cvars[name] = other.$$cvars[name];
+      }
+    }
+  end
+
+  def copy_constants(other)
+    %x{
+      var name, other_constants = other.$$const;
+
+      for (name in other_constants) {
+        Opal.const_set(self, name, other_constants[name]);
+      }
+    }
+  end
 end

data/opal/corelib/nil.rb

@@ -1,6 +1,14 @@
 class NilClass
   `def.$$meta = #{self}`
 
+  class << self
+    def allocate
+      raise TypeError, "allocator undefined for #{self.name}"
+    end
+
+    undef :new
+  end
+
   def !
     true
   end
@@ -22,11 +30,11 @@ class NilClass
   end
 
   def dup
-    raise TypeError, "can't dup #{self.class}"
+    nil
   end
 
-  def clone
-    raise TypeError, "can't clone #{self.class}"
+  def clone(freeze: true)
+    nil
   end
 
   def inspect