├── .gitignore
├── .jshintrc
├── .travis.yml
├── LICENSE.md
├── README.md
├── bower.json
├── lib
    └── router-base.js
├── package.json
└── test
    ├── data
        ├── generate-data.js
        ├── getRouteInfo-data.js
        ├── match-data.js
        └── routes.js
    └── router-base.test.js


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | node_modules
3 | 


--------------------------------------------------------------------------------
/.jshintrc:
--------------------------------------------------------------------------------
 1 | {
 2 |     "bitwise": true,
 3 |     "curly": true,
 4 |     "eqeqeq": true,
 5 |     "forin": true,
 6 |     "freeze": true,
 7 |     "immed": true,
 8 |     "newcap": true,
 9 |     "noarg": true,
10 |     "noempty": true,
11 |     "undef": true,
12 |     "latedef": "nofunc",
13 |     "unused": "vars",
14 |     "browser": true,
15 |     "node": true
16 | }
17 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | sudo: false
 2 | 
 3 | language: node_js
 4 | 
 5 | node_js:
 6 |   - "5"
 7 |   - "4"
 8 |   - "0.12"
 9 |   - "0.10"
10 | 
11 | after_script:
12 |   - npm run coveralls
13 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Alexander Savin
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Base router for your JS framework or frameworkless app
  2 | 
  3 | [![Build Status](https://travis-ci.org/apsavin/router-base.svg?branch=master)](https://travis-ci.org/apsavin/router-base) [![Coverage Status](https://coveralls.io/repos/apsavin/router-base/badge.svg)](https://coveralls.io/r/apsavin/router-base) [![NPM version](https://badge.fury.io/js/router-base.svg)](http://badge.fury.io/js/router-base) [![Bower version](https://badge.fury.io/bo/router-base.svg)](http://badge.fury.io/bo/router-base)
  4 | 
  5 | It's abstract and knows nothing about http. It's just matches and generates urls.
  6 | 
  7 | ##How to include it in my app or framework?
  8 | 
  9 | Router supports:
 10 | 
 11 | 1. [node.js](http://nodejs.org) modules,
 12 | 2. [requirejs](http://requirejs.org) modules
 13 | 3. and, of course, awesome [ym](https://github.com/ymaps/modules) modules.
 14 | 4. You can just use the `<script>` tag also, RouterBase will export the global variable then.
 15 | 
 16 | You can install it with npm:
 17 | 
 18 | ```bash
 19 | $ npm install router-base
 20 | ```
 21 | 
 22 | or bower:
 23 | 
 24 | ```bash
 25 | $ bower install router-base
 26 | ```
 27 | 
 28 | ##How to use it?
 29 | 
 30 | ###Very basic example
 31 | 
 32 | At first, you need to create an instance:
 33 | 
 34 | ```javascript
 35 | var myRouter = new RouterBase({
 36 | 
 37 |     routes: myRoutes // routes config
 38 | 
 39 | });
 40 | ```
 41 | 
 42 | Where routes config is an Array with objects, each object is a configuration for a route.
 43 | For example:
 44 | 
 45 | ```javascript
 46 | var myRoutes = [{
 47 |     id: 'simplest_route',
 48 |     path: '/a/route'
 49 | }];
 50 | 
 51 | var myRouter = new RouterBase({
 52 |     routes: myRoutes
 53 | });
 54 | 
 55 | // You can generate routes by id:
 56 | myRouter.generate('simplest_route'); 
 57 | // returns '/a/route'
 58 | 
 59 | // You can find a route by path and method:
 60 | myRouter.match({path: '/a/route', method: 'GET'}); 
 61 | // returns {id: 'simplest_route', parameters: {}, definition: { id: 'simplest_route',
 62 |                                                                    path: '/a/route',
 63 |                                                                    defaults: {},
 64 |                                                                    requirements: {},
 65 |                                                                    host: undefined,
 66 |                                                                    methods: [ 'GET', 'POST', 'PUT', 'DELETE' ],
 67 |                                                                    schemes: [ 'http', 'https' ] } }
 68 | }
 69 | 
 70 | // You can get full info about a route by id:
 71 | myRouter.getRouteInfo('simplest_route');
 72 | // for answer see [tests](https://github.com/apsavin/router-base/blob/master/test/data/getRouteInfo-data.js#L4-L41)
 73 | ```
 74 | 
 75 | You can use access to the `definition` if you want to set additional fields to the route.
 76 | For example, you can mark route as secure specifying `secure: true` in the route config
 77 | and then check this field like this:
 78 | 
 79 | ```javascript
 80 | var route = myRouter.match({path: '/a/route', method: 'GET'}); 
 81 | 
 82 | if (route && route.definition.secure) // do something
 83 | 
 84 | ```
 85 | 
 86 | I will omit the `definition` field in the next examples.
 87 | 
 88 | ###Beautiful urls examples
 89 | 
 90 | ####You can use named parameters in paths of the routes.
 91 | ```javascript
 92 | var myRoutes = [{
 93 |     id: 'route_with_parameter_in_path',
 94 |     path: '/some/path/{parameter}'
 95 | }];
 96 | 
 97 | myRouter.generate('route_with_parameter_in_path'); 
 98 | // will throw an Error, because parameter is needed for the route
 99 | myRouter.generate('route_with_parameter_in_path', {parameter: 1}); 
100 | // returns '/some/path/1'
101 | myRouter.generate('route_with_parameter_in_path', {parameter: 'value'}); 
102 | // returns '/some/path/value'
103 | 
104 | myRouter.match({path: '/some/path/', method: 'GET'}); 
105 | // returns null
106 | myRouter.match({path: '/some/path/to', method: 'GET'}); 
107 | // returns {id: 'route_with_parameter_in_path', parameters: {parameter: 'to'}, definition: {...}}
108 | ```
109 | ####Optional parameters in paths
110 | ```javascript
111 | var myRoutes = [{
112 |     id: 'route_with_parameter_in_path',
113 |     path: '/some/path/{parameter}',
114 |     defaults: {parameter: 1}
115 | }];
116 | 
117 | myRouter.generate('route_with_parameter_in_path'); 
118 | // returns '/some/path'
119 | myRouter.generate('route_with_parameter_in_path', {parameter: 1}); 
120 | // returns '/some/path/1'
121 | myRouter.generate('route_with_parameter_in_path', {parameter: 'value'}); 
122 | // returns '/some/path/value'
123 | 
124 | myRouter.match({path: '/some/path', method: 'GET'}); 
125 | // returns  {id: 'route_with_parameter_in_path', parameters: {parameter: 1}, definition: {...}}
126 | myRouter.match({path: '/some/path/to', method: 'GET'}); 
127 | // returns {id: 'route_with_parameter_in_path', parameters: {parameter: 'to'}, definition: {...}}
128 | ```
129 | ####Restricted parameters in paths
130 | ```javascript
131 | var myRoutes = [{
132 |     id: 'route_with_parameter_in_path',
133 |     path: '/some/path/{parameter}',
134 |     defaults: {parameter: 1},
135 |     requirements: {parameter: '\\d+'}
136 | }];
137 | 
138 | myRouter.generate('route_with_parameter_in_path'); 
139 | // returns '/some/path'
140 | myRouter.generate('route_with_parameter_in_path', {parameter: 1}); 
141 | // returns '/some/path/1'
142 | myRouter.generate('route_with_parameter_in_path', {parameter: 'value'}); 
143 | // throws an Error, because parameter is not numeric
144 | 
145 | myRouter.match({path: '/some/path', method: 'GET'}); 
146 | // returns {id: 'route_with_parameter_in_path', parameters: {parameter: 1}, definition: {...}}
147 | myRouter.match({path: '/some/path/to', method: 'GET'}); 
148 | // returns null
149 | ```
150 | 
151 | ##All possible routes parameters
152 | 
153 | 1. id - String, required. You can use it to link a route to your controller.
154 | 2. path - String, required. Can include named parameters in `{parameterName}` form.
155 | 3. host - String, optional. Can include named parameters in `{parameterName}` form (For example, '{sub}.example.com').
156 | 4. defaults - Object, optional. Keys are parameters names, values are parameters default values.
157 | 5. requirements - Object, optional. You can use it to restrict parameters. Keys are parameters names, values are strings. Strings from values are for regular expressions, router uses it to test parameters.
158 | 6. methods - Array, optional. For example, `['GET']` to allow only `GET` methods.
159 | 7. schemes - Array, optional. For example, `['https']` to force https.
160 | 
161 | ##RouterBase parameters
162 | 
163 | 1. routes - an Array of routes configs, the only required parameter
164 | 2. defaultMethods - what methods available for routes, `['GET', 'POST', 'PUT', 'DELETE']` by default
165 | 3. defaultSchemes - what schemes available for routes, `['http', 'https']` by default
166 | 4. symbols.parametersDelimiters. By default, `.` and `/` can be used as parameters delimiters in paths
167 | 5. symbols.parameterStart, default value is '\{'
168 | 6. symbols.parameterMatcher, default value is '.*?'
169 | 7. symbols.parameterEnd, default value is '\}'
170 | 
171 | ##Where is tests?
172 | Of course, in `test` folder. Use `npm test` to run.
173 | 


--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "router-base",
 3 |   "description": "javascript abstract, node.js and client-side router, inspired by symfony router",
 4 |   "repository": {
 5 |     "type": "git",
 6 |     "url": "https://github.com/apsavin/router-base.git"
 7 |   },
 8 |   "bugs": "https://github.com/apsavin/router-base/issues",
 9 |   "ignore": [
10 |     "node_modules"
11 |   ],
12 |   "authors": [
13 |     "Alexander Savin <box.for.postman@gmail.com>"
14 |   ],
15 |   "keywords": [
16 |       "router", "abstract", "symfony"
17 |   ]
18 | }
19 | 


--------------------------------------------------------------------------------
/lib/router-base.js:
--------------------------------------------------------------------------------
  1 | (function (global) {
  2 | 
  3 |     /**
  4 |      * @param {Object} object
  5 |      * @param {Function} callback
  6 |      * @param {Object} [ctx]
  7 |      * @returns {Object}
  8 |      */
  9 |     var map = function (object, callback, ctx) {
 10 |         var copy = {};
 11 |         for (var key in object) {
 12 |             if (object.hasOwnProperty(key)) {
 13 |                 copy[key] = callback.call(ctx, object[key], key, object);
 14 |             }
 15 |         }
 16 |         return copy;
 17 |     };
 18 | 
 19 |     /**
 20 |      * merges objects
 21 |      * @returns {{}}
 22 |      */
 23 |     var merge = function () {
 24 |         var result = {};
 25 |         Array.prototype.forEach.call(arguments, function (o) {
 26 |             for (var key in o) {
 27 |                 if (o.hasOwnProperty(key)) {
 28 |                     result[key] = o[key];
 29 |                 }
 30 |             }
 31 |         });
 32 |         return result;
 33 |     };
 34 | 
 35 |     /**
 36 |      * @param {*} o
 37 |      * @returns {*}
 38 |      */
 39 |     var clone = function (o) {
 40 |         if (Array.isArray(o)) {
 41 |             return o.map(clone);
 42 |         }
 43 |         if (o instanceof RegExp || [
 44 |                 'string',
 45 |                 'number',
 46 |                 'boolean'
 47 |             ].indexOf(typeof o) > -1 || o == null) {
 48 |             return o;
 49 |         }
 50 |         return map(o, clone);
 51 |     };
 52 | 
 53 |     /**
 54 |      * @typedef {Object} RouteDefinition
 55 |      * @property {String} id
 56 |      * @property {String} path
 57 |      * @property {String} [host]
 58 |      * @property {String} [prefix]
 59 |      * @property {Object.<String|Number>} [defaults]
 60 |      * @property {Object.<String>} [requirements]
 61 |      * @property {Array.<String>} [methods]
 62 |      * @property {Array.<String>} [schemes]
 63 |      */
 64 | 
 65 |     /**
 66 |      * @typedef {Object} RoutesDefinition
 67 |      * @property {String} [prefix]
 68 |      * @property {Array.<RouteDefinition|RoutesDefinition>} routes
 69 |      */
 70 | 
 71 |     /**
 72 |      * @typedef {Object} RouteDefinitionParsed
 73 |      * @property {String} id
 74 |      * @property {RegExp} pattern
 75 |      * @property {String} path
 76 |      * @property {Array.<String>} parameters
 77 |      * @property {RegExp} hostPattern
 78 |      * @property {String} host
 79 |      * @property {Array.<String>} hostParameters
 80 |      * @property {Object.<RegExp>} requirements
 81 |      * @property {Object.<String>} defaults
 82 |      * @property {Array.<String>} methods
 83 |      * @property {Array.<String>} schemes
 84 |      * @property {{RouteDefinition}} definition
 85 |      */
 86 | 
 87 |     /**
 88 |      * @typedef {Object} Route
 89 |      * @property {String} id
 90 |      * @property {RouteDefinition} definition
 91 |      * @property {Object.<String>} [parameters]
 92 |      */
 93 | 
 94 |     /**
 95 |      * @class RouterBase
 96 |      * @param {Object} options
 97 |      * @param {Array.<RouteDefinition|RoutesDefinition>} options.routes
 98 |      * @param {Array.<String>} [options.defaultMethods=['GET', 'POST', 'PUT', 'DELETE']]
 99 |      * @param {Array.<String>} [options.defaultSchemes=['http', 'https']]
100 |      * @param {Object} [options.symbols]
101 |      * @param {String} [options.symbols.defaultParameterRequirement='[^\\/.]*']
102 |      * @param {String} [options.symbols.parametersDelimiters='\.|\/']
103 |      * @param {String} [options.symbols.parameterStart='\{']
104 |      * @param {String} [options.symbols.parameterMatcher='.*?']
105 |      * @param {String} [options.symbols.parameterEnd='\}']
106 |      */
107 |     var RouterBase = function (options) {
108 |         var symbols = options.symbols || {},
109 |             paramsDelimiters = symbols.parametersDelimiters || '\\.|\\/',
110 |             paramStart = symbols.parameterStart || '\\{',
111 |             paramMatcher = symbols.parameterMatcher || '.*?',
112 |             paramEnd = symbols.parameterEnd || '\\}';
113 | 
114 |         /**
115 |          * @const {{regexp: RegExp, parameters: Array}}
116 |          * @private
117 |          */
118 |         this._NO_HOST = {
119 |             regexp: /.*/,
120 |             parameters: []
121 |         };
122 | 
123 |         /**
124 |          * @type {string}
125 |          * @private
126 |          */
127 |         this._defaultParameterRequirement = symbols.defaultParameterRequirement || '[^\\/.]*';
128 | 
129 |         /**
130 |          * @type {RegExp}
131 |          * @private
132 |          */
133 |         this._paramsReplaceRegExp = new RegExp('(' + paramsDelimiters + ')?' + paramStart +
134 |             '(' + paramMatcher + ')' + paramEnd, 'g');
135 | 
136 |         /**
137 |          * @type {Array.<String>}
138 |          * @private
139 |          */
140 |         this._defaultMethods = options.defaultMethods || ['GET', 'POST', 'PUT', 'DELETE'];
141 | 
142 |         /**
143 |          * @type {Array.<String>}
144 |          * @private
145 |          */
146 |         this._defaultSchemes = options.defaultSchemes || ['http', 'https'];
147 | 
148 |         /**
149 |          * @type {Array.<RouteDefinition>}
150 |          * @private
151 |          */
152 |         this._routesDefinitions = this._unifyRoutes(options.routes);
153 | 
154 |         /**
155 |          * @type {Array.<RouteDefinitionParsed>}
156 |          * @private
157 |          */
158 |         this._routes = this._parseRoutes(this._routesDefinitions);
159 | 
160 |         /**
161 |          * @type {Object.<RouteDefinitionParsed>}
162 |          * @private
163 |          */
164 |         this._routeIdToParsedDefinitionMap = {};
165 |     };
166 | 
167 |     /**
168 |      * @param {Array.<RouteDefinition|RoutesDefinition>} routes
169 |      * @param {RouteDefinition} [parentRoute]
170 |      * @returns {Array.<RouteDefinition>}
171 |      * @private
172 |      */
173 |     RouterBase.prototype._unifyRoutes = function (routes, parentRoute) {
174 |         var unifiedRoutes = [];
175 |         routes.forEach(function (route) {
176 |             unifiedRoutes = unifiedRoutes.concat(this._unifyRoute(route, parentRoute));
177 |         }, this);
178 |         return unifiedRoutes;
179 |     };
180 | 
181 |     /**
182 |      * @param {RouteDefinition|RoutesDefinition} route
183 |      * @param {RouteDefinition} [parentRoute]
184 |      * @returns {RouteDefinition|Array.<RouteDefinition>}
185 |      * @private
186 |      */
187 |     RouterBase.prototype._unifyRoute = function (route, parentRoute) {
188 |         parentRoute = parentRoute || {};
189 |         route.defaults = map(merge(parentRoute.defaults, route.defaults), function (prop) {
190 |             return String(prop);
191 |         });
192 |         route.requirements = merge(parentRoute.requirements, route.requirements);
193 |         if (parentRoute.prefix) {
194 |             route.path = parentRoute.prefix + route.path;
195 |             route.prefix = route.prefix ? parentRoute.prefix + route.prefix : parentRoute.prefix;
196 |         }
197 |         route.host = route.host || parentRoute.host;
198 |         route.methods = route.methods || parentRoute.methods || this._defaultMethods;
199 |         route.schemes = route.schemes || parentRoute.schemes || this._defaultSchemes;
200 |         for (var key in parentRoute) {
201 |             if (parentRoute.hasOwnProperty(key) && key !== 'routes' && !route[key]) {
202 |                 route[key] = parentRoute[key];
203 |             }
204 |         }
205 |         return route.routes ? this._unifyRoutes(route.routes, route) : route;
206 |     };
207 | 
208 |     /**
209 |      * @param {Array.<RouteDefinition|RoutesDefinition>} routes
210 |      * @returns {Array.<RouteDefinitionParsed>}
211 |      * @private
212 |      */
213 |     RouterBase.prototype._parseRoutes = function (routes) {
214 |         return routes.map(this._parseRoute, this);
215 |     };
216 | 
217 |     /**
218 |      * @param {RouteDefinition} route
219 |      * @param {Number} i
220 |      * @returns {RouteDefinitionParsed}
221 |      * @private
222 |      */
223 |     RouterBase.prototype._parseRoute = function (route, i) {
224 |         var defaults = route.defaults,
225 |             requirements = route.requirements,
226 |             path = route.path,
227 |             host = route.host,
228 |             parsedHost = host ? this._parsePath(host, requirements, defaults) : this._NO_HOST,
229 |             parsedPath = this._parsePath(path, requirements, defaults);
230 |         return {
231 |             id: route.id,
232 |             pattern: parsedPath.regexp,
233 |             path: path,
234 |             parameters: parsedPath.parameters,
235 |             hostPattern: parsedHost.regexp,
236 |             host: host,
237 |             hostParameters: parsedHost.parameters,
238 |             requirements: map(requirements, function (prop) {
239 |                 return new RegExp('^' + prop + '$');
240 |             }),
241 |             defaults: defaults,
242 |             methods: route.methods,
243 |             schemes: route.schemes,
244 |             definition: this._routesDefinitions[i]
245 |         };
246 |     };
247 | 
248 |     /**
249 |      * @param {String} path
250 |      * @param {Object} [requirements]
251 |      * @param {Object} [defaults]
252 |      * @returns {{regexp: RegExp, parameters: Array.<String>}}
253 |      * @private
254 |      */
255 |     RouterBase.prototype._parsePath = function (path, requirements, defaults) {
256 |         var parameters = [],
257 |             defaultParameterRequirement = this._defaultParameterRequirement,
258 |             regexp = new RegExp('^' +
259 |                 path
260 |                     .replace(/([\/\.\|])/g, '\\$1')
261 |                     .replace(this._paramsReplaceRegExp, function (match, delimiter, parameterName) {
262 |                         var optional = parameterName in defaults;
263 |                         parameters.push(parameterName);
264 |                         return (delimiter || '') + (optional && delimiter ? '?' : '') +
265 |                             '(' + (requirements[parameterName] ? requirements[parameterName] : defaultParameterRequirement) + ')' +
266 |                             (optional ? '?' : '');
267 |                     }) +
268 |                 '$');
269 |         return {
270 |             regexp: regexp,
271 |             parameters: parameters
272 |         };
273 |     };
274 | 
275 |     /**
276 |      * @param {{path: String, method: String, host: String|undefined, scheme: String|undefined}} request
277 |      * @returns {?Route}
278 |      * @public
279 |      */
280 |     RouterBase.prototype.match = function (request) {
281 |         var routes = this._routes,
282 |             route,
283 |             pathParts = request.path.split('?'),
284 |             path = pathParts[0],
285 |             query = pathParts[1] ? this._parseQuery(pathParts[1]) : null,
286 |             execPathResult,
287 |             execHostResult,
288 |             isMethodValid,
289 |             isSchemeValid;
290 |         for (var i = 0, l = routes.length; i < l; i++) {
291 |             route = routes[i];
292 |             execPathResult = route.pattern.exec(path);
293 |             if (!execPathResult) {
294 |                 continue;
295 |             }
296 |             execHostResult = route.hostPattern.exec(request.host);
297 |             if (!execHostResult) {
298 |                 continue;
299 |             }
300 |             isMethodValid = route.methods.indexOf(request.method) > -1;
301 |             if (!isMethodValid) {
302 |                 continue;
303 |             }
304 |             isSchemeValid = !request.scheme || route.schemes.indexOf(request.scheme) > -1;
305 |             if (isSchemeValid) {
306 |                 execPathResult.shift();
307 |                 execHostResult.shift();
308 |                 return {
309 |                     id: route.id,
310 |                     parameters: this._retrieveParameters(route, execPathResult, execHostResult, query),
311 |                     definition: clone(this._routesDefinitions[i])
312 |                 };
313 |             }
314 |         }
315 |         return null;
316 |     };
317 | 
318 |     /**
319 |      * @param {String} query
320 |      * @returns {{}}
321 |      * @protected
322 |      */
323 |     RouterBase.prototype._parseQuery = function (query) {
324 |         var obj = {};
325 | 
326 |         if (typeof query !== 'string' || query.length === 0) {
327 |             return obj;
328 |         }
329 | 
330 |         var regexp = /\+/g;
331 |         query = query.split('&');
332 | 
333 |         var len = query.length;
334 | 
335 |         for (var i = 0; i < len; ++i) {
336 |             var x = query[i].replace(regexp, '%20'),
337 |                 idx = x.indexOf('='),
338 |                 kstr, vstr, k, v;
339 | 
340 |             if (idx >= 0) {
341 |                 kstr = x.substr(0, idx);
342 |                 vstr = x.substr(idx + 1);
343 |             } else {
344 |                 kstr = x;
345 |                 vstr = '';
346 |             }
347 | 
348 |             k = decodeURIComponent(kstr);
349 |             v = decodeURIComponent(vstr);
350 | 
351 |             if (!obj.hasOwnProperty(k)) {
352 |                 obj[k] = v;
353 |             } else if (Array.isArray(obj[k])) {
354 |                 obj[k].push(v);
355 |             } else {
356 |                 obj[k] = [obj[k], v];
357 |             }
358 |         }
359 | 
360 |         return obj;
361 |     };
362 | 
363 |     /**
364 |      * @param {RouteDefinitionParsed} route
365 |      * @param {Array.<String>} parsedParameters
366 |      * @param {Array.<String>} parsedHostParameters
367 |      * @param {Object.<String>} [query={}]
368 |      * @returns {Object.<String>}
369 |      * @private
370 |      */
371 |     RouterBase.prototype._retrieveParameters = function (route, parsedParameters, parsedHostParameters, query) {
372 |         var parameters = query || {};
373 |         for (var key in route.defaults) {
374 |             if (route.defaults.hasOwnProperty(key)) {
375 |                 parameters[key] = route.defaults[key];
376 |             }
377 |         }
378 |         this._extendParameters(parsedParameters, route.parameters, parameters);
379 |         this._extendParameters(parsedHostParameters, route.hostParameters, parameters);
380 |         return parameters;
381 |     };
382 | 
383 |     /**
384 |      * @param {Array.<String>} input parameters values
385 |      * @param {Array.<String>} names parameters names
386 |      * @param {Object.<String>} output parameters names: parameters values
387 |      * @private
388 |      */
389 |     RouterBase.prototype._extendParameters = function (input, names, output) {
390 |         for (var i = 0, l = names.length; i < l; i++) {
391 |             if (input[i] === undefined) {
392 |                 break;
393 |             }
394 |             output[names[i]] = decodeURIComponent(input[i]);
395 |         }
396 |     };
397 | 
398 |     /**
399 |      * @param {String} id
400 |      * @param {Object.<String>} [params]
401 |      * @returns {String}
402 |      * @throws Error if required parameter is not given
403 |      * @throws Error if parameter value is not suits requirements
404 |      * @throws Error if route is not defined
405 |      * @throws URIError
406 |      * @public
407 |      */
408 |     RouterBase.prototype.generate = function (id, params) {
409 |         var routes = this._routes,
410 |             route;
411 |         for (var i = 0, l = routes.length; i < l; i++) {
412 |             route = routes[i];
413 |             if (route.id === id) {
414 |                 return this._generate(route, merge({}, params));
415 |             }
416 |         }
417 |         throw new Error('No such route: ' + id);
418 |     };
419 | 
420 |     /**
421 |      * @param {RouteDefinitionParsed} route
422 |      * @param {Object.<String>} [params]
423 |      * @returns {String}
424 |      * @throws Error if required parameter is not given
425 |      * @throws Error if parameter value is not suits requirements
426 |      * @private
427 |      */
428 |     RouterBase.prototype._generate = function (route, params) {
429 |         var path = route.path,
430 |             generatedPath,
431 |             host = route.host,
432 |             generatedHost,
433 |             defaults = route.defaults,
434 |             requirements = route.requirements,
435 |             _this = this;
436 |         generatedPath = path.replace(this._paramsReplaceRegExp, function (match, delimiter, parameterName) {
437 |             delimiter = delimiter || '';
438 |             var optional = parameterName in defaults,
439 |                 exists = params && parameterName in params;
440 |             if (exists) {
441 |                 return _this._getParameterValue(parameterName, params, requirements, delimiter);
442 |             } else if (!optional) {
443 |                 _this._throwParameterNeededError(parameterName, route.id);
444 |             }
445 | 
446 |             var hasFilledParams = false;
447 |             for (var key in params) {
448 |                 if (params.hasOwnProperty(key)) {
449 |                     if (route.parameters.indexOf(key) > -1) {
450 |                         hasFilledParams = true;
451 |                         break;
452 |                     }
453 |                 }
454 |             }
455 | 
456 |             return hasFilledParams ? delimiter + defaults[parameterName] : '';
457 |         });
458 | 
459 |         if (host) {
460 |             generatedHost = host.replace(this._paramsReplaceRegExp, function (match, delimiter, parameterName) {
461 |                 var optional = parameterName in defaults,
462 |                     exists = params && parameterName in params;
463 |                 delimiter = delimiter || '';
464 |                 if (exists) {
465 |                     return _this._getParameterValue(parameterName, params, requirements, delimiter);
466 |                 } else if (optional) {
467 |                     return delimiter + defaults[parameterName];
468 |                 } else {
469 |                     _this._throwParameterNeededError(parameterName, route.id);
470 |                 }
471 |             });
472 |         }
473 | 
474 |         var query = this._generateQuery(params);
475 | 
476 |         if (query) {
477 |             generatedPath += '?' + query;
478 |         }
479 | 
480 |         return generatedHost ? route.schemes[0] + '://' + generatedHost + generatedPath : generatedPath;
481 |     };
482 | 
483 |     /**
484 |      * @param {Object.<String>} params
485 |      * @returns {String}
486 |      * @protected
487 |      */
488 |     RouterBase.prototype._generateQuery = function (params) {
489 |         var query = '';
490 |         for (var key in params) {
491 |             if (params.hasOwnProperty(key)) {
492 |                 query += (query.length ? '&' : '') + encodeURIComponent(key) + '=' + encodeURIComponent(params[key]);
493 |             }
494 |         }
495 |         return query;
496 |     };
497 | 
498 |     /**
499 |      * @param {String} parameterName
500 |      * @param {Object.<String>} params
501 |      * @param {Object.<RegExp>} requirements
502 |      * @param {String} delimiter
503 |      * @returns {String}
504 |      * @throws Error if parameter value is invalid
505 |      * @private
506 |      */
507 |     RouterBase.prototype._getParameterValue = function (parameterName, params, requirements, delimiter) {
508 |         var value = params[parameterName];
509 |         delete params[parameterName];
510 |         if (requirements[parameterName] && !requirements[parameterName].test(value)) {
511 |             throw new Error('Parameter "' + parameterName + '" has bad value "' + value + '", not suitable for path generation');
512 |         }
513 |         return delimiter + encodeURIComponent(value);
514 |     };
515 | 
516 |     /**
517 |      * @param {String} parameterName
518 |      * @param {String} routeId
519 |      * @private
520 |      */
521 |     RouterBase.prototype._throwParameterNeededError = function (parameterName, routeId) {
522 |         throw new Error('Parameter "' + parameterName + '" is needed for route "' + routeId + '" generation');
523 |     };
524 | 
525 |     /**
526 |      * @param {String} routeId
527 |      * @returns {?RouteDefinitionParsed}
528 |      * @public
529 |      * @throws if route is not defined
530 |      */
531 |     RouterBase.prototype.getRouteInfo = function (routeId) {
532 |         if (!this._routeIdToParsedDefinitionMap[routeId]) {
533 |             for (var i = 0, l = this._routes.length; i < l; i++) {
534 |                 if (this._routes[i].id === routeId) {
535 |                     this._routeIdToParsedDefinitionMap[routeId] = this._routes[i];
536 |                     break;
537 |                 }
538 |             }
539 |         }
540 | 
541 |         if (!this._routeIdToParsedDefinitionMap[routeId]) {
542 |             throw new Error('No such route: ' + routeId);
543 |         }
544 | 
545 |         return clone(this._routeIdToParsedDefinitionMap[routeId]);
546 |     };
547 | 
548 |     /*global define: false, modules: false*/
549 |     /* istanbul ignore next */
550 |     if (typeof exports !== 'undefined') {
551 |         if (typeof module !== 'undefined' && module.exports) {
552 |             module.exports = RouterBase;
553 |         }
554 |     } else if (typeof define === 'function' && define.amd) {
555 |         define('router-base', [], function () {
556 |             return RouterBase;
557 |         });
558 |     } else if (typeof modules !== 'undefined' && modules.define) {
559 |         modules.define('router-base', function (provide) {
560 |             provide(RouterBase);
561 |         });
562 |     } else {
563 |         global.RouterBase = RouterBase;
564 |     }
565 | 
566 | })(this);
567 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "router-base",
 3 |   "version": "1.1.0",
 4 |   "engines": {
 5 |     "node": ">=0.10"
 6 |   },
 7 |   "author": "Alexander Savin",
 8 |   "main": "./lib/router-base.js",
 9 |   "description": "javascript abstract, node.js and client-side router, inspired by symfony router",
10 |   "bugs": {
11 |     "url": "https://github.com/apsavin/router-base/issues"
12 |   },
13 |   "repository": {
14 |     "type": "git",
15 |     "url": "https://github.com/apsavin/router-base.git"
16 |   },
17 |   "scripts": {
18 |     "test": "mocha test",
19 |     "coverage": "istanbul cover --report=html --dir=/tmp/router-base-coverage _mocha -- test/ && open /tmp/router-base-coverage/index.html",
20 |     "coveralls": "istanbul cover --format=lcovonly --dir=/tmp/router-base-coverage _mocha -- test/ && cat /tmp/router-base-coverage/lcov.info | coveralls"
21 |   },
22 |   "keywords": [
23 |     "router",
24 |     "routing",
25 |     "isomorphic",
26 |     "abstract",
27 |     "symfony"
28 |   ],
29 |   "license": "MIT",
30 |   "devDependencies": {
31 |     "chai": "^3.0.0",
32 |     "coveralls": "^2.11.2",
33 |     "istanbul": "^0.3.17",
34 |     "lodash.assign": "^3.2.0",
35 |     "lodash.clonedeep": "^2.4.1",
36 |     "mocha": "^2.3.3",
37 |     "mocha-oop-wrapper": "^1.1.0"
38 |   }
39 | }
40 | 


--------------------------------------------------------------------------------
/test/data/generate-data.js:
--------------------------------------------------------------------------------
  1 | var data = [
  2 |     [
  3 |         {id: 'route_that_not_exists'}
  4 |     ],
  5 |     [
  6 |         [
  7 |             {id: 'simplest_route'},
  8 |             '/a/route'
  9 |         ],
 10 |         [
 11 |             {id: 'simplest_route', parameters: {a: 1, b: 1}},
 12 |             '/a/route?a=1&b=1'
 13 |         ],
 14 |         [
 15 |             {id: 'simplest_route', parameters: {a: 1, b: 'sdf'}},
 16 |             '/a/route?a=1&b=sdf'
 17 |         ],
 18 |         [
 19 |             {id: 'simplest_route', parameters: {a: 'а', b: '&'}},
 20 |             '/a/route?a=%D0%B0&b=%26'
 21 |         ]
 22 |     ],
 23 |     [
 24 |         {id: 'simplest_route_with_default_parameter', parameters: {a: 1}},
 25 |         '/b/route?a=1'
 26 |     ],
 27 |     [
 28 |         [
 29 |             {id: 'route_with_required_parameter', parameters: {parameter: 1, a: 1}},
 30 |             '/c/1?a=1'
 31 |         ],
 32 |         [
 33 |             {id: 'route_with_required_parameter'}
 34 |         ]
 35 |     ],
 36 |     [
 37 |         [
 38 |             {id: 'route_with_not_required_parameter'},
 39 |             '/d'
 40 |         ],
 41 |         [
 42 |             {id: 'route_with_not_required_parameter', parameters: {a: 1}},
 43 |             '/d?a=1'
 44 |         ],
 45 |         [
 46 |             {id: 'route_with_not_required_parameter', parameters: {parameter: 1, a: 1}},
 47 |             '/d/1?a=1'
 48 |         ]
 49 |     ],
 50 |     [
 51 |         [
 52 |             {id: 'route_with_required_parameters', parameters: {parameter1: 1, parameter2: 2}},
 53 |             '/e/1/2'
 54 |         ],
 55 |         [
 56 |             {id: 'route_with_required_parameters'}
 57 |         ]
 58 |     ],
 59 |     [
 60 |         [
 61 |             {id: 'route_with_not_required_parameters'},
 62 |             '/f'
 63 |         ],
 64 |         [
 65 |             {id: 'route_with_not_required_parameters', parameters: {parameter2: 3}},
 66 |             '/f/1/3'
 67 |         ],
 68 |         [
 69 |             {id: 'route_with_not_required_parameters', parameters: {parameter1: 3}},
 70 |             '/f/3'
 71 |         ],
 72 |         [
 73 |             {id: 'route_with_not_required_parameters', parameters: {parameter1: 3, parameter2: 3}},
 74 |             '/f/3/3'
 75 |         ],
 76 |         [
 77 |             {id: 'route_with_not_required_parameters', parameters: {parameter1: 'а', parameter2: '&'}},
 78 |             '/f/%D0%B0/%26'
 79 |         ]
 80 |     ],
 81 |     [
 82 |         {id: 'bad_route_with_required_parameter_after_not_required_parameter', parameters: {parameter2: 2}},
 83 |         '/g/1/2'
 84 |     ],
 85 |     [
 86 |         [
 87 |             {id: 'route_with_point_as_parameters_delimiter', parameters: {parameter1: 'x'}},
 88 |             '/h/x'
 89 |         ],
 90 |         [
 91 |             {id: 'route_with_point_as_parameters_delimiter', parameters: {parameter1: 'x', parameter3: 'json'}},
 92 |             '/h/x/file.json'
 93 |         ],
 94 |         [
 95 |             {id: 'route_with_point_as_parameters_delimiter', parameters: {parameter1: 'x', parameter3: 'json', a: 'dsf'}},
 96 |             '/h/x/file.json?a=dsf'
 97 |         ]
 98 |     ],
 99 |     [
100 |         [
101 |             {id: 'route_with_required_string_parameter', parameters: {parameter: 'x'}},
102 |             '/i/x'
103 |         ],
104 |         [
105 |             {id: 'route_with_required_string_parameter', parameters: {parameter: 1}}
106 |         ]
107 |     ],
108 |     [
109 |         [
110 |             {id: 'route_with_not_required_numeric_parameter'},
111 |             '/k'
112 |         ],
113 |         [
114 |             {id: 'route_with_not_required_numeric_parameter', parameters: {parameter: 5}},
115 |             '/k/5'
116 |         ],
117 |         [
118 |             {id: 'route_with_not_required_numeric_parameter', parameters: {parameter: 'x'}}
119 |         ]
120 |     ],
121 |     [
122 |         [
123 |             {id: 'route_with_host'},
124 |             'http://m.example.com/a'
125 |         ],
126 |         [
127 |             {id: 'route_with_host', parameters: {sub: 'mobile'}},
128 |             'http://mobile.example.com/a'
129 |         ],
130 |         [
131 |             {id: 'route_with_host', parameters: {sub: 'zxc'}}
132 |         ]
133 |     ],
134 |     [
135 |         [
136 |             {id: 'route_with_host_without_defaults'}
137 |         ],
138 |         [
139 |             {id: 'route_with_host_without_defaults', parameters: {sub: 'mobile'}},
140 |             'http://mobile.example.com/m'
141 |         ],
142 |         [
143 |             {id: 'route_with_host_without_defaults', parameters: {sub: 'zxc'}}
144 |         ]
145 |     ],
146 |     [
147 |         [
148 |             {id: 'route_without_delimiter', parameters: {parameter1: 1, parameter2: 'x'}},
149 |             '/l/1x'
150 |         ],
151 |         [
152 |             {id: 'route_without_delimiter', parameters: {parameter1: 1, parameter2: '-'}}
153 |         ]
154 |     ]
155 | ];
156 | 
157 | module.exports = data
158 |     .concat(data.map(function prefix (data) {
159 |         if (Array.isArray(data[0])) {
160 |             return data.map(prefix);
161 |         }
162 |         return [
163 |             {
164 |                 id: 'prefixed_' + data[0].id,
165 |                 parameters: data[0].parameters
166 |             },
167 |             data[1] ? !data[1].indexOf('http://') ? data[1].replace('.com', '.com/prefixed') : '/prefixed' + data[1] : data[1]
168 |         ];
169 |     }))
170 |     .concat(data.map(function prefix (data) {
171 |         if (Array.isArray(data[0])) {
172 |             return data.map(prefix);
173 |         }
174 |         var key,
175 |             parametersWithEnLocale;
176 |         if (data[0]) {
177 |             var parameters = data[0].parameters;
178 |             parametersWithEnLocale = {};
179 |             for (key in parameters) {
180 |                 if (parameters.hasOwnProperty(key)) {
181 |                     parametersWithEnLocale[key] = parameters[key];
182 |                 }
183 |             }
184 |             parametersWithEnLocale.locale = 'en';
185 |         }
186 |         return [
187 |             {
188 |                 id: 'prefixed_with_locale_' + data[0].id,
189 |                 parameters: parametersWithEnLocale
190 |             },
191 |             data[1] ? !data[1].indexOf('http://') ? data[1].replace('.com', '.com/en') : '/en' + data[1] : data[1]
192 |         ];
193 |     }))
194 |     .concat(data.map(function prefix (data) {
195 |         if (Array.isArray(data[0])) {
196 |             return data.map(prefix);
197 |         }
198 | 
199 |         return [
200 |             {
201 |                 id: 'custom_property_' + data[0].id,
202 |                 parameters: data[0].parameters
203 |             },
204 |             data[1] ?
205 |                 !data[1].indexOf('http://') ? data[1].replace('.com', '.com/prefix') : 'http://example1.com/prefix' + data[1] :
206 |                 data[1]
207 |         ];
208 |     }))
209 |     .concat(data.map(function doublePrefix (data) {
210 |         if (Array.isArray(data[0])) {
211 |             return data.map(doublePrefix);
212 |         }
213 |         return [
214 |             {
215 |                 id: 'double_prefixed_' + data[0].id,
216 |                 parameters: data[0].parameters
217 |             },
218 |             data[1] ? !data[1].indexOf('http://') ? data[1].replace('.com', '.com/first_prefix/second_prefix') : '/first_prefix/second_prefix' + data[1] : data[1]
219 |         ];
220 |     }));
221 | 


--------------------------------------------------------------------------------
/test/data/getRouteInfo-data.js:
--------------------------------------------------------------------------------
  1 | module.exports = [
  2 |     [
  3 |         'simplest_route',
  4 |         {
  5 |             id: "simplest_route",
  6 |             path: "/a/route",
  7 |             pattern: /^\/a\/route$/,
  8 |             host: undefined,
  9 |             hostPattern: /.*/,
 10 |             defaults: {},
 11 |             hostParameters: [],
 12 |             methods: [
 13 |                 "GET",
 14 |                 "POST",
 15 |                 "PUT",
 16 |                 "DELETE"
 17 |             ],
 18 |             parameters: [],
 19 |             requirements: {},
 20 |             schemes: [
 21 |                 "http",
 22 |                 "https"
 23 |             ],
 24 |             definition: {
 25 |                 id: "simplest_route",
 26 |                 path: "/a/route",
 27 |                 host: undefined,
 28 |                 defaults: {},
 29 |                 methods: [
 30 |                     "GET",
 31 |                     "POST",
 32 |                     "PUT",
 33 |                     "DELETE"
 34 |                 ],
 35 |                 requirements: {},
 36 |                 schemes: [
 37 |                     "http",
 38 |                     "https"
 39 |                 ]
 40 |             }
 41 |         }
 42 |     ],
 43 |     [
 44 |         'route_with_required_parameter',
 45 |         {
 46 |             id: "route_with_required_parameter",
 47 |             path: "/c/{parameter}",
 48 |             pattern: /^\/c\/([^\/.]*)$/,
 49 |             host: undefined,
 50 |             defaults: {
 51 |                 action: "defaultAction"
 52 |             },
 53 |             hostParameters: [],
 54 |             hostPattern: /.*/,
 55 |             methods: [
 56 |                 "GET",
 57 |                 "POST"
 58 |             ],
 59 |             parameters: [
 60 |                 "parameter"
 61 |             ],
 62 |             requirements: {},
 63 |             schemes: [
 64 |                 "http",
 65 |                 "https"
 66 |             ],
 67 |             definition: {
 68 |                 id: "route_with_required_parameter",
 69 |                 path: "/c/{parameter}",
 70 |                 host: undefined,
 71 |                 defaults: {
 72 |                     action: "defaultAction"
 73 |                 },
 74 |                 methods: [
 75 |                     "GET",
 76 |                     "POST"
 77 |                 ],
 78 |                 requirements: {},
 79 |                 schemes: [
 80 |                     "http",
 81 |                     "https"
 82 |                 ]
 83 |             }
 84 |         }
 85 |     ],
 86 |     [
 87 |         'route_with_host',
 88 |         {
 89 |             id: "route_with_host",
 90 |             path: "/a",
 91 |             pattern: /^\/a$/,
 92 |             host: "{sub}.example.com",
 93 |             hostParameters: [
 94 |                 "sub"
 95 |             ],
 96 |             hostPattern: /^(m|mobile)?\.example\.com$/,
 97 |             defaults: {
 98 |                 sub: "m"
 99 |             },
100 |             methods: [
101 |                 "GET",
102 |                 "POST",
103 |                 "PUT",
104 |                 "DELETE"
105 |             ],
106 |             parameters: [],
107 |             requirements: {
108 |                 sub: /^m|mobile$/
109 |             },
110 |             schemes: [
111 |                 "http",
112 |                 "https"
113 |             ],
114 |             definition: {
115 |                 id: "route_with_host",
116 |                 path: "/a",
117 |                 host: "{sub}.example.com",
118 |                 defaults: {
119 |                     sub: "m"
120 |                 },
121 |                 methods: [
122 |                     "GET",
123 |                     "POST",
124 |                     "PUT",
125 |                     "DELETE"
126 |                 ],
127 |                 requirements: {
128 |                     sub: "m|mobile"
129 |                 },
130 |                 schemes: [
131 |                     "http",
132 |                     "https"
133 |                 ]
134 |             }
135 |         }
136 |     ],
137 |     [
138 |         'prefixed_route_with_required_parameter',
139 |         {
140 |             id: 'prefixed_route_with_required_parameter',
141 |             path: '/prefixed/c/{parameter}',
142 |             defaults: {action: 'defaultAction'},
143 |             methods: ['GET', 'POST'],
144 |             host: undefined,
145 |             hostParameters: [],
146 |             hostPattern: /.*/,
147 |             pattern: /^\/prefixed\/c\/([^\/.]*)$/,
148 |             parameters: ['parameter'],
149 |             requirements: {},
150 |             schemes: [
151 |                 "http",
152 |                 "https"
153 |             ],
154 |             definition: {
155 |                 id: 'prefixed_route_with_required_parameter',
156 |                 path: '/prefixed/c/{parameter}',
157 |                 defaults: {action: 'defaultAction'},
158 |                 host: undefined,
159 |                 prefix: '/prefixed',
160 |                 methods: ['GET', 'POST'],
161 |                 requirements: {},
162 |                 schemes: [
163 |                     "http",
164 |                     "https"
165 |                 ]
166 |             }
167 |         }
168 |     ],
169 |     [
170 |         'custom_property_route_without_delimiter',
171 |         {
172 |             id: "custom_property_route_without_delimiter",
173 |             path: "/prefix/l/{parameter1}{parameter2}",
174 |             pattern: /^\/prefix\/l\/(\d+)([a-z]+)$/,
175 |             host: "example1.com",
176 |             defaults: {},
177 |             hostParameters: [],
178 |             hostPattern: /^example1\.com$/,
179 |             methods: [
180 |                 "GET",
181 |                 "POST",
182 |                 "PUT",
183 |                 "DELETE"
184 |             ],
185 |             parameters: [
186 |                 "parameter1",
187 |                 "parameter2"
188 |             ],
189 |             requirements: {
190 |                 parameter1: /^\d+$/,
191 |                 parameter2: /^[a-z]+$/
192 |             },
193 |             schemes: [
194 |                 "http",
195 |                 "https"
196 |             ],
197 |             definition: {
198 |                 id: "custom_property_route_without_delimiter",
199 |                 path: "/prefix/l/{parameter1}{parameter2}",
200 |                 host: "example1.com",
201 |                 customProperty: "customValue",
202 |                 defaults: {},
203 |                 methods: [
204 |                     "GET",
205 |                     "POST",
206 |                     "PUT",
207 |                     "DELETE"
208 |                 ],
209 |                 prefix: "/prefix",
210 |                 requirements: {
211 |                     parameter1: "\\d+",
212 |                     parameter2: "[a-z]+"
213 |                 },
214 |                 schemes: [
215 |                     "http",
216 |                     "https"
217 |                 ]
218 |             }
219 |         }
220 |     ],
221 |     [
222 |         'route_that_not_exists'
223 |     ]
224 | ];
225 | 


--------------------------------------------------------------------------------
/test/data/match-data.js:
--------------------------------------------------------------------------------
  1 | var routes = require('./routes'),
  2 |     cloneDeep = require('lodash.clonedeep');
  3 | 
  4 | var data = [
  5 |     [
  6 |         [
  7 |             {path: '/a/route', method: 'GET'},
  8 |             {id: 'simplest_route', definition: routes[0]}
  9 |         ],
 10 |         [
 11 |             {path: '/a/route?param=value', method: 'GET'},
 12 |             {id: 'simplest_route', parameters: {param: 'value'}, definition: routes[0]}
 13 |         ],
 14 |         [
 15 |             {path: '/a/route?a=%D0%B0&b=%26', method: 'GET'},
 16 |             {id: 'simplest_route', parameters: {a: 'а', b: '&'}, definition: routes[0]}
 17 |         ],
 18 |         [
 19 |             {path: '/a/route', method: 'GET', scheme: 'http'},
 20 |             {id: 'simplest_route', definition: routes[0]}
 21 |         ],
 22 |         [
 23 |             {path: '/a/route', method: 'GET', scheme: 'ftp'},
 24 |             null
 25 |         ],
 26 |         [
 27 |             {path: '/a/rote', method: 'GET'},
 28 |             null
 29 |         ]
 30 |     ],
 31 |     [
 32 |         {path: '/b/route', method: 'GET'},
 33 |         {id: 'simplest_route_with_default_parameter', parameters: {action: 'defaultAction'}, definition: routes[1]}
 34 |     ],
 35 |     [
 36 |         [
 37 |             {path: '/c/5', method: 'GET'},
 38 |             {id: 'route_with_required_parameter', parameters: {action: 'defaultAction', parameter: '5'}, definition: routes[2]}
 39 |         ],
 40 |         [
 41 |             {path: '/c/5?d=6', method: 'GET'},
 42 |             {id: 'route_with_required_parameter', parameters: {action: 'defaultAction', parameter: '5', d: '6'}, definition: routes[2]}
 43 |         ],
 44 |         [
 45 |             {path: '/c/5?d=6&parameter=7', method: 'GET'},
 46 |             {id: 'route_with_required_parameter', parameters: {action: 'defaultAction', parameter: '5', d: '6'}, definition: routes[2]}
 47 |         ],
 48 |         [
 49 |             {path: '/c/5', method: 'POST'},
 50 |             {id: 'route_with_required_parameter', parameters: {action: 'defaultAction', parameter: '5'}, definition: routes[2]}
 51 |         ],
 52 |         [
 53 |             {path: '/c/5', method: 'PUT'},
 54 |             null
 55 |         ],
 56 |         [
 57 |             {path: '/c', method: 'GET'},
 58 |             null
 59 |         ]
 60 |     ],
 61 |     [
 62 |         [
 63 |             {path: '/d/5', method: 'GET'},
 64 |             {id: 'route_with_not_required_parameter', parameters: {parameter: '5'}, definition: routes[3]}
 65 |         ],
 66 |         [
 67 |             {path: '/d', method: 'GET'},
 68 |             {id: 'route_with_not_required_parameter', parameters: {parameter: '0'}, definition: routes[3]}
 69 |         ]
 70 |     ],
 71 |     [
 72 |         [
 73 |             {path: '/e/1/2', method: 'GET'},
 74 |             {id: 'route_with_required_parameters', parameters: {parameter1: '1', parameter2: '2'}, definition: routes[4]}
 75 |         ],
 76 |         [
 77 |             {path: '/e/a/b', method: 'GET'},
 78 |             {id: 'route_with_required_parameters', parameters: {parameter1: 'a', parameter2: 'b'}, definition: routes[4]}
 79 |         ],
 80 |         [
 81 |             {path: '/e/a', method: 'GET'},
 82 |             null
 83 |         ]
 84 |     ],
 85 |     [
 86 |         [
 87 |             {path: '/f/1/b', method: 'GET'},
 88 |             {id: 'route_with_not_required_parameters', parameters: {action: 'defaultAction', parameter1: '1', parameter2: 'b'}, definition: routes[5]}
 89 |         ],
 90 |         [
 91 |             {path: '/f/1', method: 'GET'},
 92 |             {id: 'route_with_not_required_parameters', parameters: {action: 'defaultAction', parameter1: '1', parameter2: '2'}, definition: routes[5]}
 93 |         ],
 94 |         [
 95 |             {path: '/f', method: 'GET'},
 96 |             {id: 'route_with_not_required_parameters', parameters: {action: 'defaultAction', parameter1: '1', parameter2: '2'}, definition: routes[5]}
 97 |         ],
 98 |         [
 99 |             {path: '/f/%D0%B0/%26', method: 'GET'},
100 |             {id: 'route_with_not_required_parameters', parameters: {action: 'defaultAction', parameter1: 'а', parameter2: '&'}, definition: routes[5]}
101 |         ]
102 |     ],
103 |     [
104 |         {path: '/g/2/f', method: 'GET'},
105 |         {id: 'bad_route_with_required_parameter_after_not_required_parameter', parameters: {action: 'defaultAction', parameter1: '2', parameter2: 'f'}, definition: routes[6]}
106 |     ],
107 |     [
108 |         {path: '/h/p/file.html', method: 'GET'},
109 |         {id: 'route_with_point_as_parameters_delimiter', parameters: {action: 'defaultAction', parameter1: 'p', parameter2: 'file', parameter3: 'html'}, definition: routes[7]}
110 |     ],
111 |     [
112 |         [
113 |             {path: '/i/asd', method: 'GET'},
114 |             {id: 'route_with_required_string_parameter', parameters: {action: 'defaultAction', parameter: 'asd'}, definition: routes[8]}
115 |         ],
116 |         [
117 |             {path: '/i', method: 'GET'},
118 |             null
119 |         ],
120 |         [
121 |             {path: '/i/5', method: 'GET'},
122 |             null
123 |         ]
124 |     ],
125 |     [
126 |         [
127 |             {path: '/k/3', method: 'GET'},
128 |             { id: 'route_with_not_required_numeric_parameter', parameters: {action: 'defaultAction', parameter: '3'}, definition: routes[9]}
129 |         ],
130 |         [
131 |             {path: '/k', method: 'GET'},
132 |             { id: 'route_with_not_required_numeric_parameter', parameters: {action: 'defaultAction', parameter: '0'}, definition: routes[9]}
133 |         ],
134 |         [
135 |             {path: '/k/sdf', method: 'GET'},
136 |             null
137 |         ]
138 |     ],
139 |     [
140 |         [
141 |             {path: '/a', method: 'GET', host: 'm.example.com'},
142 |             {id: 'route_with_host', parameters: {sub: 'm'}, definition: routes[10]}
143 |         ],
144 |         [
145 |             {path: '/a', method: 'GET'},
146 |             null
147 |         ],
148 |         [
149 |             {path: '/a', method: 'GET', host: 'null.example.com'},
150 |             null
151 |         ]
152 |     ],
153 |     [
154 |         [
155 |             {path: '/m', method: 'GET', host: 'm.example.com'},
156 |             {id: 'route_with_host_without_defaults', parameters: {sub: 'm'}, definition: routes[11]}
157 |         ],
158 |         [
159 |             {path: '/m', method: 'GET'},
160 |             null
161 |         ],
162 |         [
163 |             {path: '/m', method: 'GET', host: 'null.example.com'},
164 |             null
165 |         ]
166 |     ],
167 |     [
168 |         [
169 |             {path: '/l/1x', method: 'GET'},
170 |             {id: 'route_without_delimiter', parameters: {parameter1: '1', parameter2: 'x'}, definition: routes[12]}
171 |         ],
172 |         [
173 |             {path: '/l/1-', method: 'GET'},
174 |             null
175 |         ]
176 |     ]
177 | ];
178 | 
179 | module.exports = data
180 |     .concat(data.map(function createDataForRoutesWithPrefix (data) {
181 |         if (Array.isArray(data[0])) {
182 |             return data.map(createDataForRoutesWithPrefix);
183 |         }
184 | 
185 |         var input = cloneDeep(data[0]),
186 |             output = null,
187 |             prefix = '/prefixed';
188 | 
189 |         input.path = prefix + data[0].path;
190 |         if (data[1]) {
191 |             output = cloneDeep(data[1]);
192 |             output.id = output.definition.id = 'prefixed_' + data[1].id;
193 |             output.definition.prefix = prefix;
194 |             output.definition.path = prefix + output.definition.path;
195 |         }
196 | 
197 |         return [
198 |             input,
199 |             output
200 |         ];
201 |     }))
202 |     .concat(data.map(function createDataForRoutesWithLocale (data) {
203 |         var key,
204 |             definition,
205 |             getDefinition = function (data) {
206 |                 var definition = cloneDeep(data.definition);
207 |                 definition.id = 'prefixed_with_locale_' + definition.id;
208 |                 definition.prefix = '/{locale}';
209 |                 definition.requirements = {
210 |                     locale: 'en|ru'
211 |                 };
212 |                 definition.path = definition.prefix + definition.path;
213 |                 return definition;
214 |             };
215 |         if (Array.isArray(data[0])) {
216 |             var prefixedData = data.map(createDataForRoutesWithLocale);
217 | 
218 |             var correctSample = prefixedData[0],
219 |                 correctSampleParameters = correctSample[1].parameters,
220 |                 parametersWithRuLocale = {};
221 | 
222 |             if (correctSample[1].definition && correctSample[1].definition.id.indexOf('prefixed_with_locale_') === 0){
223 |                 definition = correctSample[1].definition;
224 |             } else {
225 |                 definition = getDefinition(correctSample[1]);
226 |             }
227 | 
228 |             for (key in correctSampleParameters) {
229 |                 if (correctSampleParameters.hasOwnProperty(key)) {
230 |                     parametersWithRuLocale[key] = correctSampleParameters[key];
231 |                 }
232 |             }
233 |             parametersWithRuLocale.locale = 'ru';
234 |             prefixedData.push([
235 |                 {
236 |                     path: correctSample[0].path.replace('/en/', '/ru/'),
237 |                     method: correctSample[0].method,
238 |                     scheme: correctSample[0].scheme,
239 |                     host: correctSample[0].host
240 |                 },
241 |                 {
242 |                     id: correctSample[1].id,
243 |                     parameters: parametersWithRuLocale,
244 |                     definition: definition
245 |                 }
246 |             ]);
247 |             prefixedData.push([
248 |                 {
249 |                     path: correctSample[0].path.replace('/en/', '/null/'),
250 |                     method: correctSample[0].method,
251 |                     scheme: correctSample[0].scheme,
252 |                     host: correctSample[0].host
253 |                 },
254 |                 null
255 |             ]);
256 | 
257 |             return prefixedData;
258 |         }
259 |         var parametersWithEnLocale;
260 |         if (data[1]) {
261 |             var parameters = data[1].parameters;
262 |             parametersWithEnLocale = {};
263 |             for (key in parameters) {
264 |                 if (parameters.hasOwnProperty(key)) {
265 |                     parametersWithEnLocale[key] = parameters[key];
266 |                 }
267 |             }
268 |             parametersWithEnLocale.locale = 'en';
269 |         }
270 |         return [
271 |             {
272 |                 path: '/en' + data[0].path,
273 |                 method: data[0].method,
274 |                 scheme: data[0].scheme,
275 |                 host: data[0].host
276 |             },
277 |             data[1] ? {
278 |                 id: 'prefixed_with_locale_' + data[1].id,
279 |                 parameters: parametersWithEnLocale,
280 |                 definition: getDefinition(data[1])
281 |             } : null
282 |         ];
283 |     }))
284 |     .concat(data.map(function createDataForRoutesWithCustomProperty (data) {
285 |         if (Array.isArray(data[0])) {
286 |             return data.map(createDataForRoutesWithCustomProperty);
287 |         }
288 | 
289 |         var input = cloneDeep(data[0]),
290 |             output = null,
291 |             prefix = '/prefix';
292 | 
293 |         input.path = prefix + data[0].path;
294 |         input.host = data[0].host || 'example1.com';
295 |         if (data[1]) {
296 |             output = cloneDeep(data[1]);
297 |             output.id = output.definition.id = 'custom_property_' + data[1].id;
298 |             output.definition.prefix = prefix;
299 |             output.definition.path = prefix + output.definition.path;
300 |             output.definition.customProperty = 'customValue';
301 |         }
302 | 
303 |         return [
304 |             input,
305 |             output
306 |         ];
307 |     }))
308 |     .concat(data.map(function createDataForRoutesWithDoublePrefix (data) {
309 |         if (Array.isArray(data[0])) {
310 |             return data.map(createDataForRoutesWithDoublePrefix);
311 |         }
312 | 
313 |         var input = cloneDeep(data[0]),
314 |             output = null,
315 |             prefix = '/first_prefix/second_prefix';
316 | 
317 |         input.path = prefix + data[0].path;
318 |         if (data[1]) {
319 |             output = cloneDeep(data[1]);
320 |             output.id = output.definition.id = 'double_prefixed_' + data[1].id;
321 |             output.definition.prefix = prefix;
322 |             output.definition.path = prefix + output.definition.path;
323 |         }
324 | 
325 |         return [
326 |             input,
327 |             output
328 |         ];
329 |     }));
330 | 


--------------------------------------------------------------------------------
/test/data/routes.js:
--------------------------------------------------------------------------------
  1 | var cloneDeep = require('lodash.clonedeep');
  2 | 
  3 | /**
  4 |  * @type {Array.<RouteDefinition|RoutesDefinition>}
  5 |  */
  6 | var routes = [
  7 |     {
  8 |         id: 'simplest_route',
  9 |         path: '/a/route'
 10 |     },
 11 |     {
 12 |         id: 'simplest_route_with_default_parameter',
 13 |         path: '/b/route',
 14 |         defaults: {action: 'defaultAction'}
 15 |     },
 16 |     {
 17 |         id: 'route_with_required_parameter',
 18 |         path: '/c/{parameter}',
 19 |         defaults: {action: 'defaultAction'},
 20 |         methods: ['GET', 'POST']
 21 |     },
 22 |     {
 23 |         id: 'route_with_not_required_parameter',
 24 |         path: '/d/{parameter}',
 25 |         defaults: {parameter: '0'}
 26 |     },
 27 |     {
 28 |         id: 'route_with_required_parameters',
 29 |         path: '/e/{parameter1}/{parameter2}'
 30 |     },
 31 |     {
 32 |         id: 'route_with_not_required_parameters',
 33 |         path: '/f/{parameter1}/{parameter2}',
 34 |         defaults: {action: 'defaultAction', parameter1: '1', parameter2: '2'}
 35 |     },
 36 |     {
 37 |         id: 'bad_route_with_required_parameter_after_not_required_parameter',
 38 |         path: '/g/{parameter1}/{parameter2}',
 39 |         defaults: {action: 'defaultAction', parameter1: '1'}
 40 |     },
 41 |     {
 42 |         id: 'route_with_point_as_parameters_delimiter',
 43 |         path: '/h/{parameter1}/{parameter2}.{parameter3}',
 44 |         defaults: {action: 'defaultAction', parameter2: 'file', parameter3: 'format'}
 45 |     },
 46 |     {
 47 |         id: 'route_with_required_string_parameter',
 48 |         path: '/i/{parameter}',
 49 |         defaults: {action: 'defaultAction'},
 50 |         requirements: {parameter: "[a-z]+"}
 51 |     },
 52 |     {
 53 |         id: 'route_with_not_required_numeric_parameter',
 54 |         path: '/k/{parameter}',
 55 |         defaults: {action: 'defaultAction', parameter: '0'},
 56 |         requirements: {parameter: "\\d+"}
 57 |     },
 58 |     {
 59 |         id: 'route_with_host',
 60 |         path: '/a',
 61 |         host: '{sub}.example.com',
 62 |         defaults: {sub: 'm'},
 63 |         requirements: {sub: 'm|mobile'}
 64 |     },
 65 |     {
 66 |         id: 'route_with_host_without_defaults',
 67 |         path: '/m',
 68 |         host: '{sub}.example.com',
 69 |         requirements: {sub: 'm|mobile'}
 70 |     },
 71 |     {
 72 |         id: 'route_without_delimiter',
 73 |         path: '/l/{parameter1}{parameter2}',
 74 |         requirements: {parameter1: "\\d+", parameter2: "[a-z]+"}
 75 |     }
 76 | ];
 77 | 
 78 | routes.push(
 79 |     {
 80 |         prefix: '/prefixed',
 81 |         routes: routes.map(function (route) {
 82 |             /**
 83 |              * @type {RouteDefinition}
 84 |              */
 85 |             var clone = cloneDeep(route);
 86 |             clone.id = 'prefixed_' + route.id;
 87 |             return clone;
 88 |         })
 89 |     },
 90 |     {
 91 |         prefix: '/{locale}',
 92 |         routes: routes.map(function (route) {
 93 |             /**
 94 |              * @type {RouteDefinition}
 95 |              */
 96 |             var clone = cloneDeep(route);
 97 |             clone.id = 'prefixed_with_locale_' + route.id;
 98 |             return clone;
 99 |         }),
100 |         requirements: {
101 |             locale: 'en|ru'
102 |         }
103 |     },
104 |     {
105 |         host: 'example1.com',
106 |         prefix: '/prefix',
107 |         routes: routes.map(function (route) {
108 |             /**
109 |              * @type {RouteDefinition}
110 |              */
111 |             var clone = cloneDeep(route);
112 |             clone.id = 'custom_property_' + route.id;
113 |             return clone;
114 |         }),
115 |         customProperty: 'customValue'
116 |     },
117 |     {
118 |         prefix: '/first_prefix',
119 |         routes: [{
120 |             prefix: '/second_prefix',
121 |             routes: routes.map(function (route) {
122 |                 /**
123 |                  * @type {RouteDefinition}
124 |                  */
125 |                 var clone = cloneDeep(route);
126 |                 clone.id = 'double_prefixed_' + route.id;
127 |                 return clone;
128 |             })
129 |         }]
130 |     });
131 | 
132 | module.exports = routes;
133 | 


--------------------------------------------------------------------------------
/test/router-base.test.js:
--------------------------------------------------------------------------------
  1 | var mochaOOPWrapper = require('mocha-oop-wrapper'),
  2 |     expect = require('chai').expect,
  3 |     RouterBase = require('../lib/router-base'),
  4 |     routes = require('./data/routes'),
  5 |     assign = require('lodash.assign');
  6 | 
  7 | /**
  8 |  * @class RouterBaseTest
  9 |  * @extends mochaOOPWrapper
 10 |  */
 11 | var RouterBaseTest = function () {
 12 |     this._initTests();
 13 | };
 14 | 
 15 | RouterBaseTest.prototype = assign(Object.create(mochaOOPWrapper), /** @lends RouterBaseTest# */{
 16 |     /**
 17 |      * @protected
 18 |      * @string
 19 |      */
 20 |     _name: 'RouterBase',
 21 | 
 22 |     /**
 23 |      * @protected
 24 |      */
 25 |     _describe: function () {
 26 |         this.before(function () {
 27 |             this._router = new RouterBase({
 28 |                 routes: routes
 29 |             });
 30 |         });
 31 | 
 32 |         this.describe('match method', this._checkMatchMethod);
 33 |         this.describe('generate method', this._checkGenerateMethod);
 34 |         this.describe('getRouteInfo method', this._checkGetRouteInfoMethod);
 35 |     },
 36 | 
 37 |     /**
 38 |      * @private
 39 |      */
 40 |     _checkMatchMethod: function () {
 41 |         this._checkMethod(require('./data/match-data'), this._checkMatchRoute);
 42 |     },
 43 | 
 44 |     /**
 45 |      * @private
 46 |      */
 47 |     _checkGenerateMethod: function () {
 48 |         this._checkMethod(require('./data/generate-data'), this._checkGenerateRoute);
 49 |     },
 50 | 
 51 |     /**
 52 |      * @private
 53 |      */
 54 |     _checkGetRouteInfoMethod: function () {
 55 |         this._checkMethod(require('./data/getRouteInfo-data'), this._checkGetRouteInfo);
 56 | 
 57 |         this.it('should not allow to modify internal data', function () {
 58 |             var info = this._router.getRouteInfo('simplest_route');
 59 |             delete info.id;
 60 |             info.x = 'x';
 61 |             var unmodifiedInfo = this._router.getRouteInfo('simplest_route');
 62 |             expect(unmodifiedInfo.id).to.be.eq('simplest_route');
 63 |             expect(unmodifiedInfo.x).to.be.undefined;
 64 |         });
 65 |     },
 66 | 
 67 |     /**
 68 |      * @param {Array.<Array.<Object>>} parameters
 69 |      * @param {Function} methodTestGenerator
 70 |      * @returns {Object.<Function>}
 71 |      */
 72 |     _checkMethod: function (parameters, methodTestGenerator) {
 73 |         function generateMethod(parameter) {
 74 |             if (Array.isArray(parameter[0])) {
 75 |                 parameter.forEach(generateMethod, this);
 76 |                 return;
 77 |             }
 78 | 
 79 |             var message = 'should ' +
 80 |                 (parameter[1] === undefined ? 'throw' : 'return ' + JSON.stringify(parameter[1]))
 81 |                 + ' when input is ' + JSON.stringify(parameter[0]);
 82 | 
 83 |             this.it(message, methodTestGenerator.bind(this, parameter[0], parameter[1]));
 84 |         }
 85 | 
 86 |         parameters.forEach(function (parameter) {
 87 |             generateMethod.call(this, parameter);
 88 |         }, this);
 89 |     },
 90 | 
 91 |     /**
 92 |      * @param {{path: String, method: String}} input
 93 |      * @param {{id: String, parameters: ?Object.<String>, definition: Object}} output
 94 |      */
 95 |     _checkMatchRoute: function (input, output) {
 96 |         var matchers = this._router.match(input),
 97 |             key;
 98 |         if (output === null) {
 99 |             expect(matchers).to.be.null;
100 |             return;
101 |         }
102 | 
103 |         expect(matchers).not.to.be.null;
104 |         expect(matchers.id).to.equal(output.id);
105 | 
106 |         if (output.parameters) {
107 |             for (key in output.parameters) {
108 |                 if (output.parameters.hasOwnProperty(key)) {
109 |                     expect(output.parameters[key]).to.equal(matchers.parameters[key]);
110 |                 }
111 |             }
112 |         }
113 |         for (key in matchers.definition) {
114 |             if (matchers.definition.hasOwnProperty(key)) {
115 |                 if (typeof output.definition[key] === 'undefined') {
116 |                     continue;
117 |                 }
118 |                 if (typeof matchers.definition[key] === 'object') {
119 |                     if (Array.isArray(matchers.definition[key])) {
120 |                         matchers.definition[key].forEach(function (item, i) {
121 |                             expect(output.definition[key][i]).to.eq(item);
122 |                         });
123 |                     } else {
124 |                         expect(matchers.definition[key]).to.include(output.definition[key]);
125 |                     }
126 |                 } else {
127 |                     expect(matchers.definition[key]).to.eq(output.definition[key]);
128 |                 }
129 |             }
130 |         }
131 |     },
132 | 
133 |     /**
134 |      * @param {{id: String, parameters: ?Object.<String>}} input
135 |      * @param {?String} output
136 |      */
137 |     _checkGenerateRoute: function (input, output) {
138 |         try {
139 |             expect(this._router.generate(input.id, input.parameters)).to.equal(output);
140 |         } catch (e) {
141 |             if (e.name === 'AssertionError') {
142 |                 throw e;
143 |             } else {
144 |                 expect(output).to.be.undefined;
145 |             }
146 |         }
147 |     },
148 | 
149 |     /**
150 |      * @param {?String} input
151 |      * @param {?RouteDefinitionParsed} output
152 |      * @private
153 |      */
154 |     _checkGetRouteInfo: function (input, output) {
155 |         var info;
156 |         try {
157 |             info = this._router.getRouteInfo(input);
158 |         } catch (e) {
159 |             expect(e.message).to.be.eq('No such route: ' + input);
160 |             expect(output).to.be.undefined;
161 |             return;
162 |         }
163 | 
164 |         expect(info).to.be.deep.equal(output);
165 |     }
166 | });
167 | 
168 | module.exports = new RouterBaseTest;
169 | 


--------------------------------------------------------------------------------