spade 0.0.6 → 0.0.7

data/.gitignore

@@ -12,3 +12,4 @@ packages/sproutcore-runtime/tests/ct-runner.js
 *.swp
 .DS_Store
 *.spd
+node_modules

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    spade (0.0.5)
+    spade (0.0.7)
+      childlabor (~> 0.0.3)
       eventmachine (~> 0.12.10)
       gemcutter (~> 0.6.1)
       highline (~> 1.6.1)
@@ -13,6 +14,7 @@ PATH
 GEM
   remote: http://rubygems.org/
   specs:
+    childlabor (0.0.3)
     diff-lcs (1.1.2)
     eventmachine (0.12.10)
     gemcutter (0.6.1)
@@ -27,11 +29,10 @@ GEM
     rspec-expectations (2.5.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.5.0)
-    therubyracer (0.8.0)
+    therubyracer (0.8.1)
     thor (0.14.6)
 
 PLATFORMS
-  java
   ruby
 
 DEPENDENCIES

data/examples/todos/lib/main.js

@@ -1,9 +1,10 @@
 require('sproutcore-corefoundation');
 
 // Remove loading text
-jQuery(document).ready(function() {
-  $(document.body).html('');
-});
+$(document.body).html('');
+
+// Trigger onReady handler
+SC.onReady.done();
 
 require('./todos');
 require('./~resources/templates/todos');

data/lib/node/loader.js

@@ -7,7 +7,8 @@
 
 var PATH = require('path'),
     SYS  = require('sys'),
-    FS   = require('fs');
+    FS   = require('fs'),
+    SPADE_DIR = '.spade'; // Would be nice if we could share Spade::SPADE_DIR
     
 exports.Loader = function() {
   this.root = process.cwd();
@@ -70,18 +71,19 @@ Lp.packages = function() {
   if (this._packages) return this._packages;
   var packages = {};
   this._packages = packages;
-  
-  // add global packages in spade project
-  var globals = PATH.normalize(PATH.join(__filename, '..', '..', '..', 'packages'));
-  if (PATH.existsSync(globals) && FS.statSync(globals).isDirectory()) {
-    FS.readdirSync(globals).forEach(function(name) {
-      addPackage(packages, globals, name);
+
+  // add spade install dir
+  var spadeDir = PATH.join(process.env.HOME, SPADE_DIR, 'gems');
+  if (PATH.existsSync(spadeDir) && FS.statSync(spadeDir).isDirectory()) {
+    FS.readdirSync(spadeDir).forEach(function(name){
+      addPackage(packages, spadeDir, name);
     });
   }
-  
+
+  // Add other dirs in reverse order of precedence
   var dirs = ['.spade/packages', 'node_modules', '.node_modules', 'vendor/cache', 'vendor/packages', 'packages'];
   var rootdir = PATH.normalize(this.root);
-  
+
   dirs.forEach(function(dirname) {
     dirname = dirname.split('/');
     dirname.unshift(rootdir);
@@ -98,7 +100,6 @@ Lp.packages = function() {
   return packages;
 };
 
-// FIXME: This should check to see if the package is already loaded before loading again
 Lp.loadFactory = function(spade, id, formats, done) {
   if (!formats) { formats = []; }
   if (formats.length === 0) { formats.push('js'); }

data/lib/node/sandbox.js

@@ -31,4 +31,14 @@ Sandbox.prototype.compile = function(code, filename) {
   return VM.runInContext(code, this.ctx, filename || '(unknown)');
 };
 
+Sandbox.prototype.globals = function() {
+  var output = {};
+  for (var name in this.ctx){
+    if (this.ctx.hasOwnProperty(name)) {
+      output[name] = this.ctx[name];
+    }
+  }
+  return output;
+};
+
 exports.Sandbox = Sandbox;

data/lib/spade.js

@@ -11,22 +11,22 @@
 Spade 2.0 CommonJS Runtime
 copyright 2010 Strobe Inc.
 
-Permission is hereby granted, free of charge, to any person obtaining a 
-copy of this software and associated documentation files (the "Software"), 
-to deal in the Software without restriction, including without limitation 
-the rights to use, copy, modify, merge, publish, distribute, sublicense, 
-and/or sell copies of the Software, and to permit persons to whom the 
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
 Software is furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in 
+The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 
 Spade is part of the SproutCore project.
@@ -41,31 +41,31 @@ For more information visit http://www.sproutcore.com/spade
 // Make this work when loaded from browser or from node.js
 var spade ;
 (function() {
-  
-  var Spade, Tp, Sandbox, Sp, 
+
+  var Spade, Tp, Sandbox, Sp,
       Loader, Lp, K, Compiler, Cp;
-  
+
   // defining these types here will allow the minifier the compact them
   if ('undefined' !== typeof spade) return ; // nothing to do
-  
+
   K = function() {}; // noop
 
   // assume id is already normalized
   function packageIdFor(normalizedId) {
     return normalizedId.slice(0, normalizedId.indexOf('/'));
   }
-  
+
   function remap(id, contextPkg) {
     var mappings = contextPkg ? contextPkg.mappings : null;
     if (!mappings) return id;
-    
+
     var packageId = packageIdFor(id);
     if (mappings[packageId]) {
       id = mappings[packageId] + id.slice(id.indexOf('/'));
     }
     return id;
   }
-  
+
   function normalize(id, contextId, contextPkg, _asPackage) {
     // slice separator off the end since it is not used...
     if (id[id.length-1]==='/') id = id.slice(0,-1);
@@ -104,7 +104,7 @@ var spade ;
 
     // else, just slice off beginning '/' if needed
     } else if (id[0]==='/') id = id.slice(1);
-    
+
     // if we end up with no separators, make this a pkg
     if (id.indexOf('/')<0) id = id+(_asPackage ? '/~package' : '/main');
     // may need to walk if there is a separator...
@@ -122,9 +122,25 @@ var spade ;
     return remap(id, contextPkg);
   }
 
+  function parseIdFormats(id, formats) {
+    // Handle requires with extension
+    var formatRE = new RegExp("^(.+)\\.("+formats.join('|')+")$"), match, format;
+    if (id.substring(0,5) !== "file:" && (match = id.match(formatRE))) {
+      id = match[1];
+      format = match[2];
+      formats = [format];
+    }
+
+    return {
+      id: id,
+      format: format,
+      formats: formats
+    };
+  }
+
   // ..........................................................
   // PLATFORM
-  // 
+  //
   // Detect important platform properties.  Mostly for determining code
   // that can't run one way or the other.
   var SPADE_PLATFORM;
@@ -133,50 +149,51 @@ var spade ;
   } else {
     SPADE_PLATFORM = ENV.SPADE_PLATFORM;
   }
-  
+
   var LANG;
   if ('undefined'!==typeof ENV) LANG = ENV.LANG;
   if (!LANG && 'undefined'!==typeof navigator) LANG = navigator.language;
   if (!LANG) LANG = 'en-US';
-  
+
 
   // ..........................................................
   // Sandbox - you could make a secure version if you want...
-  // 
-  
+  //
+
   // runs a factory within context and returns exports...
   function execFactory(id, factory, sandbox, spade) {
     var require, mod;
-    
+
     var pkg      = spade.package(id),
         filename = factory.filename,
         format   = factory.format,
         ARGV     = sandbox.ARGV,
-        ENV      = sandbox.ENV;
-        
+        ENV      = sandbox.ENV,
+        fullId   = id+'.'+format;
+
     require = function(moduleId) {
       return sandbox.require(moduleId, id, pkg);
     };
 
     // make the require 'object' have the same API as sandbox and spade.
     require.require = require;
-    
+
     require.exists = function(moduleId) {
-      return sandbox.exists(normalize(moduleId, id, pkg));  
+      return sandbox.exists(normalize(moduleId, id, pkg));
     };
-    
+
     require.normalize = function(moduleId) {
       return normalize(moduleId, id, pkg);
     };
-    
+
     require.async = function(moduleId, callback) {
       return sandbox.async(normalize(moduleId, id, pkg), callback);
     };
-    
+
     require.sandbox = function(name, isolate) {
       return spade.sandbox(name, isolate);
     };
-    
+
     require.url = function(moduleId, ext) {
       return sandbox.url(normalize(moduleId, id, pkg), ext);
     };
@@ -186,26 +203,26 @@ var spade ;
     };
 
     require.id = id; // so you can tell one require from another
-    
-    sandbox._modules[id] = mod = { 
-      id:        id, 
-      exports:   {}, 
-      sandbox:   sandbox 
+
+    sandbox._modules[id] = mod = {
+      id:        id,
+      exports:   {},
+      sandbox:   sandbox
     };
-    
+
     factory = factory.data; // extract the raw module body
-    
+
     // compile if needed - use cache so we only do it once per sandbox
     if ('string' === typeof factory) {
-      if (sandbox._factories[id]) {
-        factory = sandbox._factories[id];
+      if (sandbox._factories[fullId]) {
+        factory = sandbox._factories[fullId];
       } else {
-        sandbox._loading[id] = true;
+        sandbox._loading[id] = sandbox._loading[fullId] = true;
         factory = sandbox.compileFormat(factory, filename, format, pkg);
         factory = sandbox.compilePreprocessors(factory, filename, pkg, id);
         factory = sandbox.compile('(function(require, exports, __module, ARGV, ENV, __filename) {'+factory+';\n}) //@ sourceURL='+filename+'\n', filename);
-        sandbox._factories[id] = factory;
-        sandbox._loading[id] = false;
+        sandbox._factories[fullId] = factory;
+        sandbox._loading[id] = sandbox._loading[fullId] = false;
       }
     }
 
@@ -218,29 +235,29 @@ var spade ;
 
     return mod.exports;
   }
-  
+
   /**
     @constructor
-    
+
     Sandbox provides an isolated context for loading and running modules.
-    You can create new sandboxes anytime you want.  If you pass true for the 
-    isolate flag, then the sandbox will be created in a separate context if 
-    supported on the platform.  Otherwise it will share globals with the 
+    You can create new sandboxes anytime you want.  If you pass true for the
+    isolate flag, then the sandbox will be created in a separate context if
+    supported on the platform.  Otherwise it will share globals with the
     default sandbox context.
-    
-    Note that isolated sandboxes are not the same as secure sandboxes.  For 
-    example in the browser, a isolated sandbox is created using an iframe 
-    which still exposes access to the DOM and parent environment.  
-    
+
+    Note that isolated sandboxes are not the same as secure sandboxes.  For
+    example in the browser, a isolated sandbox is created using an iframe
+    which still exposes access to the DOM and parent environment.
+
     Isolated sandboxes are mostly useful for testing and sharing plugin code
     that might want to use different versions of packages.
-    
+
     @param {Spade} spade
       The spade instance
-      
+
     @param {Boolean} isolate
       Set to true if you want to isolate it
-      
+
     @returns {Sandbox} instance
   */
   Sandbox = function(spade, name, isolate) {
@@ -248,10 +265,10 @@ var spade ;
       isolate = name;
       name = null;
     }
-    
+
     if (!name) name = '(anonymous)';
-    
-    this.spade = spade; 
+
+    this.spade = spade;
     this.name  = name;
     this.isIsolated = !!isolate;
     this._factories = {}; // compiled factories
@@ -262,14 +279,14 @@ var spade ;
 
   // alias this to help minifier make the page a big smaller.
   Sp = Sandbox.prototype;
-  
+
   Sp.toString = function() {
     return '[Sandbox '+this.name+']';
   };
 
   /**
     Evaluate the passed string in the Sandbox context, returning the result.
-    This is the primitive used to compile string-encoded factories into 
+    This is the primitive used to compile string-encoded factories into
     modules that can execute within a specific context.
   */
   Sp.compile = function(code, filename) {
@@ -344,7 +361,7 @@ var spade ;
 
     var ret = this._modules[id];
     if (ret) ret = ret.exports;
-    
+
     if (ret) {
       if (!this._used[id]) this._used[id] = ret;
       return ret ;
@@ -356,9 +373,9 @@ var spade ;
       var spade = this.spade;
       if (!this.ENV) this.ENV = spade.env(); // get at the last minute
       if (!this.ARGV) this.ARGV = spade.argv();
-      
+
       ret = execFactory(id, factory, this, spade);
-      
+
       // detect circular references...
       if (this._used[id] && (this._used[id] !== ret)) {
         throw new Error("Circular require detected for module "+id);
@@ -378,34 +395,34 @@ var spade ;
     var pkg = callingId ? this.spade.package(callingId) : null;
     id = normalize(id, callingId, pkg);
     if (this._modules[id]) return true;
-    return this.spade.factoryExists(this.spade.resolve(id, this));  
+    return this.spade.factoryExists(this.spade.resolve(id, this));
   };
-  
+
   /**
     Sandbox-specific async load.  This is actually the most primitive form of
     require.
   */
   Sp.async = function(id, callback, callingId) {
     var spade = this.spade, pkg;
-    
+
     pkg = callingId ? this.spade.package(callingId) : null;
     id = spade.resolve(normalize(id, callingId, pkg), this);
     return spade.loadFactory(id, callback);
   };
-  
+
   Sp.url = function(id, ext, callingId) {
-    var ret, pkg; 
-    
+    var ret, pkg;
+
     pkg = callingId ? this.spade.package(callingId) : null;
     id = normalize(id, callingId, pkg);
-    
-    pkg = this.spade.package(id); 
+
+    pkg = this.spade.package(id);
     if (!pkg) {
       var packageId = packageIdFor(id)+'/~package';
       if (this.spade.exists(packageId)) this.spade.require(packageId);
       pkg = this.spade.package(id);
     }
-    
+
     if (!pkg) {
       throw new Error("Can't get url for non-existent package "+id);
     }
@@ -413,7 +430,7 @@ var spade ;
     if (!pkg.root) {
       throw new Error('Package for '+id+' does not support urls');
     }
-    
+
     ret = pkg.root + id.slice(id.indexOf('/'));
     if (ext) ret = ret+'.'+ext;
     return ret ;
@@ -452,7 +469,7 @@ var spade ;
   };
 
   Sp.isDestroyed = false;
-  
+
   Sp.destroy = function() {
     if (!this.isDestroyed) {
       this.isDestroyed = true;
@@ -460,16 +477,16 @@ var spade ;
     }
     return this;
   };
-  
+
   // ..........................................................
   // LOADER
-  // 
-  
+  //
+
   /**
     The built-in loader object knows how to load whole packages as long as
     you have registered an external reference to the package.  This is pkg
     info that contains:
-    
+
         {
           extern: true,  // this is not a real package yet
           src: 'http://example.com/bar',  // URL to load
@@ -479,12 +496,12 @@ var spade ;
   Loader = function() {
     this._loading = {};
   };
-  
+
   Lp = Loader.prototype;
 
   function syncLoad(spade, id, url, format, force) {
     if (force) url = url+'?'+Date.now();
-    
+
     var xhr = new XMLHttpRequest();
     xhr.open('GET', url, false);
     try {
@@ -590,21 +607,21 @@ var spade ;
     if ('undefined'===typeof document) {
       var err = new Error("Cannot load package "+id+" outside of browser");
       if (done) done(err);
-      else throw err; 
+      else throw err;
       return false;
     }
-    
+
     return true;
   }
-  
+
   Lp.loadFactory = function(spade, id, formats, done) {
 
-    var url, loaded, packageId, 
+    var url, loaded, packageId,
         extern = spade.package(id), that = this;
 
     // loader only works for sync requests if the package info permits sync
     // loading.  In production mode, normally it should not.
-    if (!done && (!extern || !extern.sync)) return this; 
+    if (!done && (!extern || !extern.sync)) return this;
 
     // this loader only works in the browser
     if (!verifyInBrowser(id, done)) return this;
@@ -617,14 +634,14 @@ var spade ;
     // not actually loadable
     } else if (!extern || !extern.extern) {
       done(new Error('Module '+id+' not found'));
-      
+
     } else {
 
       // now do actual load of src
       if (!extern.src) {
         throw new Error("Cannot load package "+id+" without a src URL");
       }
-      
+
       // if already loading, just add to queue
       packageId = packageIdFor(normalize(id));
       if (this._loading[packageId]) {
@@ -634,34 +651,34 @@ var spade ;
         this.loadURL(extern.src, function() { that.didLoad(packageId); });
         // TODO: Load dependencies
       }
-    } 
+    }
     return this;
   };
 
   Lp.exists = function(spade, id, formats) {
 
     var extern = spade.package(id);
-    
+
     // loader only works for sync requests if the package info permits sync
     // loading.  In production mode, normally it should not.
-    if (!extern || !extern.sync || !extern.root) return false; 
+    if (!extern || !extern.sync || !extern.root) return false;
 
     // this loader only works in the browser
     if (!verifyInBrowser(id)) return false;
     return syncLoadFormats(spade, id, extern, formats, true);
   };
-    
+
   Lp.didLoad = function(packageId) {
     // TODO: verify/load dependencies
     var callbacks = this._loading[packageId];
     delete this._loading[packageId];
     if (callbacks) callbacks.forEach(function(done) { done(); });
   };
-  
+
   // actually create a script tag and load it
   Lp.loadURL = function(url, callback) {
     var el, head;
-    
+
     el = document.createElement('script');
     el.src = url;
     el.type = 'text/javascript';
@@ -681,7 +698,7 @@ var spade ;
     if ( document.readyState === "complete" ) return setTimeout(callback, 1);
 
     var handler, handled = false;
-    
+
     // The DOM ready check for Internet Explorer
     function doScrollCheck() {
       if (handled) return;
@@ -701,7 +718,7 @@ var spade ;
 
     // Mozilla, Opera and webkit nightlies currently support this event
     if (document.addEventListener) {
-      
+
       handler = function() {
         if (handled) return;
         handled = true;
@@ -709,15 +726,15 @@ var spade ;
         window.removeEventListener('load', handler, false);
         callback();
       };
-      
+
       document.addEventListener( "DOMContentLoaded", handler, false);
-      
+
       // A fallback to window.onload, that will always work
       window.addEventListener( "load", handler, false );
 
     // If IE event model is used
     } else if ( document.attachEvent ) {
-      
+
       handler = function() {
         if (!handled && document.readyState === "complete") {
           handled = true;
@@ -730,7 +747,7 @@ var spade ;
       // ensure firing before onload,
       // maybe late but safe also for iframes
       document.attachEvent("onreadystatechange", handler);
-      
+
       // A fallback to window.onload, that will always work
       window.attachEvent( "onload", handler);
 
@@ -744,88 +761,88 @@ var spade ;
       if ( document.documentElement.doScroll && toplevel ) doScrollCheck();
     }
   };
-  
+
   // ..........................................................
   // Compiler Class
-  // 
-  
+  //
+
   Compiler = function() {};
   Cp = Compiler.prototype;
-  
+
   Cp.setup = function(sandbox) {
     if (sandbox.isIsolated) throw new Error("Isolated Sandbox not supported");
   };
-  
+
   Cp.compile = function(text, sandbox, filename) {
     return eval(text);
   };
-  
+
   Cp.teardown = function(sandbox) {
     // noop by default
   };
-  
+
   // ..........................................................
-  // Spade Class - defined so we can recreate 
-  // 
-  
+  // Spade Class - defined so we can recreate
+  //
+
   Spade = function() {
     this.loader   = new this.Loader(this);
     this.compiler = new this.Compiler(this);
     this.defaultSandbox  = this.sandbox();
-    this._factories = {}; 
+    this._factories = {};
     this._packages  = {};
-    
+
     // register this instance as the result of the spade package.
     var inst = this;
     this.register('spade', { "name": "spade", "version": this.VERSION });
     this.register('spade/main', function(r, e, m) { m.exports = inst; });
   };
-  
+
   Tp = Spade.prototype;
 
   Tp.VERSION  = "0.1.0";
-  
+
   // expose the classes.  We do it this way so that you can create a new
   // Spade instance and treat it like the spade module
   Tp.Spade    = Spade;
   Tp.Sandbox  = Sandbox;
   Tp.Loader   = Loader;
   Tp.Compiler = Compiler;
-  
+
   Tp.env = function() {
     if (!this.ENV) this.ENV = 'undefined' !== typeof ENV ? ENV : {};
     if (!this.ENV.SPADE_PLATFORM) this.ENV.SPADE_PLATFORM = SPADE_PLATFORM;
     if (!this.ENV.LANG) this.ENV.LANG = LANG;
     return this.ENV;
   };
-  
+
   Tp.argv = function() {
     if (!this.ARGV) this.ARGV = 'undefined' !== typeof ARGV ? ARGV : [];
     return this.ARGV;
   };
-  
+
   /**
     Expose the spade require methods to the global context.  This should allow
-    your global code to access spade in the same way that normal modules 
+    your global code to access spade in the same way that normal modules
     would.
   */
   Tp.globalize = function() {
     var spade = this;
-    
+
     // save old info for conflict...
     this._conflict = {
       require: 'undefined' !== typeof require ? require : undefined,
       ENV:     'undefined' !== typeof ENV     ? ENV     : undefined,
       ARGV:    'undefined' !== typeof ARGV    ? ARGV    : undefined
     };
-    
+
     require = function() { return spade.require.apply(spade,arguments); };
     ['async', 'sandbox', 'exists', 'url'].forEach(function(key) {
       require[key] = function() { return spade[key].apply(spade, arguments);};
     });
-    
+
     ENV = this.env();
-    ARGV = this.argv();    
+    ARGV = this.argv();
     return this;
   };
 
@@ -843,77 +860,89 @@ var spade ;
     }
     return this;
   };
-  
+
   /**
     Returns a new sandbox instance attached to the current spade instance.
     Can isolate if preferred.
-    
+
     @param {Boolean} isolate
-      true if you want the sandbox to be isolated.  Throws exception if 
+      true if you want the sandbox to be isolated.  Throws exception if
       platform cannot isolate.
-    
+
     @returns {Sandbox} sandbox instance
   */
   Tp.sandbox = function(name, isolate) {
     return new this.Sandbox(this, name, isolate);
   };
-  
+
   /**
     Register a module or package information.  You can pass one of the
     following:
-    
+
       'module/id', 'module body string'
       'module/id', function() { module func }
       'module/id', { exports: 'foo' }
       'module/id' - just register module id and no body to indicate presence
-    
-    Note also that if you pass just a packageId, it will be normalized to 
+
+    Note also that if you pass just a packageId, it will be normalized to
     packageId/~package.  This is how you register a package.
-    
+
     @param {String} id
       The module or package id
-    
+
     @param {String|Function|Hash} data
       A module function, module body (as string), or hash of exports to use.
-      
+
     @param {String} opts
-      Additional metadata only if you are registering a module factory.  Known 
+      Additional metadata only if you are registering a module factory.  Known
       keys include 'filename' and 'format' (for compilation of DSLs).
-      
+
   */
   Tp.register = function(id, data, opts) {
-    if (!data) data = K ; 
-    var t = typeof data, isExtern, factory;
+    if (!data) data = K ;
+    var t = typeof data, isExtern, factory, isPkg;
 
-    // register - note packages can only accept hashes
     id = normalize(id, null, null, true);
-    if (id.slice(-9) === '/~package' && 'object'!==typeof data) {
+    isPkg = id.slice(-9) === '/~package';
+
+    // register - note packages can only accept hashes
+    if (isPkg && 'object'!==typeof data) {
       throw new Error('You can only register hashes for packages');
     }
-    
-    this._factories[id] = factory = { data: data };
+
+    factory = { data: data };
     factory.filename = opts && opts.filename ? opts.filename : id;
     factory.format   = opts && opts.format ? opts.format : 'js';
 
+    // Store with generic id if none, or if JS
+    if (!this._factories[id] || factory.format === 'js') {
+      this._factories[id] = factory;
+    }
+
+    // Store with format
+    if (!isPkg) {
+      this._factories[id+'.'+factory.format] = factory;
+    }
+
     return this;
   };
 
   /**
-    Efficient way to register external packages.  Pass a hash of packageIds 
+    Efficient way to register external packages.  Pass a hash of packageIds
     and source URLs.  If the package is already registered, the extern will
     not replace it so this is safe to call multiple times.
   */
   Tp.externs = function(externs, extern) {
     var tmp, packages = this._packages;
-    
+
     // normalize method call.
     if ('string' === typeof externs) {
-      tmp = {}; 
-      tmp[externs] = extern;  
-      externs = tmp; 
+      tmp = {};
+      tmp[externs] = extern;
+      externs = tmp;
       extern = null;
     }
-    
+
     for(var packageId in externs) {
       if (!externs.hasOwnProperty(packageId)) continue;
       if (packages[packageId] && !packages[packageId].extern) continue;
@@ -924,20 +953,20 @@ var spade ;
       this.register(packageId, extern);
     }
   };
-  
+
   /**
     Require a module from the default sandbox.
-    
+
     @param {String} id
       The module id.
-      
-    @returns {Hash} module exports 
+
+    @returns {Hash} module exports
   */
   Tp.require = function(id) {
     return this.defaultSandbox.require(id, this.defaultSandbox.callerId);
   };
 
-  
+
   /**
     Async load a module if it is not already a registered factory.  Invoke
     the passed callback with an optional error object when the module is
@@ -946,17 +975,17 @@ var spade ;
   Tp.async = function(id, callback) {
     return this.defaultSandbox.async(id, callback);
   };
-  
+
   Tp.exists = function(id) {
     return this.defaultSandbox.exists(id);
   };
-  
+
   Tp.url = function(id, ext) {
     return this.defaultSandbox.url(id, ext);
   };
-  
+
   function _collectFormats(spade, ret, pkg) {
-    
+
     function extractFormats(formats) {
       if (formats) {
         Object.keys(formats).forEach(function(key) {
@@ -982,29 +1011,36 @@ var spade ;
     Called by the sandbox to get a factory object for the named moduleId
   */
   Tp.loadFactory = function(id, callback) {
-    var pkg, formats, ret = this._factories[id];
+    var pkg, formats, format, data, ret;
 
     // find any formats the current package might know about.  Note that for
-    // lazy-loaders this may not be entirely up to date (since not all pkgs 
+    // lazy-loaders this may not be entirely up to date (since not all pkgs
     // are registered right away)
     pkg = this.package(id);
     formats = pkg ? _collectFormats(this, ['js'], pkg) : ['js'];
-    
+
+    data = parseIdFormats(id, formats);
+    id = data.id;
+    format = data.format;
+    formats = data.formats;
+
+    ret = format ? this._factories[id+'.'+format] : this._factories[id];
+
     if (callback) {
       if (!ret) {
         if (this.loader && this.loader.loadFactory) {
           this.loader.loadFactory(this, id, formats, callback);
         } else callback(new Error('Module '+id+' not found'));
       } else callback();
-      
+
     } else if (!ret && this.loader && this.loader.loadFactory) {
       this.loader.loadFactory(this, id, formats);
-      ret = this._factories[id];
+      ret = format ? this._factories[id+'.'+format] : this._factories[id];
     }
 
     return ret ;
   };
-  
+
   /**
     Called by the sandbox to determine if the named id exists on the system.
     The id should already be normalized.  If the id is not yet registered, the
@@ -1013,13 +1049,14 @@ var spade ;
   Tp.factoryExists = function(id) {
     if (this._factories[id]) return true;
     if (!this.loader || !this.loader.exists) return false;
-    
+
     var pkg     = this.package(id),
-        formats = pkg ? _collectFormats(this, ['js'], pkg) : ['js'];
-         
-    return this.loader.exists(this, id, formats);
+        formats = pkg ? _collectFormats(this, ['js'], pkg) : ['js'],
+        data = parseIdFormats(id, formats);
+
+    return this.loader.exists(this, data.id, data.formats);
   };
-  
+
   /**
     Returns the package info, if any, for the named module or packageId
   */
@@ -1028,7 +1065,7 @@ var spade ;
     var ret = this._factories[id];
     return ret ? ret.data : null;
   };
-  
+
   /**
     Normalize a moduleId, expanding it if needed.
   */
@@ -1036,7 +1073,7 @@ var spade ;
     return normalize(id, contextId);
   };
 
-  // maps the passed ID to a potentially location specific ID.  This gives 
+  // maps the passed ID to a potentially location specific ID.  This gives
   // the loader a way to vary the factory function returned for a given id
   // per sandbox
   Tp.resolve = function(id, sandbox) {
@@ -1044,19 +1081,19 @@ var spade ;
       return this.loader.resolve(id, sandbox);
     } else return id;
   };
-  
-  // uses the loader to invoke when the app is ready.  For the browser this 
+
+  // uses the loader to invoke when the app is ready.  For the browser this
   // is on the ready event.
   Tp.ready = function(callback) {
     switch(this.readyState) {
       case 'ready':
         callback();
         break;
-      
+
       case 'scheduled':
         this._readyQueue.push(callback);
         break;
-        
+
       default:
         this._readyQueue = [callback];
         this.readyState = 'scheduled';
@@ -1068,18 +1105,18 @@ var spade ;
             that.readyState = 'ready';
             for(var idx=0;idx<len;idx++) queue[idx]();
           });
-          
+
         } else {
           throw new Error('Loader does not support activate on ready state');
         }
     }
   };
-  
+
   // instantiate spade and also attach class for testing
   spade = new Spade();
 
-  // in the browser - if ENV and ARGS are not defined, just create some 
-  // reasonable defaults.  We assume that when loading strobe from the CLI 
+  // in the browser - if ENV and ARGS are not defined, just create some
+  // reasonable defaults.  We assume that when loading strobe from the CLI
   // these will already be setup.
   if (SPADE_PLATFORM.engine === 'browser') spade.globalize();