spade 0.1.0 → 0.1.1.1

data/lib/spade/package/lib/wrapper.js

@@ -0,0 +1,15 @@
+exports.compileWrapper = function(code, spade, filename, pkg, id) {
+  var ret = ''
+
+  // Register package, probably a better way to do this
+  if (id.match(/^[^\/]+\/main$/)) {
+    ret += 'spade.register("'+pkg.name+'", '+JSON.stringify(pkg)+');\n\n';
+  }
+
+  // TODO: This probably isn't quite right
+  // TOOD: We can also pass a string here, maybe we should instead
+  ret += 'spade.register("'+id+'", function(){\n'+code+'\n});';
+
+  return ret;
+};
+

data/lib/spade/package/package.json

@@ -0,0 +1,17 @@
+{
+  "name":         "spade",
+  "version":      "0.1.1",
+
+  "description":  "Dependency Management Library for JavaScript",
+  "author":       "Charles Jolley",
+  "homepage":     "http://github.com/sproutcore/spade",
+
+  "directories": {
+    "lib":        "./lib",
+    "tests":      "./tests"
+  },
+
+  "main": "./lib/spade",
+
+  "plugin:wrapper": "spade/wrapper"
+}

data/lib/spade/package/spec/javascript/async-test.js

@@ -0,0 +1,123 @@
+// ==========================================================================
+// Project:   Spade - CommonJS Runtime
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+/*globals Ct */
+
+require('core-test');
+
+var Spade = require('spade').Spade;
+
+// ..........................................................
+// BASIC REQUIRE
+// 
+
+Ct.module('spade: async require');
+
+Ct.setup(function(t, done) {
+  t.spade = new Spade(); 
+  
+  // preload a module
+  t.spade.register('foo/baz', function(require,e) { 
+    e.id = 'foo/baz'; 
+    e.async = require.async; // export for testing
+  });
+  
+  // dummy loader loads only foo/bar on demand after delay
+  t.spade.loader = {
+    
+    requests: 0, 
+    
+    loadFactory: function(spade, id, formats, done) {
+      this.requests++;
+      if (id === 'foo/bar') {
+        setTimeout(function() {
+          spade.register(id, function(r,e) { e.id='foo/bar'; });
+          done();
+        }, 10);
+
+      } else {
+        done('Not Found'); // immediately
+      }
+    }
+  };
+  
+  done();
+});
+
+Ct.teardown(function(t, done) { 
+  delete t.spade;
+  done();
+});
+
+Ct.test('should not talk to loader if registered', function(t, done) {
+  var spade = t.spade;
+
+  t.timeout(1000);
+  
+  spade.async('foo/baz', function(err) {
+    t.equal(err, null);
+    t.equal(spade.loader.requests, 0, 'loader should not have been called');
+    t.equal(spade.require('foo/baz').id, 'foo/baz', 'should find foo');
+    done();
+  });
+  
+});
+
+Ct.test('should let loader register', function(t, done) {
+  var spade = t.spade;
+  t.timeout(1000);
+  spade.async('foo/bar', function(err) {
+    t.equal(err, null);
+    t.equal(spade.loader.requests, 1, 'loader should have been called');
+    t.equal(spade.require('foo/bar').id, 'foo/bar', 'should find foo');
+    done();
+  });
+});
+
+
+Ct.test('should normalize id', function(t, done) {
+  var spade = t.spade;
+  t.timeout(1000);
+  spade.async('/./foo/baz/../bar', function(err) {
+    t.equal(err, null);
+    t.equal(spade.loader.requests, 1, 'loader should have been called');
+    t.equal(spade.require('foo/bar').id, 'foo/bar', 'should find foo');
+    done();
+  });
+});
+
+
+Ct.test('should expose async inside of module', function(t, done) {
+  var spade = t.spade;
+  t.timeout(1000);
+
+  var async = spade.require('foo/baz').async;
+  t.ok(async, 'should have an async function');
+  
+  // normalize relative to async
+  async('./bar', function(err) {
+    t.equal(err, null);
+    t.equal(spade.loader.requests, 1, 'loader should have been called');
+    t.equal(spade.require('foo/bar').id, 'foo/bar', 'should find foo');
+    done();
+  });
+});
+
+
+Ct.test('should return err if loader does not register', function(t, done) {
+  var spade = t.spade;
+  t.timeout(1000);
+  spade.async('imaginary/bar', function(err) {
+    t.equal(err, 'Not Found');
+    t.equal(spade.loader.requests, 1, 'loader should have been called');
+
+    t.throws(function() {
+      spade.require('imaginary/bar');
+    });
+    done();
+  });
+  
+});
+

data/lib/spade/package/spec/javascript/compiler/javascript.js

@@ -0,0 +1,13 @@
+// ==========================================================================
+// Project:   Spade - CommonJS Runtime
+// Copyright: ©2011 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+//
+
+var Ct = require('core-test/sync');
+
+Ct.module('spade: Compiler JavaScript');
+
+Ct.test('works');
+

data/lib/spade/package/spec/javascript/compiler/ruby.js

@@ -0,0 +1,14 @@
+// ==========================================================================
+// Project:   Spade - CommonJS Runtime
+// Copyright: ©2011 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+//
+
+var Ct = require('core-test/sync');
+
+Ct.module('spade: Compiler Ruby');
+
+Ct.test('works');
+
+

data/lib/spade/package/spec/javascript/loader-test.js

@@ -0,0 +1,64 @@
+// ==========================================================================
+// Project:   Spade - CommonJS Runtime
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+
+var Ct = require('core-test/sync'),
+    Spade = require('spade').Spade;
+
+// ..........................................................
+// BASIC REQUIRE
+// 
+
+Ct.module('spade: basic require');
+
+Ct.setup(function(t) {
+  t.spade = new Spade(); 
+    
+  // preload a module
+  t.spade.register('foo/main', function(r, e) { e.id = 'foo'; });
+  
+  // dummy loader loads only foo/bar on demand
+  t.spade.loader = {
+    
+    requests: 0, 
+    
+    loadFactory: function(spade, id, formats, done) {
+      this.requests++;
+      if (id === 'foo/bar') {
+        spade.register(id, function(r,e) { e.id='foo/bar'; });
+      }
+      if (done) throw "should not be passed done"
+    }
+  };
+  
+});
+
+Ct.teardown(function(t) { 
+  delete t.spade;
+});
+
+Ct.test('should not talk to loader if module is registered', function(t) {
+  var spade = t.spade;
+  t.equal(spade.require('foo').id, 'foo', 'should find foo');
+  t.equal(spade.loader.requests, 0, 'loader should not have been called');
+});
+
+Ct.test('should let loader register', function(t) {
+  var spade = t.spade;
+  t.equal(spade.require('foo/bar').id, 'foo/bar', 'should find foo');
+  t.equal(spade.loader.requests, 1, 'loader should have been called');
+});
+
+Ct.test('should throw if loader does not register', function(t) {
+  var spade = t.spade;
+  t.throws(function() {
+    spade.require('imaginary/bar');
+  });
+  t.equal(spade.loader.requests, 1, 'loader should have been called');
+});
+
+
+
+Ct.run();

data/lib/spade/package/spec/javascript/normalize-test.js

@@ -0,0 +1,73 @@
+// ==========================================================================
+// Project:   Spade - CommonJS Runtime
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+
+var Ct = require('core-test/sync'),
+    Spade = require('spade').Spade;
+
+// ..........................................................
+// BASIC REQUIRE
+// 
+
+Ct.module('spade: normalize');
+
+Ct.setup(function(t) {
+  t.spade = new Spade(); 
+});
+
+Ct.teardown(function(t) { 
+  delete t.spade;
+});
+
+Ct.test('normalize', function(t) {
+  var spade = t.spade;
+  t.equal(spade.normalize('foo/bar'), 'foo/bar');
+  t.equal(spade.normalize('./foo', 'bar/baz'), 'bar/foo');
+  t.equal(spade.normalize('../foo', 'bar/baz'), 'foo/main');
+  t.equal(spade.normalize('foo/../bar//foo/./baz', 'bar/baz'), 'bar/foo/baz');
+
+  t.equal(spade.normalize('/foo/./bar'), 'foo/bar');
+  t.equal(spade.normalize('foo/../bar/'), 'bar/main');
+  t.equal(spade.normalize('/foo/../bar/'), 'bar/main');
+
+  t.equal(spade.normalize('/foo/bar'), 'foo/bar');
+  t.equal(spade.normalize('foo/bar/'), 'foo/bar');
+  t.equal(spade.normalize('/foo/bar/'), 'foo/bar');
+  
+  t.equal(spade.normalize('PKG/foo/bar'), 'PKG/foo/bar');
+  t.equal(spade.normalize('BAR/foo', 'PKG/bar/baz'), 'BAR/foo');
+  t.equal(spade.normalize('./foo', 'PKG/bar/baz'), 'PKG/bar/foo');
+  t.equal(spade.normalize('../foo', 'PKG/bar/baz'), 'PKG/foo');
+  t.equal(spade.normalize('./foo/../../bar//foo/./baz', 'PKG/bar/baz'), 'PKG/bar/foo/baz');
+  
+});
+
+Ct.test('normalize package', function(t) {
+  var spade = t.spade;
+  spade.register('sproutcore', {}); // register as a package
+  t.equal(spade.normalize('sproutcore'), 'sproutcore/main');
+  t.equal(spade.normalize('foo/sproutcore'), 'foo/sproutcore');
+});
+
+Ct.test('normalize relative require from main', function(t) {
+  // I think this is a valid test, but not certain
+  var spade = t.spade, mainRequire, otherRequire;
+  spade.register('foo', { main: './lib/foo', directories: { lib: './lib/foo' } });
+  spade.register('foo/main', 'return require;');
+  spade.register('foo/other/main', 'return require;');
+  mainRequire = spade.require('foo/main');
+  otherRequire = spade.require('foo/other/main');
+  t.equal(mainRequire.normalize('./foo/adfadf'), 'foo/adfadf', 'works for real main');
+  t.equal(otherRequire.normalize('./foo/core'), 'foo/other/foo/core', "no difference for fake main");
+});
+
+Ct.test('normalize tilde paths with lib', function(t){
+  var spade = t.spade, fooRequire;
+  spade.register('foo', { directories: { lib: './lib' }}); // register as a package
+  spade.register('foo/main', 'return require;');
+  fooRequire = spade.require('foo');
+  t.equal(fooRequire.normalize('foo/~lib/main'), 'foo/main');
+  t.equal(fooRequire.normalize('foo/~lib/core'), 'foo/core');
+});

data/lib/spade/package/spec/javascript/packages-test.js

@@ -0,0 +1,50 @@
+// ==========================================================================
+// Project:   Spade - CommonJS Runtime
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+
+var Ct = require('core-test/sync'),
+    Spade = require('spade').Spade;
+
+Ct.module('spade: packages');
+
+Ct.setup(function(t) {
+  t.spade = new Spade(); 
+});
+
+Ct.teardown(function(t) { 
+  delete t.spade;
+});
+
+Ct.test('should find registered package', function(t) {
+  
+  var spade = t.spade;
+  spade.register('PKG', { name: 'PKG' });
+  
+  t.equal(spade.package('PKG').name, 'PKG');
+  t.equal(spade.package('PKG/foo/bar').name, 'PKG');
+  
+});
+
+Ct.test('should respect mappings', function(t) {
+  
+  var spade = t.spade;
+  spade.register('PKG', { mappings: { foo: 'FOO' } });
+  
+  spade.register('PKG/bar', function(require, exports) {
+    exports.id = require('foo/foo').id;
+  });
+  
+  spade.register('FOO/foo', function(r, e) { e.id = 'FOO'; });
+  
+  t.equal(spade.require('PKG/bar').id, 'FOO'); // should remap pkg name
+  
+});
+
+Ct.test('should set default directories', function(t){
+  var spade = t.spade;
+  spade.register('PKG', { name: 'PKG' });
+
+  t.deepEqual(spade.package('PKG').directories, { 'lib': ['lib'] });
+});

data/lib/spade/package/spec/javascript/relative-require-test.js

@@ -0,0 +1,72 @@
+// ==========================================================================
+// Project:   Spade - CommonJS Runtime
+// Copyright: ©2010 Strobe Inc. All rights reserved.
+// License:   Licened under MIT license (see __preamble__.js)
+// ==========================================================================
+
+var Ct = require('core-test/sync'),
+    Spade = require('spade').Spade;
+
+// ..........................................................
+// BASIC REQUIRE
+// 
+
+Ct.module('spade: relative require');
+
+Ct.setup(function(t) {
+  t.spade = new Spade(); 
+  
+  ['foo', 'bar'].forEach(function(id) {
+    t.spade.register(id, { "name": id });
+  });
+  
+  // register some dummy modules.  These will just set an 'id' prop on exports
+  ['foo/bar', 'bar/main', 'foo/bar/baz'].forEach(function(id) {
+    t.spade.register(id, function(r, e) { e.id = id; });
+  });
+  
+});
+
+Ct.teardown(function(t) { 
+  delete t.spade;
+});
+
+Ct.test('require absolute', function(t) {
+  var spade = t.spade;
+
+  spade.register('blah/main', function(require, e) {
+    e.found = require('foo/bar').id;
+  });
+
+  t.equal(spade.require('blah').found, 'foo/bar');
+});
+
+Ct.test('require relative top level', function(t) {
+  var spade = t.spade;
+  spade.register('blah/main', function(require, e) { 
+    e.found = require('../bar').id; 
+  });
+  
+  t.equal(spade.require('blah').found, 'bar/main');
+});
+
+Ct.test('require relative nested', function(t) {
+  var spade = t.spade;
+  spade.register('foo/blah', function(require, e) { 
+    e.found = require('./bar').id; 
+  });
+  
+  t.equal(spade.require('foo/blah').found, 'foo/bar');
+});
+
+Ct.test('require relative  up nested', function(t) {
+  var spade = t.spade;
+  spade.register('bar/blah', function(require, e) { 
+    e.found = require('../foo/bar/baz').id; 
+  });
+  
+  t.equal(spade.require('bar/blah').found, 'foo/bar/baz');
+});
+
+
+Ct.run();