webruby 0.2.2 → 0.2.4

data/modules/emscripten/src/library_glfw.js

@@ -120,7 +120,6 @@ var LibraryGLFW = {
       if (event.charCode) {
         var char = GLFW.getUnicodeChar(event.charCode);
         if (char !== null && GLFW.charFunc) {
-          event.preventDefault();
           Runtime.dynCall('vii', GLFW.charFunc, [event.charCode, 1]);
         }
       }
@@ -130,13 +129,18 @@ var LibraryGLFW = {
       var key = GLFW.DOMToGLFWKeyCode(event.keyCode);
       if (key && GLFW.keyFunc) {
         GLFW.keys[key] = status;
-        event.preventDefault();
         Runtime.dynCall('vii', GLFW.keyFunc, [key, status]);
       }
     },
 
     onKeydown: function(event) {
       GLFW.onKeyChanged(event, 1);//GLFW_PRESS
+      // This logic comes directly from the sdl implementation. We cannot
+      // call preventDefault on all keydown events otherwise onKeyPress will
+      // not get called
+      if (event.keyCode === 8 /* backspace */ || event.keyCode === 9 /* tab */) {
+        event.preventDefault();
+      }
     },
 
     onKeyup: function(event) {
@@ -355,7 +359,9 @@ var LibraryGLFW = {
     }
 
     var contextAttributes = {
-      antialias: (GLFW.params[0x00020013] > 1) //GLFW_FSAA_SAMPLES
+      antialias: (GLFW.params[0x00020013] > 1), //GLFW_FSAA_SAMPLES
+      depth: (GLFW.params[0x00020009] > 0), //GLFW_DEPTH_BITS
+      stencil: (GLFW.params[0x0002000A] > 0) //GLFW_STENCIL_BITS
     }
     Module.ctx = Browser.createContext(Module['canvas'], true, true, contextAttributes);
     return 1; //GL_TRUE

data/modules/emscripten/src/library_glut.js

@@ -59,6 +59,9 @@ var LibraryGLUT = {
     getSpecialKey: function(keycode) {
         var key = null;
         switch (keycode) {
+          case 8:  key = 120 /* backspace */; break;
+          case 46: key = 111 /* delete */; break;
+
           case 0x70 /*DOM_VK_F1*/: key = 1 /* GLUT_KEY_F1 */; break;
           case 0x71 /*DOM_VK_F2*/: key = 2 /* GLUT_KEY_F2 */; break;
           case 0x72 /*DOM_VK_F3*/: key = 3 /* GLUT_KEY_F3 */; break;
@@ -228,14 +231,14 @@ var LibraryGLUT = {
       if (delta < 0) {
         button = 4; // wheel down
       }
-      
+
       if (GLUT.mouseFunc) {
         event.preventDefault();
         GLUT.saveModifiers(event);
         Runtime.dynCall('viiii', GLUT.mouseFunc, [button, 0/*GLUT_DOWN*/, Browser.mouseX, Browser.mouseY]);
       }
     },
-    
+
     // TODO add fullscreen API ala:
     // http://johndyer.name/native-fullscreen-javascript-api-plus-jquery-plugin/
     onFullScreenEventChange: function(event) {
@@ -304,7 +307,7 @@ var LibraryGLUT = {
       // Firefox
       window.addEventListener("DOMMouseScroll", GLUT.onMouseWheel, true);
     }
-    
+
     Browser.resizeListeners.push(function(width, height) {
       if (GLUT.reshapeFunc) {
       	Runtime.dynCall('vii', GLUT.reshapeFunc, [width, height]);
@@ -372,7 +375,7 @@ var LibraryGLUT = {
   },
 
   glutIdleFunc: function(func) {
-    var callback = function() {
+    function callback() {
       if (GLUT.idleFunc) {
         Runtime.dynCall('v', GLUT.idleFunc);
         Browser.safeSetTimeout(callback, 0);
@@ -427,7 +430,9 @@ var LibraryGLUT = {
   glutCreateWindow__deps: ['$Browser'],
   glutCreateWindow: function(name) {
     var contextAttributes = {
-      antialias: ((GLUT.initDisplayMode & 0x0080 /*GLUT_MULTISAMPLE*/) != 0)
+      antialias: ((GLUT.initDisplayMode & 0x0080 /*GLUT_MULTISAMPLE*/) != 0),
+      depth: ((GLUT.initDisplayMode & 0x0010 /*GLUT_DEPTH*/) != 0),
+      stencil: ((GLUT.initDisplayMode & 0x0020 /*GLUT_STENCIL*/) != 0)
     };
     Module.ctx = Browser.createContext(Module['canvas'], true, true, contextAttributes);
     return Module.ctx ? 1 /* a new GLUT window ID for the created context */ : 0 /* failure */;

data/modules/emscripten/src/library_idbfs.js

@@ -58,7 +58,7 @@ mergeInto(LibraryManager.library, {
       }
 
       var completed = 0;
-      var done = function(err) {
+      function done(err) {
         if (err) return callback(err);
         if (++completed >= total) {
           return callback(null);
@@ -68,7 +68,7 @@ mergeInto(LibraryManager.library, {
       // create a single transaction to handle and IDB reads / writes we'll need to do
       var db = src.type === 'remote' ? src.db : dst.db;
       var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
-      transaction.onerror = function() { callback(this.error); };
+      transaction.onerror = function transaction_onerror() { callback(this.error); };
       var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
 
       for (var path in create) {
@@ -92,8 +92,8 @@ mergeInto(LibraryManager.library, {
         } else {
           // save file to IDB
           var req = store.put(entry, path);
-          req.onsuccess = function() { done(null); };
-          req.onerror = function() { done(this.error); };
+          req.onsuccess = function req_onsuccess() { done(null); };
+          req.onerror = function req_onerror() { done(this.error); };
         }
       }
 
@@ -117,20 +117,20 @@ mergeInto(LibraryManager.library, {
         } else {
           // delete file from IDB
           var req = store.delete(path);
-          req.onsuccess = function() { done(null); };
-          req.onerror = function() { done(this.error); };
+          req.onsuccess = function req_onsuccess() { done(null); };
+          req.onerror = function req_onerror() { done(this.error); };
         }
       }
     },
     getLocalSet: function(mount, callback) {
       var files = {};
 
-      var isRealDir = function(p) {
+      function isRealDir(p) {
         return p !== '.' && p !== '..';
       };
-      var toAbsolute = function(root) {
+      function toAbsolute(root) {
         return function(p) {
-          return PATH.join(root, p);
+          return PATH.join2(root, p);
         }
       };
 
@@ -177,17 +177,17 @@ mergeInto(LibraryManager.library, {
       } catch (e) {
         return onerror(e);
       }
-      req.onupgradeneeded = function() {
+      req.onupgradeneeded = function req_onupgradeneeded() {
         db = req.result;
         db.createObjectStore(IDBFS.DB_STORE_NAME);
       };
-      req.onsuccess = function() {
+      req.onsuccess = function req_onsuccess() {
         db = req.result;
         // add to the cache
         IDBFS.dbs[name] = db;
         callback(null, db);
       };
-      req.onerror = function() {
+      req.onerror = function req_onerror() {
         callback(this.error);
       };
     },
@@ -198,10 +198,10 @@ mergeInto(LibraryManager.library, {
         if (err) return callback(err);
 
         var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
-        transaction.onerror = function() { callback(this.error); };
+        transaction.onerror = function transaction_onerror() { callback(this.error); };
 
         var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
-        store.openCursor().onsuccess = function(event) {
+        store.openCursor().onsuccess = function store_openCursor_onsuccess(event) {
           var cursor = event.target.result;
           if (!cursor) {
             return callback(null, { type: 'remote', db: db, files: files });

data/modules/emscripten/src/library_memfs.js

@@ -1,6 +1,8 @@
 mergeInto(LibraryManager.library, {
   $MEMFS__deps: ['$FS'],
   $MEMFS: {
+    ops_table: null,
+
     // content modes
     CONTENT_OWNING: 1, // contains a subarray into the heap, and we own it, without copying (note: someone else needs to free() it, if that is necessary)
     CONTENT_FLEXIBLE: 2, // has been modified or never set to anything, and is a flexible js array that can grow/shrink
@@ -13,51 +15,71 @@ mergeInto(LibraryManager.library, {
         // no supported
         throw new FS.ErrnoError(ERRNO_CODES.EPERM);
       }
+      if (!MEMFS.ops_table) {
+        MEMFS.ops_table = {
+          dir: {
+            node: {
+              getattr: MEMFS.node_ops.getattr,
+              setattr: MEMFS.node_ops.setattr,
+              lookup: MEMFS.node_ops.lookup,
+              mknod: MEMFS.node_ops.mknod,
+              mknod: MEMFS.node_ops.mknod,
+              rename: MEMFS.node_ops.rename,
+              unlink: MEMFS.node_ops.unlink,
+              rmdir: MEMFS.node_ops.rmdir,
+              readdir: MEMFS.node_ops.readdir,
+              symlink: MEMFS.node_ops.symlink
+            },
+            stream: {
+              llseek: MEMFS.stream_ops.llseek
+            }
+          },
+          file: {
+            node: {
+              getattr: MEMFS.node_ops.getattr,
+              setattr: MEMFS.node_ops.setattr
+            },
+            stream: {
+              llseek: MEMFS.stream_ops.llseek,
+              read: MEMFS.stream_ops.read,
+              write: MEMFS.stream_ops.write,
+              allocate: MEMFS.stream_ops.allocate,
+              mmap: MEMFS.stream_ops.mmap
+            }
+          },
+          link: {
+            node: {
+              getattr: MEMFS.node_ops.getattr,
+              setattr: MEMFS.node_ops.setattr,
+              readlink: MEMFS.node_ops.readlink
+            },
+            stream: {}
+          },
+          chrdev: {
+            node: {
+              getattr: MEMFS.node_ops.getattr,
+              setattr: MEMFS.node_ops.setattr
+            },
+            stream: FS.chrdev_stream_ops
+          },
+        };
+      }
       var node = FS.createNode(parent, name, mode, dev);
       if (FS.isDir(node.mode)) {
-        node.node_ops = {
-          getattr: MEMFS.node_ops.getattr,
-          setattr: MEMFS.node_ops.setattr,
-          lookup: MEMFS.node_ops.lookup,
-          mknod: MEMFS.node_ops.mknod,
-          mknod: MEMFS.node_ops.mknod,
-          rename: MEMFS.node_ops.rename,
-          unlink: MEMFS.node_ops.unlink,
-          rmdir: MEMFS.node_ops.rmdir,
-          readdir: MEMFS.node_ops.readdir,
-          symlink: MEMFS.node_ops.symlink
-        };
-        node.stream_ops = {
-          llseek: MEMFS.stream_ops.llseek
-        };
+        node.node_ops = MEMFS.ops_table.dir.node;
+        node.stream_ops = MEMFS.ops_table.dir.stream;
         node.contents = {};
       } else if (FS.isFile(node.mode)) {
-        node.node_ops = {
-          getattr: MEMFS.node_ops.getattr,
-          setattr: MEMFS.node_ops.setattr
-        };
-        node.stream_ops = {
-          llseek: MEMFS.stream_ops.llseek,
-          read: MEMFS.stream_ops.read,
-          write: MEMFS.stream_ops.write,
-          allocate: MEMFS.stream_ops.allocate,
-          mmap: MEMFS.stream_ops.mmap
-        };
+        node.node_ops = MEMFS.ops_table.file.node;
+        node.stream_ops = MEMFS.ops_table.file.stream;
         node.contents = [];
         node.contentMode = MEMFS.CONTENT_FLEXIBLE;
       } else if (FS.isLink(node.mode)) {
-        node.node_ops = {
-          getattr: MEMFS.node_ops.getattr,
-          setattr: MEMFS.node_ops.setattr,
-          readlink: MEMFS.node_ops.readlink
-        };
-        node.stream_ops = {};
+        node.node_ops = MEMFS.ops_table.link.node;
+        node.stream_ops = MEMFS.ops_table.link.stream;
       } else if (FS.isChrdev(node.mode)) {
-        node.node_ops = {
-          getattr: MEMFS.node_ops.getattr,
-          setattr: MEMFS.node_ops.setattr
-        };
-        node.stream_ops = FS.chrdev_stream_ops;
+        node.node_ops = MEMFS.ops_table.chrdev.node;
+        node.stream_ops = MEMFS.ops_table.chrdev.stream;
       }
       node.timestamp = Date.now();
       // add the new node to the parent
@@ -117,7 +139,7 @@ mergeInto(LibraryManager.library, {
         }
       },
       lookup: function(parent, name) {
-        throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+        throw FS.genericErrors[ERRNO_CODES.ENOENT];
       },
       mknod: function(parent, name, mode, dev) {
         return MEMFS.createNode(parent, name, mode, dev);
@@ -200,10 +222,12 @@ mergeInto(LibraryManager.library, {
 #if USE_TYPED_ARRAYS == 2
         if (length && contents.length === 0 && position === 0 && buffer.subarray) {
           // just replace it with the new data
+#if ASSERTIONS
           assert(buffer.length);
-          if (canOwn && buffer.buffer === HEAP8.buffer && offset === 0) {
-            node.contents = buffer; // this is a subarray of the heap, and we can own it
-            node.contentMode = MEMFS.CONTENT_OWNING;
+#endif
+          if (canOwn && offset === 0) {
+            node.contents = buffer; // this could be a subarray of Emscripten HEAP, or allocated from some other source.
+            node.contentMode = (buffer.buffer === HEAP8.buffer) ? MEMFS.CONTENT_OWNING : MEMFS.CONTENT_FIXED;
           } else {
             node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
             node.contentMode = MEMFS.CONTENT_FIXED;

data/modules/emscripten/src/library_nodefs.js

@@ -1,7 +1,11 @@
 mergeInto(LibraryManager.library, {
   $NODEFS__deps: ['$FS', '$PATH'],
-  $NODEFS__postset: 'if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); }',
+  $NODEFS__postset: 'if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }',
   $NODEFS: {
+    isWindows: false,
+    staticInit: function() {
+      NODEFS.isWindows = !!process.platform.match(/^win/);
+    },
     mount: function (mount) {
       assert(ENVIRONMENT_IS_NODE);
       return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0);
@@ -19,6 +23,11 @@ mergeInto(LibraryManager.library, {
       var stat;
       try {
         stat = fs.lstatSync(path);
+        if (NODEFS.isWindows) {
+          // On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so 
+          // propagate write bits to execute bits.
+          stat.mode = stat.mode | ((stat.mode & 146) >> 1);
+        }
       } catch (e) {
         if (!e.code) throw e;
         throw new FS.ErrnoError(ERRNO_CODES[e.code]);
@@ -35,6 +44,41 @@ mergeInto(LibraryManager.library, {
       parts.reverse();
       return PATH.join.apply(null, parts);
     },
+    // This maps the integer permission modes from http://linux.die.net/man/3/open
+    // to node.js-specific file open permission strings at http://nodejs.org/api/fs.html#fs_fs_open_path_flags_mode_callback
+    flagsToPermissionStringMap: {
+      0/*O_RDONLY*/: 'r',
+      1/*O_WRONLY*/: 'r+',
+      2/*O_RDWR*/: 'r+',
+      64/*O_CREAT*/: 'r',
+      65/*O_WRONLY|O_CREAT*/: 'r+',
+      66/*O_RDWR|O_CREAT*/: 'r+',
+      129/*O_WRONLY|O_EXCL*/: 'rx+',
+      193/*O_WRONLY|O_CREAT|O_EXCL*/: 'rx+',
+      514/*O_RDWR|O_TRUNC*/: 'w+',
+      577/*O_WRONLY|O_CREAT|O_TRUNC*/: 'w',
+      578/*O_CREAT|O_RDWR|O_TRUNC*/: 'w+',
+      705/*O_WRONLY|O_CREAT|O_EXCL|O_TRUNC*/: 'wx',
+      706/*O_RDWR|O_CREAT|O_EXCL|O_TRUNC*/: 'wx+',
+      1024/*O_APPEND*/: 'a',
+      1025/*O_WRONLY|O_APPEND*/: 'a',
+      1026/*O_RDWR|O_APPEND*/: 'a+',
+      1089/*O_WRONLY|O_CREAT|O_APPEND*/: 'a',
+      1090/*O_RDWR|O_CREAT|O_APPEND*/: 'a+',
+      1153/*O_WRONLY|O_EXCL|O_APPEND*/: 'ax',
+      1154/*O_RDWR|O_EXCL|O_APPEND*/: 'ax+',
+      1217/*O_WRONLY|O_CREAT|O_EXCL|O_APPEND*/: 'ax',
+      1218/*O_RDWR|O_CREAT|O_EXCL|O_APPEND*/: 'ax+',
+      4096/*O_RDONLY|O_DSYNC*/: 'rs',
+      4098/*O_RDWR|O_DSYNC*/: 'rs+'
+    },
+    flagsToPermissionString: function(flags) {
+      if (flags in NODEFS.flagsToPermissionStringMap) {
+        return NODEFS.flagsToPermissionStringMap[flags];
+      } else {
+        return flags;
+      }
+    },
     node_ops: {
       getattr: function(node) {
         var path = NODEFS.realPath(node);
@@ -45,6 +89,14 @@ mergeInto(LibraryManager.library, {
           if (!e.code) throw e;
           throw new FS.ErrnoError(ERRNO_CODES[e.code]);
         }
+        // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096.
+        // See http://support.microsoft.com/kb/140365
+        if (NODEFS.isWindows && !stat.blksize) {
+          stat.blksize = 4096;
+        }
+        if (NODEFS.isWindows && !stat.blocks) {
+          stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0;
+        }
         return {
           dev: stat.dev,
           ino: stat.ino,
@@ -82,7 +134,7 @@ mergeInto(LibraryManager.library, {
         }
       },
       lookup: function (parent, name) {
-        var path = PATH.join(NODEFS.realPath(parent), name);
+        var path = PATH.join2(NODEFS.realPath(parent), name);
         var mode = NODEFS.getMode(path);
         return NODEFS.createNode(parent, name, mode);
       },
@@ -104,7 +156,7 @@ mergeInto(LibraryManager.library, {
       },
       rename: function (oldNode, newDir, newName) {
         var oldPath = NODEFS.realPath(oldNode);
-        var newPath = PATH.join(NODEFS.realPath(newDir), newName);
+        var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
         try {
           fs.renameSync(oldPath, newPath);
         } catch (e) {
@@ -113,7 +165,7 @@ mergeInto(LibraryManager.library, {
         }
       },
       unlink: function(parent, name) {
-        var path = PATH.join(NODEFS.realPath(parent), name);
+        var path = PATH.join2(NODEFS.realPath(parent), name);
         try {
           fs.unlinkSync(path);
         } catch (e) {
@@ -122,7 +174,7 @@ mergeInto(LibraryManager.library, {
         }
       },
       rmdir: function(parent, name) {
-        var path = PATH.join(NODEFS.realPath(parent), name);
+        var path = PATH.join2(NODEFS.realPath(parent), name);
         try {
           fs.rmdirSync(path);
         } catch (e) {
@@ -140,7 +192,7 @@ mergeInto(LibraryManager.library, {
         }
       },
       symlink: function(parent, newName, oldPath) {
-        var newPath = PATH.join(NODEFS.realPath(parent), newName);
+        var newPath = PATH.join2(NODEFS.realPath(parent), newName);
         try {
           fs.symlinkSync(oldPath, newPath);
         } catch (e) {
@@ -163,7 +215,7 @@ mergeInto(LibraryManager.library, {
         var path = NODEFS.realPath(stream.node);
         try {
           if (FS.isFile(stream.node.mode)) {
-            stream.nfd = fs.openSync(path, stream.flags);
+            stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags));
           }
         } catch (e) {
           if (!e.code) throw e;
@@ -172,7 +224,7 @@ mergeInto(LibraryManager.library, {
       },
       close: function (stream) {
         try {
-          if (FS.isFile(stream.node.mode)) {
+          if (FS.isFile(stream.node.mode) && stream.nfd) {
             fs.closeSync(stream.nfd);
           }
         } catch (e) {
@@ -231,4 +283,4 @@ mergeInto(LibraryManager.library, {
       }
     }
   }
-});
+});

data/modules/emscripten/src/library_openal.js

@@ -8,13 +8,13 @@ var LibraryOpenAL = {
     QUEUE_INTERVAL: 25,
     QUEUE_LOOKAHEAD: 100,
 
-    updateSources: function(context) {
+    updateSources: function updateSources(context) {
       for (var i = 0; i < context.src.length; i++) {
         AL.updateSource(context.src[i]);
       }
     },
 
-    updateSource: function(src) {
+    updateSource: function updateSource(src) {
 #if OPENAL_DEBUG
       var idx = AL.currentContext.src.indexOf(src);
 #endif
@@ -65,7 +65,7 @@ var LibraryOpenAL = {
       }
     },
 
-    setSourceState: function(src, state) {
+    setSourceState: function setSourceState(src, state) {
 #if OPENAL_DEBUG
       var idx = AL.currentContext.src.indexOf(src);
 #endif
@@ -119,7 +119,7 @@ var LibraryOpenAL = {
       }
     },
 
-    stopSourceQueue: function(src) {
+    stopSourceQueue: function stopSourceQueue(src) {
       for (var i = 0; i < src.queue.length; i++) {
         var entry = src.queue[i];
         if (entry.src) {

data/modules/emscripten/src/library_path.js

@@ -59,26 +59,22 @@ mergeInto(LibraryManager.library, {
       }
       return root + dir;
     },
-    basename: function(path, ext) {
+    basename: function(path) {
       // EMSCRIPTEN return '/'' for '/', not an empty string
       if (path === '/') return '/';
-      var f = PATH.splitPath(path)[2];
-      if (ext && f.substr(-1 * ext.length) === ext) {
-        f = f.substr(0, f.length - ext.length);
-      }
-      return f;
+      var lastSlash = path.lastIndexOf('/');
+      if (lastSlash === -1) return path;
+      return path.substr(lastSlash+1);
     },
     extname: function(path) {
       return PATH.splitPath(path)[3];
     },
     join: function() {
       var paths = Array.prototype.slice.call(arguments, 0);
-      return PATH.normalize(paths.filter(function(p, index) {
-        if (typeof p !== 'string') {
-          throw new TypeError('Arguments to path.join must be strings');
-        }
-        return p;
-      }).join('/'));
+      return PATH.normalize(paths.join('/'));
+    },
+    join2: function(l, r) {
+      return PATH.normalize(l + '/' + r);
     },
     resolve: function() {
       var resolvedPath = '',
@@ -134,4 +130,4 @@ mergeInto(LibraryManager.library, {
       return outputParts.join('/');
     }
   }
-});
+});