opal 0.3.6 → 0.3.9

data/{lib/core → corelib}/kernel.rb

@@ -3,36 +3,28 @@
 # {BasicObject}.
 module Kernel
 
-
   def instance_variable_defined?(name)
     `name = #{name.to_s};
-    return self[name] == undefined ? Qfalse : Qtrue;`
+    return self[name.substr(1)] != undefined;`
   end
 
   def instance_variable_get(name)
     `name = #{name.to_s};
-    return self[name] == undefined ? nil : self[name];`
+    return self[name.substr(1)] == undefined ? nil : self[name.substr(1)];`
   end
 
   def instance_variable_set(name, value)
     `name = #{name.to_s};
-    return self[name] = value;`
-  end
-
-  # Returns `true` if a block was given to the current method, `false`
-  # otherwise.
-  #
-  # @NOTE: In opal, this is actually a fake method. block_given? is inlined
-  # for efficiency and implementation details.
-  #
-  # @return [true, false]
-  def block_given?
-    false
+    return self[name.substr(1)] = value;`
   end
 
   # raw object flags (used by runtime)
   def __flags__
-    `return self.$flags;`
+    `return self.$f;`
+  end
+
+  def hash
+    `return self.$h();`
   end
 
   def to_a
@@ -46,22 +38,20 @@ module Kernel
   end
 
   def kind_of?(klass)
-    `var search = self.$klass;
+    `var search = self.$k;
 
     while (search) {
       if (search == klass) {
-        return Qtrue;
+        return true;
       }
 
       search = search.$super;
     }
 
-    return Qfalse;`
+    return false;`
   end
 
-  def is_a?(klass)
-    kind_of? klass
-  end
+  alias_method :is_a?, :kind_of?
 
   def nil?
     false
@@ -82,13 +72,14 @@ module Kernel
   # @param [String, Symbol] method_id
   # @return [Boolean]
   def respond_to?(method_id)
-    `var method = self['m$' + #{`method_id`.to_s}];
+    `var method = self['m$' + method_id];
+
 
-    if (method && !method.$rbMM) {
-      return Qtrue;
+    if (method ) {
+      return true;
     }
 
-    return Qfalse;`
+    return false;`
   end
 
   def ===(other)
@@ -96,27 +87,25 @@ module Kernel
   end
 
   def send(method_id, *args, &block)
-    `var method = self.$m[#{method_id.to_s}];
+    `var method = self['m$' + method_id];
 
     if ($B.f == arguments.callee) {
       $B.f = method;
     }
 
-    args.unshift(self);
-
     return method.apply(self, args);`
   end
 
   def class
-    `return $rb.class_real(self.$klass);`
+    `return rb_class_real(self.$k);`
   end
 
   def singleton_class
-    `return $rb.singleton_class(self);`
+    `return rb_singleton_class(self);`
   end
 
   def methods
-    `return self.$klass.$methods;`
+    `return self.$k.$methods;`
   end
 
   # Returns a random number. If max is `nil`, then the result is 0. Otherwise
@@ -139,11 +128,11 @@ module Kernel
   end
 
   def __id__
-    `return self.$hash();`
+    `return self.$h();`
   end
 
   def object_id
-    `return self.$hash();`
+    `return self.$h();`
   end
 
   # Returns a simple string representation of the receiver object. The id shown in the string
@@ -152,7 +141,7 @@ module Kernel
   #
   # FIXME: proper hex output needed
   def to_s
-    "#<#{`$rb.class_real(self.$klass)`}:0x#{`(self.$hash() * 400487).toString(16)`}>"
+    "#<#{`rb_class_real(self.$k)`}:0x#{`(self.$h() * 400487).toString(16)`}>"
   end
 
   def inspect
@@ -160,7 +149,7 @@ module Kernel
   end
 
   def const_set(name, value)
-    `return rb_const_set($rb.class_real(self.$klass), name, value);`
+    `return rb_const_set(rb_class_real(self.$k), name, value);`
   end
 
   def const_defined?(name)
@@ -172,13 +161,10 @@ module Kernel
   end
 
   def extend(mod)
-    `$rb.extend_module($rb.singleton_class(self), mod);`
+    `rb_extend_module(rb_singleton_class(self), mod);`
     nil
   end
 
-  # @group Private methods
-  private
-
   # Raises an exception. If given a string, this method will raise a
   # RuntimeError with the given string as a message. Otherwise, if the first
   # parameter is a subclass of Exception, then the method will raise a new
@@ -201,16 +187,16 @@ module Kernel
   def raise(exception, string = nil)
     `var msg = nil, exc;
 
-    if (typeof exception == 'string') {
+    if (exception.$f & T_STRING) {
       msg = exception;
       exc = #{RuntimeError.new `msg`};
-    } else if (#{`exception`.kind_of? Exception}.$r) {
+    } else if (#{`exception`.kind_of? Exception}) {
       exc = exception;
     } else {
       if (string != nil) msg = string;
       exc = #{`exception`.new `msg`};
     }
-    $rb.raise_exc(exc);`
+    rb_raise_exc(exc);`
   end
 
   alias_method :fail, :raise
@@ -232,6 +218,14 @@ module Kernel
     return self;`
   end
 
+  # Executed in reverse order
+  def at_exit(&proc)
+    raise ArgumentError, "called without a block" unless block_given?
+    `rb_end_procs.push(proc);`
+
+    proc
+  end
+
   # Simple equivalent to `Proc.new`. Returns a new proc from the given block.
   #
   # @example
@@ -249,7 +243,7 @@ module Kernel
   def lambda(&block)
     raise ArgumentError,
       "tried to create Proc object without a block" unless block_given?
-    `return $rb.lambda(block);`
+    `return rb_make_lambda(block);`
   end
 
   # @endgroup

data/corelib/load_order

@@ -0,0 +1,21 @@
+core
+object
+module
+class
+kernel
+top_self
+nil_class
+boolean
+enumerable
+array
+numeric
+hash
+error
+string
+proc
+range
+regexp
+match_data
+file
+dir
+

data/{lib/core → corelib}/module.rb

@@ -25,8 +25,8 @@ class Module
   def attr_reader(*attrs)
     attrs.each do |a|
       method_id = a.to_s
-      `$rb.dm(self, method_id, function(self) {
-        var iv = self['@' + method_id];
+      `$rb.dm(self, method_id, function() {
+        var iv = this[method_id];
         return iv == undefined ? nil : iv;
       });`
     end
@@ -36,8 +36,8 @@ class Module
   def attr_writer(*attrs)
     attrs.each do |a|
       method_id = a.to_s
-      `$rb.dm(self, method_id + '=', function(self, val) {
-        return self['@' + method_id] = val;
+      `$rb.dm(self, method_id + '=', function(val) {
+        return this[method_id] = val;
       });`
     end
     nil
@@ -48,6 +48,10 @@ class Module
     self
   end
 
+  def public_instance_methods(include_super = true)
+    `return self.$methods;`
+  end
+
   def instance_methods
     `return self.$methods;`
   end
@@ -56,7 +60,7 @@ class Module
     `var ary = [], parent = self;
 
     while (parent) {
-      if (parent.$flags & $rb.FL_SINGLETON) {
+      if (parent.$f & FL_SINGLETON) {
         // nothing?
       }
       else {
@@ -74,12 +78,12 @@ class Module
   end
 
   def const_set(id, value)
-    `return $rb.cs(self, #{id.to_s}, value);`
+    `return rb_const_set(self, #{id.to_s}, value);`
   end
 
   def class_eval(str = nil, &block)
     if block_given?
-      `block(self)`
+      `block.call(self)`
     else
       raise "need to compile str"
     end
@@ -90,7 +94,7 @@ class Module
   end
 
   def extend(mod)
-    `$rb.extend_module(self, mod)`
+    `rb_extend_module(self, mod)`
     nil
   end
 end

data/{lib/core → corelib}/nil_class.rb

@@ -42,11 +42,11 @@ class NilClass
   end
 
   def |(other)
-    `return other.$r ? Qtrue : Qfalse;`
+    `return other != false && other != nil;`
   end
 
   def ^(other)
-    `return other.$r ? Qtrue : Qfalse;`
+    `return other != false && other != nil;`
   end
 end
 

data/{lib/core → corelib}/numeric.rb

@@ -39,28 +39,41 @@
 # for these purposes, but it is easily done. This approach will still
 # not allow for literals to be used to make these subclass instances.
 class Numeric
-  # Unary Plus - Returns the receivers value
-  #
-  # @example
-  #
-  #     +5
-  #     # => 5
-  #
-  # @return [Numeric] receiver
-  def +@
-    `return self;`
+
+  def +(other)
+    `return self + other;`
   end
 
-  # Unary minus - returns the receiver's value, negated.
-  #
-  # @example
-  #
-  #     -5
-  #     # => -5
-  #
-  # @return [Numeric] result
-  def -@
-    `return -self;`
+  def -(other)
+    `return self - other;`
+  end
+
+  def *(other)
+    `return self * other;`
+  end
+
+  def /(other)
+    `return self / other;`
+  end
+
+  def ==(other)
+    `return self.valueOf() === other.valueOf();`
+  end
+
+  def <(other)
+    `return self < other;`
+  end
+
+  def <=(other)
+    `return self <= other;`
+  end
+
+  def >(other)
+    `return self > other;`
+  end
+
+  def >=(other)
+    `return self >= other;`
   end
 
   # Returns `self` modulo `other`. See `divmod` for more information.
@@ -83,14 +96,6 @@ class Numeric
     `return self & num2;`
   end
 
-  # Performs multiplication
-  #
-  # @param [Numeric] other number to multiply with
-  # @return [Numeric]
-  def *(other)
-    `return self * other;`
-  end
-
   # Raises `self` to the power of `other`.
   #
   # @param [Numeric] other number to raise to
@@ -99,66 +104,6 @@ class Numeric
     `return Math.pow(self, other);`
   end
 
-  # Performs addition.
-  #
-  # @param [Numeric] other number to add
-  # @return [Numeric]
-  def +(other)
-    `return self + other;`
-  end
-
-  # Performs subtraction
-  #
-  # @param [Numeric] other number to subtract
-  # @return [Numeric]
-  def -(other)
-    `return self - other;`
-  end
-
-  # Performs division
-  #
-  # @param [Numeric] other number to divide by
-  # @return [Numeric]
-  def /(other)
-    `return self / other;`
-  end
-
-  # Returns `true` if the value of `self` is less than that or `other`, `false`
-  # otherwise.
-  #
-  # @param [Numeric] other number to compare
-  # @return [true, false] result of comparison
-  def <(other)
-    `return self < other ? Qtrue : Qfalse;`
-  end
-
-  # Returns `true` if the value of `self` is less than or equal to `other`,
-  # `false` otherwise.
-  #
-  # @param [Numeric] other number to comapre
-  # @return [true, false] result of comparison
-  def <=(other)
-    `return self <= other ? Qtrue : Qfalse;`
-  end
-
-  # Returns `true` if the value of `self` is greater than `other`, `false`
-  # otherwise.
-  #
-  # @param [Numeric] other number to compare with
-  # @return [true, false] result of comparison
-  def >(other)
-    `return self > other ? Qtrue : Qfalse;`
-  end
-
-  # Returns `true` if `self` is greater than or equal to `other`, `false`
-  # otherwise.
-  #
-  # @param [Numeric] other number to compare with
-  # @return [true, false] result of comparison
-  def >=(other)
-    `return self >= other ? Qtrue : Qfalse;`
-  end
-
   # Shift `self` left by `count` positions.
   #
   # @param [Numeric] count number to shift
@@ -187,14 +132,6 @@ class Numeric
     return 0;`
   end
 
-  # Returns `true` if `self` equals `other` numerically, `false` otherwise.
-  #
-  # @param [Numeric] other number to compare
-  # @return [true, false]
-  def ==(other)
-    `return self.valueOf() === other.valueOf() ? Qtrue : Qfalse;`
-  end
-
   # Bitwise EXCLUSIVE OR.
   #
   # @param [Numeric] other number to XOR with
@@ -225,14 +162,14 @@ class Numeric
   #
   # @return [true, false]
   def even?
-    `return (self % 2 == 0) ? Qtrue : Qfalse;`
+    `return (self % 2 == 0);`
   end
 
   # Returns `true` if self is odd, `false` otherwise.
   #
   # @return [true, false]
   def odd?
-    `return (self % 2 == 0) ? Qfalse : Qtrue;`
+    `return (self % 2 == 0) ? false : true;`
   end
 
   # Returns the number equal to `self` + 1.
@@ -346,7 +283,7 @@ class Numeric
   #
   # @return [true, false]
   def zero?
-    `return self == 0 ? Qtrue : Qfalse;`
+    `return self == 0;`
   end
 
   # Returns the receiver if it is not zero, `nil` otherwise
@@ -393,7 +330,7 @@ class Numeric
   #
   # @return [true, false]
   def integer?
-    `return self % 1 == 0 ? Qtrue : Qfalse;`
+    `return self % 1 == 0;`
   end
 
   def inspect