node package manager
Easy collaboration. Discover, share, and reuse code in your team. Create a free org »

rolley-router-engine

Rolley Router Engine

Extensible router engine middleware.

API

Use the router-engine to roll your own router middleware. This can be achieved by implementing a custom path matching library on top of the engine. For example, to implement a custom "exact" path matching router module, we could do this.

This is an extracted version of the express project. The engine has been extracted out of blakeembrey/router#router-engine project module.

var Engine = require('rolley-router-engine');
var slice = Array.prototype.slice
 
/**
 * Accepts the path and some options we defined in our engine.
 */
function toFunction (route, options) {
  if (!options.end) {
    return function (path) {
      var matches = path.substr(0, route.length) === route
 
      return matches ? { path: path } : false
    }
  }
 
  return function (path) {
    return path === route ? { path: path } : false
  }
}
 
/**
 * The constructor must return the engine instance.
 */
function ExactRouter (options) {
  return Engine.call(this, options)
}
 
/**
 * Inherits from the engine prototype.
 */
ExactRouter.prototype = Object.create(Engine.prototype)
 
/**
 * Set up `Router#use` with our custom path matching implementation.
 */
ExactRouter.prototype.use = function () {
  // Use a simple utility for supporting a single path argument like `router`. 
  var opts = Engine.sanitizeUse.apply(null, arguments)
  var match = toFunction(opts.path, { end: false })
 
  return Engine.prototype.use.call(this, opts.path, match, opts.callbacks)
}
 
/**
 * Set up `Router#route` with our custom path patching implementation.
 */
ExactRouter.prototype.route = function (path) {
  var match = toFunction(path, { end: true })
 
  return Engine.prototype.route.call(this, path, match)
}
 
/**
 * Set up all the router method shorthands.
 */
Engine.methods.forEach(function (method) {
  ExactRouter.prototype[method] = function (path) {
    var route = this.route(path)
    route[method].apply(route, slice.call(arguments, 1))
    return this
  }
})