spade 0.0.8.1 → 0.1.0

data/Gemfile

@@ -1,3 +0,0 @@
-source 'http://rubygems.org'
-
-gemspec

data/Gemfile.lock

@@ -1,40 +0,0 @@
-PATH
-  remote: .
-  specs:
-    spade (0.0.8.1)
-      childlabor (~> 0.0.3)
-      eventmachine (~> 0.12.10)
-      gemcutter (~> 0.6.1)
-      highline (~> 1.6.1)
-      json_pure (~> 1.4.6)
-      rack (~> 1.2.1)
-      therubyracer (~> 0.8.0)
-      thor (~> 0.14.3)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    childlabor (0.0.3)
-    diff-lcs (1.1.2)
-    eventmachine (0.12.10)
-    gemcutter (0.6.1)
-    highline (1.6.2)
-    json_pure (1.4.6)
-    rack (1.2.3)
-    rspec (2.6.0)
-      rspec-core (~> 2.6.0)
-      rspec-expectations (~> 2.6.0)
-      rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.3)
-    rspec-expectations (2.6.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.6.0)
-    therubyracer (0.8.2)
-    thor (0.14.6)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  rspec
-  spade!

data/lib/index.js

@@ -1,14 +0,0 @@
-// ==========================================================================
-// Project:   Spade - CommonJS Runtime
-// Copyright: ©2010 Strobe Inc. All rights reserved.
-// License:   Licened under MIT license (see __preamble__.js)
-// ==========================================================================
-/*globals process __dirname */
-
-var SPADE = require('./spade'), spade;
-
-SPADE.Spade.prototype.Sandbox = require('./node/sandbox').Sandbox;
-SPADE.Spade.prototype.Loader  = require('./node/loader').Loader;
-
-module.exports = new SPADE.Spade()
-

data/lib/node/loader.js

@@ -1,146 +0,0 @@
-// ==========================================================================
-// Project:   Spade - CommonJS Runtime
-// Copyright: ©2010 Strobe Inc. All rights reserved.
-// License:   Licened under MIT license (see __preamble__.js)
-// ==========================================================================
-/*globals process __filename __dirname */
-
-var PATH = require('path'),
-    SYS  = require('sys'),
-    FS   = require('fs'),
-    SPADE_DIR = '.spade'; // Would be nice if we could share Spade::SPADE_DIR
-    
-exports.Loader = function() {
-  this.root = process.cwd();
-};
-
-var Lp = exports.Loader.prototype;
-
-function addPackage(packages, dirname, filename) {
-  if (filename[0] === '.') return ; // nothing to do
-  var path = PATH.join(dirname, filename);
-  if (!PATH.existsSync(path) || !FS.statSync(path).isDirectory()) return;
-  
-  var jsonPath = PATH.join(path, 'package.json');
-  if (!PATH.existsSync(jsonPath)) return ; // not a pkg
-
-  var json;
-  try {
-    json = JSON.parse(FS.readFileSync(jsonPath));
-  } catch(e) {
-    json = null;
-  }
-  
-  if (!json) return; // nothing to do
-  
-  var directories = json.directories || { lib: 'lib' };
-  if (!json.directories && json.lib) directories.lib = json.lib;
-  var name = json.name || filename;
-  packages[name] = {
-    register: false,
-    path:     path,
-    directories: directories,
-    json: json
-  };
-}
-
-function finishLoad(done) {
-  if (done) done();
-  return null;
-}
-
-function registerModule(spade, id, path, done) {
-  spade.register(id, FS.readFileSync(path, 'utf8'));
-  return finishLoad(done);
-}
-
-function registerNode(spade, id, loader, done) {
-  
-  // register a package the first time someone tries to load the module
-  if (!loader._nodeRegistered) {
-    loader._nodeRegistered = true;
-    spade.register('node', { name: "node", version: process.version });
-  }
-  
-  // when loading this module, just do a native node require...
-  spade.register(id, function(r, e, m) { m.exports = require(id.slice(5)); });
-  
-}
-
-Lp.packages = function() {
-  if (this._packages) return this._packages;
-  var packages = {};
-  this._packages = packages;
-
-  // 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);
-    dirname = PATH.join.apply(PATH, dirname);
-    if (PATH.existsSync(dirname) && FS.statSync(dirname).isDirectory()) {
-      FS.readdirSync(dirname).forEach(function(name) {
-        addPackage(packages, dirname, name);
-      });
-    }
-  });
-  
-  addPackage(packages, PATH.dirname(this.root), PATH.basename(this.root));
-  
-  return packages;
-};
-
-Lp.loadFactory = function(spade, id, formats, done) {
-  if (!formats) { formats = []; }
-  if (formats.length === 0) { formats.push('js'); }
-
-  if (id.indexOf('(file)/')===0) {
-    return registerModule(spade, id, id.slice(6), done);
-  }
-  
-  if (id.indexOf('node/')===0) { return registerNode(spade, id, this, done); }
-  
-  var parts = id.split('/');
-  var packageName = parts.shift();
-  var packageInfo = this.packages()[packageName];
-  
-  if (!packageInfo) { return finishLoad(done); }
-  
-  if (parts.length>0 && (parts[0][0] === '~')) {
-    var dirname = parts.shift().slice(1);
-    dirname = packageInfo.directories[dirname] || dirname;
-  } else {
-    dirname = packageInfo.directories['lib'] || 'lib';
-  }
-  
-  // register package first if needed
-  if (!packageInfo.registered) {
-    packageInfo.registered = true;
-    spade.register(packageName, packageInfo.json);
-  }
-  
-  parts.unshift(dirname);
-  parts.unshift(packageInfo.path);
-
-  var path = PATH.join.apply(PATH,parts), loadPath;
-  for (var i=0, len=formats.length; i < len; i++) {
-    loadPath = path+'.'+formats[i];
-    if (PATH.existsSync(loadPath)) { return registerModule(spade, id, loadPath, done); }
-  }
-
-  return this._factories[id];
-};
-
-Lp.scheduleReady = function(callback) {
-  callback();
-};

data/lib/node/sandbox.js

@@ -1,44 +0,0 @@
-// ==========================================================================
-// Project:   Spade - CommonJS Runtime
-// Copyright: ©2010 Strobe Inc. All rights reserved.
-// License:   Licened under MIT license (see __preamble__.js)
-// ==========================================================================
-/*globals process */
-
-var spade = require('../spade'),
-    VM    = require('vm');
-
-var OriginalSandbox = spade.Sandbox;
-var Sandbox = function() {
-  OriginalSandbox.apply(this, arguments);
-  this.ctx = VM.createContext({
-    setTimeout: setTimeout,
-    setInterval: setInterval,
-    clearInterval: clearInterval,
-    console: console,
-    navigator: {
-      appName: 'node',
-      appVersion: process.version,
-      platform: process.platform,
-      userAgent: 'node '+process.version
-    }
-  });
-  this.ctx.window = this.ctx;
-};
-
-Sandbox.prototype = Object.create(OriginalSandbox.prototype);
-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

@@ -1,1130 +0,0 @@
-// ==========================================================================
-// Project:   Spade - CommonJS Runtime
-// Copyright: ©2010 Strobe Inc. All rights reserved.
-// License:   Licened under MIT license (see __preamble__.js)
-// ==========================================================================
-/*jslint evil:true */
-/*globals ARGS ARGV ENV __module */
-
-/*! @license
-==========================================================================
-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
-Software is furnished to do so, subject to the following conditions:
-
-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
-DEALINGS IN THE SOFTWARE.
-
-Spade is part of the SproutCore project.
-
-SproutCore and the SproutCore logo are trademarks of Sprout Systems, Inc.
-
-For more information visit http://www.sproutcore.com/spade
-
-==========================================================================
-@license */
-
-// Make this work when loaded from browser or from node.js
-var spade ;
-(function() {
-
-  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);
-
-    // need to walk if there is a .
-    if (id.indexOf('.')>=0) {
-      var parts = contextId && (id[0]==='.') ? contextId.split('/') : [],
-          idx = 0,
-          len = id.length,
-          part, next,
-          packageName = parts[0],
-          useTilde = false;
-
-      if (contextPkg && contextPkg.main && contextId === packageName+'/main') {
-      // If we're requiring from main we need to handle relative requires specially
-        useTilde = true;
-        parts = contextPkg.main.replace(/^\.?\//, '').split('/');
-      }
-
-      parts.pop(); // get rid of the last path element since it is a module.
-
-      while(idx<len) {
-        next = id.indexOf('/', idx);
-        if (next<0) next = len;
-        part = id.slice(idx, next);
-        if (part==='..') parts.pop();
-        else if (part!=='.' && part!=='' && part!==null) parts.push(part);
-        // skip .., empty, and null.
-        idx = next+1;
-      }
-
-      id = parts.join('/');
-
-      // Make the path into a root relative path
-      if (useTilde) { id = packageName+'/~'+id; }
-
-    // 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...
-    if (id.indexOf('/')>0 || id.indexOf('.')>0) {
-    }
-    // slice separators off begin and end
-    if (id[0]==='/') id = id.slice(1);
-
-    // Convert root relative paths to normal paths where possible
-    if (contextPkg && contextPkg.directories) {
-      var libPath = contextPkg.directories['lib'];
-      if (libPath) { id = id.replace('~'+libPath.replace(/^\.?\//, '')+'/', ''); }
-    }
-
-    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;
-  if (('undefined'===typeof ENV) || !ENV.SPADE_PLATFORM) {
-    SPADE_PLATFORM = { ENGINE: 'browser' };
-  } 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,
-        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));
-    };
-
-    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);
-    };
-
-    require.runCommand = function(command, args){
-      return sandbox.runCommand(command, args, id, pkg);
-    };
-
-    require.id = id; // so you can tell one require from another
-
-    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[fullId]) {
-        factory = sandbox._factories[fullId];
-      } else {
-        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[fullId] = factory;
-        sandbox._loading[id] = sandbox._loading[fullId] = false;
-      }
-    }
-
-    if ('function' === typeof factory) {
-      var ret = factory(require, mod.exports, mod, ARGV, ENV, filename);
-      if (ret !== undefined) mod.exports = ret; // allow return exports
-    } else {
-      mod.exports = factory;
-    }
-
-    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
-    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.
-
-    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) {
-    if (typeof name !== 'string') {
-      isolate = name;
-      name = null;
-    }
-
-    if (!name) name = '(anonymous)';
-
-    this.spade = spade;
-    this.name  = name;
-    this.isIsolated = !!isolate;
-    this._factories = {}; // compiled factories
-    this._loading   = {}; // list of loading modules
-    this._modules   = {}; // cached export results
-    this._used      = {}; // to detect circular references
-  };
-
-  // 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
-    modules that can execute within a specific context.
-  */
-  Sp.compile = function(code, filename) {
-    if (this.isDestroyed) throw new Error("Sandbox destroyed");
-    if (!this._compilerInited) {
-      this._compilerInited = true;
-      this.spade.compiler.setup(this);
-    }
-    return this.spade.compiler.compile(code, this, filename);
-  };
-
-  function findPlugins(sandbox, pkg, type, key, single) {
-    var plugins = [], ret = [], found;
-
-    found = pkg && pkg['plugin:'+type];
-    if (key) { found = found && found[key]; }
-    if (found) {
-      if (single) { return found; }
-      plugins = plugins.concat(found);
-    }
-
-    // look in immediate dependencies only, if we wanted to have formats we would have required them
-    var deps = pkg && pkg.dependencies;
-    if (deps) {
-      for(var packageId in deps) {
-        pkg = sandbox.spade.package(packageId);
-        found = pkg && pkg['plugin:'+type];
-        if (key) { found = found && found[key]; }
-        if (found) plugins = plugins.concat(found);
-      }
-    }
-
-    // Remove duplicates
-    for (var i=0,len=plugins.length; i < len; i++) {
-      if (ret.indexOf(plugins[i]) < 0) { ret.push(plugins[i]); }
-    }
-
-    if (single) {
-      if (ret.length > 1) { console.warn("Found multiple plugins when expecting one for type: '"+type+"' and key: '"+key+"'"); }
-      return ret[0] || null;
-    } else {
-      return ret;
-    }
-  }
-
-  Sp.compileFormat = function(code, filename, format, pkg) {
-    var plugin = findPlugins(this, pkg, 'formats', format, true);
-    if (plugin) { plugin = this.require(plugin); }
-    return plugin ? plugin.compileFormat(code, this, filename, format, pkg) : code;
-  };
-
-  Sp.compilePreprocessors = function(code, filename, pkg, id) {
-    var plugins = findPlugins(this, pkg, 'preprocessors'), plugin;
-    for (var i=0, len=plugins.length; i < len; i++) {
-      // Avoid trying to process self
-      if (plugins[i] === id) { continue; }
-      plugin = this.require(plugins[i]);
-      if (!this._loading[id] || plugin.compilePreprocessor) {
-        code = plugin.compilePreprocessor(code, this, filename, pkg);
-      }
-    }
-    return code;
-  };
-
-  /**
-    Sandbox-specific require.  This is actually the most primitive form of
-    require.
-  */
-  Sp.require = function(id, callingId) {
-    var pkg = callingId ? this.spade.package(callingId) : null;
-    id = normalize(id, callingId, pkg);
-
-    var ret = this._modules[id];
-    if (ret) ret = ret.exports;
-
-    if (ret) {
-      if (!this._used[id]) this._used[id] = ret;
-      return ret ;
-
-    } else {
-      var factory = this.spade.loadFactory(this.spade.resolve(id, this));
-      if (!factory) throw new Error('Module '+id+' not found');
-
-      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);
-      }
-    }
-
-    return ret ;
-  };
-
-  /**
-    Sandbox-specific test to determine if the named module exists or not.
-    This property only reflects what is immediately available through the
-    sync-loader.  Using the async loader may change the return value of this
-    call.
-  */
-  Sp.exists = function(id, callingId) {
-    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));
-  };
-
-  /**
-    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;
-
-    pkg = callingId ? this.spade.package(callingId) : null;
-    id = normalize(id, callingId, pkg);
-
-    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);
-    }
-
-    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 ;
-  };
-
-  Sp.runCommand = function(command, args, callerId, pkg){
-    var xhr = new XMLHttpRequest(),
-        url = "_spade/command",
-        params = [];
-
-    args.command = command;
-    args.callerId = callerId;
-    args.pkgRoot = pkg && pkg.root;
-
-    for (var arg in args){
-      params.push(encodeURIComponent(arg)+"="+encodeURIComponent(args[arg]));
-    }
-    params = params.join('&');
-
-    xhr.open('POST', url, false);
-
-    try {
-      xhr.send(params);
-    } catch(e) {
-      throw new Error('unable to run command `'+command+'`, most likely either this browser or server does not support this');
-    }
-
-    if (xhr.status === 200) {
-      return xhr.responseText;
-    // Safari returns -1100 for file:// not found
-    } else if (xhr.status === 404 || xhr.status === -1100) {
-      throw new Error('unable to run command `'+command+'`, most likely you are running without a supported server');
-    } else {
-      throw new Error('running command `'+command+'` return status '+xhr.status+': '+xhr.responseText);
-    }
-  };
-
-  Sp.isDestroyed = false;
-
-  Sp.destroy = function() {
-    if (!this.isDestroyed) {
-      this.isDestroyed = true;
-      this.spade.compiler.teardown(this);
-    }
-    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
-          expects: ['foo', 'bar', 'baz']  // optional modules to expect
-        }
-  */
-  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 {
-      xhr.send(null);
-    } catch(e) {
-      throw new Error('unable to fetch '+url+', most likely this browser is not supported');
-    }
-
-    // successful file:// requests return 0 in Safari and Firefox
-    if (xhr.status === 200 || xhr.status === 0) {
-      var body = xhr.responseText;
-      if (body.slice(0,2) === '#!') body = body.slice(body.indexOf('\n'));
-
-      if (!format) format = 'js';
-      spade.register(id, body, { format: format });
-      return true;
-
-    // Safari returns -1100 for file:// not found
-    } else if (xhr.status === 404 || xhr.status === -1100) {
-      return false;
-
-    } else {
-      throw new Error('fetching '+url+' return status '+xhr.status+': '+xhr.responseText);
-    }
-  }
-
-  function resolveUrl(id, extern) {
-    var dirname, idx,
-        packageUrl = extern.root,
-        url;
-
-    id = normalize(id);
-    id = id.slice(id.indexOf('/')+1); // slide off pkg
-
-    // get directory
-    if (id[0]==='~') {
-      idx = id.indexOf('/');
-      dirname = idx>=0 ? id.slice(0, idx) : id;
-      id = dirname.length>=id.length ? null : id.slice(dirname.length+1);
-      dirname = dirname.slice(1); // get rid of ~
-    } else dirname = 'lib';
-
-    // map to directories
-    if (extern.directories && extern.directories[dirname]) {
-      dirname = extern.directories[dirname];
-    }
-
-    // combine elements to form URL
-    url = packageUrl;
-    if (url === '.') url = null;
-    if (dirname && dirname !== '.') url = url ? url+'/'+dirname : dirname;
-    if (id && id !== '.') url = url ? url+'/'+id : id;
-
-    // Clean up '.' and '..'
-    var parts = url.split('/');
-    for(var i=0,len=parts.length; i<len;) {
-      if (parts[i] === '.') {
-        parts = parts.slice(0,i).concat(parts.slice(i+1)); // Remove item
-        // Retry at same index
-      } else if (parts[i] === '..') {
-        if (i === 0) {
-          console.warn("Can't resolve leading '..'");
-          i++; // Go to next
-        } else {
-          parts = parts.slice(0,i-1).concat(parts.slice(i+1)); // Remove previous and current item
-          i--; // Retry at previous index
-        }
-      } else {
-        i++; // Go to next
-      }
-    }
-    url = parts.join('/');
-
-    return url;
-  }
-  Lp.resolveUrl = resolveUrl;
-
-  function syncLoadFormats(spade, id, extern, formats) {
-    var packageUrl = extern.root,
-        url = resolveUrl(id, extern);
-
-    // If we know about a file we want to try to load it first
-    if (extern.files) {
-      var relativeUrl = url.replace(packageUrl+'/', '');
-      for (var i=0,len=formats.length; i<len; i++) {
-        // See if we know about a match
-        if (extern.files.indexOf(relativeUrl+'.'+formats[i]) > -1) {
-          // Move format to the front
-          formats = [formats[i]].concat(formats.slice(0,i)).concat(formats.slice(i+1));
-          break;
-        }
-      }
-    }
-
-    function tryFormat(format) {
-      return syncLoad(spade, id, url+'.'+format, format, true);
-    }
-
-    return !!formats.some(tryFormat);
-  }
-
-  function verifyInBrowser(id, done) {
-    if ('undefined'===typeof document) {
-      var err = new Error("Cannot load package "+id+" outside of browser");
-      if (done) done(err);
-      else throw err;
-      return false;
-    }
-
-    return true;
-  }
-
-  Lp.loadFactory = function(spade, id, formats, done) {
-
-    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;
-
-    // this loader only works in the browser
-    if (!verifyInBrowser(id, done)) return this;
-
-    if (!done) {
-      url = extern.src;
-      if (!url) loaded = syncLoadFormats(spade, id, extern, formats);
-      else loaded = syncLoad(spade, id, url);
-      if (!loaded) throw new Error('fetching '+id+' not found');
-    // 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]) {
-        this._loading[packageId].push(done);
-      } else {
-        this._loading[packageId] = [done];
-        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;
-
-    // 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';
-    el.onload = callback;
-
-    head = document.head || document.body;
-    head.appendChild(el);
-    head = el = null;
-  };
-
-  // NOTE: On ready stuff mostly stolen from jQuery 1.4.  Need to incl here
-  // because spade will often be used to load jQuery.
-  // Will only be invoked once.  Just be prepared to call it
-  Lp.scheduleReady = function(callback) {
-
-    // handle case where ready is invoked AFTER the document is already ready
-    if ( document.readyState === "complete" ) return setTimeout(callback, 1);
-
-    var handler, handled = false;
-
-    // The DOM ready check for Internet Explorer
-    function doScrollCheck() {
-      if (handled) return;
-
-      try {
-        // If IE is used, use the trick by Diego Perini
-        // http://javascript.nwbox.com/IEContentLoaded/
-        document.documentElement.doScroll("left");
-      } catch(e) {
-        setTimeout( doScrollCheck, 1 );
-        return;
-      }
-
-      // and execute any waiting functions
-      handler();
-    }
-
-    // Mozilla, Opera and webkit nightlies currently support this event
-    if (document.addEventListener) {
-
-      handler = function() {
-        if (handled) return;
-        handled = true;
-        document.removeEventListener("DOMContentLoaded", handler, false);
-        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;
-          document.detachEvent( "onreadystatechange", handler );
-          window.detachEvent('onload', handler);
-          callback();
-        }
-      };
-
-      // 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);
-
-      // If IE and not a frame
-      // continually check to see if the document is ready
-      var toplevel = false;
-
-      try {
-        toplevel = window.frameElement === null;
-      } catch(e) {}
-      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 = function() {
-    this.loader   = new this.Loader(this);
-    this.compiler = new this.Compiler(this);
-    this.defaultSandbox  = this.sandbox();
-    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
-    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();
-    return this;
-  };
-
-  /**
-    Restores original values after a call to globalize().  If you call this
-    method more than once it will have no effect.
-  */
-  Tp.noConflict = function() {
-    var c = this._conflict;
-    if (c) {
-      delete this._conflict;
-      require = c.require;
-      ENV = c.ENV;
-      ARGV = c.ARGV;
-    }
-    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
-      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
-    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
-      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, isPkg;
-
-    id = normalize(id, null, null, true);
-    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');
-    }
-
-    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
-    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;
-      extern = null;
-    }
-
-    for(var packageId in externs) {
-      if (!externs.hasOwnProperty(packageId)) continue;
-      if (packages[packageId] && !packages[packageId].extern) continue;
-
-      extern = externs[packageId];
-      if ('string' === typeof extern) extern = {name: packageId, src: extern};
-      extern.extern = true;
-      this.register(packageId, extern);
-    }
-  };
-
-  /**
-    Require a module from the default sandbox.
-
-    @param {String} id
-      The module id.
-
-    @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
-    ready to load.
-  */
-  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) {
-          if (ret.indexOf(key)<0) ret.unshift(key); // new formats go first
-        });
-      }
-    }
-
-    extractFormats(pkg['plugin:formats']);
-
-    var deps = pkg.dependencies;
-    if (!deps) return ret;
-
-    for(var packageId in deps) {
-      pkg = spade.package(packageId);
-      if (pkg) extractFormats(pkg['plugin:formats']);
-    }
-
-    return ret ;
-  }
-
-  /**
-    Called by the sandbox to get a factory object for the named moduleId
-  */
-  Tp.loadFactory = function(id, callback) {
-    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
-    // 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 = 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
-    loader will also be consulted.
-  */
-  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'],
-        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
-  */
-  Tp.package = function(id) {
-    id = packageIdFor(normalize(id))+'/~package';
-    var ret = this._factories[id];
-    return ret ? ret.data : null;
-  };
-
-  /**
-    Normalize a moduleId, expanding it if needed.
-  */
-  Tp.normalize = function(id, contextId) {
-    return normalize(id, contextId);
-  };
-
-  // 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) {
-    if (sandbox && this.loader && this.loader.resolve) {
-      return this.loader.resolve(id, sandbox);
-    } else return id;
-  };
-
-  // 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';
-        if (this.loader && this.loader.scheduleReady) {
-          var that = this;
-          this.loader.scheduleReady(function() {
-            var queue = that._readyQueue, len = queue ? queue.length : 0;
-            that._readyQueue = null;
-            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
-  // these will already be setup.
-  if (SPADE_PLATFORM.engine === 'browser') spade.globalize();
-
-  // make this work when called as a module
-  if ('undefined' !== typeof require) {
-    if ('undefined' !== typeof __module) __module.exports = spade;
-    else if ('undefined' !== typeof module) module.exports = spade;
-  }
-
-})();
-