/** * Represents a mapping between a url and a controller/action pair. May also contain * additional params. * * This is a private internal class that should not need to be used by end-developer code. * Its API and existence are subject to change so use at your own risk. * * @private */Ext.define('Ext.route.Route', { requires: [ 'Ext.route.Action' ], /** * @event beforeroute * @member Ext.GlobalEvents * * Fires when a route is about to be executed. This allows pre-processing to add additional * {@link Ext.route.Action#before before} or {@link Ext.route.Action#action action} handlers * when the {@link Ext.route.Action Action} is run. * * The route can be prevented from executing by returning `false` in a listener * or executing the {@link Ext.route.Action#stop stop} method on the action. * * @param {Ext.route.Route} route The route being executed. * @param {Ext.route.Action} action The action that will be run. */ config: { /** * @cfg {String} name The name of this route. The name can be used when using * {@link Ext.route.Mixin#redirectTo}. */ name: null, /** * @cfg {String} url (required) The url regex to match against. */ url: null, /** * @cfg {Boolean} [allowInactive=false] `true` to allow this route to be triggered on * a controller that is not active. */ allowInactive: false, /** * @cfg {Boolean} [caseInsensitive=false] `true` to allow the tokens to be matched with * case-insensitive. */ caseInsensitive: false, /** * @cfg {Object[]} [handler=[]] The array of connected handlers to this route. Each object * should specify a function and scope: * * handlers: [{ * fn: function() {}, * scope: {} * }] * * If the `fn` is a string, the function will be resolved from the `scope`. */ handlers: [] }, /** * @cfg {Object} conditions Optional set of conditions for each token in the url * string. Each key should be one of the tokens, each value should be a regex that the * token should accept. For example, if you have a Route with a url like * `"files/:fileName"` and you want it to match urls like "files/someImage.jpg" then * you can set these conditions to allow the :fileName token to accept strings * containing a period ("."): * * conditions: { * ':fileName': "[0-9a-zA-Z\.]+" * } */ /** * @property {String} [defaultMatcher='([%a-zA-Z0-9\\-\\_\\s,]+)'] The default RegExp string * to use to match parameters with. */ defaultMatcher: '([%a-zA-Z0-9\\-\\_\\s,]+)', /** * @private * @property {RegExp} matcherRegex A regular expression to match the token to the configured {@link #url}. */ /** * @private * @property {RegExp} paramMatchingRegex A regular expression to check if there are parameters in the configured {@link #url}. */ paramMatchingRegex: /:([0-9A-Za-z\_]*)/g, /** * @private * @property {Array} paramsInMatchString An array of parameters in the configured {@link #url}. */ /** * @protected * @property {Boolean} [isRoute=true] */ isRoute: true, constructor: function (config) { var me = this, url; this.initConfig(config); Ext.apply(me, config, { conditions: {} }); url = me.getUrl(); me.paramsInMatchString = url.match(me.paramMatchingRegex) || []; me.matcherRegex = me.createMatcherRegex(url); }, /** * Attempts to recognize a given url string and return a meta data object including * any URL parameter matches. * * @param {String} url The url to recognize. * @return {Object/Boolean} The matched data, or `false` if no match. */ recognize: function (url) { var me = this, recognized = me.recognizes(url), matches, urlParams; if (url === me.lastToken) { //url matched the lastToken return true; } if (recognized) { matches = me.matchesFor(url); urlParams = url.match(me.matcherRegex); urlParams.shift(); return Ext.applyIf(matches, { historyUrl: url, urlParams: urlParams }); } return false; }, /** * Returns true if this {@link Ext.route.Route} matches the given url string. * * @param {String} url The url to test. * @return {Boolean} `true` if this {@link Ext.route.Route} recognizes the url. */ recognizes: function (url) { return this.matcherRegex.test(url); }, /** * The method to execute the action using the configured before function which will * kick off the actual {@link #actions} on the {@link #controller}. * * @param {Object} argConfig The object from the {@link Ext.route.Route}'s * recognize method call. * @return {Ext.promise.Promise} */ execute: function (token, argConfig) { var me = this, allowInactive = me.getAllowInactive(), handlers = me.getHandlers(), queue = Ext.route.Router.getQueueRoutes(), length = handlers.length, befores = [], actions = [], urlParams = (argConfig && argConfig.urlParams) || [], i, handler, scope, action, promises; me.lastToken = token; if (!queue) { promises = []; } return new Ext.Promise(function (resolve, reject) { for (i = 0; i < length; i++) { handler = handlers[i]; scope = handler.scope; if (!allowInactive && scope.isActive && !scope.isActive()) { continue; } if (queue) { if (handler.before) { befores.push({ fn: handler.before, scope: scope }); } if (handler.action) { actions.push({ fn: handler.action, scope: scope }); } } else { action = { urlParams: urlParams }; if (handler.before) { action.befores = { fn: handler.before, scope: scope }; } if (handler.action) { action.actions = { fn: handler.action, scope: scope }; } action = new Ext.route.Action(action); if (Ext.fireEvent('beforeroute', action, me) === false) { action.destroy(); } else { promises.push(action.run()); } } } if (queue) { action = new Ext.route.Action({ actions: actions, befores: befores, urlParams: urlParams }); if (Ext.fireEvent('beforeroute', action, me) === false) { action.destroy(); reject(); } else { action.run().then(resolve, reject); } } else { Ext.Promise.all(promises).then(resolve, reject); } }); }, /** * Returns a hash of matching url segments for the given url. * * @param {String} url The url to extract matches for * @return {Object} matching url segments */ matchesFor: function (url) { var params = {}, keys = this.paramsInMatchString, values = url.match(this.matcherRegex), length = keys.length, i; //first value is the entire match so reject values.shift(); for (i = 0; i < length; i++) { params[keys[i].replace(':', '')] = values[i]; } return params; }, /** * Takes the configured url string including wildcards and returns a regex that can be * used to match against a url. * * @param {String} url The url string. * @return {RegExp} The matcher regex. */ createMatcherRegex: function (url) { // Converts a route string into an array of symbols starting with a colon. e.g. // ":controller/:action/:id" => [':controller', ':action', ':id'] var paramsInMatchString = this.paramsInMatchString, conditions = this.conditions, defaultMatcher = this.defaultMatcher, length = paramsInMatchString.length, modifiers = this.getCaseInsensitive() ? 'i' : '', i, params, matcher; if (url === '*') { // handle wildcard routes, won't have conditions url = url.replace('*', '\\*'); } else { for (i = 0; i < length; i++) { params = paramsInMatchString[i]; matcher = conditions[params] || defaultMatcher; url = url.replace(new RegExp(params), matcher); } } //we want to match the whole string, so include the anchors return new RegExp('^' + url + '$', modifiers); }, /* * Adds a handler to the {@link #handlers} stack. * * @param {Object} handler An object to describe the handler. A handler should define a `fn` * and `scope`. If the `fn` is a String, the function will be resolved from the `scope`. * @return {Ext.route.Route} this */ addHandler: function (handler) { var handlers = this.getHandlers(); handlers.push(handler); return this; }, /** * Removes a handler from th {@link #handlers} stack. This normally happens when * destroying a class instance. * * @param {Object/Ext.Base} scope The class instance to match handlers with. * @param {Object} config An optional object to describe which handlers to remove. * This can be used to remove all handlers with a certain `before` or `action`. * @return {Ext.route.Route} this */ removeHandler: function (scope, config) { var handlers = this.getHandlers(), length = handlers.length, newHandlers = [], i, handler; for (i = 0; i < length; i++) { handler = handlers[i]; if (handler.scope === scope) { if (!config || ( Ext.isDefined(config.action) ? handler.action === config.action : true && Ext.isDefined(config.before) ? handler.before === config.before : true ) ) { continue; } } newHandlers.push(handler); } this.setHandlers(newHandlers); return this; }});