├── .gitignore
├── .npmignore
├── .travis.yml
├── test
    ├── mocha.opts
    ├── diez.container.js
    ├── diez.state.js
    ├── diez.has.js
    ├── diez.contains.js
    ├── diez.lookup.js
    ├── diez.get.js
    ├── diez.resolve.js
    └── diez.register.js
├── index.js
├── examples
    └── express
    │   ├── screenshot.png
    │   ├── server.js
    │   ├── README.md
    │   ├── routes.js
    │   ├── layout.html
    │   ├── app.js
    │   └── handlers
    │       ├── app.js
    │       └── welcome.js
├── lib
    ├── core.js
    ├── diez.js
    ├── scalar.js
    ├── factory.js
    └── api.js
├── LICENSE
├── package.json
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | npm-debug.log
3 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | .travis.yml
2 | examples
3 | LICENSE
4 | test
5 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | 
3 | node_js:
4 |   - 0.10
5 |   - 0.11
6 | 


--------------------------------------------------------------------------------
/test/mocha.opts:
--------------------------------------------------------------------------------
1 | --compilers js:6to5/register
2 | --reporter spec
3 | --ui bdd
4 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | var diez = require('./lib/diez');
2 | 
3 | module.exports = diez(); // Root container
4 | 


--------------------------------------------------------------------------------
/examples/express/screenshot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ericclemmons/diez/HEAD/examples/express/screenshot.png


--------------------------------------------------------------------------------
/lib/core.js:
--------------------------------------------------------------------------------
 1 | var _       = require('lodash');
 2 | var assert  = require('assert');
 3 | var stampit = require('stampit');
 4 | 
 5 | module.exports = stampit().methods({
 6 |   matches: function() {
 7 |     throw new Error('Stamp is missing `.matches` function');
 8 |   },
 9 | 
10 |   resolve: function() {
11 |     throw new Error('Stamp is missing `.resolve` function');
12 |   },
13 | });
14 | 


--------------------------------------------------------------------------------
/examples/express/server.js:
--------------------------------------------------------------------------------
 1 | require("6to5/register")({
 2 |   only: /examples/
 3 | });
 4 | 
 5 | var app   = require('./app');
 6 | var diez  = require('../../');
 7 | var util  = require('util');
 8 | 
 9 | app.set('port', process.env.PORT || 3000);
10 | 
11 | app.listen(app.get('port'), function() {
12 |   console.info('Express server listening on port %s (%s)', app.get('port'), app.get('env'));
13 | });
14 | 


--------------------------------------------------------------------------------
/examples/express/README.md:
--------------------------------------------------------------------------------
 1 | # Server-side React with Diez & Express
 2 | 
 3 | > ![](screenshot.png)
 4 | 
 5 | ## [Demo][4] ([source][5])
 6 | 
 7 | 
 8 | ## Usage
 9 | 
10 | Run:
11 | 
12 | ```
13 | .../examples/express $ node server.js
14 | ```
15 | 
16 | Open:
17 | 
18 | > <http://localhost:3000/>
19 | 
20 | [4]: https://protected-castle-7387.herokuapp.com/
21 | [5]: https://github.com/ericclemmons/diez/tree/master/examples/express
22 | 


--------------------------------------------------------------------------------
/lib/diez.js:
--------------------------------------------------------------------------------
 1 | var _         = require('lodash');
 2 | var stampit   = require('stampit');
 3 | var api       = require('./api');
 4 | var version   = require('../package.json').version;
 5 | 
 6 | var diez = stampit.compose(api).state({
 7 |   id:       null,
 8 |   parent:   null,
 9 |   version:  version,
10 | }).enclose(function() {
11 |   this.id = _.uniqueId('diez_'),
12 | 
13 |   this.container = function() {
14 |     return diez({ parent: this });
15 |   };
16 | 
17 |   this.register('container', this);
18 | });
19 | 
20 | module.exports = diez;
21 | 


--------------------------------------------------------------------------------
/examples/express/routes.js:
--------------------------------------------------------------------------------
 1 | var diez  = require('../../');
 2 | var React = require('react');
 3 | 
 4 | var App     = require('./handlers/app');
 5 | var Welcome = require('./handlers/welcome');
 6 | 
 7 | var {
 8 |   Route,
 9 |   DefaultRoute
10 | } = require('react-router');
11 | 
12 | var Routes = function(App, Welcome) {
13 |   return (
14 |     <Route handler={App} path="/">
15 |       <DefaultRoute name="welcome" handler={Welcome} />
16 |     </Route>
17 |   );
18 | };
19 | 
20 | diez.register(Routes, [App, Welcome]);
21 | 
22 | module.exports = Routes;
23 | 


--------------------------------------------------------------------------------
/lib/scalar.js:
--------------------------------------------------------------------------------
 1 | var _       = require('lodash');
 2 | var assert  = require('assert');
 3 | var core    = require('./core');
 4 | var stampit = require('stampit');
 5 | 
 6 | module.exports = stampit().compose(core).state({
 7 |   name:   null,
 8 |   value:  null,
 9 | }).methods({
10 |   matches: function(reference) {
11 |     return this.name === reference;
12 |   },
13 | 
14 |   resolve: function() {
15 |     return this.value;
16 |   },
17 | }).enclose(function() {
18 |   assert(_.isString(this.name));
19 |   assert(!_.isNull(this.value) && !_.isUndefined(this.value));
20 | });
21 | 


--------------------------------------------------------------------------------
/examples/express/layout.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1">
 7 |     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.2/css/bootstrap.min.css">
 8 |     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.2/css/bootstrap-theme.min.css">
 9 |   </head>
10 |   <body>
11 |     <div id="app">
12 |       <noscript>
13 |         Whoops!  This should've been rendered on the server.
14 |       </noscript>
15 |     </div>
16 |   </body>
17 | </html>
18 | 


--------------------------------------------------------------------------------
/test/diez.container.js:
--------------------------------------------------------------------------------
 1 | var assert  = require('assert');
 2 | var diez    = require('..');
 3 | 
 4 | describe('.container', function() {
 5 |   beforeEach(function() {
 6 |     this.container = diez.container();
 7 |   });
 8 | 
 9 |   it('should set `parent`', function() {
10 |     assert(this.container.parent);
11 |   });
12 | 
13 |   it('should be a child of the parent', function() {
14 |     assert.equal(this.container.parent, diez);
15 |   });
16 | 
17 |   it('should have a \'container\' alias that references itself', function() {
18 |     assert(this.container.contains('container'));
19 |     assert.equal(this.container.get('container'), this.container);
20 |   });
21 | });
22 | 
23 | 


--------------------------------------------------------------------------------
/test/diez.state.js:
--------------------------------------------------------------------------------
 1 | var assert  = require('assert');
 2 | var diez    = require('..');
 3 | 
 4 | describe('state', function() {
 5 |   it('should default to a `null` parent', function() {
 6 |     assert.equal(null, diez.parent);
 7 |   });
 8 | 
 9 |   it('should set a version', function() {
10 |     assert(diez.version);
11 |   });
12 | 
13 |   it('should have an id', function() {
14 |     assert(diez.id, 'diez_1');
15 |   });
16 | 
17 |   describe('in a new container', function() {
18 |     beforeEach(function() {
19 |       this.container = diez.container();
20 |     });
21 | 
22 |     it('should have an id', function() {
23 |       assert(this.container.id, 'diez_2');
24 |     });
25 | 
26 |     it('should have a different id', function() {
27 |       assert(this.container.id, diez.id);
28 |     });
29 |   });
30 | });
31 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Internet Systems Consortium (ISC) license
 2 | =========================================
 3 | 
 4 | Copyright (c) 2015 Eric Clemmons
 5 | 
 6 | Permission to use, copy, modify, and/or distribute this software for any purpose
 7 | with or without fee is hereby granted, provided that the above copyright notice
 8 | and this permission notice appear in all copies.
 9 | 
10 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
11 | REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
12 | FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
13 | INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
14 | OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
15 | TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
16 | THIS SOFTWARE.
17 | 


--------------------------------------------------------------------------------
/examples/express/app.js:
--------------------------------------------------------------------------------
 1 | var diez    = require('../../');
 2 | var fs      = require('fs');
 3 | var path    = require('path');
 4 | var React   = require('react');
 5 | var Router  = require('react-router');
 6 | var util    = require('util');
 7 | 
 8 | var app     = module.exports = require('express')();
 9 | var layout  = fs.readFileSync(path.join(__dirname, 'layout.html'), 'utf8');
10 | var Routes  = require('./routes');
11 | 
12 | app
13 |   .use(function(req, res, next) {
14 |     req.container = diez.container();
15 |     req.container.register('request', req);
16 | 
17 |     next();
18 |   })
19 |   .get('/', function(req, res, next) {
20 |     Router.create({
21 |       routes:   req.container.get(Routes),
22 |       location: req.url
23 |     }).run(function(Handler) {
24 |       var element   = React.createElement(Handler);
25 |       var content   = React.renderToStaticMarkup(element);
26 |       var noscript  = /<noscript>[\S\s.]*<\/noscript>/m;
27 | 
28 |       res.send(layout.replace(noscript, content));
29 | 
30 |       next();
31 |     });
32 |   })
33 | ;
34 | 


--------------------------------------------------------------------------------
/test/diez.has.js:
--------------------------------------------------------------------------------
 1 | var assert  = require('assert');
 2 | var diez    = require('..');
 3 | 
 4 | describe('.has', function() {
 5 |   beforeEach(function() {
 6 |     this.container = diez.container();
 7 |   });
 8 | 
 9 |   describe('when given a reference', function() {
10 |     describe('that is not registered', function() {
11 |       it('should return false', function() {
12 |         assert.equal(this.container.has('name'), false);
13 |       });
14 |     });
15 | 
16 |     describe('that is registered', function() {
17 |       beforeEach(function() {
18 |         this.container.register('name', 'value');
19 |       });
20 | 
21 |       it('should return true', function() {
22 |         assert(this.container.has('name'));
23 |       });
24 | 
25 |       describe('in a parent container', function() {
26 |         beforeEach(function() {
27 |           this.child = this.container.container();
28 |         });
29 | 
30 |         it('should return false', function() {
31 |           assert.equal(this.child.has('name'), false);
32 |         });
33 |       });
34 |     });
35 |   });
36 | });
37 | 


--------------------------------------------------------------------------------
/test/diez.contains.js:
--------------------------------------------------------------------------------
 1 | var assert  = require('assert');
 2 | var diez    = require('..');
 3 | 
 4 | describe('.contains', function() {
 5 |   beforeEach(function() {
 6 |     this.container = diez.container();
 7 |   });
 8 | 
 9 |   describe('when given a reference', function() {
10 |     describe('that is not registered', function() {
11 |       it('should return false', function() {
12 |         assert.equal(this.container.contains('name'), false);
13 |       });
14 |     });
15 | 
16 |     describe('that is registered', function() {
17 |       beforeEach(function() {
18 |         this.container.register('name', 'value');
19 |       });
20 | 
21 |       it('should return true', function() {
22 |         assert(this.container.contains('name'));
23 |       });
24 | 
25 |       describe('in a parent container', function() {
26 |         beforeEach(function() {
27 |           this.child = this.container.container();
28 |         });
29 | 
30 |         it('should return true', function() {
31 |           assert(this.child.contains('name'));
32 |         });
33 |       });
34 |     });
35 |   });
36 | });
37 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "diez",
 3 |   "version": "2.0.1",
 4 |   "description": "Incredibly simple, Dependency Injection for isomorphic Javascript applications.",
 5 |   "main": "index.js",
 6 |    "engines": {
 7 |     "node": "0.10.x"
 8 |   },
 9 |   "dependencies": {
10 |     "lodash": "^3.1.0",
11 |     "stampit": "^1.1.0"
12 |   },
13 |   "devDependencies": {
14 |     "6to5": "^3.5.3",
15 |     "express": "^4.11.2",
16 |     "mocha": "^2.1.0",
17 |     "react": "^0.12.2",
18 |     "react-router": "^0.11.6"
19 |   },
20 |   "scripts": {
21 |     "start": "node examples/express/server.js",
22 |     "test": "./node_modules/.bin/mocha"
23 |   },
24 |   "repository": {
25 |     "type": "git",
26 |     "url": "git://github.com/ericclemmons/diez.git"
27 |   },
28 |   "keywords": [
29 |     "container",
30 |     "di",
31 |     "dic",
32 |     "dependency",
33 |     "injection",
34 |     "ioc"
35 |   ],
36 |   "author": "Eric Clemmons <eric@smarterspam.com>",
37 |   "license": "ISC",
38 |   "bugs": {
39 |     "url": "https://github.com/ericclemmons/diez/issues"
40 |   },
41 |   "homepage": "https://github.com/ericclemmons/diez"
42 | }
43 | 


--------------------------------------------------------------------------------
/examples/express/handlers/app.js:
--------------------------------------------------------------------------------
 1 | var diez  = require('../../../');
 2 | var React = require('react');
 3 | 
 4 | var {
 5 |   Link,
 6 |   RouteHandler,
 7 | } = require('react-router');
 8 | 
 9 | var App = React.createClass({
10 |   render() {
11 |     return (
12 |       <section>
13 |         {this.renderHeader()}
14 | 
15 |         <RouteHandler />
16 | 
17 |         <hr />
18 | 
19 |         {this.renderFooter()}
20 |       </section>
21 |     );
22 |   },
23 | 
24 |   renderHeader() {
25 |     return (
26 |       <nav className="navbar navbar-inverse navbar-static-top">
27 |         <div className="container">
28 |           <div className="navbar-header">
29 |             <Link to="welcome" className="navbar-brand">
30 |               Server-side React with Diez & Express
31 |             </Link>
32 |           </div>
33 |         </div>
34 |       </nav>
35 |     );
36 |   },
37 | 
38 |   renderFooter() {
39 |     return (
40 |       <footer className="footer">
41 |         <p className="text-center">
42 |           &copy;
43 |           &nbsp;
44 |           <a href="https://github.com/ericclemmons/diez">
45 |             ericclemmons/diez
46 |           </a>
47 |         </p>
48 |       </footer>
49 |     );
50 |   },
51 | });
52 | 
53 | module.exports = App;
54 | 


--------------------------------------------------------------------------------
/lib/factory.js:
--------------------------------------------------------------------------------
 1 | var _       = require('lodash');
 2 | var assert  = require('assert');
 3 | var core    = require('./core');
 4 | var util    = require('util');
 5 | var stampit = require('stampit');
 6 | 
 7 | module.exports = stampit().compose(core).state({
 8 |   factory:      null,
 9 |   dependencies: null,
10 | }).methods({
11 |   matches: function(reference) {
12 |     return this.factory === reference;
13 |   },
14 | 
15 |   resolve: function(container) {
16 |     var deps = this.dependencies.map(function(dep) {
17 |       return container.contains(dep) ? container.get(dep) : dep;
18 |     });
19 | 
20 |     var value = this.factory.apply(this.factory, deps);
21 | 
22 |     if (_.isUndefined(value)) {
23 |       throw new TypeError('Factory did not return a value');
24 |     }
25 | 
26 |     return value;
27 |   },
28 | }).enclose(function() {
29 |   assert(_.isFunction(this.factory));
30 |   assert(_.isArray(this.dependencies));
31 | 
32 |   var signature = this.factory.toString().match(/function\s([^\(]*\(.+\))/);
33 | 
34 |   assert.equal(
35 |     this.factory.length,
36 |     this.dependencies.length,
37 | 
38 |     util.format(
39 |       'Factory signature %s requires %s arguments, but got %s',
40 |       signature ? signature[1] : '',
41 |       this.factory.length,
42 |       this.dependencies.length
43 |     )
44 |   );
45 | });
46 | 


--------------------------------------------------------------------------------
/test/diez.lookup.js:
--------------------------------------------------------------------------------
 1 | var assert  = require('assert');
 2 | var diez    = require('..');
 3 | 
 4 | describe('.lookup', function() {
 5 |   beforeEach(function() {
 6 |     this.container = diez.container();
 7 |   });
 8 | 
 9 |   describe('when given a reference', function() {
10 |     describe('that is not registered', function() {
11 |       it('should throw an error', function() {
12 |         assert.throws(this.container.lookup.bind(this.container, 'name'))
13 |       });
14 |     });
15 | 
16 |     describe('that is registered', function() {
17 |       beforeEach(function() {
18 |         this.container.register('name', 'value');
19 |       });
20 | 
21 |       it('should return the stamp', function() {
22 |         var stamp = this.container.lookup('name');
23 | 
24 |         assert(stamp);
25 |         assert(stamp.matches);
26 |         assert(stamp.resolve);
27 |       });
28 | 
29 |       describe('in a parent container', function() {
30 |         beforeEach(function() {
31 |           this.child = this.container.container();
32 |         });
33 | 
34 |         it('should return the stamp', function() {
35 |           var stamp = this.container.lookup('name');
36 | 
37 |           assert(stamp);
38 |           assert(stamp.matches);
39 |           assert(stamp.resolve);
40 |         });
41 |       });
42 |     });
43 |   });
44 | });
45 | 


--------------------------------------------------------------------------------
/examples/express/handlers/welcome.js:
--------------------------------------------------------------------------------
 1 | var diez  = require('../../../');
 2 | var React = require('react');
 3 | 
 4 | var Welcome = function(request) {
 5 |   return React.createClass({
 6 |     render() {
 7 |       return (
 8 |         <section>
 9 |           <div className="jumbotron">
10 |             <div className="container">
11 |               <h1>Welcome!</h1>
12 | 
13 |               <p>
14 |                 You're visiting from
15 | 
16 |                 <code>
17 |                   {request.ip}
18 |                 </code>
19 | 
20 |                 with:
21 | 
22 |                 <pre>
23 |                   <code>
24 |                     {request.get('User-Agent')}
25 |                   </code>
26 |                 </pre>
27 |               </p>
28 | 
29 |               <p>
30 |                 <small>
31 |                   View the source :)
32 |                 </small>
33 |               </p>
34 |             </div>
35 |           </div>
36 | 
37 |           <div className="container">
38 |             <p>
39 |               <em>
40 |                 These components are using per-<code>request</code> information injected via Diez.
41 |               </em>
42 |             </p>
43 |           </div>
44 |         </section>
45 |       );
46 |     }
47 |   });
48 | };
49 | 
50 | diez.register(Welcome, ['request']);
51 | 
52 | module.exports = Welcome;
53 | 


--------------------------------------------------------------------------------
/lib/api.js:
--------------------------------------------------------------------------------
 1 | var _       = require('lodash');
 2 | var stampit = require('stampit');
 3 | var util    = require('util');
 4 | 
 5 | var factory = require('./factory');
 6 | var scalar  = require('./scalar');
 7 | 
 8 | module.exports = stampit().enclose(function() {
 9 |   var references = [];
10 | 
11 |   this.contains = function(reference) {
12 |     try {
13 |       this.lookup(reference);
14 | 
15 |       return true;
16 |     } catch(e) {
17 |       return false;
18 |     }
19 |   };
20 | 
21 |   this.get = _.memoize(function(reference) {
22 |     if (!reference) {
23 |       throw new TypeError('diez.get requires a reference');
24 |     }
25 | 
26 |     return this.resolve(reference);
27 |   });
28 | 
29 |   this.has = function(reference) {
30 |     return _.any(references, function(stamp) {
31 |       return stamp.matches(reference);
32 |     });
33 |   };
34 | 
35 |   this.lookup = function(reference) {
36 |     var stamp =  _.find(references, function(stamp) {
37 |       return stamp.matches(reference);
38 |     });
39 | 
40 |     if (stamp) {
41 |       return stamp;
42 |     }
43 | 
44 |     if (this.parent) {
45 |       return this.parent.lookup(reference);
46 |     }
47 | 
48 |     throw new Error('Diez could not find this reference');
49 |   };
50 | 
51 |   this.register = function(reference, value) {
52 |     if (_.isString(reference)) {
53 |       references.push(scalar({
54 |         name:   reference,
55 |         value:  value,
56 |       }));
57 | 
58 |       return this;
59 |     };
60 | 
61 |     if (_.isFunction(reference)) {
62 |       references.push(factory({
63 |         factory:      reference,
64 |         dependencies: value || [],
65 |       }));
66 | 
67 |       return this;
68 |     };
69 | 
70 |     throw new TypeError('diez.register requires a String or Function');
71 |   };
72 | 
73 |   this.resolve = function(reference) {
74 |     return this.lookup(reference).resolve(this);
75 |   };
76 | });
77 | 


--------------------------------------------------------------------------------
/test/diez.get.js:
--------------------------------------------------------------------------------
 1 | var assert  = require('assert');
 2 | var diez    = require('..');
 3 | 
 4 | describe('.get', function() {
 5 |   describe('when given a reference', function() {
 6 |     beforeEach(function() {
 7 |       this.container  = diez.container();
 8 |       this.request    = function() { return { body: 'GET /hello' }; };
 9 |       this.response   = function() { return { body: '200 OK' }; };
10 |       this.factory    = function(request, response) { return [request, response]; };
11 |     });
12 | 
13 |     describe('that is registered', function() {
14 |       beforeEach(function() {
15 |         this.container.register(this.factory, [this.request, this.response]);
16 |       });
17 | 
18 |       it('should return the same instance', function() {
19 |         var a = this.container.get(this.factory);
20 |         var b = this.container.get(this.factory);
21 | 
22 |         assert.deepEqual(a, b);
23 |         assert.equal(a, b);
24 |       });
25 | 
26 |       describe('with registered dependencies', function() {
27 |         beforeEach(function() {
28 |           this.container.register(this.request);
29 |           this.container.register(this.response);
30 |         });
31 | 
32 |         it('should return the same instantiated dependencies each time', function() {
33 |           var a = this.container.get(this.factory);
34 |           var b = this.container.get(this.factory);
35 | 
36 |           assert.equal(a[0], b[0]);
37 |           assert.equal(a[1], b[1]);
38 |         });
39 |       });
40 | 
41 |       describe('in a parent container', function() {
42 |         beforeEach(function() {
43 |           this.child = this.container.container();
44 |         });
45 | 
46 |         it('should return the same instance', function() {
47 |           var a = this.child.get(this.factory);
48 |           var b = this.child.get(this.factory);
49 | 
50 |           assert.deepEqual(a, b);
51 |           assert.equal(a, b);
52 |         });
53 |       });
54 |     });
55 | 
56 |     describe('that is not registered', function() {
57 |       it('should throw an error', function() {
58 |         assert.throws(this.container.get.bind(this.container, this.factory));
59 |       });
60 |     });
61 |   });
62 | });
63 | 


--------------------------------------------------------------------------------
/test/diez.resolve.js:
--------------------------------------------------------------------------------
 1 | var assert  = require('assert');
 2 | var diez    = require('..');
 3 | 
 4 | describe('.resolve', function() {
 5 |   describe('when given a reference', function() {
 6 |     beforeEach(function() {
 7 |       this.container  = diez.container();
 8 |       this.request    = function() { return { body: 'GET /hello' }; };
 9 |       this.response   = function() { return { body: '200 OK' }; };
10 |       this.factory    = function(request, response) { return [request, response]; };
11 |     });
12 | 
13 |     describe('that is registered', function() {
14 |       beforeEach(function() {
15 |         this.container.register(this.factory, [this.request, this.response]);
16 |       });
17 | 
18 |       it('should return a new instance each time', function() {
19 |         var a = this.container.resolve(this.factory);
20 |         var b = this.container.resolve(this.factory);
21 | 
22 |         assert.deepEqual(a, b);
23 |         assert.notEqual(a, b);
24 |       });
25 | 
26 |       describe('with registered dependencies', function() {
27 |         beforeEach(function() {
28 |           this.container.register(this.request);
29 |           this.container.register(this.response);
30 |         });
31 | 
32 |         it('should instantiate dependencies', function() {
33 |           var a = this.container.resolve(this.factory);
34 |           var b = this.container.resolve(this.factory);
35 | 
36 |           assert.deepEqual(a[0], b[0]);
37 |           assert.deepEqual(a[1], b[1]);
38 |         });
39 |       });
40 | 
41 |       describe('in a parent container', function() {
42 |         beforeEach(function() {
43 |           this.child = this.container.container();
44 |         });
45 | 
46 |         it('should return a new instance each time', function() {
47 |           var a = this.child.resolve(this.factory);
48 |           var b = this.child.resolve(this.factory);
49 | 
50 |           assert.deepEqual(a, b);
51 |           assert.notEqual(a, b);
52 |         });
53 |       });
54 |     });
55 | 
56 |     describe('that is not registered', function() {
57 |       it('should throw an error', function() {
58 |         assert.throws(this.container.resolve.bind(this.container, this.factory));
59 |       });
60 |     });
61 |   });
62 | });
63 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Diez ![https://img.shields.io/npm/v/diez.svg](https://img.shields.io/npm/v/diez.svg?style=flat-square)
  2 | 
  3 | > Incredibly simple, Dependency Injection for isomorphic Javascript applications.
  4 | 
  5 | [![](https://img.shields.io/github/issues-raw/ericclemmons/diez.svg?style=flat-square)](https://github.com/ericclemmons/diez/issues)
  6 | [![](https://img.shields.io/travis/ericclemmons/diez/master.svg?style=flat-square)](https://travis-ci.org/ericclemmons/diez)
  7 | [![](https://img.shields.io/david/ericclemmons/diez.svg?style=flat-square)](https://david-dm.org/ericclemmons/diez#info=dependencies)
  8 | [![](https://img.shields.io/david/dev/ericclemmons/diez.svg?style=flat-square)](https://david-dm.org/ericclemmons/diez#info=devDependencies)
  9 | 
 10 | 
 11 | ## The Problem
 12 | 
 13 | When using libraries such as [React][1], [React Router][2], & [RefluxJS][3],
 14 | you'll find that **singletons don't work well on the server-side**
 15 | for Actions, Routes, Stores, & Views, as they share state between all requests.
 16 | 
 17 | _On the client-side, each user's browser serves as a container to scope
 18 | functions.  Similarly, Diez introduces a container for each request on the server._
 19 | 
 20 | 
 21 | ## The Solution
 22 | 
 23 | Luckily, all it takes is to turn your _singletons_ into _factories_ by wrapping
 24 | them with `function(...) { return ...; }` & registering them via `diez.register`.
 25 | 
 26 | Diez will retrieve them while **isolating instances to a single container-per-request**.
 27 | 
 28 | - - -
 29 | 
 30 | ## Demo
 31 | 
 32 | - [Server-side React with Diez & Express][4] ([source][5])
 33 | 
 34 | - - -
 35 | 
 36 | ## Getting Started
 37 | 
 38 | Suppose you're rendering your [React][1] view on the server with [React Router][2],
 39 | but rely on `request`-specific data, such as the user's `ip`, for some reason.
 40 | 
 41 | 
 42 | ### Step 0 - Install Diez
 43 | 
 44 | ```shell
 45 | $ npm install --save diez
 46 | ```
 47 | 
 48 | ### Step 1 - Create a container per request
 49 | 
 50 | In your application middleware:
 51 | 
 52 | ```javascript
 53 | // server.js
 54 | app.use(function(req, res, next) {
 55 |   // This container & it's references are sandboxed to this request.
 56 |   req.container = diez.container();
 57 |   req.container.register('request', req);
 58 | });
 59 | ```
 60 | 
 61 | Now, every call to `req.container.get('request')` returns `req`.
 62 | 
 63 | 
 64 | ### Step 2 - Inject [React][1] components with dependencies
 65 | 
 66 | **Before**, your view is a singleton:
 67 | 
 68 | ```javascript
 69 | // MyView.js
 70 | var MyView = React.createClass({
 71 |   render: function() {
 72 |     <p>
 73 |       Hello!
 74 |     </p>
 75 |   }
 76 | });
 77 | 
 78 | module.exports = MyView;
 79 | ```
 80 | 
 81 | **After**, your view is a factory with dependencies defined:
 82 | 
 83 | ```javascript
 84 | // MyView.js
 85 | var diez = require('diez');
 86 | 
 87 | // Convert singleton to factory
 88 | var MyView = function(request) {
 89 |   return React.createClass({
 90 |     render: function() {
 91 |       <p>
 92 |         Hello, {request.ip}!
 93 |       </p>
 94 |     }
 95 |   });
 96 | };
 97 | 
 98 | // Register component with dependencies
 99 | diez.register(MyView, ['request']);
100 | 
101 | module.exports = MyView;
102 | ```
103 | 
104 | 
105 | ### Step 3 - Retrieve injected components
106 | 
107 | ```javascript
108 | app.get('/', function(req, res) {
109 |   // Get instantiated MyView with dependencies injected
110 |   var component = req.container.get(MyView);
111 |   var element   = React.createElement(view);
112 | 
113 |   res.send(React.renderToString(element));
114 | });
115 | ```
116 | 
117 | That's it!
118 | 
119 | - - -
120 | 
121 | ## [License][6]
122 | 
123 | > Internet Systems Consortium license
124 | > ===================================
125 | >
126 | > Copyright (c) 2015 Eric Clemmons
127 | >
128 | > Permission to use, copy, modify, and/or distribute this software for any purpose
129 | > with or without fee is hereby granted, provided that the above copyright notice
130 | > and this permission notice appear in all copies.
131 | >
132 | > THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
133 | > REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
134 | > FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
135 | > INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
136 | > OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
137 | > TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
138 | > THIS SOFTWARE.
139 | 
140 | 
141 | [1]: http://facebook.github.io/react/
142 | [2]: https://github.com/rackt/react-router
143 | [3]: https://github.com/spoike/refluxjs/
144 | [4]: https://protected-castle-7387.herokuapp.com/
145 | [5]: https://github.com/ericclemmons/diez/tree/master/examples/express
146 | [6]: https://github.com/ericclemmons/diez/blob/master/LICENSE
147 | 


--------------------------------------------------------------------------------
/test/diez.register.js:
--------------------------------------------------------------------------------
  1 | var assert  = require('assert');
  2 | var diez    = require('..');
  3 | 
  4 | describe('.register', function() {
  5 |   beforeEach(function() {
  6 |     this.container = diez.container();
  7 |   });
  8 | 
  9 |   describe('when given a function', function() {
 10 |     beforeEach(function() {
 11 |       this.factory = function() {};
 12 |     });
 13 | 
 14 |     it('should not throw an error', function() {
 15 |       assert.doesNotThrow(this.container.register.bind(this.container, this.factory));
 16 |     });
 17 | 
 18 |     it('should return the container', function() {
 19 |       assert.equal(this.container.register(this.factory), this.container);
 20 |     });
 21 |   });
 22 | 
 23 |   describe('when given a string', function() {
 24 |     it('should throw an error', function() {
 25 |       assert.throws(this.container.register.bind(this.container, 'name'));
 26 |     });
 27 | 
 28 |     describe('and a value', function() {
 29 |       it('should not throw an error', function() {
 30 |         assert.doesNotThrow(this.container.register.bind(this.container, 'name', 'value'));
 31 |       });
 32 | 
 33 |       it('should return the container', function() {
 34 |         assert.equal(this.container.register('name', 'value'), this.container);
 35 |       });
 36 |     });
 37 |   });
 38 | 
 39 |   describe('when given something else', function() {
 40 |     it('should throw an error', function() {
 41 |       assert.throws(this.container.register.bind(this.container, null,      []));
 42 |       assert.throws(this.container.register.bind(this.container, undefined, []));
 43 |       assert.throws(this.container.register.bind(this.container, NaN,       []));
 44 |       assert.throws(this.container.register.bind(this.container, 12345,     []));
 45 |       assert.throws(this.container.register.bind(this.container, true,      []));
 46 |       assert.throws(this.container.register.bind(this.container, {},        []));
 47 |       assert.throws(this.container.register.bind(this.container, /name/,    []));
 48 |     });
 49 |   });
 50 | });
 51 | 
 52 | //   it('should accept a string', function() {})
 53 | //     assert.doesNotThrow(this.container.register.bind(this.container, this.factory));
 54 | 
 55 | //   it('should require a Function', function() {
 56 | //   });
 57 | 
 58 | //   it('should only accept a Function', function() {
 59 | //   });
 60 | 
 61 | //   describe('when registered', function() {
 62 | //     beforeEach(function() {
 63 | //       this.container.register(this.factory, [this.request, this.response]);
 64 | //     });
 65 | 
 66 | //     it('should be known via .has', function() {
 67 | //       assert(this.container.has(this.factory));
 68 | //     });
 69 | 
 70 | //     it('should be known via .owns', function() {
 71 | //       assert(this.container.owns(this.factory));
 72 | //     });
 73 | 
 74 | //     describe('and retrieved via .get', function() {
 75 | //       describe('with unregistered dependencies', function() {
 76 | //         it('should instantiate the factory', function() {
 77 | //           var actual    = this.container.get(this.factory);
 78 | //           var expected  = this.factory(this.request, this.response);
 79 | 
 80 | //           assert.deepEqual(actual, expected);
 81 | //         });
 82 | 
 83 | //         it('should return the same instance', function() {
 84 | //           assert.equal(this.container.get(this.factory), this.container.get(this.factory));
 85 | //         });
 86 | 
 87 | //         describe('via a child container', function() {
 88 | //           beforeEach(function() {
 89 | //             this.child = this.container.container();
 90 | //           });
 91 | 
 92 | //           it('should be known via .has', function() {
 93 | //             assert(this.child.has(this.factory));
 94 | //           });
 95 | 
 96 | //           it('should not be known via .owns', function() {
 97 | //             assert(!this.child.owns(this.factory));
 98 | //           });
 99 | 
100 | //           it('should instantiate the factory', function() {
101 | //             var actual    = this.child.get(this.factory);
102 | //             var expected  = this.factory(this.request, this.response);
103 | 
104 | //             assert.deepEqual(actual, expected);
105 | //           });
106 | 
107 | //           it('should return a different instance', function() {
108 | //             var f1 = this.container.get(this.factory);
109 | //             var f2 = this.child.get(this.factory);
110 | 
111 | //             assert.notEqual(f1, f2);
112 | //             assert.deepEqual(f1, f2);
113 | //           });
114 | //         });
115 | //       });
116 | 
117 | //       describe('with registered dependencies', function() {
118 | //         beforeEach(function() {
119 | //           this.container.register(this.request);
120 | //           this.container.register(this.response);
121 | //         });
122 | 
123 | //         it('should instantiate the factory & dependencies', function() {
124 | //           var actual    = this.container.get(this.factory);
125 | //           var expected  = this.factory(this.request(), this.response());
126 | 
127 | //           assert.deepEqual(actual, expected);
128 | //         });
129 | 
130 | //         it('should return the same instance', function() {
131 | //           assert.equal(this.container.get(this.factory), this.container.get(this.factory));
132 | //         });
133 | 
134 | //         describe('via a child container', function() {
135 | //           beforeEach(function() {
136 | //             this.child = this.container.container();
137 | //           });
138 | 
139 | //           it('should instantiate the factory & dependencies', function() {
140 | //             var actual    = this.child.get(this.factory);
141 | //             var expected  = this.factory(this.request(), this.response());
142 | 
143 | //             assert.deepEqual(actual, expected);
144 | //           });
145 | 
146 | //           it('should return different instances', function() {
147 | //             var f1  = this.container.get(this.factory);
148 | //             var f2  = this.child.get(this.factory);
149 | 
150 | //             var d11 = this.container.get(this.request);
151 | //             var d12 = this.child.get(this.request);
152 | 
153 | //             var d21 = this.container.get(this.response);
154 | //             var d22 = this.child.get(this.response);
155 | 
156 | //             assert.notEqual(f1, f2);
157 | //             assert.deepEqual(f1, f2);
158 | 
159 | //             assert.notEqual(d11, d12);
160 | //             assert.deepEqual(d11, d12);
161 | 
162 | //             assert.notEqual(d21, d22);
163 | //             assert.deepEqual(d21, d22);
164 | //           });
165 | //         });
166 | //       });
167 | //     });
168 | //   });
169 | // });
170 | 


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