opal 0.10.0 → 0.11.0

data/stdlib/native.rb

@@ -12,6 +12,9 @@
 #   do_later = $$[:setTimeout] # Accessing the "setTimeout" property
 #   do_later.call(->{ puts :hello}, 500)
 #
+# `$$` and `$global` wrap `Opal.global`, which the Opal JS runtime
+# sets to the global `this` object.
+#
 module Native
   def self.is_a?(object, klass)
     %x{
@@ -81,7 +84,7 @@ module Native
   def self.proc(&block)
     raise LocalJumpError, "no block given" unless block
 
-    Kernel.proc {|*args|
+    ::Kernel.proc {|*args|
       args.map! { |arg| Native(arg) }
       instance = Native(`this`)
 
@@ -189,8 +192,8 @@ module Native
   end
 
   def initialize(native)
-    unless Kernel.native?(native)
-      Kernel.raise ArgumentError, "#{native.inspect} isn't native"
+    unless ::Kernel.native?(native)
+      ::Kernel.raise ArgumentError, "#{native.inspect} isn't native"
     end
 
     @native = native
@@ -245,7 +248,7 @@ class Native::Object < BasicObject
   include ::Native
 
   def ==(other)
-    `#@native === #{Native.try_convert(other)}`
+    `#@native === #{::Native.try_convert(other)}`
   end
 
   def has_key?(name)
@@ -284,7 +287,7 @@ class Native::Object < BasicObject
   end
 
   def []=(key, value)
-    native = Native.try_convert(value)
+    native = ::Native.try_convert(value)
 
     if `#{native} === nil`
       `#@native[key] = #{value}`
@@ -295,7 +298,7 @@ class Native::Object < BasicObject
 
   def merge!(other)
     %x{
-      other = #{Native.convert(other)};
+      other = #{::Native.convert(other)};
 
       for (var prop in other) {
         #@native[prop] = other[prop];
@@ -306,7 +309,7 @@ class Native::Object < BasicObject
   end
 
   def respond_to?(name, include_all = false)
-    Kernel.instance_method(:respond_to?).bind(self).call(name, include_all)
+    ::Kernel.instance_method(:respond_to?).bind(self).call(name, include_all)
   end
 
   def respond_to_missing?(name, include_all = false)
@@ -343,7 +346,7 @@ class Native::Object < BasicObject
   end
 
   def to_a(options = {}, &block)
-    Native::Array.new(@native, options, &block).to_a
+    ::Native::Array.new(@native, options, &block).to_a
   end
 
   def inspect
@@ -526,7 +529,9 @@ class Hash
 
   def initialize(defaults = undefined, &block)
     %x{
-      if (defaults != null && defaults.constructor === Object) {
+      if (defaults != null &&
+           (defaults.constructor === undefined ||
+             defaults.constructor === Object)) {
         var smap = self.$$smap,
             keys = self.$$keys,
             key, value;
@@ -534,15 +539,19 @@ class Hash
         for (key in defaults) {
           value = defaults[key];
 
-          if (value && value.constructor === Object) {
+          if (value &&
+               (value.constructor === undefined ||
+                 value.constructor === Object)) {
             smap[key] = #{Hash.new(`value`)};
           } else if (value && value.$$is_array) {
             value = value.map(function(item) {
-              if (item && item.constructor === Object) {
+              if (item &&
+                   (item.constructor === undefined ||
+                     item.constructor === Object)) {
                 return #{Hash.new(`item`)};
               }
 
-              return item;
+              return #{Native(`item`)};
             });
             smap[key] = value
           } else {

data/stdlib/nodejs/dir.rb

@@ -21,7 +21,7 @@ class Dir
       %x{
         var result = [];
         var entries = __fs__.readdirSync(#{dirname});
-        for (var i = 0; i < entries.length; i++) {
+        for (var i = 0, ii = entries.length; i < ii; i++) {
           result.push(entries[i]);
         }
         return result;

data/stdlib/nodejs/file.rb

@@ -1,5 +1,12 @@
 %x{
-  var warnings = {};
+  var warnings = {}, errno_code, errno_codes = [
+    'EACCES',
+    'EISDIR',
+    'EMFILE',
+    'ENOENT',
+    'EPERM'
+  ];
+
   function handle_unsupported_feature(message) {
     switch (Opal.config.unsupported_features_severity) {
     case 'error':
@@ -19,6 +26,24 @@
     warnings[string] = true;
     #{warn(`string`)};
   }
+  function executeIOAction(action) {
+    try {
+      return action();
+    } catch (error) {
+      if (errno_codes.indexOf(error.code) >= 0) {
+        var error_class = #{Errno.const_get(`error.code`)}
+        throw #{`error_class`.new(`error.message`)};
+      }
+      throw error;
+    }
+  }
+
+  for(var i = 0, ii = errno_codes.length; i < ii; i++) {
+    errno_code = errno_codes[i];
+    if (!#{Errno.const_defined?(`errno_code`)}) {
+      #{Errno.const_set(`errno_code`, Class.new(SystemCallError))}
+    }
+  }
 }
 
 class File < IO
@@ -30,18 +55,22 @@ class File < IO
   `var __fs__ = #{@__fs__}`
   `var __path__ = #{@__path__}`
 
+  if `__path__.sep !== #{Separator}`
+    ALT_SEPARATOR = `__path__.sep`
+  end
+
   def self.read path
-    `__fs__.readFileSync(#{path}).toString()`
+    `return executeIOAction(function(){return __fs__.readFileSync(#{path}).toString()})`
   end
 
   def self.write path, data
-    `__fs__.writeFileSync(#{path}, #{data})`
+    `executeIOAction(function(){return __fs__.writeFileSync(#{path}, #{data})})`
     data.size
   end
 
   def self.exist? path
     path = path.path if path.respond_to? :path
-    `__fs__.existsSync(#{path})`
+    `return executeIOAction(function(){return __fs__.existsSync(#{path})})`
   end
 
   def self.realpath(pathname, dir_string = nil, cache = nil, &block)
@@ -49,12 +78,12 @@ class File < IO
     if block_given?
       `
       __fs__.realpath(#{pathname}, #{cache}, function(error, realpath){
-        if (error) #{raise error.message}
+        if (error) Opal.IOError.$new(error.message)
         else #{block.call(`realpath`)}
       })
       `
     else
-      `__fs__.realpathSync(#{pathname}, #{cache})`
+      `return executeIOAction(function(){return __fs__.realpathSync(#{pathname}, #{cache})})`
     end
   end
 
@@ -63,22 +92,47 @@ class File < IO
   end
 
   def self.directory? path
-    return nil unless exist? path
-    `!!__fs__.lstatSync(path).isDirectory()`
+    return false unless exist? path
+    result = `executeIOAction(function(){return !!__fs__.lstatSync(path).isDirectory()})`
+    unless result
+      realpath = realpath(path)
+      if realpath != path
+        result = `executeIOAction(function(){return !!__fs__.lstatSync(realpath).isDirectory()})`
+      end
+    end
+    result
   end
 
   def self.file? path
-    return nil unless exist? path
-    `!!__fs__.lstatSync(path).isFile()`
+    return false unless exist? path
+    result = `executeIOAction(function(){return !!__fs__.lstatSync(path).isFile()})`
+    unless result
+      realpath = realpath(path)
+      if realpath != path
+        result = `executeIOAction(function(){return !!__fs__.lstatSync(realpath).isFile()})`
+      end
+    end
+    result
+  end
+
+  def self.readable? path
+    return false unless exist? path
+    %{
+      try {
+        __fs__.accessSync(path, __fs__.R_OK);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    }
   end
 
   def self.size path
-    return nil unless exist? path
-    `__fs__.lstatSync(path).size`
+    `return executeIOAction(function(){return __fs__.lstatSync(path).size})`
   end
 
-  def self.open path, flags
-    file = new(path, flags)
+  def self.open(path, mode = 'r')
+    file = new(path, mode)
     if block_given?
       begin
         yield(file)
@@ -96,12 +150,12 @@ class File < IO
   end
 
   def self.mtime path
-    `__fs__.statSync(#{path}).mtime`
+    `return executeIOAction(function(){return __fs__.statSync(#{path}).mtime})`
   end
 
   # Instance Methods
 
-  def initialize(path, flags)
+  def initialize(path, flags = 'r')
     binary_flag_regexp = /b/
     encoding_flag_regexp = /:(.*)/
     # binary flag is unsupported
@@ -112,25 +166,25 @@ class File < IO
     flags = flags.gsub(encoding_flag_regexp, '')
     @path = path
     @flags = flags
-    @fd = `__fs__.openSync(path, flags)`
+    @fd = `executeIOAction(function(){return __fs__.openSync(path, flags)})`
   end
 
   attr_reader :path
 
   def write string
-    `__fs__.writeSync(#{@fd}, #{string})`
+    `executeIOAction(function(){return __fs__.writeSync(#{@fd}, #{string})})`
   end
 
   def flush
-    `__fs__.fsyncSync(#@fd)`
+    `executeIOAction(function(){return __fs__.fsyncSync(#@fd)})`
   end
 
   def close
-    `__fs__.closeSync(#{@fd})`
+    `executeIOAction(function(){return __fs__.closeSync(#{@fd})})`
   end
 
   def mtime
-    `__fs__.statSync(#{@path}).mtime`
+    `return executeIOAction(function(){return __fs__.statSync(#{@path}).mtime})`
   end
 end
 
@@ -144,10 +198,10 @@ class File::Stat
   end
 
   def file?
-    `__fs__.statSync(#{@path}).isFile()`
+    `return executeIOAction(function(){return __fs__.statSync(#{@path}).isFile()})`
   end
 
   def mtime
-    `__fs__.statSync(#{@path}).mtime`
+    `return executeIOAction(function(){return __fs__.statSync(#{@path}).mtime})`
   end
 end

data/stdlib/nodejs/io.rb

@@ -1,3 +1,20 @@
+%x{
+  function executeIOAction(action) {
+    try {
+      return action();
+    } catch (error) {
+      if (error.code === 'EACCES' ||
+          error.code === 'EISDIR' ||
+          error.code === 'EMFILE' ||
+          error.code === 'ENOENT' ||
+          error.code === 'EPERM') {
+        throw Opal.IOError.$new(error.message)
+      }
+      throw error;
+    }
+  }
+}
+
 class IO
 
   @__fs__ = node_require :fs
@@ -10,12 +27,20 @@ class IO
     @eof = false
     @lineno = 0
   end
+  
+  def self.write(path, data)
+    File.write(path, data)
+  end
+
+  def self.read(path)
+    File.read(path)
+  end
 
   def read
     if @eof
       ''
     else
-      res = `__fs__.readFileSync(#{@path}).toString()`
+      res = `executeIOAction(function(){return __fs__.readFileSync(#{@path}).toString()})`
       @eof = true
       @lineno = res.size
       res
@@ -51,6 +76,10 @@ class IO
       read.each_line
     end
   end
+
+  def self.binread(path)
+    `return executeIOAction(function(){return __fs__.readFileSync(#{path}).toString('binary')})`
+  end
 end
 
 STDOUT.write_proc = -> (string) {`process.stdout.write(string)`}