opal 1.3.2 → 1.4.0.alpha1

data/opal/corelib/module.rb

@@ -1,6 +1,6 @@
-# helpers: truthy, coerce_to
+# helpers: truthy, coerce_to, const_set, Object
 
-class Module
+class ::Module
   def self.allocate
     %x{
       var module = Opal.allocate_module(nil, function(){});
@@ -21,8 +21,8 @@ class Module
   end
 
   def <(other)
-    unless Module === other
-      raise TypeError, 'compared with non class/module'
+    unless ::Module === other
+      ::Kernel.raise ::TypeError, 'compared with non class/module'
     end
 
     # class cannot be a descendant of itself
@@ -56,8 +56,8 @@ class Module
   end
 
   def >(other)
-    unless Module === other
-      raise TypeError, 'compared with non class/module'
+    unless ::Module === other
+      ::Kernel.raise ::TypeError, 'compared with non class/module'
     end
 
     other < self
@@ -74,7 +74,7 @@ class Module
       }
     }
 
-    unless Module === other
+    unless ::Module === other
       return nil
     end
 
@@ -84,8 +84,8 @@ class Module
   end
 
   def alias_method(newname, oldname)
-    newname = `$coerce_to(newname, #{String}, 'to_str')`
-    oldname = `$coerce_to(oldname, #{String}, 'to_str')`
+    newname = `$coerce_to(newname, #{::String}, 'to_str')`
+    oldname = `$coerce_to(oldname, #{::String}, 'to_str')`
     `Opal.alias(self, newname, oldname)`
 
     self
@@ -147,7 +147,7 @@ class Module
         })(ivar);
 
         // initialize the instance variable as nil
-        Opal.defineProperty(proto, ivar, nil);
+        Opal.prop(proto, ivar, nil);
 
         body.$$parameters = [];
         body.$$arity = 0;
@@ -180,7 +180,7 @@ class Module
         body.$$arity = 1;
 
         // initialize the instance variable as nil
-        Opal.defineProperty(proto, ivar, nil);
+        Opal.prop(proto, ivar, nil);
 
         Opal.defn(self, id, body);
       }
@@ -192,11 +192,11 @@ class Module
   def autoload(const, path)
     %x{
       if (!#{Opal.const_name?(const)}) {
-        #{raise NameError, "autoload must be constant name: #{const}"}
+        #{::Kernel.raise ::NameError, "autoload must be constant name: #{const}"}
       }
 
       if (path == "") {
-        #{raise ArgumentError, 'empty file name'}
+        #{::Kernel.raise ::ArgumentError, 'empty file name'}
       }
 
       if (!self.$$const.hasOwnProperty(#{const})) {
@@ -232,25 +232,25 @@ class Module
   end
 
   def class_variable_get(name)
-    name = Opal.class_variable_name!(name)
+    name = ::Opal.class_variable_name!(name)
 
     `Opal.class_variable_get(self, name, false)`
   end
 
   def class_variable_set(name, value)
-    name = Opal.class_variable_name!(name)
+    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)
+    name = ::Opal.class_variable_name!(name)
 
     `Opal.class_variables(self).hasOwnProperty(name)`
   end
 
   def remove_class_variable(name)
-    name = Opal.class_variable_name!(name)
+    name = ::Opal.class_variable_name!(name)
 
     %x{
       if (Opal.hasOwnProperty.call(self.$$cvars, name)) {
@@ -258,7 +258,7 @@ class Module
         delete self.$$cvars[name];
         return value;
       } else {
-        #{raise NameError, "cannot remove #{name} for #{self}"}
+        #{::Kernel.raise ::NameError, "cannot remove #{name} for #{self}"}
       }
     }
   end
@@ -270,7 +270,7 @@ class Module
   def self.constants(inherit = undefined)
     %x{
       if (inherit == null) {
-        var nesting = (self.$$nesting || []).concat(Opal.Object),
+        var nesting = (self.$$nesting || []).concat($Object),
             constant, constants = {},
             i, ii;
 
@@ -295,7 +295,7 @@ class Module
   def const_defined?(name, inherit = true)
     name = Opal.const_name!(name)
 
-    raise NameError.new("wrong constant name #{name}", name) unless name =~ Opal::CONST_NAME_REGEXP
+    ::Kernel.raise ::NameError.new("wrong constant name #{name}", name) unless name =~ ::Opal::CONST_NAME_REGEXP
 
     %x{
       var module, modules = [self], module_constants, i, ii;
@@ -306,7 +306,7 @@ class Module
 
         // 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));
+          modules = modules.concat([$Object]).concat(Opal.ancestors($Object));
         }
       }
 
@@ -340,11 +340,11 @@ class Module
       return name.split('::').inject(self) { |o, c| o.const_get(c) }
     end
 
-    raise NameError.new("wrong constant name #{name}", name) unless name =~ Opal::CONST_NAME_REGEXP
+    ::Kernel.raise ::NameError.new("wrong constant name #{name}", name) unless name =~ ::Opal::CONST_NAME_REGEXP
 
     %x{
       if (inherit) {
-        return $$([self], name);
+        return Opal.$$([self], name);
       } else {
         return Opal.const_get_local(self, name);
       }
@@ -352,19 +352,19 @@ class Module
   end
 
   def const_missing(name)
-    full_const_name = self == Object ? name : "#{self}::#{name}"
+    full_const_name = self == ::Object ? name : "#{self}::#{name}"
 
-    raise NameError.new("uninitialized constant #{full_const_name}", name)
+    ::Kernel.raise ::NameError.new("uninitialized constant #{full_const_name}", name)
   end
 
   def const_set(name, value)
-    name = Opal.const_name!(name)
+    name = ::Opal.const_name!(name)
 
-    if name !~ Opal::CONST_NAME_REGEXP || name.start_with?('::')
-      raise NameError.new("wrong constant name #{name}", name)
+    if name !~ ::Opal::CONST_NAME_REGEXP || name.start_with?('::')
+      ::Kernel.raise ::NameError.new("wrong constant name #{name}", name)
     end
 
-    `Opal.const_set(self, name, value)`
+    `$const_set(self, name, value)`
 
     value
   end
@@ -373,38 +373,50 @@ class Module
   end
 
   def define_method(name, method = undefined, &block)
-    if `method === undefined && block === nil`
-      raise ArgumentError, 'tried to create a Proc object without a block'
-    end
+    %x{
+      if (method === undefined && block === nil)
+        #{::Kernel.raise ::ArgumentError, 'tried to create a Proc object without a block'}
+    }
 
     block ||= case method
-              when Proc
+              when ::Proc
                 method
 
-              when Method
+              when ::Method
                 `#{method.to_proc}.$$unbound`
 
-              when UnboundMethod
+              when ::UnboundMethod
                 ->(*args) {
                   bound = method.bind(self)
                   bound.call(*args)
                 }
 
               else
-                raise TypeError, "wrong argument type #{block.class} (expected Proc/Method)"
+                ::Kernel.raise ::TypeError, "wrong argument type #{block.class} (expected Proc/Method)"
               end
 
     %x{
-      var id = '$' + name;
+      // Wrapping and forwarding is required to make super work, as the
+      // same block can be used to define multiple methods.
+      var wrapper = function() {
+        block.$$jsid        = name
+        block.$$p           = wrapper.$$p
+        block.$$s           = null;
+        block.$$def         = wrapper;
+        block.$$define_meth = true;
 
-      block.$$jsid        = name;
-      block.$$s           = null;
-      block.$$def         = block;
-      block.$$define_meth = true;
+        return block.apply(this, arguments)
+      }
 
-      Opal.defn(self, id, block);
+      var id = '$' + name;
+      wrapper.$$jsid        = name
+      wrapper.$$s           = null;
+      wrapper.$$def         = wrapper;
+      wrapper.$$define_meth = true;
 
-      return name;
+      Object.assign(wrapper, block)
+
+      return Opal.defn(self, id, wrapper);
     }
   end
 
@@ -428,7 +440,7 @@ class Module
         var mod = mods[i];
 
         if (!mod.$$is_module) {
-          #{raise TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
+          #{::Kernel.raise ::TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
         }
 
         #{`mod`.append_features self};
@@ -446,7 +458,7 @@ class Module
   def include?(mod)
     %x{
       if (!mod.$$is_module) {
-        #{raise TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
+        #{::Kernel.raise ::TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
       }
 
       var i, ii, mod2, ancestors = Opal.ancestors(self);
@@ -467,10 +479,10 @@ class Module
       var meth = self.$$prototype['$' + name];
 
       if (!meth || meth.$$stub) {
-        #{raise NameError.new("undefined method `#{name}' for class `#{self.name}'", name)};
+        #{::Kernel.raise ::NameError.new("undefined method `#{name}' for class `#{self.name}'", name)};
       }
 
-      return #{UnboundMethod.new(self, `meth.$$owner || #{self}`, `meth`, name)};
+      return #{::UnboundMethod.new(self, `meth.$$owner || #{self}`, `meth`, name)};
     }
   end
 
@@ -504,22 +516,18 @@ class Module
 
   def module_eval(*args, &block)
     if block.nil? && `!!Opal.compile`
-      Kernel.raise ArgumentError, 'wrong number of arguments (0 for 1..3)' unless (1..3).cover? args.size
+      ::Kernel.raise ::ArgumentError, 'wrong number of arguments (0 for 1..3)' unless (1..3).cover? args.size
 
       string, file, _lineno = *args
       default_eval_options = { file: (file || '(eval)'), eval: true }
       compiling_options = __OPAL_COMPILER_CONFIG__.merge(default_eval_options)
-      compiled = Opal.compile string, compiling_options
-      block = Kernel.proc do
-        %x{
-          return (function(self) {
-            return eval(compiled);
-          })(self)
-        }
+      compiled = ::Opal.compile string, compiling_options
+      block = ::Kernel.proc do
+        %x{new Function("Opal,self", "return " + compiled)(Opal, self)}
       end
     elsif args.any?
-      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"
+      ::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{
@@ -534,12 +542,10 @@ class Module
     }
   end
 
-  alias class_eval module_eval
-
   def module_exec(*args, &block)
     %x{
       if (block === nil) {
-        #{raise LocalJumpError, 'no block given'}
+        #{::Kernel.raise ::LocalJumpError, 'no block given'}
       }
 
       var block_self = block.$$s, result;
@@ -552,8 +558,6 @@ class Module
     }
   end
 
-  alias class_exec module_exec
-
   def method_defined?(method)
     %x{
       var body = self.$$prototype['$' + method];
@@ -565,6 +569,7 @@ class Module
     %x{
       if (methods.length === 0) {
         self.$$module_function = true;
+        return nil;
       }
       else {
         for (var i = 0, length = methods.length; i < length; i++) {
@@ -574,6 +579,7 @@ class Module
 
           Opal.defs(self, id, func);
         }
+        return methods.length === 1 ? methods[0] : methods;
       }
 
       return self;
@@ -596,7 +602,7 @@ class Module
 
         base = base.$$base_module;
 
-        if (base === Opal.Object) {
+        if (base === $Object) {
           break;
         }
       }
@@ -612,14 +618,14 @@ class Module
   def prepend(*mods)
     %x{
       if (mods.length === 0) {
-        #{raise ArgumentError, 'wrong number of arguments (given 0, expected 1+)'}
+        #{::Kernel.raise ::ArgumentError, 'wrong number of arguments (given 0, expected 1+)'}
       }
 
       for (var i = mods.length - 1; i >= 0; i--) {
         var mod = mods[i];
 
         if (!mod.$$is_module) {
-          #{raise TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
+          #{::Kernel.raise ::TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
         }
 
         #{`mod`.prepend_features self};
@@ -633,7 +639,7 @@ class Module
   def prepend_features(prepender)
     %x{
       if (!self.$$is_module) {
-        #{raise TypeError, "wrong argument type #{self.class} (expected Module)"};
+        #{::Kernel.raise ::TypeError, "wrong argument type #{self.class} (expected Module)"};
       }
 
       Opal.prepend_features(self, prepender)
@@ -652,8 +658,6 @@ class Module
     `Opal.Module.$name.call(self)` || "#<#{`self.$$is_module ? 'Module' : 'Class'`}:0x#{__id__.to_s(16)}>"
   end
 
-  alias inspect to_s
-
   def undef_method(*names)
     %x{
       for (var i = 0, length = names.length; i < length; i++) {
@@ -699,34 +703,47 @@ class Module
       var name, other_constants = other.$$const;
 
       for (name in other_constants) {
-        Opal.const_set(self, name, other_constants[name]);
+        $const_set(self, name, other_constants[name]);
       }
     }
   end
 
-  def refine(mod, &block)
-    s, m, mod_id = self, nil, nil
+  def refine(klass, &block)
+    refinement_module, m, klass_id = self, nil, nil
     %x{
-      mod_id = Opal.id(mod);
+      klass_id = Opal.id(klass);
       if (typeof self.$$refine_modules === "undefined") {
         self.$$refine_modules = {};
       }
-      if (typeof self.$$refine_modules[mod_id] === "undefined") {
-        m = self.$$refine_modules[mod_id] = #{::Module.new};
+      if (typeof self.$$refine_modules[klass_id] === "undefined") {
+        m = self.$$refine_modules[klass_id] = #{::Refinement.new};
       }
       else {
-        m = self.$$refine_modules[mod_id];
+        m = self.$$refine_modules[klass_id];
       }
+      m.refinement_module = refinement_module
+      m.refined_class = klass
     }
-    m.define_singleton_method :inspect do
-      "#<refinement:#{mod.inspect}@#{s.inspect}>"
-    end
     m.class_exec(&block)
     m
   end
 
   # Compiler overrides this method
   def using(mod)
-    raise 'Module#using is not permitted in methods'
+    ::Kernel.raise 'Module#using is not permitted in methods'
+  end
+
+  alias class_eval module_eval
+  alias class_exec module_exec
+  alias inspect to_s
+end
+
+class ::Refinement < ::Module
+  def inspect
+    if @refinement_module
+      "#<refinement:#{@refined_class.inspect}@#{@refinement_module.inspect}>"
+    else
+      super
+    end
   end
 end

data/opal/corelib/nil.rb

@@ -1,9 +1,9 @@
-class NilClass
+class ::NilClass
   `self.$$prototype.$$meta = #{self}`
 
   class << self
     def allocate
-      raise TypeError, "allocator undefined for #{name}"
+      ::Kernel.raise ::TypeError, "allocator undefined for #{name}"
     end
 
     undef :new
@@ -46,7 +46,7 @@ class NilClass
   end
 
   def singleton_class
-    NilClass
+    ::NilClass
   end
 
   def to_a
@@ -61,28 +61,26 @@ class NilClass
     0
   end
 
-  alias to_f to_i
-
   def to_s
     ''
   end
 
   def to_c
-    Complex.new(0, 0)
+    ::Complex.new(0, 0)
   end
 
   def rationalize(*args)
-    raise ArgumentError if args.length > 1
-    Rational(0, 1)
+    ::Kernel.raise ::ArgumentError if args.length > 1
+    ::Kernel.Rational(0, 1)
   end
 
   def to_r
-    Rational(0, 1)
+    ::Kernel.Rational(0, 1)
   end
 
   def instance_variables
     []
   end
-end
 
-NIL = nil
+  alias to_f to_i
+end