static _didFetchManifest()

in resources/perf.webkit.org/public/v3/models/manifest.js [44:108]
51 lines of code
5 McCabe index (conditional complexity)

    static _didFetchManifest(rawResponse)
    {
        Instrumentation.startMeasuringTime('Manifest', '_didFetchManifest');

        const tests = [];
        const testParentMap = {};
        for (let testId in rawResponse.tests)
            tests.push(new Test(testId, rawResponse.tests[testId]));

        function buildObjectsFromIdMap(idMap, constructor, resolver) {
            for (let id in idMap) {
                if (resolver)
                    resolver(idMap[id]);
                new constructor(id, idMap[id]);
            }
        }

        buildObjectsFromIdMap(rawResponse.metrics, Metric, (raw) => {
            raw.test = Test.findById(raw.test);
        });

        buildObjectsFromIdMap(rawResponse.platformGroups, PlatformGroup);
        buildObjectsFromIdMap(rawResponse.all, Platform, (raw) => {
            raw.lastModifiedByMetric = {};
            raw.lastModified.forEach((lastModified, index) => {
                raw.lastModifiedByMetric[raw.metrics[index]] = lastModified;
            });
            raw.metrics = raw.metrics.map((id) => { return Metric.findById(id); });
            raw.group = PlatformGroup.findById(raw.group);
        });
        buildObjectsFromIdMap(rawResponse.builders, Builder);
        buildObjectsFromIdMap(rawResponse.repositories, Repository);
        buildObjectsFromIdMap(rawResponse.bugTrackers, BugTracker, (raw) => {
            if (raw.repositories)
                raw.repositories = raw.repositories.map((id) => { return Repository.findById(id); });
        });
        buildObjectsFromIdMap(rawResponse.triggerables, Triggerable, (raw) => {
            raw.acceptedRepositories = raw.acceptedRepositories.map((repositoryId) => {
                return Repository.findById(repositoryId);
            });
            raw.repositoryGroups = raw.repositoryGroups.map((group) => {
                group.repositories = group.repositories.map((entry) => {
                    return {repository: Repository.findById(entry.repository), acceptsPatch: entry.acceptsPatch};
                });
                return TriggerableRepositoryGroup.ensureSingleton(group.id, group);
            });
            raw.configurations = raw.configurations.map((configuration) => {
                const [testId, platformId, supportedRepetitionTypes] = configuration;
                return {test: Test.findById(testId), platform: Platform.findById(platformId), supportedRepetitionTypes};
            });
        });

        if (typeof(UploadedFile) != 'undefined')
            UploadedFile.fileUploadSizeLimit = rawResponse.fileUploadSizeLimit || 0;

        Instrumentation.endMeasuringTime('Manifest', '_didFetchManifest');

        return {
            siteTitle: rawResponse.siteTitle,
            dashboards: rawResponse.dashboards, // FIXME: Add an abstraction around dashboards.
            summaryPages: rawResponse.summaryPages,
            testAgeToleranceInHours: rawResponse.testAgeToleranceInHours,
            maxRootReuseAgeInDays: rawResponse.maxRootReuseAgeInDays,
        }
    }