Simple routing library for node.js


mapleTree is a small, recursive router for Node.js. It works by creating a routing tree and searching for full and partial matches. mapleTree is designed to be minimal. It is written with the intention that other libraries will be built on top of it or extend its functionality.

####Install npm install mapleTree

git clone git://
cd mapleTree
npm link
 var mapleTree = require('mapleTree')
   , router = new mapleTree.RouteTree()
 router.define('/foo/bar', function () {
   console.log('foo/bar route')
 router.define('/hello/:foo', function () {
 m = router.match('/hello/world')
 //m.perfect === true
 // === 'world'
 //router.match('/hello/world/foo').perfect === false

 router.define('/files/:file.:format', function () { //note, the period is interpreted literally
   console.log('file callback')
   console.log('filename =>' + this.params.file + '.'+ this.params.format)
 m = router.match('/files/home.html')
 //m.perfect === true
 //m.params.file === 'home'
 //m.params.format === 'html'
  *  the matcher object  contains a few important properties. It is what is returned from a router.match() call
  * = {Array}                           //collection of callbacks, the best match at zero index
  *  matcher.fn = {function}                         //placeholder for best matching function. The best depends on 'fifo' being true or false. (see below)
  *  matcher.perfect = {boolean} default => false    //true if matched exact path. false if it only matched partially
  *  matcher.extras = {Array}                        //match a regexp capture group that isn't part of params. i.e when using wildcard
  *  matcher.params = {Object}                       //collection of colon args
  * {function}                         //invoke next matching function if one exists

 var match = router.match('/foo/bar')
 match.fn()                            //prints 'foo/bar route'

 match = router.match('/hello/world')
 match.fn()                            //prints 'hello/:foo'
 console.log(         //prints 'world'

 match = router.match('/files/index.html')
 match.fn()  //prints 'filename => index.html'

router.match('/files')           //matcher.perfect === false
router.match('/files/home.html') //matcher.perfect === true
 router = new mapleTree.RouteTree({'fifo' : false })

 router.define('/hello', function () {
 router.define('/hello/world', function () {
 router.define('/hello/world/foo', function () {

 var match = router.match('/hello/world/foo')
 /* PRINTS =>
  *  /hello/world/foo
  *  /hello/world
  *  /hello

 router.fifo = true  //first match is invoked first now
 //or when creating the router you can pass an options obj  => new maple.RouteTree({'fifo' : true})
 match = router.match('/hello/world/foo')
 /* PRINTS =>
  *  /hello
  *  /hello/world
  *  /hello/world/foo

The pattern API works similarly to the define API. You pass mapleTree.pattern a patterned URL to match against, and it returns a function that when passed a string as a parameter will return a boolean indicating whether it matches the parameter or not.

var mapleTree = require('mapleTree')
var match = mapleTree.pattern('/test/:var') //returns a function
console.log(match('/test/yes')) // true
console.log(match('/test'))     // false
console.log(match('/test/'))    // false

var match = mapleTree.pattern('wildcard/*')
console.log(match('/wildcard'))                      // false
console.log(match('/wildcard/some/extended/route/')) // true

Routing using will not match against the root (/) route. I figure if you need a function to run against the root, it is better served being run outside of the router, considering you want it to run every time. I could be wrong about this stance though, and am interested in listening to arguments defending the contrary. Maybe if enough people want the functionality I can add it as an option when instantiating the router similar to fifo.


is not the same as:


if you want to match both '/hello' and '/hello/' define your route this way:


because it makes the trailing slash optional.