A fair amount of refactoring

Author: Karl Hepler

package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-middleware",
-  "version": "2.1.4",
+  "version": "2.1.5",
   "description": "Laravel-like middleware for angular uiRouter",
   "main": "dist/angular-middleware.js",
   "scripts": {

src/middleware.factory.js

@@ -33,13 +33,13 @@ function middlewareFactory($injector, $q) {
 	/**
 	 * Initialize $middleware
 	 *
-	 * @param {object} toRoute
-	 * @param {mixed} toParams
+	 * @param   {object} toRoute
+	 * @param   {mixed}  toParams
 	 * @returns {promise}
 	 */
 	return function initialize(toRoute, toParams) {
-		// Return early if the toRoute doesn't have middleware
-		if ( _bypassAll || !hasMiddleware(_globalMiddleware) && !hasMiddleware(toRoute) ) {
+		// Return if we should bypass
+		if ( shouldBypass(toRoute) ) {
 			return $q.resolve();
 		}
 
@@ -51,9 +51,7 @@ function middlewareFactory($injector, $q) {
 
 		// Set the middleware names.
 		// Make sure the globals are first, then concat toRoute
-		middleware.names =
-			getMiddlewareNames(_globalMiddleware)
-			.concat(getMiddlewareNames(toRoute));
+		middleware.names = concatMiddlwareNames([_globalMiddleware, toRoute]);
 
 		// Create a deferred promise
 		middleware.resolution = $q.defer();
@@ -66,40 +64,97 @@ function middlewareFactory($injector, $q) {
 	};
 
 	/**
-	 * Gets the route middleware property
-	 * @param {object} toRoute
-	 * @returns {array|string}
-   */
-	function getRouteMiddleware(route) {
-		return route.middleware || ((route.data || {}).vars || {}).middleware;
+	 * Determine if we should bypass the middleware
+	 *
+	 * @param   {object} route
+	 * @returns {boolean}
+	 */
+	function shouldBypass(route) {
+		// If the bypassAll flag is set,
+		// then we should bypass all - duh
+		if ( _bypassAll ) {
+			return true;
+		}
+
+		// We can only bypass at this point
+		// if there is no middleware to process
+		return !middlewareExists(route);
+	}
+
+	/**
+	 * Determine if any middleware exists
+	 *
+	 * @param   {object} route
+	 * @returns {boolean}
+	 */
+	function middlewareExists(route) {
+		return hasMiddleware(_globalMiddleware)
+			|| hasMiddleware(route);
 	}
 
 	/**
 	 * Determine if the given route has middleware
 	 *
-	 * @param {object} toRoute
+	 * @param   {object} route
 	 * @returns {boolean}
 	 */
 	function hasMiddleware(route) {
 		var middleware = getRouteMiddleware(route);
 		return !!middleware && !!middleware.length;
 	}
 
+	/**
+	 * Gets the route middleware property
+	 * 
+	 * @param   {object} route
+	 * @returns {array|string}
+   */
+	function getRouteMiddleware(route) {
+		return route.middleware
+			|| ((route.data || {}).vars || {}).middleware;
+	}
+
+	/**
+	 * Concat the middleware names of the given routes
+	 *
+	 * @param  {array} routes
+	 * @return {array}
+	 */
+	function concatMiddlewareNames(routes) {
+		var output = [];
+
+		// Concat each route's middleware names
+		for (var i = 0; i < routes.length; i++) {
+			output.concat(
+				getMiddlewareNames(routes[i])
+			);
+		}
+
+		return output;
+	}
+
 	/**
 	 * Get the middleware names
 	 * from an array or a piped string
 	 *
-	 * @param {object} route
+	 * @param   {object} route
 	 * @returns {array}
 	 */
 	function getMiddlewareNames(route) {
 		var middleware = getRouteMiddleware(route);
-		// Return the middleware names as an array
-		return middleware instanceof Array
-			? middleware
-			: typeof middleware === 'undefined'
-				? []
-				: middleware.split('|');
+
+		// If the middleware is an array, just return it
+		if ( middleware instanceof Array ) {
+			return middleware;
+		}
+
+		// If there is no middleware, then return an empty array
+		if ( typeof middleware === 'undefined' ) {
+			return [];
+		}
+
+		// Otherwise, split the pipes & return an array
+		return middleware.split('|');
 	}
 
 	/**