Code coverage report for ./src/DependencyParser.js

Statements: 98.21% (55 / 56)      Branches: 85.71% (30 / 35)      Functions: 81.82% (9 / 11)      Lines: 98.21% (55 / 56)      Ignored: none     

All files » ./src\ » DependencyParser.js
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 941   1   1 1 1   1 19     1 26 26 26 14 14     26     1 570 570 551   570     1 570 570 513 513 513     570     1 4 4 4 4 42 26 26     4     1       1 246     1 439 439 439 90 90     439 439 1 1     438 438   438 438 193       435     1        
void function (define) {
 
    define(
        function (require) {
            var u = require('./util');
            var DependencyTree = require('./DependencyTree');
            var SETTER_REGEX = /^set([A-Z].*)$/;
 
            function DependencyParser(context) {
                this.context = context;
            }
 
            DependencyParser.prototype.getPropertyFromSetter = function (name) {
                var prop = null;
                var matches = name.match(SETTER_REGEX);
                if (matches) {
                    prop = matches[1];
                    prop = prop.charAt(0).toLowerCase() + prop.slice(1);
                }
 
                return prop;
            };
 
            DependencyParser.prototype.getDepsFromArgs = function (args) {
                var deps = [];
                for (var i = args.length - 1; i > -1; --i) {
                    u.hasReference(args[i]) && u.addToSet(deps, args[i].$ref);
                }
                return deps;
            };
 
            DependencyParser.prototype.getDepsFromProperties = function (properties) {
                var deps = [];
                for (var k in properties) {
                    Eif (u.hasOwn(properties, k)) {
                        var prop = properties[k];
                        u.hasReference(prop) && u.addToSet(deps, prop.$ref);
                    }
                }
                return deps;
            };
 
            DependencyParser.prototype.getDepsFromSetters = function (instance, exclude) {
                exclude = exclude || {};
                var deps = [];
                var prop = null;
                for (var k in instance) {
                    if (typeof instance[k] === 'function') {
                        prop = this.getPropertyFromSetter(k);
                        prop && !exclude.hasOwnProperty(prop) && deps.push(prop);
                    }
                }
                return deps;
            };
 
            DependencyParser.prototype.getDepsFromInterfaces = function () {
 
            };
 
            DependencyParser.prototype.getDependentModules = function (component, result, deps) {
                return getDependentModules(component, this.context, result || {}, new DependencyTree(), deps);
            };
 
            function getDependentModules(component, context, result, depTree, deps) {
                Eif (component) {
                    var module = component.module;
                    if (typeof component.creator !== 'function' && module) {
                        result[module] = result[module] || [];
                        result[module].push(component);
                    }
 
                    var circular = depTree.checkForCircular(component.id);
                    if (circular) {
                        var msg = component.id + ' has circular dependencies ';
                        throw new u.CircularError(msg, component);
                    }
 
                    depTree.addData(component);
                    var child = depTree.appendChild(new DependencyTree());
 
                    deps = deps || component.argDeps.concat(component.propDeps).concat(component.setterDeps || []);
                    for (var i = deps.length - 1; i > -1; --i) {
                        getDependentModules(context.getComponentConfig(deps[i]), context, result, child);
                    }
                }
 
                return result;
            }
 
            return DependencyParser;
        }
    );
 
}(typeof define === 'function' && define.amd ? define : function (factory) { module.exports = factory; });