odgn-mapletree v0.5.1

mapleTree

mapleTree is a small, recursive router for javascript. 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/odogono/mapleTree.git
cd mapleTree
npm link

API

Simple Routing

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

Normal route

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

Colon Agruments

 router.define('/hello/:foo', function () {
   console.log('hello/:foo')
 })
 m = router.match('/hello/world')
 //m.perfect === true
 //m.params.foo === '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'

router.match

 /*
  *  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 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
  *  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'

wildcard routes

router.define('/files/*')

router.match('/files')           //matcher.perfect === false
router.match('/files/home.html') //matcher.perfect === true

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

 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 (or other patterns)

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

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