updated app

first-project/node_modules/derby/lib/derby.server.js

@@ -0,0 +1,166 @@
+var fs = require('fs')
+  , path = require('path')
+  , http = require('http')
+  , racer = require('racer')
+  , tracks = require('tracks')
+  , up = require('up')
+  , View = require('./View.server')
+  , autoRefresh = require('./refresh.server').autoRefresh
+  , util = racer.util
+  , merge = util.merge
+  , isProduction = util.isProduction
+  , proto;
+
+module.exports = derbyServer;
+
+function derbyServer(derby) {
+  merge(derby, proto);
+
+  Object.defineProperty(derby, 'version', {
+    get: function() {
+      return require('../package.json').version;
+    }
+  });
+}
+derbyServer.decorate = 'derby';
+derbyServer.useWith = {server: true, browser: false};
+
+
+proto = {
+  // TODO: Remove in lieu of get / set methods
+  options: {}
+
+, run: function(file, port, options) {
+    var master, onMessage, server, upService;
+
+    // Resolve relative filenames
+    file = path.resolve(file);
+    if (port == null) port = isProduction ? 80 : 3000;
+    if (options == null) options = {numWorkers: 1};
+
+    try {
+      server = require(file);
+    } catch (e) {
+      console.error('Error requiring server module from `%s`', file);
+      throw e;
+    }
+    if (!(server instanceof http.Server)) {
+      throw new Error('`' + file + '` does not export a valid `http.Server`');
+    }
+    if (!isProduction) {
+      // TODO: This extends the internal API of Up. It would be better
+      // if Up supported workers being able to force a global reload
+      onMessage = up.Worker.prototype.onMessage;
+      up.Worker.prototype.onMessage = function(message) {
+        if (message.type === 'reload') {
+          return upService.reload();
+        }
+        onMessage.call(this, message);
+      };
+    }
+    master = http.createServer().listen(port);
+    upService = up(master, file, options);
+    process.on('SIGUSR2', function() {
+      console.log('SIGUSR2 signal detected - reloading');
+      upService.reload();
+    });
+    console.log('Starting cluster with %d workers in %s mode',
+      options.numWorkers, process.env.NODE_ENV);
+    console.log('`kill -s SIGUSR2 %s` to force cluster reload', process.pid);
+    console.log('Go to: http://localhost:%d/', port);
+  }
+
+, createApp: function(appModule) {
+    var appExports = appModule.exports
+      , view = new View(this._libraries)
+      , options = this.options
+      , session, store;
+
+    view._derbyOptions = options;
+    view._appFilename = appModule.filename;
+    function setStore(_store) {
+      autoRefresh(_store, options, view);
+      if (session != null) session._setStore(_store);
+      return store = _store;
+    }
+
+    // Expose methods on the application module
+
+    function Page(model, res) {
+      this._model = model;
+      this._res = res;
+    }
+    Page.prototype.render = function(ns, ctx, status) {
+      view.render(this._res, this._model, ns, ctx, status);
+    };
+
+    function createPage(req, res) {
+      var model = req.model || store.createModel();
+      return new Page(model, res);
+    }
+    function onRoute(callback, page, params, next, isTransitional) {
+      if (isTransitional) {
+        callback(page._model, params, next);
+      } else {
+        callback(page, page._model, params, next);
+      }
+    }
+    tracks.setup(appExports, createPage, onRoute);
+
+    appExports._setStore = setStore;
+    appExports.view = view;
+    appExports.ready = function() {};
+    appExports.createStore = function(options) {
+      return setStore(racer.createStore(options));
+    };
+    appExports.session = function() {
+      return session = racer.session(store);
+    };
+    appExports.render = function(res, model, ns, ctx, status) {
+      return view.render(res, model, ns, ctx, status);
+    };
+
+    // Render immediately upon creating the app so that files
+    // will be cached for the first render
+    process.nextTick(function() {
+      view.render();
+    });
+    return appExports;
+  }
+
+, createStatic: function(root) {
+    return new Static(root, this._libraries);
+  }
+
+, createStore: function() {
+    var len = arguments.length
+      , last = arguments[len - 1]
+      , options, app, store;
+    // Last argument may be a createStore options object
+    if (!last.view) {
+      options = last;
+      len--;
+    }
+    store = racer.createStore(options);
+    for (var i = len; i--;) {
+      app = arguments[i];
+      app._setStore(store);
+    }
+    return store;
+  }
+};
+
+function Static(root, libraries) {
+  this.root = root;
+  this.libraries = libraries;
+  this.views = {};
+}
+Static.prototype.render = function(name, res, model, ns, ctx, status) {
+  var view = this.views[name];
+  if (!view) {
+    view = this.views[name] = new View(this.libraries);
+    view._root = this.root;
+    view._clientName = name;
+  }
+  view.render(res, model, ns, ctx, status, true);
+};