spade-core 0.1.0

data/lib/spade/core.rb

@@ -0,0 +1,47 @@
+module Spade
+  module Core
+  end
+
+  JSPATH = File.expand_path("../js/spade.js", __FILE__)
+  SPADE_DIR = '.spade'
+
+  # find the current path with a package.json or .packages or cur_path
+  def self.discover_root(cur_path)
+    ret = File.expand_path(cur_path)
+    while ret != '/' && ret != '.'
+      return ret if File.exists?(File.join(ret,'package.json')) || File.exists?(File.join(ret,'.spade'))
+      ret = File.dirname ret
+    end
+
+    return cur_path
+  end
+
+  # The next 5 methods should maybe be in Runtime
+
+  def self.current_context
+    @current_context
+  end
+
+  def self.current_context=(ctx)
+    @current_context = ctx
+  end
+
+  def self.exports=(klass)
+    exports(klass, nil)
+  end
+
+  def self.exports(klass, path = nil)
+    path = @current_path if path.nil?
+    @exports ||= {}
+    @exports[path] = klass
+  end
+
+  def self.exports_for(path)
+    @current_path = path
+    require path
+    @current_path = nil
+
+    @exports ||= {}
+    @exports[path]
+  end
+end

data/lib/spade/core/version.rb

@@ -0,0 +1,5 @@
+module Spade
+  module Core
+    VERSION = '0.1.0'
+  end
+end

data/lib/spade/js/spade.js

@@ -0,0 +1,1130 @@
+// ==========================================================================
+// 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;
+  }
+
+})();
+

data/spade-core.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'spade/core/version'
+
+Gem::Specification.new do |s|
+  s.name        = "spade-core"
+  s.version     = Spade::Core::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Charles Jolley", "Peter Wagenet"]
+  s.email       = ["charles@sproutcore.com", "peterw@strobecorp.com"]
+  s.homepage    = "http://github.com/strobecorp/spade-runtime"
+  s.summary = s.description = "Core Libraries for Spade Package Manager and Runtime"
+
+  s.add_development_dependency "rspec"
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.require_paths      = ["lib"]
+end
+
+

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: spade-core
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Charles Jolley
+- Peter Wagenet
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-13 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Core Libraries for Spade Package Manager and Runtime
+email: 
+- charles@sproutcore.com
+- peterw@strobecorp.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/spade/core.rb
+- lib/spade/core/version.rb
+- lib/spade/js/spade.js
+- spade-core.gemspec
+homepage: http://github.com/strobecorp/spade-runtime
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Core Libraries for Spade Package Manager and Runtime
+test_files: []
+