opal 0.3.2 → 0.3.6

data/{gems/core/lib → lib}/core/basic_object.rb

@@ -4,7 +4,8 @@
 # methods are defined on it. It therefore becomes useful for such
 # applications as HashStructs.
 class BasicObject
-  def initialize
+
+  def initialize(*a)
     # ...
   end
 
@@ -17,13 +18,29 @@ class BasicObject
     self == other
   end
 
-  def __send__(method_id, *args)
-    `args.unshift(self);
-    return self.$m[#{method_id.to_s}].apply(self, args);`
+  def !()
+    self ? false : true
+  end
+
+  def !=(obj)
+    self == obj ? false : true
+  end
+
+  def __send__(method_id, *args, &block)
+    `var method = self.$m[#{method_id.to_s}];
+
+    if ($B.f == arguments.callee) {
+      $B.f = method;
+    }
+
+    args.unshift(self);
+
+    return method.apply(self, args);`
   end
 
   def instance_eval(&block)
-    `block(self)` if block_given?
+    raise ArgumentError, "block not supplied" unless block_given?
+    `block(self);`
     self
   end
 

data/lib/core/class.rb

@@ -0,0 +1,38 @@
+class Class < Module
+
+  def allocate
+    `return new $rb.RObject(self);`
+  end
+
+  def new(*args)
+    obj = allocate
+
+    `if ($B.f == arguments.callee) {
+      $B.f = obj.$m.initialize;
+    }`
+
+    obj.initialize *args
+    obj
+  end
+
+  def inherited(cls)
+    nil
+  end
+
+  def superclass
+    `var sup = self.$super;
+
+    if (!sup) {
+      if (self == $rb.BasicObject) return nil;
+      throw new Error('RuntimeError: uninitialized class');
+    }
+
+    return sup;`
+  end
+
+  def native_prototype(proto)
+    `$rb.native_prototype(self, proto);`
+    nil
+  end
+end
+

data/{gems/core/lib → lib}/core/dir.rb

@@ -3,7 +3,7 @@ class Dir
   # OPAL_FS simply points to the main opal.fs namespace. This might be the
   # default fs in the browser, or may be overriden within the opal build tools
   # when running on top of the gem runtime. Both are compatible interfaces.
-  `var OPAL_FS = VM.opal.fs;`
+  `var OPAL_FS = $rb.opal.fs;`
 
   # Returns a string that is the current working directory for this process.
   #

data/lib/core/enumerable.rb

@@ -0,0 +1,33 @@
+# The {Enumerable} module.
+module Enumerable
+
+  # Returns an array containing the items in the receiver.
+  #
+  # @example
+  #
+  #     (1..4).to_a       # => [1, 2, 3, 4]
+  #     [1, 2, 3].to_a    # => [1, 2, 3]
+  #
+  # @return [Array]
+  def to_a
+    ary = []
+    each { |arg| `ary.push(arg);` }
+    ary
+  end
+
+  alias_method :entries, :to_a
+
+  def collect(&block)
+    raise "Enumerable#collect no block given" unless block_given?
+    `var result = [];`
+
+    each do |*args|
+      `result.push(#{block.call *args});`
+    end
+
+    `return result;`
+  end
+
+  alias_method :map, :collect
+end
+

data/{gems/core/lib → lib}/core/error.rb

@@ -33,8 +33,6 @@
 # platform to platform basis.
 class Exception
 
-  # We also need to set err.$m to the right method table incase a subclass adds
-  # custom methods.. just get this from the klass: self.
   def self.allocate
     `var err = new Error();
     err.$klass = self;
@@ -44,11 +42,10 @@ class Exception
 
   def initialize(message = '')
     @message = message
-    `return self.message = self.$klass.__classid__ + ': ' + message;`
   end
 
   def message
-    @message
+    @message || `self.message`
   end
 
   def inspect

data/{gems/core/lib → lib}/core/file.rb

@@ -1,7 +1,7 @@
 
 class File
   # Use either the browser fs namespace or overriden gem interface.
-  `var OPAL_FS = VM.opal.fs;`
+  `var OPAL_FS = $rb.opal.fs;`
 
   # Converts the given `file_name` into its absolute path. The current working
   # directory is used as the reference unless the `dir_string` is given, in
@@ -10,8 +10,12 @@ class File
   # @param [String] file_name
   # @param [String] dir_string
   # @return [String]
-  def self.expand_path(file_name, dir_string)
-    `return OPAL_FS.expand_path(file_name, dir_string);`
+  def self.expand_path(file_name, dir_string = nil)
+    if dir_string
+      `return OPAL_FS.expand_path(file_name, dir_string);`
+    else
+      `return OPAL_FS.expand_path(file_name);`
+    end
   end
 
   # Returns a new string constructed by joining the given args with the default
@@ -50,5 +54,9 @@ class File
   def self.basename(file_name, suffix)
     `return OPAL_FS.basename(file_name, suffix);`
   end
+
+  def self.exist?(path)
+    `return OPAL_FS.exist_p(path) ? Qtrue : Qfalse;`
+  end
 end
 

data/{gems/core/lib → lib}/core/hash.rb

@@ -38,6 +38,18 @@
 # When `Enumerable` gets implemented, the relevant methods will be moved
 # back into that module.
 class Hash
+
+  # Creates a new hash populated with the given objects.
+  #
+  # @return [Hash]
+  def self.[](*args)
+    `return $rb.H.apply(null, args);`
+  end
+
+  def self.allocate
+    `return $rb.H();`
+  end
+
   # Returns a new array populated with the values from `self`.
   #
   # @example

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

@@ -2,87 +2,7 @@
 # lot of the core object functionality. It is not, however, included in
 # {BasicObject}.
 module Kernel
-  # Repeatedly executes the given block.
-  #
-  # @example
-  #
-  #     loop do
-  #       puts "this will infinetly repeat"
-  #     end
-  #
-  # @return [Object] returns the receiver.
-  def loop
-    `while (true) {
-      try {
-        #{yield};
-      } catch (e) {
-        switch (e.$keyword) {
-          case 2:
-            return e['@exit_value'];
-          default:
-            throw e;
-        }
-      }
-    }
-
-    return self;`
-  end
-
-  # Simple equivalent to `Proc.new`. Returns a new proc from the given block.
-  #
-  # @example
-  #
-  #     proc { puts "a" }
-  #     # => #<Proc 02002>
-  #
-  # @return [Proc]
-  def proc(&block)
-    raise ArgumentError, "block required" unless block_given?
-    block
-  end
-
-  def lambda(&block)
-    raise ArgumentError, "block required" unless block_given?
-    block
-  end
-
-  # 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
-  # instance of the given exception class with the string as a message, if it
-  # exists, or a fdefault message otherwise.
-  #
-  # @example String message
-  #
-  #     raise "some error"
-  #     # => RuntimeError: some error
-  #
-  # @example Exception subclass
-  #
-  #     raise StandardError, "something went wrong"
-  #     # => StandardError: something went wrong
-  #
-  # @param [Exception, String] exception
-  # @param [String]
-  # @return [nil]
-  def raise(exception, string = nil)
-    `var msg = nil, exc;
 
-    if (typeof exception == 'string') {
-      msg = exception;
-      exc = #{RuntimeError.new `msg`};
-    } else if (#{`exception`.kind_of? Exception}.$r) {
-      exc = exception;
-    } else {
-      if (string != nil) msg = string;
-      exc = #{`exception`.new `msg`};
-    }
-    VM.raise(exc);`
-  end
-
-  def fail(exception, string = nil)
-    raise exception, string
-  end
 
   def instance_variable_defined?(name)
     `name = #{name.to_s};
@@ -110,6 +30,11 @@ module Kernel
     false
   end
 
+  # raw object flags (used by runtime)
+  def __flags__
+    `return self.$flags;`
+  end
+
   def to_a
     [self]
   end
@@ -157,7 +82,7 @@ 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`.to_s}];
 
     if (method && !method.$rbMM) {
       return Qtrue;
@@ -170,12 +95,28 @@ module Kernel
     self == other
   end
 
-  def send(method_id, *args)
-    __send__ method_id, *args
+  def send(method_id, *args, &block)
+    `var method = self.$m[#{method_id.to_s}];
+
+    if ($B.f == arguments.callee) {
+      $B.f = method;
+    }
+
+    args.unshift(self);
+
+    return method.apply(self, args);`
   end
 
   def class
-    `return VM.class_real(self.$klass);`
+    `return $rb.class_real(self.$klass);`
+  end
+
+  def singleton_class
+    `return $rb.singleton_class(self);`
+  end
+
+  def methods
+    `return self.$klass.$methods;`
   end
 
   # Returns a random number. If max is `nil`, then the result is 0. Otherwise
@@ -211,7 +152,7 @@ module Kernel
   #
   # FIXME: proper hex output needed
   def to_s
-    "#<#{`VM.class_real(self.$klass)`}:0x#{`(self.$hash() * 400487).toString(16)`}>"
+    "#<#{`$rb.class_real(self.$klass)`}:0x#{`(self.$hash() * 400487).toString(16)`}>"
   end
 
   def inspect
@@ -219,11 +160,98 @@ module Kernel
   end
 
   def const_set(name, value)
-    `return rb_const_set(VM.class_real(self.$klass), name, value);`
+    `return rb_const_set($rb.class_real(self.$klass), name, value);`
   end
 
   def const_defined?(name)
     false
   end
+
+  def =~(obj)
+    nil
+  end
+
+  def extend(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
+  # instance of the given exception class with the string as a message, if it
+  # exists, or a fdefault message otherwise.
+  #
+  # @example String message
+  #
+  #     raise "some error"
+  #     # => RuntimeError: some error
+  #
+  # @example Exception subclass
+  #
+  #     raise StandardError, "something went wrong"
+  #     # => StandardError: something went wrong
+  #
+  # @param [Exception, String] exception
+  # @param [String]
+  # @return [nil]
+  def raise(exception, string = nil)
+    `var msg = nil, exc;
+
+    if (typeof exception == 'string') {
+      msg = exception;
+      exc = #{RuntimeError.new `msg`};
+    } else if (#{`exception`.kind_of? Exception}.$r) {
+      exc = exception;
+    } else {
+      if (string != nil) msg = string;
+      exc = #{`exception`.new `msg`};
+    }
+    $rb.raise_exc(exc);`
+  end
+
+  alias_method :fail, :raise
+
+  # Repeatedly executes the given block.
+  #
+  # @example
+  #
+  #     loop do
+  #       puts "this will infinetly repeat"
+  #     end
+  #
+  # @return [Object] returns the receiver.
+  def loop
+    `while (true) {
+      #{yield};
+    }
+
+    return self;`
+  end
+
+  # Simple equivalent to `Proc.new`. Returns a new proc from the given block.
+  #
+  # @example
+  #
+  #     proc { puts "a" }
+  #     # => #<Proc 02002>
+  #
+  # @return [Proc]
+  def proc(&block)
+    raise ArgumentError,
+      "tried to create Proc object without a block" unless block_given?
+    block
+  end
+
+  def lambda(&block)
+    raise ArgumentError,
+      "tried to create Proc object without a block" unless block_given?
+    `return $rb.lambda(block);`
+  end
+
+  # @endgroup
 end