/*! * Express - view * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca> * MIT Licensed */ /** * Module dependencies. */ var path = require('path')  , extname = path.extname  , dirname = path.dirname  , basename = path.basename  , utils = require('connect').utils  , View = require('./view/view')  , partial = require('./view/partial')  , union = require('./utils').union  , merge = utils.merge  , http = require('http')  , res = http.ServerResponse.prototype; /** * Expose constructors. */ exports = module.exports = View; /** * Export template engine registrar. */ exports.register = View.register; /** * Lookup and compile `view` with cache support by supplying * both the `cache` object and `cid` string, * followed by `options` passed to `exports.lookup()`. * * @param {String} view * @param {Object} cache * @param {Object} cid * @param {Object} options * @return {View} * @api private */ exports.compile = function(view, cache, cid, options){  if (cache && cid && cache[cid]){    options.filename = cache[cid].path;    return cache[cid];  }   // lookup  view = exports.lookup(view, options);   // hints  if (!view.exists) {    if (options.hint) hintAtViewPaths(view.original, options);    var err = new Error('failed to locate view "' + view.original.view + '"');    err.view = view.original;    throw err;  }   // compile  options.filename = view.path;  view.fn = view.templateEngine.compile(view.contents, options);  cache[cid] = view;   return view;}; /** * Lookup `view`, returning an instanceof `View`. * * Options: * *   - `root` root directory path *   - `defaultEngine` default template engine *   - `parentView` parent `View` object *   - `cache` cache object *   - `cacheid` optional cache id * * Lookup: * *   - partial `_<name>` *   - any `<name>/index` *   - non-layout `../<name>/index` *   - any `<root>/<name>` *   - partial `<root>/_<name>` * * @param {String} view * @param {Object} options * @return {View} * @api private */ exports.lookup = function(view, options){  var orig = view = new View(view, options)    , partial = options.isPartial    , layout = options.isLayout;   // Try _ prefix ex: ./views/_<name>.jade  // taking precedence over the direct path  if (partial) {    view = new View(orig.prefixPath, options);    if (!view.exists) view = orig;  }   // Try index ex: ./views/user/index.jade  if (!layout && !view.exists) view = new View(orig.indexPath, options);   // Try ../<name>/index ex: ../user/index.jade  // when calling partial('user') within the same dir  if (!layout && !view.exists) view = new View(orig.upIndexPath, options);   // Try root ex: <root>/user.jade  if (!view.exists) view = new View(orig.rootPath, options);   // Try root _ prefix ex: <root>/_user.jade  if (!view.exists && partial) view = new View(view.prefixPath, options);   view.original = orig;  return view;}; /** * Partial render helper. * * @api private */ function renderPartial(res, view, options, parentLocals, parent){  var collection, object, locals;   if (options) {    // collection    if (options.collection) {      collection = options.collection;      delete options.collection;    } else if ('length' in options) {      collection = options;      options = {};    }     // locals    if (options.locals) {      locals = options.locals;      delete options.locals;    }     // object    if ('Object' != options.constructor.name) {      object = options;      options = {};    } else if (undefined != options.object) {      object = options.object;      delete options.object;    }  } else {    options = {};  }   // Inherit locals from parent  union(options, parentLocals);   // Merge locals  if (locals) merge(options, locals);   // Partials dont need layouts  options.isPartial = true;  options.layout = false;   // Deduce name from view path  var name = options.as || partial.resolveObjectName(view);   // Render partial  function render(){    if (object) {      if ('string' == typeof name) {        options[name] = object;      } else if (name === global) {        merge(options, object);      }    }    return res.render(view, options, null, parent, true);  }   // Collection support  if (collection) {    var len = collection.length      , buf = ''      , keys      , key      , val;     options.collectionLength = len;     if ('number' == typeof len || Array.isArray(collection)) {      for (var i = 0; i < len; ++i) {        val = collection[i];        options.firstInCollection = i == 0;        options.indexInCollection = i;        options.lastInCollection = i == len - 1;        object = val;        buf += render();      }    } else {      keys = Object.keys(collection);      len = keys.length;      options.collectionLength = len;      options.collectionKeys = keys;      for (var i = 0; i < len; ++i) {        key = keys[i];        val = collection[key];        options.keyInCollection = key;        options.firstInCollection = i == 0;        options.indexInCollection = i;        options.lastInCollection = i == len - 1;        object = val;        buf += render();      }    }     return buf;  } else {    return render();  }}; /** * Render `view` partial with the given `options`. Optionally a * callback `fn(err, str)` may be passed instead of writing to * the socket. * * Options: * *   - `object` Single object with name derived from the view (unless `as` is present) * *   - `as` Variable name for each `collection` value, defaults to the view name. *     * as: 'something' will add the `something` local variable *     * as: this will use the collection value as the template context *     * as: global will merge the collection value's properties with `locals` * *   - `collection` Array of objects, the name is derived from the view name itself. *     For example _video.html_ will have a object _video_ available to it. * * @param  {String} view * @param  {Object|Array|Function} options, collection, callback, or object * @param  {Function} fn * @return {String} * @api public */ res.partial = function(view, options, fn){  var app = this.app    , options = options || {}    , viewEngine = app.set('view engine')    , parent = {};   // accept callback as second argument  if ('function' == typeof options) {    fn = options;    options = {};  }   // root "views" option  parent.dirname = app.set('views') || process.cwd() + '/views';   // utilize "view engine" option  if (viewEngine) parent.engine = viewEngine;   // render the partial  try {    var str = renderPartial(this, view, options, null, parent);  } catch (err) {    if (fn) {      fn(err);    } else {      this.req.next(err);    }    return;  }   // callback or transfer  if (fn) {    fn(null, str);  } else {    this.send(str);  }}; /** * Render `view` with the given `options` and optional callback `fn`. * When a callback function is given a response will _not_ be made * automatically, however otherwise a response of _200_ and _text/html_ is given. * * Options: * *  - `scope`     Template evaluation context (the value of `this`) *  - `debug`     Output debugging information *  - `status`    Response status code * * @param  {String} view * @param  {Object|Function} options or callback function * @param  {Function} fn * @api public */ res.render = function(view, opts, fn, parent, sub){  // support callback function as second arg  if ('function' == typeof opts) {    fn = opts, opts = null;  }   try {    return this._render(view, opts, fn, parent, sub);  } catch (err) {    // callback given    if (fn) {      fn(err);    // unwind to root call to prevent multiple callbacks    } else if (sub) {      throw err;    // root template, next(err)    } else {      this.req.next(err);    }  }}; // private render() res._render = function(view, opts, fn, parent, sub){  var options = {}    , self = this    , app = this.app    , helpers = app._locals    , dynamicHelpers = app.dynamicViewHelpers    , viewOptions = app.set('view options')    , root = app.set('views') || process.cwd() + '/views';   // cache id  var cid = app.enabled('view cache')    ? view + (parent ? ':' + parent.path : '')    : false;   // merge "view options"  if (viewOptions) merge(options, viewOptions);   // merge res._locals  if (this._locals) merge(options, this._locals);   // merge render() options  if (opts) merge(options, opts);   // merge render() .locals  if (opts && opts.locals) merge(options, opts.locals);   // status support  if (options.status) this.statusCode = options.status;   // capture attempts  options.attempts = [];   var partial = options.isPartial    , layout = options.layout;   // Layout support  if (true === layout || undefined === layout) {    layout = 'layout';  }   // Default execution scope to a plain object  options.scope = options.scope || {};   // Populate view  options.parentView = parent;   // "views" setting  options.root = root;   // "view engine" setting  options.defaultEngine = app.set('view engine');   // charset option  if (options.charset) this.charset = options.charset;   // Dynamic helper support  if (false !== options.dynamicHelpers) {    // cache    if (!this.__dynamicHelpers) {      this.__dynamicHelpers = {};      for (var key in dynamicHelpers) {        this.__dynamicHelpers[key] = dynamicHelpers[key].call(            this.app          , this.req          , this);      }    }     // apply    merge(options, this.__dynamicHelpers);  }   // Merge view helpers  union(options, helpers);   // Always expose partial() as a local  options.partial = function(path, opts){    return renderPartial(self, path, opts, options, view);  };   // View lookup  options.hint = app.enabled('hints');  view = exports.compile(view, app.cache, cid, options);   // layout helper  options.layout = function(path){    layout = path;  };   // render  var str = view.fn.call(options.scope, options);   // layout expected  if (layout) {    options.isLayout = true;    options.layout = false;    options.body = str;    this.render(layout, options, fn, view, true);  // partial return  } else if (partial) {    return str;  // render complete, and  // callback given  } else if (fn) {    fn(null, str);  // respond  } else {    this.send(str);  }} /** * Hint at view path resolution, outputting the * paths that Express has tried. * * @api private */ function hintAtViewPaths(view, options) {  console.error();  console.error('failed to locate view "' + view.view + '", tried:');  options.attempts.forEach(function(path){    console.error('  - %s', path);  });  console.error();}