add extjs 6.0.1 sources

[extjs.git] / extjs / packages / core / src / class / Inventory.js

    // @tag class\r
/**\r
 * @class Ext.Inventory\r
 * @private\r
 */\r
Ext.Inventory = function () {\r
// @define Ext.Script\r
// @define Ext.Inventory\r
// @require Ext.Function\r
    var me = this;\r
\r
    me.names = [];\r
    me.paths = {};\r
\r
    me.alternateToName = {};\r
    me.aliasToName = {};\r
    me.nameToAliases = {};\r
    me.nameToAlternates = {};\r
};\r
\r
Ext.Inventory.prototype = {\r
    _array1: [0],\r
\r
    prefixes: null,\r
\r
    dotRe: /\./g,\r
    wildcardRe: /\*/g,\r
\r
    addAlias: function (className, alias, update) {\r
        return this.addMapping(className, alias, this.aliasToName, this.nameToAliases, update);\r
    },\r
\r
    addAlternate: function (className, alternate) {\r
        return this.addMapping(className, alternate, this.alternateToName, this.nameToAlternates);\r
    },\r
\r
    addMapping: function (className, alternate, toName, nameTo, update) {\r
        var name = className.$className || className,\r
            mappings = name,\r
            array = this._array1,\r
            a, aliases, cls, i, length,\r
            nameMapping;\r
\r
        if (Ext.isString(name)) {\r
            mappings = {};\r
            mappings[name] = alternate;\r
        }\r
\r
        for (cls in mappings) {\r
            aliases = mappings[cls];\r
            if (Ext.isString(aliases)) {\r
                array[0] = aliases;\r
                aliases = array;\r
            }\r
\r
            length = aliases.length;\r
            nameMapping = nameTo[cls] || (nameTo[cls] = []);\r
            for (i = 0; i < length; ++i) {\r
                if (!(a = aliases[i])) {\r
                    continue;\r
                }\r
\r
                if (toName[a] !== cls) {\r
                    //<debug>\r
                    if (!update && toName[a]) {\r
                        Ext.log.warn("Overriding existing mapping: '" + a + "' From '" +\r
                            toName[a] + "' to '" + cls + "'. Is this intentional?");\r
                    }\r
                    //</debug>\r
\r
                    toName[a] = cls;\r
                    nameMapping.push(a);\r
                }\r
            }\r
        }\r
    },\r
\r
    /**\r
     * Get the aliases of a class by the class name\r
     *\r
     * @param {String} name\r
     * @return {Array} aliases\r
     */\r
    getAliasesByName: function (name) {\r
        return this.nameToAliases[name] || null;\r
    },\r
\r
    getAlternatesByName: function (name) {\r
        return this.nameToAlternates[name] || null;\r
    },\r
\r
    /**\r
     * Get the name of a class by its alias.\r
     *\r
     * @param {String} alias\r
     * @return {String} className\r
     */\r
    getNameByAlias: function(alias) {\r
        return this.aliasToName[alias] || '';\r
    },\r
\r
    /**\r
     * Get the name of a class by its alternate name.\r
     *\r
     * @param {String} alternate\r
     * @return {String} className\r
     */\r
    getNameByAlternate: function (alternate) {\r
        return this.alternateToName[alternate] || '';\r
    },\r
\r
    /**\r
     * Converts a string expression to an array of matching class names. An expression can\r
     * either refers to class aliases or class names. Expressions support wildcards:\r
     *\r
     *      // returns ['Ext.window.Window']\r
     *     var window = Ext.ClassManager.getNamesByExpression('widget.window');\r
     *\r
     *     // returns ['widget.panel', 'widget.window', ...]\r
     *     var allWidgets = Ext.ClassManager.getNamesByExpression('widget.*');\r
     *\r
     *     // returns ['Ext.data.Store', 'Ext.data.ArrayProxy', ...]\r
     *     var allData = Ext.ClassManager.getNamesByExpression('Ext.data.*');\r
     *\r
     * @param {String/String[]} expression\r
     * @param {Object} [exclude=null] An object keyed by class name containing classes to\r
     * exclude from the returned classes. This must be provided if `accumulate` is set to\r
     * `true`.\r
     * @param {Boolean} [accumulate=false] Pass `true` to add matching classes to the\r
     * specified `exclude` object.\r
     * @return {String[]} An array of class names.\r
     */\r
    getNamesByExpression: function (expression, exclude, accumulate) {\r
        var me = this,\r
            aliasToName = me.aliasToName,\r
            alternateToName = me.alternateToName,\r
            nameToAliases = me.nameToAliases,\r
            nameToAlternates = me.nameToAlternates,\r
            map = accumulate ? exclude : {},\r
            names = [],\r
            expressions = Ext.isString(expression) ? [expression] : expression,\r
            length = expressions.length,\r
            wildcardRe = me.wildcardRe,\r
            expr, i, list, match, n, name, regex;\r
\r
        for (i = 0; i < length; ++i) {\r
            if ((expr = expressions[i]).indexOf('*') < 0) {\r
                // No wildcard\r
                if (!(name = aliasToName[expr])) {\r
                    if (!(name = alternateToName[expr])) {\r
                        name = expr;\r
                    }\r
                }\r
\r
                if (!(name in map) && !(exclude && (name in exclude))) {\r
                    map[name] = 1;\r
                    names.push(name);\r
                }\r
            } else {\r
                regex = new RegExp('^' + expr.replace(wildcardRe, '(.*?)') + '$');\r
\r
                for (name in nameToAliases) {\r
                    if (!(name in map) && !(exclude && (name in exclude))) {\r
                        if (!(match = regex.test(name))) {\r
                            n = (list = nameToAliases[name]).length;\r
                            while (!match && n-- > 0) {\r
                                match = regex.test(list[n]);\r
                            }\r
\r
                            list = nameToAlternates[name];\r
                            if (list && !match) {\r
                                n = list.length;\r
                                while (!match && n-- > 0) {\r
                                    match = regex.test(list[n]);\r
                                }\r
                            }\r
                        }\r
\r
                        if (match) {\r
                            map[name] = 1;\r
                            names.push(name);\r
                        }\r
                    }\r
                }\r
            }\r
        }\r
\r
        return names;\r
    },\r
\r
    getPath: function (className) {\r
        var me = this,\r
            paths = me.paths,\r
            ret = '',\r
            prefix;\r
\r
        if (className in paths) {\r
            ret = paths[className];\r
        } else {\r
            prefix = me.getPrefix(className);\r
            if (prefix) {\r
                className = className.substring(prefix.length + 1);\r
                ret = paths[prefix];\r
                if (ret) {\r
                    ret += '/';\r
                }\r
            }\r
\r
            ret += className.replace(me.dotRe, '/') + '.js';\r
        }\r
\r
        return ret;\r
    },\r
\r
    getPrefix: function (className) {\r
        if (className in this.paths) {\r
            return className;\r
        }\r
\r
        var prefixes = this.getPrefixes(),\r
            i = prefixes.length,\r
            length, prefix;\r
\r
        // Walk the prefixes backwards so we consider the longest ones first.\r
        while (i-- > 0) {\r
            length = (prefix = prefixes[i]).length;\r
            if (length < className.length && className.charAt(length) === '.'\r
                                          && prefix === className.substring(0, length)) {\r
                return prefix;\r
            }\r
        }\r
\r
        return '';\r
    },\r
\r
    getPrefixes: function () {\r
        var me = this,\r
            prefixes = me.prefixes;\r
\r
        if (!prefixes) {\r
            me.prefixes = prefixes = me.names.slice(0);\r
            prefixes.sort(me._compareNames);\r
        }\r
\r
        return prefixes;\r
    },\r
\r
    removeName: function (name) {\r
        var me = this,\r
            aliasToName = me.aliasToName,\r
            alternateToName = me.alternateToName,\r
            nameToAliases = me.nameToAliases,\r
            nameToAlternates = me.nameToAlternates,\r
            aliases = nameToAliases[name],\r
            alternates = nameToAlternates[name],\r
            i, a;\r
\r
        delete nameToAliases[name];\r
        delete nameToAlternates[name];\r
\r
        if (aliases) {\r
            for (i = aliases.length; i--;) {\r
                // Aliases can be reassigned so if this class is the current mapping of\r
                // the alias, remove it. Since there is no chain to restore what was\r
                // removed this is not perfect.\r
                if (name === (a = aliases[i])) {\r
                    delete aliasToName[a];\r
                }\r
            }\r
        }\r
\r
        if (alternates) {\r
            for (i = alternates.length; i--; ) {\r
                // Like aliases, alternate class names can also be remapped.\r
                if (name === (a = alternates[i])) {\r
                    delete alternateToName[a];\r
                }\r
            }\r
        }\r
    },\r
\r
    resolveName: function (name) {\r
        var me = this,\r
            trueName;\r
\r
        // If the name has a registered alias, it is a true className (not an alternate)\r
        // so we can stop now.\r
        if (!(name in me.nameToAliases)) {\r
            // The name is not a known class name, so check to see if it is a known alias:\r
            if (!(trueName = me.aliasToName[name])) {\r
                // The name does not correspond to a known alias, so check if it is a known\r
                // alternateClassName:\r
                trueName = me.alternateToName[name];\r
            }\r
        }\r
\r
        return trueName || name;\r
    },\r
\r
    /**\r
     * This method returns a selector object that produces a selection of classes and\r
     * delivers them to the desired `receiver`.\r
     * \r
     * The returned selector object has the same methods as the given `receiver` object\r
     * but these methods on the selector accept a first argument that expects a pattern\r
     * or array of patterns. The actual method on the `receiver` will be called with an\r
     * array of classes that match these patterns but with any patterns passed to an\r
     * `exclude` call removed.\r
     * \r
     * For example:\r
     * \r
     *      var sel = inventory.select({\r
     *              require: function (classes) {\r
     *                  console.log('Classes: ' + classes.join(','));\r
     *              }\r
     *          });\r
     * \r
     *      sel.exclude('Ext.chart.*').exclude('Ext.draw.*').require('*');\r
     *      \r
     *      // Logs all classes except those in the Ext.chart and Ext.draw namespaces.\r
     * \r
     * @param {Object} receiver\r
     * @param {Object} [scope] Optional scope to use when calling `receiver` methods.\r
     * @return {Object} An object with the same methods as `receiver` plus `exclude`.\r
     */\r
    select: function (receiver, scope) {\r
        var me = this,\r
            excludes = {},\r
            ret = {\r
                excludes: excludes,\r
\r
                exclude: function () {\r
                    me.getNamesByExpression(arguments, excludes, true);\r
                    return this;\r
                }\r
            },\r
            name;\r
\r
        for (name in receiver) {\r
            ret[name] = me.selectMethod(excludes, receiver[name], scope || receiver);\r
        }\r
\r
        return ret;\r
    },\r
\r
    selectMethod: function (excludes, fn, scope) {\r
        var me = this;\r
\r
        return function (include) {\r
            var args = Ext.Array.slice(arguments, 1);\r
            \r
            args.unshift(me.getNamesByExpression(include, excludes));\r
\r
            return fn.apply(scope, args);\r
        };\r
    },\r
\r
    /**\r
     * Sets the path of a namespace.\r
     * For Example:\r
     *\r
     *      inventory.setPath('Ext', '.');\r
     *      inventory.setPath({\r
     *          Ext: '.'\r
     *      });\r
     *\r
     * @param {String/Object} name The name of a single mapping or an object of mappings.\r
     * @param {String} [path] If `name` is a String, then this is the path for that name.\r
     * Otherwise this parameter is ignored.\r
     * @return {Ext.Inventory} this\r
     * @method\r
     */\r
    setPath: Ext.Function.flexSetter(function (name, path) {\r
        var me = this;\r
\r
        me.paths[name] = path;\r
        me.names.push(name);\r
\r
        me.prefixes = null;\r
\r
        return me;\r
    }),\r
\r
    _compareNames: function (lhs, rhs) {\r
        var cmp = lhs.length - rhs.length;\r
        if (!cmp) {\r
            cmp = (lhs < rhs) ? -1 : 1;\r
        }\r
        return cmp;\r
    }\r
};\r