quicksilver-cli/util/gradle.js

Cli tool for Quicksilver

"use strict";
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
const system_1 = require("./system");
const placeholder_1 = require("./placeholder");
const environment_1 = require("./environment");
const path = __importStar(require("path"));
const fs = __importStar(require("fs"));
const HelpUtil = __importStar(require("./help"));
const { spawn } = require('child_process');
const log4js = require("log4js");
const projectJson = require("../resources/project/project.json");
function getGradleResource(fileName) {
    return path.join(__dirname, "../resources/gradle", fileName);
}
function getRootProjectGradle(nexus, quicksilver, group, version) {
    const gradle = fs.readFileSync(getGradleResource("root"), { encoding: "utf8" });
    const args = {
        "nexus": nexus,
        "quicksilver": quicksilver,
        "group": group,
        "version": version
    };
    return placeholder_1.replace(gradle, args);
}
exports.getRootProjectGradle = getRootProjectGradle;
function getLibProjectGradle() {
    return fs.readFileSync(getGradleResource("lib"), { encoding: "utf8" });
}
exports.getLibProjectGradle = getLibProjectGradle;
function getBuildProjectGradle(projectName, httpPort, httpsPort) {
    const productName = projectName.charAt(0).toUpperCase() + projectName.substring(1);
    const gradle = fs.readFileSync(getGradleResource("build"), { encoding: "utf8" });
    const args = {
        "productName": productName,
        "projectName": projectName,
        "httpPort": httpPort,
        "httpsPort": httpsPort
    };
    return placeholder_1.replace(gradle, args);
}
exports.getBuildProjectGradle = getBuildProjectGradle;
function getModuleProjectGradle(rootProjectName, moduleName) {
    const gradle = fs.readFileSync(getGradleResource("module"), { encoding: "utf8" });
    const args = {
        "rootProjectName": rootProjectName,
        "moduleName": moduleName,
        "order": projectJson.order
    };
    return placeholder_1.replace(gradle, args);
}
exports.getModuleProjectGradle = getModuleProjectGradle;
function getRunProjectGradle(dependenceProjectName) {
    const gradle = fs.readFileSync(getGradleResource("run"), { encoding: "utf8" });
    const args = {
        "dependenceProjectName": dependenceProjectName
    };
    return placeholder_1.replace(gradle, args);
}
exports.getRunProjectGradle = getRunProjectGradle;
function modifySettingsGradle(projectPath) {
    const project = path.basename(projectPath);
    const rootProjectPath = path.dirname(projectPath);
    const settingsGradle = path.join(rootProjectPath, "settings.gradle");
    const appendMessage = `
include '${project}'
`;
    const data = fs.readFileSync(settingsGradle, 'utf8');
    const projectRegExp = new RegExp(`include\\s+'${project}'`);
    if (!projectRegExp.test(data)) {
        fs.appendFileSync(settingsGradle, appendMessage);
    }
}
exports.modifySettingsGradle = modifySettingsGradle;
async function runGradleTask(projectPath, task, options) {
    const logger = log4js.getLogger("gradle");
    return new Promise((resolve, reject) => {
        logger.info(`Executing gradle task '${task}'...`);
        const command = system_1.isWindows ? "gradle.bat" : "gradle";
        options = Object.assign({ cwd: projectPath }, options);
        const gradle = spawn(command, [task], options);
        if (gradle.stdout) {
            gradle.stdout.on('data', data => {
                logger.debug(`${data}`);
            });
        }
        if (gradle.stderr) {
            gradle.stderr.on('data', data => {
                reject(`${data}`);
            });
        }
        gradle.on('close', (code) => {
            if (code == 0) {
                HelpUtil.print("");
                logger.info(`Completed gradle task '${task}'.`);
                resolve("success");
            }
            else {
                reject(`Executing gradle task '${task}' with errors: Code=${code}`);
            }
        });
        gradle.on("error", err => {
            reject(err);
        });
    });
}
exports.runGradleTask = runGradleTask;
async function init(projectPath) {
    try {
        const result = await runGradleTask(projectPath, "wrapper", { stdio: "inherit" });
        fs.writeFileSync(path.join(projectPath, "build.gradle"), "");
        fs.writeFileSync(path.join(projectPath, "settings.gradle"), "");
        return result;
    }
    catch (e) {
        return Promise.reject(e.toString());
    }
}
exports.init = init;
async function projects(projectPath) {
    return runGradleTask(projectPath, `projects`, { stdio: "inherit" });
}
exports.projects = projects;
async function clean(projectPath) {
    return runGradleTask(projectPath, "clean", { stdio: "inherit" });
}
exports.clean = clean;
async function build(projectPath) {
    const env = await environment_1.getEnv(projectPath, "gradle");
    return runGradleTask(projectPath, "build", { env: env, stdio: "inherit" });
}
exports.build = build;
async function qsArchive(projectPath, os) {
    const env = await environment_1.getEnv(projectPath, "gradle");
    return runGradleTask(projectPath, `qsArchive-${os}`, { env: env, stdio: "inherit" });
}
exports.qsArchive = qsArchive;