wheel-of-fortune-participants/dist/cli.cjs.js

Easy generate files for https://github.com/finanzcheck/wheel-of-fortune

'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var program = _interopDefault(require('commander'));
var path = _interopDefault(require('path'));
var mime = _interopDefault(require('mime-types'));
var faker = _interopDefault(require('faker'));
var fs = _interopDefault(require('fs'));
var shelljs = require('shelljs');
var Chance = _interopDefault(require('chance'));

var chance = new Chance();

const MIN = 20;
const MAX = 50;

class Generator {
    /**
     *
     * @param {String} ext
     * @param {String} filename
     * @param {Number} [min]
     * @param {Number} [max]
     */
    constructor(ext, filename) {
        let min = arguments.length <= 2 || arguments[2] === undefined ? MIN : arguments[2];
        let max = arguments.length <= 3 || arguments[3] === undefined ? MAX : arguments[3];

        this.ext = ext;
        this._filename = filename;
        this.min = min;
        this.max = max;
        this._participants = null;
    }

    /**
     *
     * @returns {Generator}
     */
    generate() {
        shelljs.mkdir('-p', path.dirname(this.filename));
        fs.writeFileSync(this.filename, this, 'utf8');
        return this;
    }

    /**
     *
     * @returns {String}
     */
    get filename() {
        const _filename = this._filename;
        const ext = this.ext;

        return `${ _filename }.${ ext }`;
    }

    /**
     *
     * @returns {[{name:String, spokes:Number}]}
     */
    get participants() {
        const _participants = this._participants;
        const min = this.min;
        const max = this.max;

        if (null !== _participants) {
            return _participants;
        }
        const p = () => {
            let spokes = chance.integer({ min: 0, max: 79 });
            let name = faker.fake('{{name.firstName}} {{name.lastName}}');
            return { spokes, name };
        };

        let participants = [];
        let i = 0,
            amount = chance.integer({ min, max });
        for (i; i < amount; i++) {
            participants.push(p());
        }
        this._participants = participants;
        return participants;
    }

    /**
     *
     * @returns {string}
     */
    toString() {
        return '';
    }

    /**
     *
     * @returns {Generator}
     */
    log() {
        const filename = this.filename;
        const participants = this.participants;

        console.log(`${ filename } successful generated with ${ participants.length } participants.`);
        return this;
    }

    /**
     *
     * @param generator
     * @returns {Generator}
     */
    static file(generator) {
        return generator.generate().log();
    }
}

class GeneratorCSV extends Generator {
    constructor(filename, cols) {
        super('csv', filename);
        this.cols = cols;
    }

    /**
     *
     * @returns {string}
     */
    toString() {
        let participants = super.participants.map(data => {
            let p = [];
            this.cols.forEach(col => {
                p.push(data[col]);
            });
            return p.join(';');
        });
        return [this.cols.join(';')].concat(participants).join(require('os').EOL);
    }

    /**
     *
     * @param filename
     * @param cols
     * @returns {Generator}
     */
    static file(filename, cols) {
        return super.file(new GeneratorCSV(filename, cols));
    }
}

class GeneratorJSON extends Generator {
    constructor(filename) {
        super('json', filename);
    }

    /**
     *
     * @returns {String}
     */
    toString() {
        return JSON.stringify(super.participants, null, 2);
    }

    /**
     *
     * @param filename
     * @returns {Generator}
     */
    static file(filename) {
        return super.file(new GeneratorJSON(filename));
    }
}

var version = "0.9.0";

program.version(version).usage('[options] <file>').option('-t, --type [json]', 'add file type', 'json').option('-r, --reverse', 'output cols on csv `spokes;names`').parse(process.argv);

var file = program.args[0] || '';
var output = 0 === program.args.length ? 'log' : 'file';
var fileType = mime.lookup(file);
var type = program.type;

if ('file' === output && file && 0 === path.extname(file).trim().length && ('json' === type || 'csv' === type)) {
    console.error('Unkown type! Please specify type!');
    process.exit(1);
}

file = file.substring(0, file.lastIndexOf('.'));

switch (fileType) {
    case 'text/csv':
        type = 'csv';
        break;
    case 'application/json':
        type = 'json';
        break;
}

var generator;

switch (type) {
    case 'csv':
        var cols = ['name', 'spokes'];
        if (program.reverse) {
            cols.reverse();
        }
        generator = new GeneratorCSV(file, cols);
        break;
    case 'json':
        generator = new GeneratorJSON(file);
        break;
}

if ('file' === output) {
    generator.generate().log();
} else {
    console.log(generator + '');
}

process.exit(0);