testcafe/lib/compiler/index.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const strip_bom_1 = __importDefault(require("strip-bom"));
const promisified_functions_1 = require("../utils/promisified-functions");
const runtime_1 = require("../errors/runtime");
const types_1 = require("../errors/types");
const compilers_1 = require("./compilers");
const SOURCE_CHUNK_LENGTH = 1000;
class Compiler {
    constructor(sources, options) {
        this.sources = sources;
        compilers_1.initTestFileCompilers(options);
    }
    static getSupportedTestFileExtensions() {
        return lodash_1.uniq(compilers_1.getTestFileCompilers().map(compiler => compiler.getSupportedExtension()));
    }
    async _createTestFileInfo(filename) {
        let code = null;
        try {
            code = await promisified_functions_1.readFile(filename);
        }
        catch (err) {
            throw new runtime_1.GeneralError(types_1.RUNTIME_ERRORS.cannotFindSpecifiedTestSource, filename);
        }
        code = strip_bom_1.default(code).toString();
        const compiler = lodash_1.find(compilers_1.getTestFileCompilers(), someCompiler => someCompiler.canCompile(code, filename));
        if (!compiler)
            return null;
        return {
            filename,
            code,
            compiler,
            compiledCode: null
        };
    }
    async _createTestFilesInfo(filenames) {
        const testFilesInfo = await Promise.all(filenames.map(filename => this._createTestFileInfo(filename)));
        return testFilesInfo.filter(info => !!info);
    }
    async _precompileFiles(compiler, testFilesInfo) {
        if (!compiler.canPrecompile)
            return;
        const precompiledCode = await compiler.precompile(testFilesInfo);
        for (let i = 0; i < testFilesInfo.length; i++)
            testFilesInfo[i].compiledCode = precompiledCode[i];
    }
    _getCompilerTasks(testFilesInfo) {
        const tasks = new WeakMap();
        const compilers = [];
        for (const info of testFilesInfo) {
            const { compiler } = info;
            if (!tasks.has(compiler)) {
                compilers.push(compiler);
                tasks.set(compiler, []);
            }
            tasks.get(info.compiler).push(info);
        }
        return compilers.map(compiler => ({ compiler, compilerTestFilesInfo: tasks.get(compiler) }));
    }
    async _getTests({ compiler, filename, code, compiledCode }) {
        if (compiledCode)
            return await compiler.execute(compiledCode, filename);
        return await compiler.compile(code, filename);
    }
    async _compileTestFiles(filenames) {
        const testFilesInfo = await this._createTestFilesInfo(filenames);
        const compilerTasks = this._getCompilerTasks(testFilesInfo);
        await Promise.all(compilerTasks.map(({ compiler, compilerTestFilesInfo }) => this._precompileFiles(compiler, compilerTestFilesInfo)));
        const tests = [];
        for (const info of testFilesInfo)
            tests.push(await this._getTests(info));
        return tests;
    }
    async getTests() {
        // NOTE: split sources into chunks because the fs module can't read all files
        // simultaneously if the number of them is too large (several thousands).
        const sourceChunks = lodash_1.chunk(this.sources, SOURCE_CHUNK_LENGTH);
        let tests = [];
        while (sourceChunks.length)
            tests = tests.concat(await this._compileTestFiles(sourceChunks.shift()));
        Compiler.cleanUp();
        return lodash_1.flattenDeep(tests).filter(test => !!test);
    }
    static cleanUp() {
        compilers_1.getTestFileCompilers().forEach(compiler => compiler.cleanUp());
    }
}
exports.default = Compiler;
module.exports = exports.default;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/compiler/index.js"],"names":[],"mappings":"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","sourcesContent":["import { flattenDeep, find, chunk, uniq } from 'lodash';\nimport stripBom from 'strip-bom';\nimport { readFile } from '../utils/promisified-functions';\nimport { GeneralError } from '../errors/runtime';\nimport { RUNTIME_ERRORS } from '../errors/types';\nimport { getTestFileCompilers, initTestFileCompilers } from './compilers';\n\n\nconst SOURCE_CHUNK_LENGTH = 1000;\n\nexport default class Compiler {\n    constructor (sources, options) {\n        this.sources = sources;\n\n        initTestFileCompilers(options);\n    }\n\n    static getSupportedTestFileExtensions () {\n        return uniq(getTestFileCompilers().map(compiler => compiler.getSupportedExtension()));\n    }\n\n    async _createTestFileInfo (filename) {\n        let code = null;\n\n        try {\n            code = await readFile(filename);\n        }\n        catch (err) {\n            throw new GeneralError(RUNTIME_ERRORS.cannotFindSpecifiedTestSource, filename);\n        }\n\n        code = stripBom(code).toString();\n\n        const compiler = find(getTestFileCompilers(), someCompiler => someCompiler.canCompile(code, filename));\n\n        if (!compiler)\n            return null;\n\n        return {\n            filename,\n            code,\n            compiler,\n\n            compiledCode: null\n        };\n    }\n\n    async _createTestFilesInfo (filenames) {\n        const testFilesInfo = await Promise.all(filenames.map(filename => this._createTestFileInfo(filename)));\n\n        return testFilesInfo.filter(info => !!info);\n    }\n\n    async _precompileFiles (compiler, testFilesInfo) {\n        if (!compiler.canPrecompile)\n            return;\n\n        const precompiledCode = await compiler.precompile(testFilesInfo);\n\n        for (let i = 0; i < testFilesInfo.length; i++)\n            testFilesInfo[i].compiledCode = precompiledCode[i];\n    }\n\n    _getCompilerTasks (testFilesInfo) {\n        const tasks     = new WeakMap();\n        const compilers = [];\n\n        for (const info of testFilesInfo) {\n            const { compiler } = info;\n\n            if (!tasks.has(compiler)) {\n                compilers.push(compiler);\n                tasks.set(compiler, []);\n            }\n\n            tasks.get(info.compiler).push(info);\n        }\n\n        return compilers.map(compiler => ({ compiler, compilerTestFilesInfo: tasks.get(compiler) }));\n    }\n\n    async _getTests ({ compiler, filename, code, compiledCode }) {\n        if (compiledCode)\n            return await compiler.execute(compiledCode, filename);\n\n        return await compiler.compile(code, filename);\n    }\n\n    async _compileTestFiles (filenames) {\n        const testFilesInfo = await this._createTestFilesInfo(filenames);\n        const compilerTasks = this._getCompilerTasks(testFilesInfo);\n\n        await Promise.all(compilerTasks.map(({ compiler, compilerTestFilesInfo }) => this._precompileFiles(compiler, compilerTestFilesInfo)));\n\n        const tests = [];\n\n        for (const info of testFilesInfo)\n            tests.push(await this._getTests(info));\n\n        return tests;\n    }\n\n    async getTests () {\n        // NOTE: split sources into chunks because the fs module can't read all files\n        // simultaneously if the number of them is too large (several thousands).\n        const sourceChunks = chunk(this.sources, SOURCE_CHUNK_LENGTH);\n\n        let tests = [];\n\n        while (sourceChunks.length)\n            tests = tests.concat(await this._compileTestFiles(sourceChunks.shift()));\n\n        Compiler.cleanUp();\n\n        return flattenDeep(tests).filter(test => !!test);\n    }\n\n    static cleanUp () {\n        getTestFileCompilers().forEach(compiler => compiler.cleanUp());\n    }\n}\n"]}