191
Pp
particle-play / files
particle-play / node_modules / connect / lib / middleware / router.js
8.5 KB
1 2/*! 3 * Connect - router 4 * Copyright(c) 2010 Sencha Inc. 5 * Copyright(c) 2011 TJ Holowaychuk 6 * MIT Licensed 7 */ 8 9/** 10 * Module dependencies. 11 */ 12 13var utils = require('../utils') 14 , parse = require('url').parse; 15 16/** 17 * Expose router. 18 */ 19 20exports = module.exports = router; 21 22/** 23 * Supported HTTP / WebDAV methods. 24 */ 25 26var _methods = exports.methods = [ 27 'get' 28 , 'post' 29 , 'put' 30 , 'delete' 31 , 'connect' 32 , 'options' 33 , 'trace' 34 , 'copy' 35 , 'lock' 36 , 'mkcol' 37 , 'move' 38 , 'propfind' 39 , 'proppatch' 40 , 'unlock' 41 , 'report' 42 , 'mkactivity' 43 , 'checkout' 44 , 'merge' 45]; 46 47/** 48 * Provides Sinatra and Express-like routing capabilities. 49 * 50 * Examples: 51 * 52 * connect.router(function(app){ 53 * app.get('/user/:id', function(req, res, next){ 54 * // populates req.params.id 55 * }); 56 * app.put('/user/:id', function(req, res, next){ 57 * // populates req.params.id 58 * }); 59 * }) 60 * 61 * @param {Function} fn 62 * @return {Function} 63 * @api public 64 */ 65 66function router(fn){ 67 var self = this 68 , methods = {} 69 , routes = {} 70 , params = {}; 71 72 if (!fn) throw new Error('router provider requires a callback function'); 73 74 // Generate method functions 75 _methods.forEach(function(method){ 76 methods[method] = generateMethodFunction(method.toUpperCase()); 77 }); 78 79 // Alias del -> delete 80 methods.del = methods.delete; 81 82 // Apply callback to all methods 83 methods.all = function(){ 84 var args = arguments; 85 _methods.forEach(function(name){ 86 methods[name].apply(this, args); 87 }); 88 return self; 89 }; 90 91 // Register param callback 92 methods.param = function(name, fn){ 93 params[name] = fn; 94 }; 95 96 fn.call(this, methods); 97 98 function generateMethodFunction(name) { 99 var localRoutes = routes[name] = routes[name] || []; 100 return function(path, fn){ 101 var keys = [] 102 , middleware = []; 103 104 // slice middleware 105 if (arguments.length > 2) { 106 middleware = Array.prototype.slice.call(arguments, 1, arguments.length); 107 fn = middleware.pop(); 108 middleware = utils.flatten(middleware); 109 } 110 111 fn.middleware = middleware; 112 113 if (!path) throw new Error(name + ' route requires a path'); 114 if (!fn) throw new Error(name + ' route ' + path + ' requires a callback'); 115 var regexp = path instanceof RegExp 116 ? path 117 : normalizePath(path, keys); 118 localRoutes.push({ 119 fn: fn 120 , path: regexp 121 , keys: keys 122 , orig: path 123 , method: name 124 }); 125 return self; 126 }; 127 } 128 129 function router(req, res, next){ 130 var route 131 , self = this; 132 133 (function pass(i){ 134 if (route = match(req, routes, i)) { 135 var i = 0 136 , keys = route.keys; 137 138 req.params = route.params; 139 140 // Param preconditions 141 (function param(err) { 142 try { 143 var key = keys[i++] 144 , val = req.params[key] 145 , fn = params[key]; 146 147 if ('route' == err) { 148 pass(req._route_index + 1); 149 // Error 150 } else if (err) { 151 next(err); 152 // Param has callback 153 } else if (fn) { 154 // Return style 155 if (1 == fn.length) { 156 req.params[key] = fn(val); 157 param(); 158 // Middleware style 159 } else { 160 fn(req, res, param, val); 161 } 162 // Finished processing params 163 } else if (!key) { 164 // route middleware 165 i = 0; 166 (function nextMiddleware(err){ 167 var fn = route.middleware[i++]; 168 if ('route' == err) { 169 pass(req._route_index + 1); 170 } else if (err) { 171 next(err); 172 } else if (fn) { 173 fn(req, res, nextMiddleware); 174 } else { 175 route.call(self, req, res, function(err){ 176 if (err) { 177 next(err); 178 } else { 179 pass(req._route_index + 1); 180 } 181 }); 182 } 183 })(); 184 // More params 185 } else { 186 param(); 187 } 188 } catch (err) { 189 next(err); 190 } 191 })(); 192 } else if ('OPTIONS' == req.method) { 193 options(req, res, routes); 194 } else { 195 next(); 196 } 197 })(); 198 }; 199 200 router.remove = function(path, method){ 201 var fns = router.lookup(path, method); 202 fns.forEach(function(fn){ 203 routes[fn.method].splice(fn.index, 1); 204 }); 205 }; 206 207 router.lookup = function(path, method, ret){ 208 ret = ret || []; 209 210 // method specific lookup 211 if (method) { 212 method = method.toUpperCase(); 213 if (routes[method]) { 214 routes[method].forEach(function(route, i){ 215 if (path == route.orig) { 216 var fn = route.fn; 217 fn.regexp = route.path; 218 fn.keys = route.keys; 219 fn.path = route.orig; 220 fn.method = route.method; 221 fn.index = i; 222 ret.push(fn); 223 } 224 }); 225 } 226 // global lookup 227 } else { 228 _methods.forEach(function(method){ 229 router.lookup(path, method, ret); 230 }); 231 } 232 233 return ret; 234 }; 235 236 router.match = function(url, method, ret){ 237 var ret = ret || [] 238 , i = 0 239 , fn 240 , req; 241 242 // method specific matches 243 if (method) { 244 method = method.toUpperCase(); 245 req = { url: url, method: method }; 246 while (fn = match(req, routes, i)) { 247 i = req._route_index + 1; 248 ret.push(fn); 249 } 250 // global matches 251 } else { 252 _methods.forEach(function(method){ 253 router.match(url, method, ret); 254 }); 255 } 256 257 return ret; 258 }; 259 260 return router; 261} 262 263/** 264 * Respond to OPTIONS. 265 * 266 * @param {ServerRequest} req 267 * @param {ServerResponse} req 268 * @param {Array} routes 269 * @api private 270 */ 271 272function options(req, res, routes) { 273 var pathname = parse(req.url).pathname 274 , body = optionsFor(pathname, routes).join(','); 275 res.writeHead(200, { 276 'Content-Length': body.length 277 , 'Allow': body 278 }); 279 res.end(body); 280} 281 282/** 283 * Return OPTIONS array for the given `path`, matching `routes`. 284 * 285 * @param {String} path 286 * @param {Array} routes 287 * @return {Array} 288 * @api private 289 */ 290 291function optionsFor(path, routes) { 292 return _methods.filter(function(method){ 293 var arr = routes[method.toUpperCase()]; 294 for (var i = 0, len = arr.length; i < len; ++i) { 295 if (arr[i].path.test(path)) return true; 296 } 297 }).map(function(method){ 298 return method.toUpperCase(); 299 }); 300} 301 302/** 303 * Normalize the given path string, 304 * returning a regular expression. 305 * 306 * An empty array should be passed, 307 * which will contain the placeholder 308 * key names. For example "/user/:id" will 309 * then contain ["id"]. 310 * 311 * @param {String} path 312 * @param {Array} keys 313 * @return {RegExp} 314 * @api private 315 */ 316 317function normalizePath(path, keys) { 318 path = path 319 .concat('/?') 320 .replace(/\/\(/g, '(?:/') 321 .replace(/(\/)?(\.)?:(\w+)(?:(\(.*?\)))?(\?)?/g, function(_, slash, format, key, capture, optional){ 322 keys.push(key); 323 slash = slash || ''; 324 return '' 325 + (optional ? '' : slash) 326 + '(?:' 327 + (optional ? slash : '') 328 + (format || '') + (capture || '([^/]+?)') + ')' 329 + (optional || ''); 330 }) 331 .replace(/([\/.])/g, '\\$1') 332 .replace(/\*/g, '(.+)'); 333 return new RegExp('^' + path + '$', 'i'); 334} 335 336/** 337 * Attempt to match the given request to 338 * one of the routes. When successful 339 * a route function is returned. 340 * 341 * @param {ServerRequest} req 342 * @param {Object} routes 343 * @return {Function} 344 * @api private 345 */ 346 347function match(req, routes, i) { 348 var captures 349 , method = req.method 350 , i = i || 0; 351 if ('HEAD' == method) method = 'GET'; 352 if (routes = routes[method]) { 353 var url = parse(req.url) 354 , pathname = url.pathname; 355 for (var len = routes.length; i < len; ++i) { 356 var route = routes[i] 357 , fn = route.fn 358 , path = route.path 359 , keys = fn.keys = route.keys; 360 if (captures = path.exec(pathname)) { 361 fn.method = method; 362 fn.params = []; 363 for (var j = 1, len = captures.length; j < len; ++j) { 364 var key = keys[j-1], 365 val = typeof captures[j] === 'string' 366 ? decodeURIComponent(captures[j]) 367 : captures[j]; 368 if (key) { 369 fn.params[key] = val; 370 } else { 371 fn.params.push(val); 372 } 373 } 374 req._route_index = i; 375 return fn; 376 } 377 } 378 } 379}