xonecas.io
186
Ft

fractal-tree / files

fractal-tree / 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}