Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Recursive route tree for Node.js
JavaScript
Tag: v0.5.0

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.
tests
.gitignore
LICENSE
README.mkd
compile.js
package.json
treeRouter.js

README.mkd

mapleTree

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

From Source

git clone git://github.com/saambarati/mapleTree.git
cd mapleTree
npm link

API

Simple Routing

 var mapleTree = require('mapleTree')
   , router = new mapleTree.RouteTree()

 router.define('/foo/bar', function () {
   console.log('foo/bar route')
 })

 router.define('/hello/:foo', function () {
   console.log('hello/:foo')
 })

 router.define('/files/:file.:format', function () {
   console.log('file callback')
   console.log('filename =>' + this.params.file + '.'+ this.params.format)
 })

 /*
  *  the matcher object  contains a few important properties. It is what is returned from a router.match() call
  *  matcher.cbs = {Array}                           //collection of callbacks, the closest match first
  *  matcher.fn = {function}                         //placeholder for best matching function. The best depends on 'fifo' being true or false. (see below)
  *  matcher.perfect = {boolean} default => false    //were we able to match an exact path, or did we only match partially?
  *  matcher.extras = {Array}                        //match a regexp capture group that isn't part of params
  *  matcher.params = {Object}                       //collection of colon args
  *  matcher.next {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(match.params.foo) //prints 'world'

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

Partial Matches -- first in first out / first in last out

 var mapleTree = require('mapleTree')
   , router = new mapleTree.RouteTree({'fifo' : false })

 router.define('/hello', function () {
   console.log('/hello')
   this.next()
 })
 router.define('/hello/world', function () {
   console.log('/hello/world')
   this.next()
 })
 router.define('/hello/world/foo', function () {
   console.log('/hello/world/foo')
   this.next()
 })

 var match = router.match('/hello/world/foo')
 match.fn()
 /* 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')
 match.fn()
 /* PRINTS =>
  *  /hello/
  *  /hello/world/
  *  /hello/world/foo/
 */

URL Pattern Matching

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('/nope/'))    // false

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

Tidbits

Routing using match.next 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.

Trailing slashes at the end of routes are significant.

tree.define('/hello')

is not the same as:

tree.define('/hello/')

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

tree.define('/hello/?')

because it makes the trailing slash optional.

Licensed under The MIT License
Something went wrong with that request. Please try again.