1. module express-handlebars
   1. function express-handlebars (config)
   2. function express-handlebars.ExpressHandlebars (config)
   3. function express-handlebars.create (config)
   4. object express-handlebars.ExpressHandlebars.prototype
   5. object express-handlebars.utils
2. module express-handlebars.ExpressHandlebars
   1. function express-handlebars.ExpressHandlebars (config)
3. module express-handlebars.ExpressHandlebars.prototype
   1. function express-handlebars.ExpressHandlebars.prototype._compileTemplate (template, options)
   2. function express-handlebars.ExpressHandlebars.prototype._getDir (dirPath, options)
   3. function express-handlebars.ExpressHandlebars.prototype._getFile (filePath, options)
   4. function express-handlebars.ExpressHandlebars.prototype._getTemplateName (filePath, namespace)
   5. function express-handlebars.ExpressHandlebars.prototype._precompileTemplate (template, options)
   6. function express-handlebars.ExpressHandlebars.prototype._renderTemplate (template, context, options)
   7. function express-handlebars.ExpressHandlebars.prototype._resolveLayoutPath (layoutPath)
   8. function express-handlebars.ExpressHandlebars.prototype.getPartials (options)
   9. function express-handlebars.ExpressHandlebars.prototype.getTemplate (filePath, options)
   10. function express-handlebars.ExpressHandlebars.prototype.getTemplates (dirPath, options)
   11. function express-handlebars.ExpressHandlebars.prototype.render (filePath, context, options)
   12. function express-handlebars.ExpressHandlebars.prototype.renderView (viewPath, options, callback)
4. module express-handlebars.utils
   1. function express-handlebars.utils.assign ()
   2. function express-handlebars.utils.passError (callback)
   3. function express-handlebars.utils.passValue (callback)

module express-handlebars

function express-handlebars (config)

• description and source-code

  function exphbs(config) {
      return create(config).engine;
  }

• example usage

  n/a

function express-handlebars.ExpressHandlebars (config)

• description and source-code

  function ExpressHandlebars(config) {
      // Config properties with defaults.
      utils.assign(this, {
          handlebars     : Handlebars,
          extname        : '.handlebars',
          layoutsDir     : 'views/layouts/',
          partialsDir    : 'views/partials/',
          defaultLayout  : undefined,
          helpers        : undefined,
          compilerOptions: undefined,
      }, config);
  
      // Express view engine integration point.
      this.engine = this.renderView.bind(this);
  
      // Normalize `extname`.
      if (this.extname.charAt(0) !== '.') {
          this.extname = '.' + this.extname;
      }
  
      // Internal caches of compiled and precompiled templates.
      this.compiled    = Object.create(null);
      this.precompiled = Object.create(null);
  
      // Private internal file system cache.
      this._fsCache = Object.create(null);
  }

• example usage

  n/a

function express-handlebars.create (config)

• description and source-code

  function create(config) {
      return new ExpressHandlebars(config);
  }

• example usage

  ...
  Another way to use this view engine is to create an instance(s) of `ExpressHandlebars`, allowing access to the full API:
  
  ```javascript
  var express = require('express');
  var exphbs  = require('express-handlebars');
  
  var app = express();
  var hbs = exphbs.create({ /* config */ });
  
  // Register `hbs.engine` with the Express app.
  app.engine('handlebars', hbs.engine);
  app.set('view engine', 'handlebars');
  
  // ...still have a reference to `hbs`, on which methods like `loadPartials()`
  // can be called.
  ...

module express-handlebars.ExpressHandlebars

function express-handlebars.ExpressHandlebars (config)

• description and source-code

  function ExpressHandlebars(config) {
      // Config properties with defaults.
      utils.assign(this, {
          handlebars     : Handlebars,
          extname        : '.handlebars',
          layoutsDir     : 'views/layouts/',
          partialsDir    : 'views/partials/',
          defaultLayout  : undefined,
          helpers        : undefined,
          compilerOptions: undefined,
      }, config);
  
      // Express view engine integration point.
      this.engine = this.renderView.bind(this);
  
      // Normalize `extname`.
      if (this.extname.charAt(0) !== '.') {
          this.extname = '.' + this.extname;
      }
  
      // Internal caches of compiled and precompiled templates.
      this.compiled    = Object.create(null);
      this.precompiled = Object.create(null);
  
      // Private internal file system cache.
      this._fsCache = Object.create(null);
  }

• example usage

  n/a

module express-handlebars.ExpressHandlebars.prototype

function express-handlebars.ExpressHandlebars.prototype._compileTemplate (template, options)

• description and source-code

  _compileTemplate = function (template, options) {
      return this.handlebars.compile(template, options);
  }

• example usage

  ...
      // remove from cache if there was a problem.
      template = cache[filePath] = this._getFile(filePath, {cache: options.cache})
          .then(function (file) {
              if (precompiled) {
                  return this._precompileTemplate(file, this.compilerOptions);
              }
  
              return this._compileTemplate(file, this.compilerOptions);
          }.bind(this));
  
      return template.catch(function (err) {
          delete cache[filePath];
          throw err;
      });
  };
  ...

function express-handlebars.ExpressHandlebars.prototype._getDir (dirPath, options)

• description and source-code

  _getDir = function (dirPath, options) {
      dirPath = path.resolve(dirPath);
      options || (options = {});
  
      var cache = this._fsCache;
      var dir   = options.cache && cache[dirPath];
  
      if (dir) {
          return dir.then(function (dir) {
              return dir.concat();
          });
      }
  
      var pattern = '**/*' + this.extname;
  
      // Optimistically cache dir promise to reduce file system I/O, but remove
      // from cache if there was a problem.
      dir = cache[dirPath] = new Promise(function (resolve, reject) {
          glob(pattern, {
              cwd   : dirPath,
              follow: true
          }, function (err, dir) {
              if (err) {
                  reject(err);
              } else {
                  resolve(dir);
              }
          });
      });
  
      return dir.then(function (dir) {
          return dir.concat();
      }).catch(function (err) {
          delete cache[dirPath];
          throw err;
      });
  }

• example usage

  ...
      });
  };
  
  ExpressHandlebars.prototype.getTemplates = function (dirPath, options) {
      options || (options = {});
      var cache = options.cache;
  
      return this._getDir(dirPath, {cache: cache}).then(function (filePaths) {
  var templates = filePaths.map(function (filePath) {
      return this.getTemplate(path.join(dirPath, filePath), options);
  }, this);
  
  return Promise.all(templates).then(function (templates) {
      return filePaths.reduce(function (hash, filePath, i) {
          hash[filePath] = templates[i];
  ...

function express-handlebars.ExpressHandlebars.prototype._getFile (filePath, options)

• description and source-code

  _getFile = function (filePath, options) {
      filePath = path.resolve(filePath);
      options || (options = {});
  
      var cache = this._fsCache;
      var file  = options.cache && cache[filePath];
  
      if (file) {
          return file;
      }
  
      // Optimistically cache file promise to reduce file system I/O, but remove
      // from cache if there was a problem.
      file = cache[filePath] = new Promise(function (resolve, reject) {
          fs.readFile(filePath, 'utf8', function (err, file) {
              if (err) {
                  reject(err);
              } else {
                  resolve(file);
              }
          });
      });
  
      return file.catch(function (err) {
          delete cache[filePath];
          throw err;
      });
  }

• example usage

  ...
  
      if (template) {
  return template;
      }
  
      // Optimistically cache template promise to reduce file system I/O, but
      // remove from cache if there was a problem.
      template = cache[filePath] = this._getFile(filePath, {cache: options.cache})
  .then(function (file) {
      if (precompiled) {
          return this._precompileTemplate(file, this.compilerOptions);
      }
  
      return this._compileTemplate(file, this.compilerOptions);
  }.bind(this));
  ...

function express-handlebars.ExpressHandlebars.prototype._getTemplateName (filePath, namespace)

• description and source-code

  _getTemplateName = function (filePath, namespace) {
      var extRegex = new RegExp(this.extname + '$');
      var name     = filePath.replace(extRegex, '');
  
      if (namespace) {
          name = namespace + '/' + name;
      }
  
      return name;
  }

• example usage

  ...
  
  // Express provides `settings.views` which is the path to the views dir that
  // the developer set on the Express app. When this value exists, it's used
  // to compute the view's name.
  var view;
  var viewsPath = options.settings && options.settings.views;
  if (viewsPath) {
      view = this._getTemplateName(path.relative(viewsPath, viewPath));
  }
  
  // Merge render-level and instance-level helpers together.
  var helpers = utils.assign({}, this.helpers, options.helpers);
  
  // Merge render-level and instance-level partials together.
  var partials = Promise.all([
  ...

function express-handlebars.ExpressHandlebars.prototype._precompileTemplate (template, options)

• description and source-code

  _precompileTemplate = function (template, options) {
      return this.handlebars.precompile(template, options);
  }

• example usage

  ...
  }
  
  // Optimistically cache template promise to reduce file system I/O, but
  // remove from cache if there was a problem.
  template = cache[filePath] = this._getFile(filePath, {cache: options.cache})
      .then(function (file) {
          if (precompiled) {
              return this._precompileTemplate(file, this.compilerOptions);
          }
  
          return this._compileTemplate(file, this.compilerOptions);
      }.bind(this));
  
  return template.catch(function (err) {
      delete cache[filePath];
  ...

function express-handlebars.ExpressHandlebars.prototype._renderTemplate (template, context, options)

• description and source-code

  _renderTemplate = function (template, context, options) {
      return template(context, options);
  }

• example usage

  ...
              exphbs: utils.assign({}, options, {
                  filePath: filePath,
                  helpers : helpers,
                  partials: partials,
              }),
          });
  
          return this._renderTemplate(template, context, {
              data    : data,
              helpers : helpers,
              partials: partials,
          });
      }.bind(this));
  };
  ...

function express-handlebars.ExpressHandlebars.prototype._resolveLayoutPath (layoutPath)

• description and source-code

  _resolveLayoutPath = function (layoutPath) {
      if (!layoutPath) {
          return null;
      }
  
      if (!path.extname(layoutPath)) {
          layoutPath += this.extname;
      }
  
      return path.resolve(this.layoutsDir, layoutPath);
  }

• example usage

  ...
          data    : options.data,
          helpers : helpers,
          partials: partials,
      };
  
      this.render(viewPath, context, options)
          .then(function (body) {
  var layoutPath = this._resolveLayoutPath(options.layout);
  
  if (layoutPath) {
      return this.render(
          layoutPath,
          utils.assign({}, context, {body: body}),
          utils.assign({}, options, {layout: undefined})
      );
  ...

function express-handlebars.ExpressHandlebars.prototype.getPartials (options)

• description and source-code

  getPartials = function (options) {
      var partialsDirs = Array.isArray(this.partialsDir) ?
              this.partialsDir : [this.partialsDir];
  
      partialsDirs = partialsDirs.map(function (dir) {
          var dirPath;
          var dirTemplates;
          var dirNamespace;
  
          // Support `partialsDir` collection with object entries that contain a
          // templates promise and a namespace.
          if (typeof dir === 'string') {
              dirPath = dir;
          } else if (typeof dir === 'object') {
              dirTemplates = dir.templates;
              dirNamespace = dir.namespace;
              dirPath      = dir.dir;
          }
  
          // We must have some path to templates, or templates themselves.
          if (!(dirPath || dirTemplates)) {
              throw new Error('A partials dir must be a string or config object');
          }
  
          // Make sure we're have a promise for the templates.
          var templatesPromise = dirTemplates ? Promise.resolve(dirTemplates) :
                  this.getTemplates(dirPath, options);
  
          return templatesPromise.then(function (templates) {
              return {
                  templates: templates,
                  namespace: dirNamespace,
              };
          });
      }, this);
  
      return Promise.all(partialsDirs).then(function (dirs) {
          var getTemplateName = this._getTemplateName.bind(this);
  
          return dirs.reduce(function (partials, dir) {
              var templates = dir.templates;
              var namespace = dir.namespace;
              var filePaths = Object.keys(templates);
  
              filePaths.forEach(function (filePath) {
                  var partialName       = getTemplateName(filePath, namespace);
                  partials[partialName] = templates[filePath];
              });
  
              return partials;
          }, {});
      }.bind(this));
  }

• example usage

  ...
  ```
  
  `getPartials()` would produce the following result:
  
  ```javascript
  var hbs = require('express-handlebars').create();
  
  hbs.getPartials().then(function (partials) {
      console.log(partials);
      // => { 'foo/bar': [Function],
      // =>    title: [Function] }
  });
  ```
  
  #### `getTemplate(filePath, [options])`
  ...

function express-handlebars.ExpressHandlebars.prototype.getTemplate (filePath, options)

• description and source-code

  getTemplate = function (filePath, options) {
      filePath = path.resolve(filePath);
      options || (options = {});
  
      var precompiled = options.precompiled;
      var cache       = precompiled ? this.precompiled : this.compiled;
      var template    = options.cache && cache[filePath];
  
      if (template) {
          return template;
      }
  
      // Optimistically cache template promise to reduce file system I/O, but
      // remove from cache if there was a problem.
      template = cache[filePath] = this._getFile(filePath, {cache: options.cache})
          .then(function (file) {
              if (precompiled) {
                  return this._precompileTemplate(file, this.compilerOptions);
              }
  
              return this._compileTemplate(file, this.compilerOptions);
          }.bind(this));
  
      return template.catch(function (err) {
          delete cache[filePath];
          throw err;
      });
  }

• example usage

  ...
  
  ExpressHandlebars.prototype.getTemplates = function (dirPath, options) {
      options || (options = {});
      var cache = options.cache;
  
      return this._getDir(dirPath, {cache: cache}).then(function (filePaths) {
  var templates = filePaths.map(function (filePath) {
      return this.getTemplate(path.join(dirPath, filePath), options);
  }, this);
  
  return Promise.all(templates).then(function (templates) {
      return filePaths.reduce(function (hash, filePath, i) {
          hash[filePath] = templates[i];
          return hash;
      }, {});
  ...

function express-handlebars.ExpressHandlebars.prototype.getTemplates (dirPath, options)

• description and source-code

  getTemplates = function (dirPath, options) {
      options || (options = {});
      var cache = options.cache;
  
      return this._getDir(dirPath, {cache: cache}).then(function (filePaths) {
          var templates = filePaths.map(function (filePath) {
              return this.getTemplate(path.join(dirPath, filePath), options);
          }, this);
  
          return Promise.all(templates).then(function (templates) {
              return filePaths.reduce(function (hash, filePath, i) {
                  hash[filePath] = templates[i];
                  return hash;
              }, {});
          });
      }.bind(this));
  }

• example usage

  ...
  // We must have some path to templates, or templates themselves.
  if (!(dirPath || dirTemplates)) {
      throw new Error('A partials dir must be a string or config object');
  }
  
  // Make sure we're have a promise for the templates.
  var templatesPromise = dirTemplates ? Promise.resolve(dirTemplates) :
          this.getTemplates(dirPath, options);
  
  return templatesPromise.then(function (templates) {
      return {
          templates: templates,
          namespace: dirNamespace,
      };
  });
  ...

function express-handlebars.ExpressHandlebars.prototype.render (filePath, context, options)

• description and source-code

  render = function (filePath, context, options) {
      options || (options = {});
  
      return Promise.all([
          this.getTemplate(filePath, {cache: options.cache}),
          options.partials || this.getPartials({cache: options.cache}),
      ]).then(function (templates) {
          var template = templates[0];
          var partials = templates[1];
          var helpers  = options.helpers || this.helpers;
  
          // Add ExpressHandlebars metadata to the data channel so that it's
          // accessible within the templates and helpers, namespaced under:
          // `@exphbs.*`
          var data = utils.assign({}, options.data, {
              exphbs: utils.assign({}, options, {
                  filePath: filePath,
                  helpers : helpers,
                  partials: partials,
              }),
          });
  
          return this._renderTemplate(template, context, {
              data    : data,
              helpers : helpers,
              partials: partials,
          });
      }.bind(this));
  }

• example usage

  ...
  
  var app = express();
  
  app.engine('handlebars', exphbs({defaultLayout: 'main'}));
  app.set('view engine', 'handlebars');
  
  app.get('/', function (req, res) {
      res.render('home');
  });
  
  app.listen(3000);
  ```
  
  **views/layouts/main.handlebars:**
  ...

function express-handlebars.ExpressHandlebars.prototype.renderView (viewPath, options, callback)

• description and source-code

  renderView = function (viewPath, options, callback) {
      options || (options = {});
  
      var context = options;
  
      // Express provides `settings.views` which is the path to the views dir that
      // the developer set on the Express app. When this value exists, it's used
      // to compute the view's name.
      var view;
      var viewsPath = options.settings && options.settings.views;
      if (viewsPath) {
          view = this._getTemplateName(path.relative(viewsPath, viewPath));
      }
  
      // Merge render-level and instance-level helpers together.
      var helpers = utils.assign({}, this.helpers, options.helpers);
  
      // Merge render-level and instance-level partials together.
      var partials = Promise.all([
          this.getPartials({cache: options.cache}),
          Promise.resolve(options.partials),
      ]).then(function (partials) {
          return utils.assign.apply(null, [{}].concat(partials));
      });
  
      // Pluck-out ExpressHandlebars-specific options and Handlebars-specific
      // rendering options.
      options = {
          cache : options.cache,
          view  : view,
          layout: 'layout' in options ? options.layout : this.defaultLayout,
  
          data    : options.data,
          helpers : helpers,
          partials: partials,
      };
  
      this.render(viewPath, context, options)
          .then(function (body) {
              var layoutPath = this._resolveLayoutPath(options.layout);
  
              if (layoutPath) {
                  return this.render(
                      layoutPath,
                      utils.assign({}, context, {body: body}),
                      utils.assign({}, options, {layout: undefined})
                  );
              }
  
              return body;
          }.bind(this))
          .then(utils.passValue(callback))
          .catch(utils.passError(callback));
  }

• example usage

  n/a

module express-handlebars.utils

function express-handlebars.utils.assign ()

• description and source-code

  function assign() { [native code] }

• example usage

  ...
  
  module.exports = ExpressHandlebars;
  
  // -----------------------------------------------------------------------------
  
  function ExpressHandlebars(config) {
  // Config properties with defaults.
  utils.assign(this, {
      handlebars     : Handlebars,
      extname        : '.handlebars',
      layoutsDir     : 'views/layouts/',
      partialsDir    : 'views/partials/',
      defaultLayout  : undefined,
      helpers        : undefined,
      compilerOptions: undefined,
  ...

function express-handlebars.utils.passError (callback)

• description and source-code

  function passError(callback) {
      return function (reason) {
          setImmediate(function () {
              callback(reason);
          });
      };
  }

• example usage

  ...
                      utils.assign({}, options, {layout: undefined})
                  );
              }
  
              return body;
          }.bind(this))
          .then(utils.passValue(callback))
          .catch(utils.passError(callback));
  };
  
  // -- Protected Hooks ----------------------------------------------------------
  
  ExpressHandlebars.prototype._compileTemplate = function (template, options) {
      return this.handlebars.compile(template, options);
  };
  ...

function express-handlebars.utils.passValue (callback)

• description and source-code

  function passValue(callback) {
      return function (value) {
          setImmediate(function () {
              callback(null, value);
          });
      };
  }

• example usage

  ...
                  utils.assign({}, context, {body: body}),
                  utils.assign({}, options, {layout: undefined})
              );
          }
  
          return body;
      }.bind(this))
      .then(utils.passValue(callback))
      .catch(utils.passError(callback));
  };
  
  // -- Protected Hooks ----------------------------------------------------------
  
  ExpressHandlebars.prototype._compileTemplate = function (template, options) {
  return this.handlebars.compile(template, options);
  ...