@codefresh-io/pipeline-autobot/analyzer/index.js

const AnalyzerContext = require('./analyzer.context');

const _ = require('lodash');
const Promise = require('bluebird');

const { stringify, emptyLine }= require('../json-to-yaml');
const { defaultYaml }= require('../helpers/common');

const fs = require('fs');
const path = require('path');

class Analyzer {

    async _defaultYaml() {
        return defaultYaml(this.source);
    }

    async init(context, source) {
        this.analyzerContext = new AnalyzerContext(context);
        this.source = source;
        await this.analyzerContext.loadRepoInfo();
        this.chain = {};
    }

    _addToChain(key, func) {
        const values = this.chain[key] || [];
        values.push(func);
        this.chain[key] = values;
    }

    /**
     * add step to yaml
     * @param step
     * @returns {Analyzer}
     */
    step(step) {
        this._addToChain('step', async () => {
            const res = await step(this.analyzerContext);
            if(res) {
                this.analyzerContext.addStep(res);
            }

        });
        return this;
    }

    /**
     * add header to yaml (before steps)
     * @param header
     * @returns {Analyzer}
     */
    header(header) {
        this._addToChain('header', () => {
            this.analyzerContext.addHeader(header(this.source))
        });
        return this;
    }

    /**
     * apply enricher key - value to each existing step
     * @param enricher
     * @returns {Analyzer}
     */
    enrich(enricher) {
        this._addToChain('enrich', () => enricher(this.analyzerContext));
        return this;
    }

    transform(transformer) {
        this._addToChain('transform', () => transformer(this.analyzerContext));
        return this;
    }

    async resolve() {
        // handle transforms because result of it not require next actions
        const transformers = _.get(this.chain, 'transform', [])
            .map(t => t());
        const result = await Promise.all(transformers);
        const filteredResult = result.filter(r => r !== null);
        if (!_.isEmpty(filteredResult)) {
            return filteredResult[0];
        }

        try{
            // process other events from chain
            // sequence is important there
            for(const item of ['header', 'step', 'enrich']){
                // using loop for store order
                for(const step of this.chain[item]){
                    await step();
                }
            }
        }
        catch (e) {
            console.error(e);
            return this._defaultYaml();
        }


        const steps = this.analyzerContext.getSteps();
        Object.keys(steps).forEach(stepName => Object.assign(steps[stepName], {[emptyLine()]: true}));

        return stringify({
            ...this.analyzerContext.getHeaders(),
            [emptyLine()]: true,
            steps
        });
    }

}

module.exports = Analyzer;