@atomist/sdm-pack-fingerprints/lib/machine/AtomicAspect.js

an Atomist SDM Extension Pack for fingerprinting code

"use strict";
/*
 * Copyright © 2019 Atomist, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
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 clj_editors_1 = require("@atomist/clj-editors");
const Aspects_1 = require("./Aspects");
function isAtomicAspect(aspect) {
    const maybe = aspect;
    return !!maybe.consolidate;
}
exports.isAtomicAspect = isAtomicAspect;
/**
 * Create a composite aspect from the given other aspects or extractors.
 * Will use a single fingerprint that is made of many others. Ordering is significant:
 * atomic aspects can only be computed after normal fingerprints have been calculated.
 * @param aspectData identifying data of new composite fingerprint
 * @param narrower function to select fingerprints from the various aspects that we are interested in
 * @param aspect0 first aspect to combine
 * @param aspects other aspects
 */
function atomicAspect(aspectData, narrower, aspect0, ...aspects) {
    const prefix = aspectData.displayName + ":";
    const allAspects = [aspect0, ...aspects];
    const apply = allAspects.some(f => !f.apply) ?
        undefined :
        applyAll(allAspects, narrower);
    return Object.assign({}, aspectData, { apply, consolidate: (fps) => __awaiter(this, void 0, void 0, function* () {
            // Extract a single composite fingerprint
            return createCompositeFingerprint(prefix, fps.filter(narrower));
        }) });
}
exports.atomicAspect = atomicAspect;
function createCompositeFingerprint(prefix, fingerprints) {
    return fingerprints.length === 0 ?
        undefined :
        {
            name: prefix + fingerprints.map(fp => fp.name).join("&"),
            version: "0.1.0",
            abbreviation: prefix,
            sha: clj_editors_1.sha256(JSON.stringify(fingerprints)),
            data: fingerprints,
        };
}
function applyAll(aspects, narrower) {
    return (p, fp) => __awaiter(this, void 0, void 0, function* () {
        for (const individualFingerprint of fp.data) {
            const aspect = Aspects_1.aspectOf(individualFingerprint, aspects);
            if (!!aspect && !!aspect.apply) {
                const result = yield aspect.apply(p, individualFingerprint);
                if (!result) {
                    return result;
                }
            }
        }
        return true;
    });
}
//# sourceMappingURL=AtomicAspect.js.map