@atomist/automation-client/lib/project/util/projectUtils.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const Flushable_1 = require("../../internal/common/Flushable");
const async_1 = require("../../internal/util/async");
const string_1 = require("../../internal/util/string");
/**
 * Promise of an array of files. Usually sourced from Project.streamFiles
 */
function toPromise(stream) {
    return new Promise((resolve, reject) => {
        const files = [];
        stream
            .on("data", f => files.push(f))
            .on("error", reject)
            .on("end", _ => resolve(files));
    });
}
exports.toPromise = toPromise;
/**
 * Does at least one file matching the given predicate exist in this project?
 * If no predicate is supplied, does at least one file match the glob pattern?
 * No guarantees about ordering
 * @param p
 * @param globPatterns positive and negative globs to match
 * @param test return a boolean or promise. Defaults to true
 * @return {Promise<boolean>}
 */
function fileExists(p, globPatterns, test = () => true) {
    return __awaiter(this, void 0, void 0, function* () {
        return (yield countFiles(p, globPatterns, test)) > 0;
    });
}
exports.fileExists = fileExists;
/**
 * Count files matching the given predicate in this project
 * If no predicate is supplied, does at least one file match the glob pattern?
 * No guarantees about ordering
 * @param p
 * @param globPatterns positive and negative globs to match
 * @param test return a boolean or promise. Defaults to true
 * @return {Promise<boolean>}
 */
function countFiles(p, globPatterns, test = () => true) {
    return __awaiter(this, void 0, void 0, function* () {
        const results = yield gatherFromFiles(p, globPatterns, (f) => __awaiter(this, void 0, void 0, function* () { return (yield test(f)) === true; }));
        return results.length;
    });
}
exports.countFiles = countFiles;
/**
 * Gather values from files
 * @param {ProjectAsync} project to act on
 * @param {string} globPatterns glob pattern for files to match
 * @param {(f: File) => Promise<T>} gather function returning a promise (of the value you're gathering) from each file.
 * Undefined returns will be filtered out
 * @return {Promise<T[]>}
 */
function gatherFromFiles(project, globPatterns, gather) {
    return new Promise((resolve, reject) => {
        const gathered = [];
        project.streamFiles(...string_1.toStringArray(globPatterns))
            .on("data", f => {
            const g = gather(f);
            if (g) {
                gathered.push(g);
            }
        })
            .on("error", reject)
            .on("end", _ => {
            resolve(Promise.all(gathered).then(ts => ts.filter(t => !!t)));
        });
    });
}
exports.gatherFromFiles = gatherFromFiles;
/**
 * Perform the same operation on all the files.
 * @param project project to act on
 * @param globPatterns glob patterns to match
 * @param op operation to perform on files. Can return void or a promise.
 */
function doWithFiles(project, globPatterns, op) {
    return new Promise((resolve, reject) => {
        const filePromises = [];
        return project.streamFiles(...string_1.toStringArray(globPatterns))
            .on("data", f => {
            const r = op(f);
            if (async_1.isPromise(r)) {
                filePromises.push(r.then(_ => f.flush()));
            }
            else {
                if (f.dirty) {
                    filePromises.push(f.flush());
                }
            }
        })
            .on("error", reject)
            .on("end", _ => {
            resolve(Promise.all(filePromises));
        });
    }).then(files => project);
}
exports.doWithFiles = doWithFiles;
/**
 * Delete files matching the glob pattern and extra test (if supplied)
 * @param project project to act on
 * @param globPatterns glob patterns for files to delete
 * @param test additional, optional test for files to be deleted
 */
function deleteFiles(project, globPatterns, test = () => true) {
    const fp = project;
    return new Promise((resolve, reject) => {
        let deleted = 0;
        project.streamFiles(...string_1.toStringArray(globPatterns))
            .on("data", f => {
            if (test(f)) {
                ++deleted;
                Flushable_1.defer(fp, project.deleteFile(f.path));
            }
        })
            .on("error", reject)
            .on("end", () => {
            resolve(fp.flush()
                .then(() => deleted));
        });
    });
}
exports.deleteFiles = deleteFiles;
//# sourceMappingURL=projectUtils.js.map