├── .gitignore
├── package.json
├── README.md
├── transport.js
├── tests
    ├── sandbox
    │   ├── evaluate.js
    │   ├── require.js
    │   ├── creation.js
    │   └── misc.js
    ├── packages-test.js
    ├── require-test.js
    ├── loader-test.js
    ├── relative-require-test.js
    ├── normalize-test.js
    └── async-test.js
├── LICENSE.txt
└── lib
    └── spade.js


/.gitignore:
--------------------------------------------------------------------------------
1 | Gemfile.lock
2 | .bundle
3 | bin
4 | *.bpkg
5 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name":         "spade",
 3 |   "version":      "1.0.2",
 4 | 
 5 |   "description":  "Dependency Management Library for JavaScript",
 6 |   "summary":      "Dependency Management Library for JavaScript",
 7 |   "author":       "Charles Jolley",
 8 |   "homepage":     "http://github.com/sproutcore/spade",
 9 | 
10 |   "directories": {
11 |     "lib": "lib",
12 |     "tests": "tests"
13 |   },
14 | 
15 |   "dependencies:development": {
16 |     "qunit": "~> 1.0.0"
17 |   },
18 |   
19 |   "bpm:provides": {
20 |     "transport": {
21 |       "main": "spade/transport"
22 |     }
23 |   }
24 | 
25 | }
26 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | spade - JavaScript module loader
 2 | 
 3 | Spade is a module loader for use with [bpm](https://github.com/getbpm/bpm)
 4 | By default BPM loads all JavaScript files alphabetically. However, for
 5 | more complex projects this is undesirable. Spade adds a require method
 6 | that can be called to load and execute specific files.
 7 | 
 8 | ## Basic Usage
 9 | 
10 | In an existing BPM project:
11 | 
12 | 1. Add spade as a dependency
13 | 
14 |     bpm add spade
15 | 
16 | 2. Update your index.html
17 |    When using spade, files are no longer automatically loaded, so you'll
18 |    have to update your index.html to load your main.js. After bpm_lib.js
19 |    is sourced add the following line:
20 | 
21 |      <script>spade.require('YOUR_APP');</script>
22 | 
23 | 3. Start using `require` in your JavaScript!
24 | 
25 | ## Useful Tips
26 | 
27 | Like node.js, require can return a JavaScript object. However, unlike
28 | node.js you can define globals within your files. The ability to define
29 | globals makes it easier to develop in a browser environment.
30 | 


--------------------------------------------------------------------------------
/transport.js:
--------------------------------------------------------------------------------
 1 | /*globals BPM_PLUGIN */
 2 | 
 3 | BPM_PLUGIN.compileTransport = function(code, context, filename) {
 4 |   var format = context.settings['spade:format'];
 5 |   if (format === 'none') { return code };
 6 | 
 7 |   var ret = '',
 8 |       packageName = context['package'].name,
 9 |       id = packageName+'/'+context.moduleId;
10 | 
11 |   // Register package, probably a better way to do this
12 |   if (id.match(/^[^\/]+\/main$/)) {
13 | 
14 |     var ctx = context['package'],
15 |         pkg = { name: ctx.name, 
16 |                 version: ctx.version, 
17 |                 dependencies: ctx.dependencies };
18 | 
19 |     ret += 'spade.register("'+packageName+'", '+JSON.stringify(pkg)+');\n\n';
20 |   }
21 | 
22 |   if (format === 'function') {
23 |     code = 'function(require, exports, __module, ARGV, ENV, __filename){\n'+code+'\n}';
24 |   } else {
25 |     code = context.minify("(function(require, exports, __module, ARGV, ENV, __filename){"+code+"\n});");
26 |     code = JSON.stringify(code);
27 |   }
28 | 
29 |   ret += 'spade.register("'+id+'", '+code+');';
30 | 
31 |   return ret;
32 | };
33 | 
34 | 


--------------------------------------------------------------------------------
/tests/sandbox/evaluate.js:
--------------------------------------------------------------------------------
 1 | // ==========================================================================
 2 | // Project:   Spade - CommonJS Runtime
 3 | // Copyright: ©2011 Strobe Inc. All rights reserved.
 4 | // License:   Licened under MIT license (see __preamble__.js)
 5 | // ==========================================================================
 6 | /*globals spade */
 7 | 
 8 | (function() {
 9 | 
10 | var t = {}, Spade = spade.Spade, Sandbox = spade.Sandbox;
11 |   
12 | 
13 | module('spade: Sandbox evaluation', {
14 |   setup: function() {
15 |     t.sandbox = new Sandbox(new Spade());
16 |   },
17 |   
18 |   teardown: function() {
19 |     delete t.sandbox;
20 |   }
21 | });
22 | 
23 | test('normal', function(){
24 |   equal(t.sandbox._evaluatorInited, undefined);
25 |   equal(t.sandbox.evaluate('2 * 2'), 4);
26 |   equal(t.sandbox._evaluatorInited, true);
27 | });
28 | 
29 | test('already initialized', function(){
30 |   // Initialize
31 |   t.sandbox.evaluate('');
32 |   // Test
33 |   equal(t.sandbox.evaluate('3 * 3'), 9);
34 | });
35 | 
36 | test('destroyed', function(){
37 |   t.sandbox.destroy();
38 |   raises(function(){ t.sandbox.evaluate('4 * 4'); }, Error, "Sandbox destroyed");
39 | });
40 | 
41 | })();
42 | 
43 | 


--------------------------------------------------------------------------------
/tests/sandbox/require.js:
--------------------------------------------------------------------------------
 1 | // ==========================================================================
 2 | // Project:   Spade - CommonJS Runtime
 3 | // Copyright: ©2011 Strobe Inc. All rights reserved.
 4 | // License:   Licened under MIT license (see __preamble__.js)
 5 | // ==========================================================================
 6 | /*globals spade */
 7 | 
 8 | (function() {
 9 | 
10 | var t = {}, Spade = spade.Spade, Sandbox = spade.Sandbox;
11 |   
12 | 
13 | module('spade: Sandbox require', {
14 |   setup: function() {
15 |     t.sandbox = new Sandbox(new Spade()); 
16 |     t.sandbox.spade.register('testing', { name: 'testing' });
17 |     t.sandbox.spade.register('testing/main', "exports.hello = 'hi';");
18 |   },
19 |   
20 |   teardown: function() {
21 |     delete t.sandbox;
22 |   }
23 | });
24 | 
25 | test("require new", function(){
26 |   equal(t.sandbox.require('testing').hello, 'hi');
27 | });
28 | 
29 | // NOTE: This test doesn't necessarily tell us that anything special is happening, just that it works
30 | test("require existing", function(){
31 |   // Cache it
32 |   t.sandbox.require('testing');
33 |   // Now require again
34 |   equal(t.sandbox.require('testing').hello, 'hi');
35 | });
36 | 
37 | test("throw if doesn't exist", function(){
38 |   raises(function(){ t.sandbox.require('missing'); }, "Module missing not found");
39 | });
40 | 
41 | })();
42 | 
43 | 
44 | 


--------------------------------------------------------------------------------
/tests/sandbox/creation.js:
--------------------------------------------------------------------------------
 1 | // ==========================================================================
 2 | // Project:   Spade - CommonJS Runtime
 3 | // Copyright: ©2011 Strobe Inc. All rights reserved.
 4 | // License:   Licened under MIT license (see __preamble__.js)
 5 | // ==========================================================================
 6 | /*globals spade */
 7 | 
 8 | (function() {
 9 | 
10 | var t = {}, Spade = spade.Spade, Sandbox = spade.Sandbox;
11 |   
12 | 
13 | module('spade: Sandbox Creation', {
14 |   setup: function() {
15 |     t.spade = new Spade(); 
16 |   },
17 |   
18 |   teardown: function() {
19 |     delete t.spade;
20 |   }
21 | });
22 | 
23 | test('basic sandbox', function() {
24 |   var spade = t.spade,
25 |       sandbox = new Sandbox(spade);
26 |       
27 |   // note: using equal() here causes an infinite loop for some reason
28 |   ok(sandbox.spade === spade, 'sandbox.spade == spade');
29 |   equal(sandbox.name, '(anonymous)');
30 |   equal(sandbox.isIsolated, false);
31 | });
32 | 
33 | test('named sandbox', function() {
34 |   var sandbox = new Sandbox(t.spade, 'Test Sandbox');
35 | 
36 |   equal(sandbox.name, 'Test Sandbox');
37 | });
38 | 
39 | test('isolated sandbox', function() {
40 |   var sandbox = new Sandbox(t.spade, 'Test Sandbox', true),
41 |       sandbox2 = new Sandbox(t.spade, true);
42 | 
43 |   equal(sandbox.isIsolated, true);
44 |   equal(sandbox2.isIsolated, true);
45 | });
46 | 
47 | })();
48 | 
49 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | ==========================================================================
 2 | Spade 2.0 CommonJS Runtime
 3 | copyright 2010 Strobe Inc.
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a
 6 | copy of this software and associated documentation files (the "Software"),
 7 | to deal in the Software without restriction, including without limitation
 8 | the rights to use, copy, modify, merge, publish, distribute, sublicense,
 9 | and/or sell copies of the Software, and to permit persons to whom the
10 | Software is furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 | DEALINGS IN THE SOFTWARE.
22 | 
23 | Spade is part of the SproutCore project.
24 | 
25 | SproutCore and the SproutCore logo are trademarks of Sprout Systems, Inc.
26 | 
27 | For more information visit http://www.sproutcore.com/spade
28 | 
29 | ==========================================================================
30 | 


--------------------------------------------------------------------------------
/tests/packages-test.js:
--------------------------------------------------------------------------------
 1 | // ==========================================================================
 2 | // Project:   Spade - CommonJS Runtime
 3 | // Copyright: ©2010 Strobe Inc. All rights reserved.
 4 | // License:   Licened under MIT license (see __preamble__.js)
 5 | // ==========================================================================
 6 | /*globals spade deepEqual */
 7 | 
 8 | (function() {
 9 |   
10 | var t = {}, Spade = spade.Spade;
11 | 
12 | module('spade: packages', {
13 |   setup: function() {
14 |     t.spade = new Spade();
15 |   },
16 |   
17 |   teardown: function() {
18 |     delete t.spade;
19 |   }
20 | });
21 | 
22 | test('should find registered package', function() {
23 |   
24 |   var spade = t.spade;
25 |   spade.register('PKG', { name: 'PKG' });
26 |   
27 |   equal(spade.package('PKG').name, 'PKG');
28 |   equal(spade.package('PKG/foo/bar').name, 'PKG');
29 |   
30 | });
31 | 
32 | test('should respect mappings', function() {
33 |   
34 |   var spade = t.spade;
35 |   spade.register('PKG', { mappings: { foo: 'FOO' } });
36 |   
37 |   spade.register('PKG/bar', function(require, exports) {
38 |     exports.id = require('foo/foo').id;
39 |   });
40 |   
41 |   spade.register('FOO/foo', function(r, e) { e.id = 'FOO'; });
42 |   
43 |   equal(spade.require('PKG/bar').id, 'FOO'); // should remap pkg name
44 |   
45 | });
46 | 
47 | test('should set default directories', function() {
48 |   var spade = t.spade;
49 |   spade.register('PKG', { name: 'PKG' });
50 |   deepEqual(spade.package('PKG').directories, { 'lib': ['lib'] });
51 | });
52 | 
53 | })();
54 | 


--------------------------------------------------------------------------------
/tests/require-test.js:
--------------------------------------------------------------------------------
 1 | // ==========================================================================
 2 | // Project:   Spade - CommonJS Runtime
 3 | // Copyright: ©2010 Strobe Inc. All rights reserved.
 4 | // License:   Licened under MIT license (see __preamble__.js)
 5 | // ==========================================================================
 6 | /*globals spade raises */
 7 | 
 8 | (function() {
 9 |   
10 | var t = {},
11 |     Spade = spade.Spade;
12 |     
13 | // ..........................................................
14 | // BASIC REQUIRE
15 | //
16 | 
17 | module('spade: basic require', {
18 |   setup: function() {
19 |     t.spade = new Spade();
20 |   },
21 |   
22 |   teardown: function() {
23 |     delete t.spade;
24 |   }
25 | });
26 | 
27 | test('register then require a module', function() {
28 |   var spade = t.spade;
29 | 
30 |   spade.register('foo/bar', function(require, exports) {
31 |     exports.foo = 'bar';
32 |   });
33 | 
34 |   var exp = spade.require('foo/bar');
35 |   equal(exp.foo, 'bar', 'exports.foo == bar - means require succeeded');
36 | });
37 | 
38 | test('register a string factory then require', function() {
39 |   var spade = t.spade;
40 | 
41 |   spade.register('foo/bar', "exports.foo = 'bar';");
42 | 
43 |   var exp = spade.require('foo/bar');
44 |   equal(exp.foo, 'bar', 'exports.foo == bar - means require succeeded');
45 | });
46 | 
47 | test('require a non-existant module will throw an exception', function() {
48 |   var spade = t.spade;
49 |   raises(function() {
50 |     spade.require('imaginary/foo');
51 |   }, 'Module imaginary/foo not found');
52 | });
53 | 
54 | test('require a module that was just registered symbolically.  This is for compatibility with non-module items', function() {
55 |   var spade = t.spade;
56 |   spade.register('not/a-module');
57 |   ok(spade.require('not/a-module'));
58 | });
59 | 
60 | })();
61 | 


--------------------------------------------------------------------------------
/tests/loader-test.js:
--------------------------------------------------------------------------------
 1 | // ==========================================================================
 2 | // Project:   Spade - CommonJS Runtime
 3 | // Copyright: ©2010 Strobe Inc. All rights reserved.
 4 | // License:   Licened under MIT license (see __preamble__.js)
 5 | // ==========================================================================
 6 | /*globals spade */
 7 | 
 8 | (function() {
 9 | 
10 | var t = {}, Spade = spade.Spade;
11 |   
12 | // ..........................................................
13 | // BASIC REQUIRE
14 | // 
15 | 
16 | module('spade: loader', {
17 |   setup: function() {
18 |     t.spade = new Spade(); 
19 | 
20 |     // preload a module
21 |     t.spade.register('foo/main', function(r, e) { e.id = 'foo'; });
22 | 
23 |     // dummy loader loads only foo/bar on demand
24 |     t.spade.loader = {
25 | 
26 |       requests: 0, 
27 | 
28 |       loadFactory: function(spade, id, formats, done) {
29 |         this.requests++;
30 |         if (id === 'foo/bar') {
31 |           spade.register(id, function(r,e) { e.id='foo/bar'; });
32 |         }
33 |         if (done) throw "should not be passed done"
34 |       }
35 |     };
36 |   },
37 |   
38 |   teardown: function() {
39 |     delete t.spade;
40 |   }
41 | });
42 | 
43 | test('should not talk to loader if module is registered', function() {
44 |   var spade = t.spade;
45 |   equal(spade.require('foo').id, 'foo', 'should find foo');
46 |   equal(spade.loader.requests, 0, 'loader should not have been called');
47 | });
48 | 
49 | test('should let loader register', function() {
50 |   var spade = t.spade;
51 |   equal(spade.require('foo/bar').id, 'foo/bar', 'should find foo');
52 |   equal(spade.loader.requests, 1, 'loader should have been called');
53 | });
54 | 
55 | test('should throw if loader does not register', function() {
56 |   var spade = t.spade;
57 |   raises(function() {
58 |     spade.require('imaginary/bar');
59 |   });
60 |   equal(spade.loader.requests, 1, 'loader should have been called');
61 | });
62 | 
63 | })();
64 | 


--------------------------------------------------------------------------------
/tests/sandbox/misc.js:
--------------------------------------------------------------------------------
 1 | // ==========================================================================
 2 | // Project:   Spade - CommonJS Runtime
 3 | // Copyright: ©2011 Strobe Inc. All rights reserved.
 4 | // License:   Licened under MIT license (see __preamble__.js)
 5 | // ==========================================================================
 6 | /*globals spade */
 7 | 
 8 | (function() {
 9 | 
10 | var t = {}, Spade = spade.Spade, Sandbox = spade.Sandbox;
11 |   
12 | 
13 | module('spade: Sandbox Miscellaneous', {
14 |   setup: function() {
15 |     t.sandbox = new Sandbox(new Spade(), 'Test Sandbox');
16 |   },
17 |   
18 |   teardown: function() {
19 |     delete t.sandbox;
20 |   }
21 | });
22 | 
23 | test('toString', function(){
24 |   equal(t.sandbox.toString(), '[Sandbox Test Sandbox]');
25 | });
26 | 
27 | test("exists", function(){
28 |   t.sandbox.spade.register('test', { name: 'test' });
29 |   t.sandbox.spade.register('test/main', '');
30 | 
31 |   ok(t.sandbox.exists('test'), "test should exist");
32 |   ok(!t.sandbox.exists('missing'), "missing should not exist");
33 | });
34 | 
35 | test("async", function(){
36 |   t.sandbox.spade.register('test', { name: 'test' });
37 |   t.sandbox.spade.register('test/main', 'exports.hello = "hi";');
38 | 
39 |   stop(1000);
40 |   t.sandbox.async('test', function(err) {
41 |     equals(err, null, 'should not return an error');
42 |     start();
43 |   });
44 | });
45 | 
46 | test("url", function(){
47 |   t.sandbox.spade.register('no-root', { name: 'no-root' });
48 |   t.sandbox.spade.register('with-root', { name: 'with-root', root: 'root/url' });
49 | 
50 |   raises(function(){ t.sandbox.url('missing'); }, "Can't get url for non-existent package missing/main");
51 |   raises(function(){ t.sandbox.url('no-root'); }, "Package for no-root/main does not support urls");
52 |   equal(t.sandbox.url('with-root'), 'root/url/main');
53 | });
54 | 
55 | test("destroy", function(){
56 |   equal(t.sandbox.isDestroyed, false);
57 |   t.sandbox.destroy();
58 |   equal(t.sandbox.isDestroyed, true);
59 | });
60 | 
61 | })();
62 | 
63 | 


--------------------------------------------------------------------------------
/tests/relative-require-test.js:
--------------------------------------------------------------------------------
 1 | // ==========================================================================
 2 | // Project:   Spade - CommonJS Runtime
 3 | // Copyright: ©2010 Strobe Inc. All rights reserved.
 4 | // License:   Licened under MIT license (see __preamble__.js)
 5 | // ==========================================================================
 6 | /*globals spade */
 7 | 
 8 | (function() {
 9 | 
10 | var t = {}, Spade = spade.Spade;
11 |   
12 | // ..........................................................
13 | // BASIC REQUIRE
14 | // 
15 | 
16 | module('spade: relative require', {
17 |   setup: function() {
18 |     t.spade = new Spade(); 
19 | 
20 |     ['foo', 'bar'].forEach(function(id) {
21 |       t.spade.register(id, { "name": id });
22 |     });
23 | 
24 |     // register some dummy modules.  These will just set an 'id' prop on exports
25 |     ['foo/bar', 'bar/main', 'foo/bar/baz'].forEach(function(id) {
26 |       t.spade.register(id, function(r, e) { e.id = id; });
27 |     });
28 |   },
29 |   
30 |   teardown: function() {
31 |     delete t.spade;
32 |   }
33 | });
34 | 
35 | test('require absolute', function() {
36 |   var spade = t.spade;
37 | 
38 |   spade.register('blah/main', function(require, e) {
39 |     e.found = require('foo/bar').id;
40 |   });
41 | 
42 |   equal(spade.require('blah').found, 'foo/bar');
43 | });
44 | 
45 | test('require relative top level', function() {
46 |   var spade = t.spade;
47 |   spade.register('blah/main', function(require, e) { 
48 |     e.found = require('../bar').id; 
49 |   });
50 |   
51 |   equal(spade.require('blah').found, 'bar/main');
52 | });
53 | 
54 | test('require relative nested', function() {
55 |   var spade = t.spade;
56 |   spade.register('foo/blah', function(require, e) { 
57 |     e.found = require('./bar').id; 
58 |   });
59 |   
60 |   equal(spade.require('foo/blah').found, 'foo/bar');
61 | });
62 | 
63 | test('require relative  up nested', function() {
64 |   var spade = t.spade;
65 |   spade.register('bar/blah', function(require, e) { 
66 |     e.found = require('../foo/bar/baz').id; 
67 |   });
68 |   
69 |   equal(spade.require('bar/blah').found, 'foo/bar/baz');
70 | });
71 | 
72 | })();


--------------------------------------------------------------------------------
/tests/normalize-test.js:
--------------------------------------------------------------------------------
 1 | // ==========================================================================
 2 | // Project:   Spade - CommonJS Runtime
 3 | // Copyright: ©2010 Strobe Inc. All rights reserved.
 4 | // License:   Licened under MIT license (see __preamble__.js)
 5 | // ==========================================================================
 6 | /*globals spade */
 7 | 
 8 | (function() {
 9 |   
10 | var t = {};   
11 | var t3; 
12 | 
13 | // ..........................................................
14 | // BASIC REQUIRE
15 | // 
16 | 
17 | module('spade: normalize', {
18 |   setup: function() {
19 |     t.spade = new spade.Spade(); 
20 |   }, 
21 |   
22 |   teardown: function() {
23 |     delete t.spade;
24 |   }
25 | });
26 | 
27 | test('normalize', function() {
28 |   var spade = t.spade;
29 |   equal(spade.normalize('foo/bar'), 'foo/bar');
30 |   equal(spade.normalize('./foo', 'bar/baz'), 'bar/foo');
31 |   equal(spade.normalize('../foo', 'bar/baz'), 'foo/main');
32 |   equal(spade.normalize('foo/../bar//foo/./baz', 'bar/baz'), 'bar/foo/baz');
33 | 
34 |   equal(spade.normalize('/foo/./bar'), 'foo/bar');
35 |   equal(spade.normalize('foo/../bar/'), 'bar/main');
36 |   equal(spade.normalize('/foo/../bar/'), 'bar/main');
37 | 
38 |   equal(spade.normalize('/foo/bar'), 'foo/bar');
39 |   equal(spade.normalize('foo/bar/'), 'foo/bar');
40 |   equal(spade.normalize('/foo/bar/'), 'foo/bar');
41 |   
42 |   equal(spade.normalize('PKG/foo/bar'), 'PKG/foo/bar');
43 |   equal(spade.normalize('BAR/foo', 'PKG/bar/baz'), 'BAR/foo');
44 |   equal(spade.normalize('./foo', 'PKG/bar/baz'), 'PKG/bar/foo');
45 |   equal(spade.normalize('../foo', 'PKG/bar/baz'), 'PKG/foo');
46 |   equal(spade.normalize('./foo/../../bar//foo/./baz', 'PKG/bar/baz'), 'PKG/bar/foo/baz');
47 |   
48 | });
49 | 
50 | test('normalize package', function() {
51 |   var spade = t.spade;
52 |   spade.register('sproutcore', {}); // register as a package
53 |   equal(spade.normalize('sproutcore'), 'sproutcore/main');
54 |   equal(spade.normalize('foo/sproutcore'), 'foo/sproutcore');
55 | });
56 | 
57 | test('normalize relative require from main', function() {
58 |   // I think this is a valid test, but not certain
59 |   var spade = t.spade, mainRequire, otherRequire;
60 |   spade.register('foo', { main: './lib/foo', directories: { lib: './lib/foo' } });
61 |   spade.register('foo/main', 'return require;');
62 |   spade.register('foo/other/main', 'return require;');
63 |   mainRequire = spade.require('foo/main');
64 |   otherRequire = spade.require('foo/other/main');
65 |   equal(mainRequire.normalize('./foo/adfadf'), 'foo/adfadf', 'works for real main');
66 |   equal(otherRequire.normalize('./foo/core'), 'foo/other/foo/core', "no difference for fake main");
67 | });
68 | 
69 | test('normalize tilde paths with lib', function() {
70 |   var spade = t.spade, fooRequire;
71 |   spade.register('foo', { directories: { lib: './lib' }}); // register as a package
72 |   spade.register('foo/main', 'return require;');
73 |   fooRequire = spade.require('foo');
74 |   equal(fooRequire.normalize('foo/~lib/main'), 'foo/main');
75 |   equal(fooRequire.normalize('foo/~lib/core'), 'foo/core');
76 | });
77 | 
78 | })();
79 | 


--------------------------------------------------------------------------------
/tests/async-test.js:
--------------------------------------------------------------------------------
  1 | // ==========================================================================
  2 | // Project:   Spade - CommonJS Runtime
  3 | // Copyright: ©2010 Strobe Inc. All rights reserved.
  4 | // License:   Licened under MIT license (see __preamble__.js)
  5 | // ==========================================================================
  6 | /*globals spade */
  7 | 
  8 | (function() {
  9 | 
 10 | var t = {}, Spade = spade.Spade;
 11 |   
 12 | // ..........................................................
 13 | // BASIC REQUIRE
 14 | // 
 15 | 
 16 | module('spade: async require', {
 17 |   setup: function() {
 18 |     t.spade = new Spade(); 
 19 | 
 20 |     // preload a module
 21 |     t.spade.register('foo/baz', function(require,e) { 
 22 |       e.id = 'foo/baz'; 
 23 |       e.async = require.async; // export for testing
 24 |     });
 25 | 
 26 |     // dummy loader loads only foo/bar on demand after delay
 27 |     t.spade.loader = {
 28 | 
 29 |       requests: 0, 
 30 | 
 31 |       loadFactory: function(spade, id, done) {
 32 |         this.requests++;
 33 |         if (id === 'foo/bar') {
 34 |           setTimeout(function() {
 35 |             spade.register(id, function(r,e) { e.id='foo/bar'; });
 36 |             done();
 37 |           }, 10);
 38 | 
 39 |         } else {
 40 |           done('Not Found'); // immediately
 41 |         }
 42 |       }
 43 |     };
 44 |   },
 45 |   
 46 |   teardown: function() {
 47 |     delete t.spade;
 48 |   }
 49 | });
 50 | 
 51 | test('should not talk to loader if registered', function() {
 52 |   var spade = t.spade;
 53 | 
 54 |   stop(1000);
 55 |   
 56 |   spade.async('foo/baz', function(err) {
 57 |     start();
 58 |     equal(err, null);
 59 |     equal(spade.loader.requests, 0, 'loader should not have been called');
 60 |     equal(spade.require('foo/baz').id, 'foo/baz', 'should find foo');
 61 |   });
 62 |   
 63 | });
 64 | 
 65 | test('should let loader register', function() {
 66 |   var spade = t.spade;
 67 |   stop(1000);
 68 |   spade.async('foo/bar', function(err) {
 69 |     start();
 70 |     equal(err, null);
 71 |     equal(spade.loader.requests, 1, 'loader should have been called');
 72 |     equal(spade.require('foo/bar').id, 'foo/bar', 'should find foo');
 73 |   });
 74 | });
 75 | 
 76 | 
 77 | test('should normalize id', function() {
 78 |   var spade = t.spade;
 79 |   stop(1000);
 80 |   spade.async('/./foo/baz/../bar', function(err) {
 81 |     start();
 82 |     equal(err, null);
 83 |     equal(spade.loader.requests, 1, 'loader should have been called');
 84 |     equal(spade.require('foo/bar').id, 'foo/bar', 'should find foo');
 85 |   });
 86 | });
 87 | 
 88 | 
 89 | test('should expose async inside of module', function() {
 90 |   var spade = t.spade;
 91 |   stop(1000);
 92 | 
 93 |   var async = spade.require('foo/baz').async;
 94 |   ok(async, 'should have an async function');
 95 |   
 96 |   // normalize relative to async
 97 |   async('./bar', function(err) {
 98 |     start();
 99 |     equal(err, null);
100 |     equal(spade.loader.requests, 1, 'loader should have been called');
101 |     equal(spade.require('foo/bar').id, 'foo/bar', 'should find foo');
102 |   });
103 | });
104 | 
105 | 
106 | test('should return err if loader does not register', function() {
107 |   var spade = t.spade;
108 |   stop(1000);
109 |   spade.async('imaginary/bar', function(err) {
110 |     start();
111 |     equal(err, 'Not Found');
112 |     equal(spade.loader.requests, 1, 'loader should have been called');
113 | 
114 |     raises(function() {
115 |       spade.require('imaginary/bar');
116 |     });
117 |   });
118 |   
119 | });
120 | 
121 | })();
122 | 


--------------------------------------------------------------------------------
/lib/spade.js:
--------------------------------------------------------------------------------
   1 | // ==========================================================================
   2 | // Project:   Spade - CommonJS Runtime
   3 | // Copyright: ©2010 Strobe Inc. All rights reserved.
   4 | // License:   Licened under MIT license
   5 | // ==========================================================================
   6 | /*jslint evil:true */
   7 | /*globals spade ARGS ARGV ENV __module ActiveXObject */
   8 | 
   9 | (function() {
  10 | 
  11 | var K, Sandbox, Sp, Evaluator, Ep, Loader, Lp, Spade, Tp;
  12 | 
  13 | 
  14 | // ..........................................................
  15 | // HELPER FUNCTIONS
  16 | // 
  17 | 
  18 | K = function() {}; // noop
  19 | 
  20 | // assume id is already normalized
  21 | function packageIdFor(normalizedId) {
  22 |   return normalizedId.slice(0, normalizedId.indexOf('/'));
  23 | }
  24 | 
  25 | function remap(id, contextPkg) {
  26 |   var mappings = contextPkg ? contextPkg.mappings : null;
  27 |   if (!mappings) { return id; }
  28 | 
  29 |   var packageId = packageIdFor(id);
  30 |   if (mappings[packageId]) {
  31 |     id = mappings[packageId] + id.slice(id.indexOf('/'));
  32 |   }
  33 |   return id;
  34 | }
  35 | 
  36 | // convert a relative or otherwise de-normalized module id into canoncial form
  37 | // normalize('./foo', 'bar/baz') -> 'bar/foo'
  38 | // normalize('foo', 'bar/baz') -> 'foo/main' (or foo/~package is asPackage)
  39 | // normalize('foo/bar', 'bar/baz') -> 'foo/bar'
  40 | function normalize(id, contextId, contextPkg, _asPackage) {
  41 |   var idx, len;
  42 | 
  43 |   // slice separator off the end since it is not used...
  44 |   if (id[id.length-1]==='/') { id = id.slice(0,-1); }
  45 | 
  46 |   // need to walk if there is a .
  47 |   if (id.indexOf('.')>=0) {
  48 |     var parts = contextId && (id.charAt(0) ==='.') ? contextId.split('/') : [],
  49 |         part, next,
  50 |         packageName = parts[0],
  51 |         needsCleanup = false;
  52 | 
  53 |     idx = 0;
  54 |     len = id.length;
  55 | 
  56 |     if (contextPkg && contextPkg.main && contextId === packageName+'/main') {
  57 |     // If we're requiring from main we need to handle relative requires specially
  58 |       needsCleanup = true;
  59 |       parts = contextPkg.main.replace(/^\.?\//, '').split('/');
  60 |     }
  61 | 
  62 |     parts.pop(); // get rid of the last path element since it is a module.
  63 | 
  64 |     while(idx<len) {
  65 |       next = id.indexOf('/', idx);
  66 |       if (next<0) { next = len; }
  67 |       part = id.slice(idx, next);
  68 |       if (part==='..') { parts.pop(); }
  69 |       else if (part!=='.' && part!=='' && part!==null) { parts.push(part); }
  70 |       // skip .., empty, and null.
  71 |       idx = next+1;
  72 |     }
  73 | 
  74 |     id = parts.join('/');
  75 | 
  76 |     if (needsCleanup) {
  77 |       var libPaths = contextPkg.directories.lib;
  78 |       for (idx=0,len=libPaths.length; idx<len; idx++){
  79 |         id = id.replace(libPaths[idx].replace(/^\.?\//, '')+'/', '');
  80 |       }
  81 |       id = packageName+'/'+id;
  82 |     }
  83 | 
  84 |   // else, just slice off beginning '/' if needed
  85 |   } else if (id[0]==='/') { id = id.slice(1); }
  86 | 
  87 |   // if we end up with no separators, make this a pkg
  88 |   if (id.indexOf('/')<0) { id = id+(_asPackage ? '/~package' : '/main'); }
  89 | 
  90 |   // slice separators off begin and end
  91 |   if (id[0]==='/') { id = id.slice(1); }
  92 | 
  93 |   // Remove unnecessary ~lib references
  94 |   id = id.replace('~lib/', '');
  95 | 
  96 |   return remap(id, contextPkg);
  97 | }
  98 | 
  99 | // ..........................................................
 100 | // SANDBOX - you could make a secure version if you want
 101 | // 
 102 | 
 103 | // runs a factory within context and returns exports...
 104 | function execFactory(id, factory, sandbox, spade) {
 105 |   var require, mod, factoryData, fullId;
 106 | 
 107 |   var filename = factory.filename,
 108 |       ARGV     = sandbox.ARGV,
 109 |       ENV      = sandbox.ENV;
 110 | 
 111 |   require = sandbox.makeRequire(id, spade);
 112 |   
 113 |   sandbox._modules[id] = mod = {
 114 |     id:        id,
 115 |     exports:   {},
 116 |     sandbox:   sandbox
 117 |   };
 118 | 
 119 |   factoryData = factory.data; // extract the raw module body
 120 | 
 121 |   // evaluate if needed - use cache so we only do it once per sandbox
 122 |   if ('string' === typeof factoryData) {
 123 |     
 124 |     if (sandbox._factories[id]) {
 125 |       factoryData = sandbox._factories[id];
 126 |     } else {
 127 |       sandbox._loading[id] = true;
 128 | 
 129 |       // The __evalFunc keeps IE 9 happy since it doesn't like
 130 |       // unassigned anonymous functions
 131 |       factoryData = sandbox.evaluate('__evalFunc = '+factoryData+'\n//@ sourceURL='+filename+'\n', filename);
 132 |       sandbox._factories[id] = factoryData;
 133 |       sandbox._loading[id] = false;
 134 |     }
 135 |   }
 136 | 
 137 |   if ('function' === typeof factoryData) {
 138 |     var ret = factoryData(require, mod.exports, mod, ARGV, ENV, filename);
 139 |     if (ret !== undefined) { mod.exports = ret; } // allow return exports
 140 |   } else {
 141 |     mod.exports = factoryData;
 142 |   }
 143 | 
 144 |   return mod.exports;
 145 | }
 146 | 
 147 | /**
 148 |   @constructor
 149 | 
 150 |   Sandbox provides an isolated context for loading and running modules.
 151 |   You can create new sandboxes anytime you want.  If you pass true for the
 152 |   isolate flag, then the sandbox will be created in a separate context if
 153 |   supported on the platform.  Otherwise it will share globals with the
 154 |   default sandbox context.
 155 | 
 156 |   Note that isolated sandboxes are not the same as secure sandboxes.  For
 157 |   example in the browser, a isolated sandbox is created using an iframe
 158 |   which still exposes access to the DOM and parent environment.
 159 | 
 160 |   Isolated sandboxes are mostly useful for testing and sharing plugin code
 161 |   that might want to use different versions of packages.
 162 | 
 163 |   @param {Spade} spade
 164 |     The spade instance
 165 | 
 166 |   @param {String} name
 167 |     (Optional) name of the sandbox for debugging purposes
 168 |     
 169 |   @param {Boolean} isolate
 170 |     Set to true if you want to isolate it
 171 | 
 172 |   @returns {Sandbox} instance
 173 | */
 174 | Sandbox = function(spade, name, isolate) {
 175 |   
 176 |   // name parameter is optional
 177 |   if (typeof name !== 'string') {
 178 |     isolate = name;
 179 |     name = null;
 180 |   }
 181 | 
 182 |   if (!name) { name = '(anonymous)'; }
 183 | 
 184 |   this.spade = spade;
 185 |   this.name  = name;
 186 |   this.isIsolated = !!isolate;
 187 |   this._factories = {}; // evaluated factories
 188 |   this._loading   = {}; // list of loading modules
 189 |   this._modules   = {}; // cached export results
 190 |   this._used      = {}; // to detect circular references
 191 | };
 192 | 
 193 | // alias this to help minifier make the page a bit smaller.
 194 | Sp = Sandbox.prototype;
 195 | 
 196 | Sp.toString = function() {
 197 |   return '[Sandbox '+this.name+']';
 198 | };
 199 | 
 200 | /**
 201 |   Evaluate the passed string in the Sandbox context, returning the result.
 202 |   This is the primitive used to evalute string-encoded factories into
 203 |   modules that can execute within a specific context.
 204 | */
 205 | Sp.evaluate = function(code, filename) {
 206 |   if (this.isDestroyed) { throw new Error("Sandbox destroyed"); }
 207 |   if (!this._evaluatorInited) {
 208 |     this._evaluatorInited = true;
 209 |     this.spade.evaluator.setup(this);
 210 |   }
 211 |   return this.spade.evaluator.evaluate(code, this, filename);
 212 | };
 213 | 
 214 | /**
 215 |   NOTE: This is a primitive form of the require() method.  Usually you should
 216 |   use the require() method defined in your module.
 217 | 
 218 |   Sandbox-specific require.  This is the most primitive form of require.  All
 219 |   other requires() pass through here.
 220 |   
 221 |   @param {String} id
 222 |     The module id you want to require.
 223 |     
 224 |   @param {String} callingId
 225 |     (Optional) The id of the module requiring the module.  This is needed if 
 226 |     you the id you pass in might be relative.
 227 |     
 228 |   @returns {Object} exports of the required module
 229 | */
 230 | Sp.require = function(id, callingId) {
 231 |   var spade = this.spade,
 232 |       pkg, ret, factory;
 233 |       
 234 |   pkg = callingId ? spade.package(callingId) : null;
 235 |   id = normalize(id, callingId, pkg);
 236 | 
 237 |   ret = this._modules[id];
 238 |   if (ret) { ret = ret.exports; }
 239 | 
 240 |   if (ret) {
 241 |     
 242 |     // save so we can detect circular references later
 243 |     if (!this._used[id]) { this._used[id] = ret; }
 244 |     return ret ;
 245 | 
 246 |   } else {
 247 |     factory = spade.loadFactory(spade.resolve(id, this));
 248 |     if (!factory) { throw new Error('Module '+id+' not found'); }
 249 | 
 250 |     if (!this.ENV)  { this.ENV = spade.env(); } // get at the last minute
 251 |     if (!this.ARGV) { this.ARGV = spade.argv(); }
 252 | 
 253 |     ret = execFactory(id, factory, this, spade);
 254 | 
 255 |     if (this._used[id] && (this._used[id] !== ret)) {
 256 |       throw new Error("Circular require detected for module "+id);
 257 |     }
 258 |   }
 259 | 
 260 |   return ret ;
 261 | };
 262 | 
 263 | /**
 264 |   NOTE: This is a primitive form of the exists() method.  Usually you should
 265 |   use the require.exists() method defined on the require() function in your
 266 |   module.
 267 | 
 268 |   Sandbox-specific test to determine if the named module exists or not.
 269 |   This property only reflects what is immediately available through the
 270 |   sync-loader.  Using the async loader may change the return value of this
 271 |   call.
 272 |   
 273 |   @param {String} id
 274 |     The module id you want to test
 275 |     
 276 |   @param {String} callingId
 277 |     (Optional) The id of the module requesting the module.  Required if the id 
 278 |     you pass in might be relative.
 279 |     
 280 |   @returns {Object} exports of the required module
 281 | */
 282 | Sp.exists = function(id, callingId) {
 283 |   var spade = this.spade, pkg;
 284 |   pkg = callingId ? spade.package(callingId) : null;
 285 |   id  = normalize(id, callingId, pkg);
 286 |   if (this._modules[id]) { return true; }
 287 |   return spade.factoryExists(spade.resolve(id, this));
 288 | };
 289 | 
 290 | /**
 291 |   NOTE: This is a primitive form of the async() method.  Usually you should
 292 |   use the require.async() method defined on the require() function in your
 293 |   module.
 294 |   
 295 |   Asynchronously attempts to load a module, invoking a callback if and when
 296 |   the module is loaded.  If the module is already defined, the callback will
 297 |   be invoked immediately.  Otherwise, this will use the Loader plugin on the
 298 |   main spade context to attempt to load the module.  If the module cannot 
 299 |   be loaded, the callback will be invoked with an error object as its first
 300 |   parameter to inform you that it failed.
 301 |   
 302 |   Note that the default Loader that ships with spade is not actually capable
 303 |   of asynchronously loading modules, which means this method will always fail
 304 |   unless the module is already present.  You can use the spade-loader package
 305 |   to install an async loader that will work.
 306 |   
 307 |   @param {String} id
 308 |     The module id you want to load
 309 | 
 310 |   @param {Function} callback
 311 |     A callback to invoke when the module is loaded or if the load has failed.
 312 |     The calback should expect an error object (or null) as the first 
 313 |     parameter.
 314 |     
 315 |   @param {String} callingId
 316 |     (Optional) The id of the module requesting the module.  Required if the id 
 317 |     you pass in might be relative.
 318 |     
 319 |   @returns {void}
 320 | */
 321 | Sp.async = function(id, callback, callingId) {
 322 |   var spade = this.spade, pkg;
 323 |   pkg = callingId ? spade.package(callingId) : null;
 324 |   id = spade.resolve(normalize(id, callingId, pkg), this);
 325 |   spade.loadFactory(id, callback);
 326 | };
 327 | 
 328 | /**
 329 |   NOTE: This is a primitive form of the url() method.  Usually you should
 330 |   use the require.url() method defined on the require() function in your
 331 |   module.
 332 | 
 333 |   Returns the URL of the given resource based on the settings of the named
 334 |   package.  This method requires the package information to include a `root`
 335 |   property that defines the root URL where resources can be found.  
 336 |   
 337 |   This method is useful for finding non-JavaScript resources such as images,
 338 |   video, etc.
 339 |   
 340 |   @param {String} id
 341 |     A module id form of the reference you want to load.
 342 |     
 343 |   @param {String} ext
 344 |     (Optional) and extension to append to the returned URL.
 345 |     
 346 |   @param {String} callingId
 347 |     (Optional) The id of the module requesting the module.  Required if the id 
 348 |     you pass in might be relative.
 349 | 
 350 |   @param {String} the computed URL.
 351 | */
 352 | Sp.url = function(id, ext, callingId) {
 353 |   var spade = this.spade, ret, pkg;
 354 | 
 355 |   pkg = callingId ? spade.package(callingId) : null;
 356 |   id = normalize(id, callingId, pkg);
 357 | 
 358 |   pkg = spade.package(id);
 359 |   if (!pkg) {
 360 |     var packageId = packageIdFor(id)+'/~package';
 361 |     if (spade.exists(packageId)) { spade.require(packageId); }
 362 |     pkg = spade.package(id);
 363 |   }
 364 | 
 365 |   if (!pkg) {
 366 |     throw new Error("Can't get url for non-existent package "+id);
 367 |   }
 368 | 
 369 |   if (!pkg.root) {
 370 |     throw new Error('Package for '+id+' does not support urls');
 371 |   }
 372 | 
 373 |   ret = pkg.root + id.slice(id.indexOf('/'));
 374 |   if (ext) { ret = ret+'.'+ext; }
 375 |   return ret ;
 376 | };
 377 | 
 378 | Sp.isDestroyed = false;
 379 | 
 380 | Sp.destroy = function() {
 381 |   if (!this.isDestroyed) {
 382 |     this.isDestroyed = true;
 383 |     this.spade.evaluator.teardown(this);
 384 |   }
 385 |   return this;
 386 | };
 387 | 
 388 | /**
 389 |   Return a new require function for the normalized module ID.  Normally you
 390 |   would not call this method yourself but you might override it if you want 
 391 |   to add new API to the require() methods passed into modules.
 392 | */
 393 | Sp.makeRequire = function(id, spade) {
 394 |   var pkg     = spade.package(id),
 395 |       sandbox = this,
 396 |       require;
 397 | 
 398 |   require = function(moduleId) {
 399 |     return sandbox.require(moduleId, id, pkg);
 400 |   };
 401 | 
 402 |   // make the require 'object' have the same API as sandbox and spade.
 403 |   require.require = require;
 404 | 
 405 |   require.exists = function(moduleId) {
 406 |     return sandbox.exists(normalize(moduleId, id, pkg));
 407 |   };
 408 | 
 409 |   require.normalize = function(moduleId) {
 410 |     return normalize(moduleId, id, pkg);
 411 |   };
 412 | 
 413 |   require.async = function(moduleId, callback) {
 414 |     return sandbox.async(normalize(moduleId, id, pkg), callback);
 415 |   };
 416 | 
 417 |   require.sandbox = function(name, isolate) {
 418 |     return spade.sandbox(name, isolate);
 419 |   };
 420 | 
 421 |   require.url = function(moduleId, ext) {
 422 |     return sandbox.url(normalize(moduleId, id, pkg), ext);
 423 |   };
 424 | 
 425 |   require.id = id; // so you can tell one require from another
 426 | 
 427 |   return require;
 428 | };
 429 | 
 430 | // ..........................................................
 431 | // LOADER
 432 | //
 433 | 
 434 | /**
 435 |   @constructor 
 436 |   
 437 |   The Loader object is used to asynchronously load modules from the server.
 438 |   It also provides other low-level URL resolution and event handling 
 439 |   functions needed to integrate with the low-level environment.  The default
 440 |   implementation does not support any kind of async loading.  See the 
 441 |   spade-loader package for a way to add support for this.
 442 | */
 443 | Loader = function() {
 444 |   this._loading = {};
 445 | };
 446 | 
 447 | Lp = Loader.prototype;
 448 | 
 449 | /**
 450 |   Called by spade whenever a module is requested that has not already been
 451 |   registered in memory.  This function should attempt to load the module if 
 452 |   possible, registering any packages on the spade instance.
 453 |   
 454 |   If a `done` is a function, then this method should run asynchronously -
 455 |   invoking the callback when complete.  If the load failed, this method should
 456 |   pass an error as the first parameter.  Otherwise it should not pass any 
 457 |   parameter.
 458 |   
 459 |   If `done` is null, then this method should run synchronously and then simply
 460 |   return when it is complete.  If the named module cannot be loaded, you can
 461 |   just return with no errors as the spade environment will detect this 
 462 |   condition and fail.
 463 |   
 464 |   Note that loaders are not required to support both sync and async loading. 
 465 |   If you don't support one or the other, simply throw an error.
 466 |   
 467 |   @method
 468 |   
 469 |   @param {Spade} spade
 470 |     The spade instance.
 471 |     
 472 |   @param {String} id
 473 |     The normalized module id to load.
 474 |     
 475 |   @param {Function} done
 476 |     (Optional) if passed, run this function async and invoke the done callback
 477 |     when complete.
 478 |     
 479 |   @returns {void}
 480 | */
 481 | Lp.loadFactory = null;
 482 | 
 483 | /**
 484 |   Called by spade whenever it wants to detect if a given module exists and the
 485 |   id is not yet registered with the spade instance.
 486 |   
 487 |   This method should do its best to determine if the module exists and return
 488 |   the appropriate value.  Note that if you only support async loading of 
 489 |   modules then you may not be able to detect when a module is defined outside
 490 |   of what is already registered. In this case it is OK to simply return false.
 491 |   
 492 |   @method
 493 |   
 494 |   @param {Spade} spade
 495 |     The spade instance.
 496 |     
 497 |   @param {String} id
 498 |     The normalized module id to load
 499 |     
 500 |   @returns {Boolean} true if module exists
 501 | */
 502 | Lp.exists = null;
 503 | 
 504 | // NOTE: On ready stuff mostly stolen from jQuery 1.4.  Need to incl here
 505 | // because spade will often be used to load jQuery.
 506 | // Will only be invoked once.  Just be prepared to call it
 507 | /**
 508 |   Called once by spade on page load to schedule a ready callback, which should
 509 |   be invoked once the documents 'ready' event (or an equivalent) is fired.
 510 | 
 511 |   You should never call this method yourself but you might override it when
 512 |   using spade outside of a proper browser.
 513 | 
 514 |   @param {Function} callback
 515 |     The callback to be invoked when the document is 'ready'.
 516 |     
 517 |   @returns {void}
 518 | */
 519 | Lp.scheduleReady = function(callback) {
 520 | 
 521 |   // handle case where ready is invoked AFTER the document is already ready
 522 |   if ( document.readyState === "complete" ) { return setTimeout(callback, 1); }
 523 | 
 524 |   var handler, handled = false;
 525 | 
 526 |   // The DOM ready check for Internet Explorer
 527 |   function doScrollCheck() {
 528 |     if (handled) { return; }
 529 | 
 530 |     try {
 531 |       // If IE is used, use the trick by Diego Perini
 532 |       // http://javascript.nwbox.com/IEContentLoaded/
 533 |       document.documentElement.doScroll("left");
 534 |     } catch(e) {
 535 |       setTimeout( doScrollCheck, 1 );
 536 |       return;
 537 |     }
 538 | 
 539 |     // and execute any waiting functions
 540 |     handler();
 541 |   }
 542 | 
 543 |   // Mozilla, Opera and webkit nightlies currently support this event
 544 |   if (document.addEventListener) {
 545 | 
 546 |     handler = function() {
 547 |       if (handled) { return; }
 548 |       handled = true;
 549 |       document.removeEventListener("DOMContentLoaded", handler, false);
 550 |       window.removeEventListener('load', handler, false);
 551 |       callback();
 552 |     };
 553 | 
 554 |     document.addEventListener( "DOMContentLoaded", handler, false);
 555 | 
 556 |     // A fallback to window.onload, that will always work
 557 |     window.addEventListener( "load", handler, false );
 558 | 
 559 |   // If IE event model is used
 560 |   } else if ( document.attachEvent ) {
 561 | 
 562 |     handler = function() {
 563 |       if (!handled && document.readyState === "complete") {
 564 |         handled = true;
 565 |         document.detachEvent( "onreadystatechange", handler );
 566 |         window.detachEvent('onload', handler);
 567 |         callback();
 568 |       }
 569 |     };
 570 | 
 571 |     // ensure firing before onload,
 572 |     // maybe late but safe also for iframes
 573 |     document.attachEvent("onreadystatechange", handler);
 574 | 
 575 |     // A fallback to window.onload, that will always work
 576 |     window.attachEvent( "onload", handler);
 577 | 
 578 |     // If IE and not a frame
 579 |     // continually check to see if the document is ready
 580 |     var toplevel = false;
 581 | 
 582 |     try {
 583 |       toplevel = window.frameElement === null;
 584 |     } catch(e) {}
 585 |     if ( document.documentElement.doScroll && toplevel ) { doScrollCheck(); }
 586 |   }
 587 | };
 588 | 
 589 | // ..........................................................
 590 | // Evaluator Class
 591 | //
 592 | 
 593 | /**
 594 |   @constructor
 595 |   
 596 |   An Evaluator instance is used to evaluate code inside of a sandbox.  A 
 597 |   default instance is created on spade and used automatically by sandboxes. 
 598 |   You can extend this class and replace the default one on spade in order to
 599 |   provide additional new features, such as sandbox isolation or secure eval.
 600 | 
 601 |   The default Evaluator simply evals code in the current context using the 
 602 |   built-in eval() function.  It does not support isolated sandboxes.  To add
 603 |   isolated sandbox support, add the `spade-isolate` package.
 604 | */
 605 | Evaluator = function() {};
 606 | Ep = Evaluator.prototype;
 607 | 
 608 | /**
 609 |   Called once on each new sandbox to allow the evaluator to setup any required
 610 |   context for future calls.  For isolated sandboxes, this is usually where
 611 |   you would create the new compilation context and store it on the sandbox for
 612 |   future use.
 613 |   
 614 |   The default implementation does nothing, but will throw an exception if you
 615 |   try to setup a new isolated sandbox. (Since the feature is not supported.).
 616 |   If you override this method, you do not need to call the default function.
 617 |   
 618 |   @param {Sandbox} sandbox
 619 |     The sandbox to setup.
 620 |     
 621 |   @returns {void}
 622 | */
 623 | Ep.setup = function(sandbox) {
 624 |   if (sandbox.isIsolated) { 
 625 |     throw new Error("Isolated sandboxes are not supported."); 
 626 |   }
 627 | };
 628 | 
 629 | /**
 630 |   Evaluates the passed JavaScript within the context of a sandbox and returns
 631 |   the resulting value (usually a function).  The default version simply calls
 632 |   the built-in eval().
 633 |   
 634 |   @param {String} text
 635 |     The code to evaluate.
 636 |     
 637 |   @param {Sandbox} sandbox
 638 |     The sandbox owning the code.
 639 |     
 640 |   @param {String} filename
 641 |     An optional filename to associate with the text (may be useful for debug
 642 |     support)
 643 |     
 644 |   @returns {Object} evaluated result.
 645 | */
 646 | Ep.evaluate = function(text, sandbox, filename) {
 647 |   return eval(text);
 648 | };
 649 | 
 650 | /**
 651 |   Called once by the sandbox when it is destroyed to allow the evaluator to
 652 |   cleanup any data it might have stashed on the sandbox.  For isolated 
 653 |   sandboxes, this method might destroy the compilation context to allow its 
 654 |   memory to be reclaimed.
 655 |   
 656 |   Since the default evaluator does not support isolated contexts, this method
 657 |   is a no-op.
 658 |   
 659 |   @param {Sandbox} sandbox
 660 |     The sandbox about to be destroyed.
 661 |     
 662 |   @returns {void}
 663 | */
 664 | Ep.teardown = function(sandbox) {
 665 |   // noop by default
 666 | };
 667 | 
 668 | // ..........................................................
 669 | // Spade Class - defined so we can recreate
 670 | //
 671 | 
 672 | /**
 673 |   @constructor
 674 |   
 675 |   The root object used to coordinate the entire spade environment.  A global
 676 |   instance of this class is created on page load called `spade`.  Most of the
 677 |   time you will only interact with this object directly to register new 
 678 |   modules and perhaps to load a new module outside of traditional module code.
 679 |   
 680 |   Note that if you are using BPM and your app is actually published as modules
 681 |   then you won't actually need reference this object at all as the details are
 682 |   handled for you.
 683 | 
 684 |   # Registering a Module
 685 |   
 686 |   If you are manually constructing a JavaScript file to load from the server
 687 |   and you want to register new modules, you will need to use the
 688 |   `spade.register()` method:
 689 |   
 690 |       spade.register('package_name/module_name', function() { ... });
 691 |       
 692 |   This will make the module `package_name/module_name` available to all other
 693 |   modules.  The first time the module is required, your passed function will
 694 |   be called.
 695 |   
 696 |   You can also register metadata about a package by registering the 
 697 |   `package_name/~package` module:
 698 |   
 699 |       spade.register('package_name/~package', { 
 700 |         "name": "package_name",
 701 |         "version": "1.0.0",
 702 |         ...
 703 |       });
 704 |       
 705 |   Note that in addition to factory functions you can also pass in JSON hashes
 706 |   (which will simply be returned directory) or a string of code - which will
 707 |   be eval'd on demand.
 708 |   
 709 |   The string format is particularly important because defining modules as 
 710 |   strings can dramatically improve load time on mobile devices while also 
 711 |   allowing you to easily support isolated sandbox contexts.
 712 |   
 713 |   # Requiring a Module
 714 |   
 715 |   Normally when you write module code that is managed by Spade you will have
 716 |   a `require()` method defined within the module that you should use to load
 717 |   modules.
 718 |   
 719 |   If you happen to be writing code outside of a spade module and need to 
 720 |   require a module, however, you can use the `spade.require()` method instead:
 721 |   
 722 |       var jQuery = spade.require('jquery');
 723 |       
 724 |   This works just like the built-in require method except it will not support
 725 |   relative modules (since there is no module to be relative too).  This 
 726 |   method will require modules from the default sandbox, found at 
 727 |   `spade.defaultSandbox`.
 728 |   
 729 |   # Plugins
 730 |   
 731 |   Spade supports a number of plugins that you can use to enhance the way 
 732 |   spade discovers and loads modules.  The two plugins currently supported are
 733 |   a `loader` and `evaluator`.
 734 |   
 735 |   The `loader` plugin is used to asynchronously discover and load modules. It
 736 |   expects the object to be an instance of Spade.Loader.  See `Loader` 
 737 |   documentation for more information.
 738 |   
 739 |   The `evaluator` plugin is used to evaluate code within a sandbox context. It
 740 |   can be enhanced to support isolated sandboxes as well as worker threads and
 741 |   many other contexts.  See the `Evaluator` documentation for more 
 742 |   information.
 743 |   
 744 | */
 745 | Spade = function() {
 746 |   this.loader   = new this.Loader(this);
 747 |   this.evaluator = new this.Evaluator(this);
 748 |   this.defaultSandbox  = this.sandbox();
 749 |   this._factories = {};
 750 |   this._packages  = {};
 751 | };
 752 | 
 753 | Tp = Spade.prototype;
 754 | 
 755 | Tp.VERSION  = "1.0.0";
 756 | 
 757 | // expose the classes.  We do it this way so that you can create a new
 758 | // Spade instance and treat it like the spade module
 759 | Tp.Spade    = Spade;
 760 | Tp.Sandbox  = Sandbox;
 761 | Tp.Loader   = Loader;
 762 | Tp.Evaluator = Evaluator;
 763 | 
 764 | /**
 765 |   Computes and returns a normalized ENV hash.  By default this will look for
 766 |   a globally defined variable called `ENV` and use that.  If not defined,
 767 |   it will look for a locally defined `ENV` variable instead.
 768 |   
 769 |   In either case, this method will also normalize the variable to include at
 770 |   least the `LANG` and `SPADE_PLATFORM` properties.
 771 |   
 772 |   @returns {Hash} the environment hash
 773 | */
 774 | Tp.env = function() {
 775 |   var env = this.ENV;
 776 |   if (!env) { this.ENV = env = ('undefined' !== typeof ENV) ? ENV : {}; }
 777 |   if (!env.SPADE_PLATFORM) { env.SPADE_PLATFORM = 'browser'; }
 778 |   if (!env.LANG) {
 779 |     env.LANG = ('undefined' !== typeof navigator) ? navigator.language : 'en-US';
 780 |   }
 781 |     
 782 |   return env;
 783 | };
 784 | 
 785 | /**
 786 |   Computes and returns the ARGV array for the current spade environment.  By
 787 |   default this will look for a globally defined variable called `ARGV` and 
 788 |   use that.
 789 |   
 790 |   ARGV is a useful way to pass in startup options to spade modules.
 791 |   
 792 |   @returns {Array} the argv array
 793 | */
 794 | Tp.argv = function() {
 795 |   var argv = this.ARGV;
 796 |   if (!argv) { argv= this.ARGV = ('undefined' !== typeof ARGV) ? ARGV : []; }
 797 |   return argv;
 798 | };
 799 | 
 800 | /**
 801 |   Restores original values after a call to `spade.globalize()`.  If you call 
 802 |   this method more than once it will have no effect.
 803 |   
 804 |   @returns {void}
 805 | */
 806 | Tp.noConflict = function() {
 807 |   var c = this._conflict;
 808 |   if (c) {
 809 |     delete this._conflict;
 810 |     spade = this._conflict;
 811 |   }
 812 |   return this;
 813 | };
 814 | 
 815 | /**
 816 |   Returns a new sandbox instance attached to the current spade instance.
 817 |   If you pass true for the `isolate` parameter, the new sandbox will attempt
 818 |   to load its code in an isolated compilation context (possibly using an 
 819 |   iframe in browsers).  Note that isolated sandboxes are not supported by 
 820 |   default.  Include the spade-isolate package instead.
 821 | 
 822 |   @param {String} name
 823 |     (Optional) name for the sandbox for debugging purposes.
 824 |   
 825 |   @param {Boolean} isolate
 826 |     true if you want the sandbox to be isolated.  Throws exception if
 827 |     platform cannot isolate.
 828 | 
 829 |   @returns {Sandbox} sandbox instance
 830 | */
 831 | Tp.sandbox = function(name, isolate) {
 832 |   return new this.Sandbox(this, name, isolate);
 833 | };
 834 | 
 835 | /**
 836 |   Register a module or package information.  You can pass one of the
 837 |   following:
 838 | 
 839 |     'module/id', 'module body string'
 840 |     'module/id', function() { module func }
 841 |     'module/id', { exports: 'foo' }
 842 |     'module/id' - just register module id and no body to indicate presence
 843 | 
 844 |   Note also that if you pass just a packageId, it will be normalized to
 845 |   packageId/~package.  This is how you register a package.
 846 | 
 847 |   @param {String} id
 848 |     The module or package id
 849 | 
 850 |   @param {String|Function|Hash} data
 851 |     A module function, module body (as string), or hash of exports to use.
 852 | 
 853 |   @param {String} opts
 854 |     Additional metadata only if you are registering a module factory.  Known
 855 |     keys include 'filename' and 'format' (for compilation of DSLs).
 856 | 
 857 |   @returns {void}
 858 | */
 859 | Tp.register = function(id, data, opts) {
 860 |   if (!data) { data = K ; }
 861 |   var t = typeof data, isExtern, factory, isPkg;
 862 | 
 863 |   id = normalize(id, null, null, true);
 864 |   isPkg = id.slice(-9) === '/~package';
 865 | 
 866 |   // register - note packages can only accept hashes
 867 |   if (isPkg && 'object'!==typeof data) {
 868 |     throw new Error('You can only register hashes for packages');
 869 |   }
 870 | 
 871 |   // Set some package defaults
 872 |   if (isPkg) {
 873 |     if (!data.directories) { data.directories = {}; }
 874 |     if (!data.directories.lib) {
 875 |       data.directories.lib = ['lib'];
 876 |     } else if (typeof data.directories.lib === 'string') {
 877 |       data.directories.lib = [data.directories.lib];
 878 |     }
 879 |   }
 880 | 
 881 |   factory = { data: data };
 882 |   factory.filename     = opts && opts.filename ? opts.filename : id;
 883 | 
 884 |   // Store with generic id if none, or if JS
 885 |   this._factories[id] = factory;
 886 |   return this;
 887 | };
 888 | 
 889 | /**
 890 |   Efficient way to register external packages.  Pass a hash of packageIds
 891 |   and source URLs.  If the package is already registered, the extern will
 892 |   not replace it so this is safe to call multiple times.
 893 |   
 894 |   @param {Hash} externs
 895 |     A hash of package names and package settings.
 896 |     
 897 |   @returns {void}
 898 | */
 899 | Tp.externs = function(externs, extern) {
 900 |   var tmp, packages = this._packages;
 901 | 
 902 |   // normalize method call.
 903 |   if ('string' === typeof externs) {
 904 |     tmp = {};
 905 |     tmp[externs] = extern;
 906 |     externs = tmp;
 907 |     extern = null;
 908 |   }
 909 | 
 910 |   for(var packageId in externs) {
 911 |     if (!externs.hasOwnProperty(packageId)) { continue; }
 912 |     if (packages[packageId] && !packages[packageId].extern) { continue; }
 913 | 
 914 |     extern = externs[packageId];
 915 |     if ('string' === typeof extern) { extern = {name: packageId, src: extern}; }
 916 |     extern.extern = true;
 917 |     this.register(packageId, extern);
 918 |   }
 919 | };
 920 | 
 921 | /**
 922 |   Require a module from the default sandbox.
 923 | 
 924 |   @param {String} id
 925 |     The module id.
 926 | 
 927 |   @returns {Hash} module exports
 928 | */
 929 | Tp.require = function(id) {
 930 |   return this.defaultSandbox.require(id, this.defaultSandbox.callerId);
 931 | };
 932 | 
 933 | /**
 934 |   Async load a module if it is not already a registered factory.  Invoke
 935 |   the passed callback with an optional error object when the module is
 936 |   ready to load.
 937 | */
 938 | Tp.async = function(id, callback) {
 939 |   return this.defaultSandbox.async(id, callback);
 940 | };
 941 | 
 942 | /**
 943 |   Returns true if the passed module exists in the default sandbox.
 944 |   
 945 |   @param {String} id
 946 |     The module id to check.
 947 |     
 948 |   @returns {Boolean} true if module id exists
 949 | */
 950 | Tp.exists = function(id) {
 951 |   return this.defaultSandbox.exists(id);
 952 | };
 953 | 
 954 | /**
 955 |   Returns the URL for a resource matching the passed module id and optional
 956 |   extension.
 957 |   
 958 |   @param {String} id
 959 |     the module id to resolve
 960 |   
 961 |   @param {String} ext
 962 |     (Optional) extension to append to URL
 963 |     
 964 |   @returns {String} url
 965 | */
 966 | Tp.url = function(id, ext) {
 967 |   return this.defaultSandbox.url(id, ext);
 968 | };
 969 | 
 970 | /**
 971 |   Called by the sandbox to get a factory object for the named moduleId.  
 972 |   Normally you will not need to call this method directly or even override it.
 973 |   
 974 |   @param {String} id
 975 |     Fully normalized module id
 976 |     
 977 |   @param {Function} callback
 978 |     (Optional) callback to invoke once factory is loaded.  If not passed, this
 979 |     method will run sync.  Otherwise it will run async.
 980 |     
 981 |   @returns {Hash} factory hash.
 982 | */
 983 | Tp.loadFactory = function(id, callback) {
 984 |   
 985 |   var ret = this._factories[id],
 986 |       loader = this.loader;
 987 | 
 988 |   if (callback) {
 989 |     if (!ret) {
 990 |       if (loader && loader.loadFactory) {
 991 |         loader.loadFactory(this, id, callback);
 992 |       } else { callback(new Error('Module '+id+' not found')); }
 993 |     } else { callback(); }
 994 | 
 995 |   } else if (!ret && loader && loader.loadFactory) {
 996 |     loader.loadFactory(this, id);
 997 |     ret = this._factories[id];
 998 |   }
 999 | 
1000 |   return ret ;
1001 | };
1002 | 
1003 | /**
1004 |   Called by the sandbox to determine if the named id exists on the system.
1005 |   The id should already be normalized.  If the id is not yet registered, the
1006 |   loader will also be consulted.
1007 |   
1008 |   Normally you will not need to call this method directly or override it.
1009 |   
1010 |   @param {String} id
1011 |     Fully normalized module id
1012 |     
1013 |   @returns {Boolean} true if factory exists
1014 | */
1015 | Tp.factoryExists = function(id) {
1016 |   if (this._factories[id]) { return true; }
1017 |   var loader = this.loader;
1018 |   return loader && loader.exists && loader.exists(this, id);
1019 | };
1020 | 
1021 | /**
1022 |   Returns the package info, if any, for the named module or packageId
1023 |   
1024 |   @param {String} id
1025 |     A package name or fully normalized module id.
1026 |     
1027 |   @returns {Hash} package info or null if package is not registered
1028 | */
1029 | Tp.package = function(id) {
1030 |   id = packageIdFor(normalize(id))+'/~package';
1031 |   var ret = this._factories[id];
1032 |   return ret ? ret.data : null;
1033 | };
1034 | 
1035 | /**
1036 |   Normalize a moduleId, expanding relative values if needed.
1037 |   
1038 |   @param {String} id
1039 |     The module id, possibly de-normalized.
1040 |     
1041 |   @param {String} contextId
1042 |     (Optional) The normalized module id of the calling module.  Required if 
1043 |     your module id might be relative.
1044 |     
1045 |   @returns {String} the normalized module id
1046 | */
1047 | Tp.normalize = function(id, contextId) {
1048 |   return normalize(id, contextId);
1049 | };
1050 | 
1051 | /**
1052 |   Maps the passed module id to a potentially location specific module id.
1053 |   This gives the loader a way to vary the factory function returns for a given
1054 |   module id per sandbox.  Useful when supporting multiple versions of the 
1055 |   same package.
1056 |   
1057 |   @param {String} id
1058 |     Normalized module id
1059 |     
1060 |   @param {Sandbox} sandbox
1061 |     The requesting sandbox
1062 |     
1063 |   @returns {String} resolved module id
1064 | */
1065 | Tp.resolve = function(id, sandbox) {
1066 |   var loader = this.loader;
1067 |   return sandbox && loader && loader.resolve ? loader.resolve(id, sandbox):id;
1068 | };
1069 | 
1070 | /**
1071 |   Invokes the passed callback when the browser is ready.  This will work 
1072 |   regardless of the environment you are in.
1073 |   
1074 |   @param {Function} callback
1075 |     Invoked when the browser is ready.  If browser is alrady ready, invoked
1076 |     immediately.
1077 |     
1078 |   @returns {void}
1079 | */
1080 | Tp.ready = function(callback) {
1081 |   switch(this.readyState) {
1082 |     case 'ready':
1083 |       callback();
1084 |       break;
1085 | 
1086 |     case 'scheduled':
1087 |       this._readyQueue.push(callback);
1088 |       break;
1089 | 
1090 |     default:
1091 |       this._readyQueue = [callback];
1092 |       this.readyState = 'scheduled';
1093 |       if (this.loader.scheduleReady) {
1094 |         var that = this;
1095 |         this.loader.scheduleReady(function() {
1096 |           var queue = that._readyQueue, len = queue ? queue.length : 0;
1097 |           that._readyQueue = null;
1098 |           that.readyState = 'ready';
1099 |           for(var idx=0;idx<len;idx++) { queue[idx](); }
1100 |         });
1101 | 
1102 |       } else {
1103 |         throw new Error('Loader does not support activate on ready state');
1104 |       }
1105 |   }
1106 | };
1107 | 
1108 | // instantiate spade and also attach class for testing
1109 | var newSpade = new Spade();
1110 | if ('undefined' !== typeof spade) newSpade._conflict = spade;
1111 | spade = newSpade;
1112 | 
1113 | // make this work when called as a module - both from within spade and from
1114 | // node.
1115 | if ('undefined' !== typeof require) {
1116 |   if ('undefined' !== typeof __module) { __module.exports = spade; }
1117 |   else if ('undefined' !== typeof module) { module.exports = spade; }
1118 | }
1119 | 
1120 | })();
1121 | 


--------------------------------------------------------------------------------