opal 0.4.3 → 0.4.4

data/corelib/{opal/class.rb → module.rb}

@@ -1,12 +1,11 @@
-class Class
-  def self.new(sup = Object, &block)
+class Module
+  def self.new(&block)
     %x{
-      function AnonClass(){};
-      var klass   = Opal.boot(sup, AnonClass)
+      function AnonModule(){}
+      var klass = Opal.boot(Module, AnonModule);
       klass._name = nil;
-      klass._scope = sup._scope;
-
-      sup.$inherited(klass);
+      klass._scope = Module._scope;
+      klass._klass = Module;
 
       if (block !== nil) {
         var block_self = block._s;
@@ -19,10 +18,6 @@ class Class
     }
   end
 
-  def self.bridge_class(name, constructor)
-    `__opal.bridge(name, constructor)`
-  end
-
   def ===(object)
     %x{
       if (object == null) {
@@ -43,14 +38,6 @@ class Class
     }
   end
 
-  def allocate
-    %x{
-      var obj = new #{self}._alloc;
-      obj._id = Opal.uid();
-      return obj;
-    }
-  end
-
   def alias_method(newname, oldname)
     `#{self}._proto['$' + newname] = #{self}._proto['$' + oldname]`
     self
@@ -110,7 +97,7 @@ class Class
       //}
 
       if (klass._included_in) {
-        __opal.donate(klass, methods.slice(), true);
+        $opal.donate(klass, methods.slice(), true);
       }
     }
 
@@ -175,13 +162,13 @@ class Class
       var name_re = /^[A-Z][A-Za-z0-9_]+$/;
       var scopes = [#{self}._scope];
       var own_only;
-      if (#{self} === Opal.Class) {
+      if (#{self} === Opal.Class || #{self} === Opal.Module) {
         own_only = false;
       }
       else {
         own_only = true;
         var parent = #{self}._super;
-        while (parent !== Opal.Object) {
+        while (parent && (parent !== Opal.Object)) {
           scopes.push(parent._scope);
           parent = parent._super;
         }
@@ -242,7 +229,7 @@ class Class
           return scopes[i][name];
         }
        }
- 
+
       return #{const_missing name};
     }
   end
@@ -261,6 +248,11 @@ class Class
     end
     %x{
       #{self}._scope[name] = #{value};
+
+      if (value._isClass && value._name === nil) {
+        value._name = #{self.name} + '::' + name;
+      }
+
       return #{value}
     }
   end
@@ -272,7 +264,7 @@ class Class
       }
 
       if (block === nil) {
-        no_block_given();
+        throw new Error("no block given");
       }
 
       var jsid    = '$' + name;
@@ -281,7 +273,7 @@ class Class
       block._s    = null;
 
       #{self}._proto[jsid] = block;
-      __opal.donate(#{self}, [jsid]);
+      $opal.donate(#{self}, [jsid]);
 
       return null;
     }
@@ -327,13 +319,10 @@ class Class
   def included(mod)
   end
 
-  def inherited(cls)
-  end
-
   def module_eval(&block)
     %x{
       if (block === nil) {
-        no_block_given();
+        throw new Error("no block given");
       }
 
       var block_self = block._s, result;
@@ -350,11 +339,8 @@ class Class
 
   def method_defined?(method)
     %x{
-      if (typeof(#{self}._proto['$' + method]) === 'function') {
-        return true;
-      }
-
-      return false;
+      var body = #{self}._proto['$' + method];
+      return (!!body) && !body.rb_stub;
     }
   end
 
@@ -374,34 +360,20 @@ class Class
     `#{self}._name`
   end
 
-  def new(*args, &block)
-    %x{
-      if (#{self}._proto.$initialize) {
-        var obj = new #{self}._alloc;
-        obj._id = Opal.uid();
-
-        obj.$initialize._p = block;
-        obj.$initialize.apply(obj, args);
-        return obj;
-      }
-      else {
-        var cons = function() {};
-        cons.prototype = #{self}.prototype;
-        var obj = new cons;
-        #{self}.apply(obj, args);
-        return obj;
-      }
-    }
-  end
-
   def public(*)
   end
 
   alias private public
   alias protected public
 
-  def superclass
-    `#{self}._super || nil`
+  alias public_method_defined? method_defined?
+
+  def remove_const(name)
+    %x{
+      var old = #{self}._scope[name];
+      delete #{self}._scope[name];
+      return old;
+    }
   end
 
   def to_s
@@ -409,7 +381,7 @@ class Class
   end
 
   def undef_method(symbol)
-    `#{self}._proto['$' + symbol] = undefined`
+    `$opal.add_stub_for(#{self}._proto, "$" + symbol)`
     self
   end
 end

data/corelib/native.rb

@@ -0,0 +1,148 @@
+module Kernel
+  def native?(value)
+    `value == null || !value._klass`
+  end
+
+  def Native(obj)
+    if native?(obj)
+      Native.new(obj)
+    else
+      obj
+    end
+  end
+end
+
+class Native < BasicObject
+  module Base
+    module Helpers
+      def alias_native(new, old)
+        define_method new do |*args|
+          Native.call(@native, old, *args)
+        end
+      end
+    end
+
+    def self.included(klass)
+      klass.instance_eval {
+        extend Helpers
+      }
+    end
+
+    def initialize(native)
+      unless native?(native)
+        raise ArgumentError, "the passed value isn't native"
+      end
+
+      @native = native
+    end
+
+    def to_n
+      @native
+    end
+  end
+
+  def self.try_convert(value)
+    %x{
+      if (#{native?(value)}) {
+        return #{value}.valueOf();
+      }
+      else if (#{value.respond_to? :to_n}) {
+        return #{value.to_n};
+      }
+      else {
+        return nil;
+      }
+    }
+  end
+
+  def self.convert(value)
+    native = try_convert(value)
+
+    if `#{native} === nil`
+      raise ArgumentError, "the passed value isn't a native"
+    end
+
+    native
+  end
+
+  def self.call(obj, key, *args, &block)
+    args << block if block
+
+    %x{
+      var prop = #{obj}[#{key}];
+
+      if (prop == null) {
+        return nil;
+      }
+      else if (prop instanceof Function) {
+        var result = prop.apply(#{obj}, #{args});
+
+        return result == null ? nil : result;
+      }
+      else if (#{native?(`prop`)}) {
+        return #{Native(`prop`)};
+      }
+      else {
+        return prop;
+      }
+    }
+  end
+
+  include Base
+
+  def nil?
+    `#@native == null`
+  end
+
+  def each
+    return Enumerator.new(self, :each) unless block_given?
+
+    %x{
+      for (var key in #@native) {
+        #{yield `key`, `#@native[key]`}
+      }
+    }
+
+    self
+  end
+
+  def [](key)
+    raise 'cannot get value from nil native' if nil?
+
+    %x{
+      var prop = #@native[key];
+
+      if (prop instanceof Function) {
+        return prop;
+      }
+      else {
+        return #{::Native.call(@native, key)}
+      }
+    }
+  end
+
+  def []=(key, value)
+    raise 'cannot set value on nil native' if nil?
+
+    native = Native.try_convert(value)
+
+    if `#{native} === nil`
+      `#@native[key] = #{value}`
+    else
+      `#@native[key] = #{native}`
+    end
+  end
+
+  def method_missing(mid, *args, &block)
+    raise 'cannot call method from nil native' if nil?
+
+    %x{
+      if (mid.charAt(mid.length - 1) === '=') {
+        return #{self[mid.slice(0, mid.length - 1)] = args[0]};
+      }
+      else {
+        return #{::Native.call(@native, mid, *args, &block)};
+      }
+    }
+  end
+end

data/corelib/{opal/nil_class.rb → nil_class.rb}

@@ -15,10 +15,6 @@ class NilClass
     `other === nil`
   end
 
-  def as_json
-    self
-  end
-
   def dup
     raise TypeError
   end
@@ -40,7 +36,7 @@ class NilClass
   end
 
   def to_h
-    `__opal.hash()`
+    `$opal.hash()`
   end
 
   def to_i
@@ -49,10 +45,6 @@ class NilClass
 
   alias to_f to_i
 
-  def to_json
-    'null'
-  end
-
   def to_n
     `null`
   end
@@ -62,7 +54,7 @@ class NilClass
   end
 
   def object_id
-    `#{NilClass}._id || (#{NilClass}._id = Opal.uid())`
+    `#{NilClass}._id || (#{NilClass}._id = $opal.uid())`
   end
   alias hash object_id
 end

data/corelib/{opal/numeric.rb → numeric.rb}

@@ -93,10 +93,6 @@ class Numeric
     `Math.abs(#{self})`
   end
 
-  def as_json
-    self
-  end
-
   def ceil
     `Math.ceil(#{self})`
   end
@@ -108,8 +104,8 @@ class Numeric
   def downto(finish, &block)
     %x{
       for (var i = #{self}; i >= finish; i--) {
-        if (block(i) === __breaker) {
-          return __breaker.$v;
+        if (block(i) === $breaker) {
+          return $breaker.$v;
         }
       }
 
@@ -159,13 +155,34 @@ class Numeric
     `#{self} - 1`
   end
 
+  def step(limit, step = 1, &block)
+    %x{
+      var working = #{self};
+
+      if (step > 0) {
+        while (working <= limit) {
+          block(working);
+          working += step;
+        }
+      }
+      else {
+        while (working >= limit) {
+          block(working);
+          working += step;
+        }
+      }
+
+      return #{self};
+    }
+  end
+
   alias succ next
 
   def times(&block)
     %x{
       for (var i = 0; i < #{self}; i++) {
-        if (block(i) === __breaker) {
-          return __breaker.$v;
+        if (block(i) === $breaker) {
+          return $breaker.$v;
         }
       }
 
@@ -181,10 +198,6 @@ class Numeric
     `parseInt(#{self})`
   end
 
-  def to_json
-    `#{self}.toString()`
-  end
-
   def to_s(base = 10)
     `#{self}.toString()`
   end
@@ -198,8 +211,8 @@ class Numeric
 
     %x{
       for (var i = #{self}; i <= finish; i++) {
-        if (block(i) === __breaker) {
-          return __breaker.$v;
+        if (block(i) === $breaker) {
+          return $breaker.$v;
         }
       }
 
@@ -218,3 +231,15 @@ class Numeric
 end
 
 Fixnum = Numeric
+
+class Integer < Numeric
+  def self.===(other)
+    other.is_a?(Numeric) && `(other % 1) == 0`
+  end
+end
+
+class Float < Numeric
+  def self.===(other)
+    other.is_a?(Numeric) && `(other % 1) != 0`
+  end
+end