cli

#!/usr/bin/env node

const userDirectory = process.cwd();

const fs = require('fs');
const cpp = require('child-process-promise');
const copy = require('recursive-copy');
const rimraf = require('rimraf');
const tmp = require('tmp');

const path = require('path');
const modulePath = require('npm-module-path');
const which = require('npm-which')(userDirectory);

const unique = require('array-unique').immutable;

const state = {
    inModuleDir : false,
    ielmModulePath: undefined,
    runLocally: false,
    commandToRun: 'run',
    ielmUserPath: undefined
};

if (process.argv && process.argv.length) {
    process.argv.forEach((arg) => {
        if ((arg === 'build') ||
            (arg === 'run') ||
            (arg === 'clean-run') ||
            (arg === 'run-dev') ||
            (arg === 'clean-run-dev') ||
            (arg === 'test')) {
                state.commandToRun = arg;
            };
        if (arg === 'local') {
            state.runLocally = true;
        }
        if (arg.startsWith('path=')) {
            state.ielmUserPath = arg.substring(5);
        }
    })
}

const outputDir = state.runLocally ? `${userDirectory}/output` : tmp.dirSync().name;

console.log(`:: ${state.commandToRun}`);

const serverDir = 'src/server';
const npmBinLocalDir = `${userDirectory}/node_modules/.bin`;

const ielmBinary = 'ielm.js';
const componentsDir = `${serverDir}/Component`;
const serverScript = `${serverDir}/server.js`;
const simpleHttpServerBin = state.runLocally
    ? `${npmBinLocalDir}/node-simplehttpserver`
    : getModulePath('node-simplehttpserver');
const simpleHttpServerPort = 8080;
const webpackDevServerBin = state.runLocally
    ? `${npmBinLocalDir}/webpack-dev-server`
    : getModulePath('webpack-dev-server');
const elmPackageSource = `${serverDir}/elm-package.sample.json`;
const elmPackageDest = `${outputDir}/elm-package.json`;
const componentsDest = `${outputDir}/Component`;
const elmStuffDest = `${outputDir}/elm-stuff`;
const iElmJsDest = `${outputDir}/ielm.js`;
const iElmHtmlDest = `${outputDir}/index.html`;

function build() {
    // webpack
    return goToModuleDir()
        .then(() => execInPromise('webpack'))
        .then(goBackToOriginalDir)
        .catch(reportError);
}

function run() {
    return goToModuleDir()
        .then(buildIfNotExists)
        .then(createOutputDir)
        .then(copyComponents)
        .then(copyElmPackage)
        .then(copyIElmStaticFiles)
        .then(goBackToOriginalDir)
        .then(copyElmStuff)
        .then(() => chdirInPromise(state.ielmModulePath))
        .then(() => { startServer(); return null; })
        .then(() => chdirInPromise(outputDir))
        .then(installPackages)
        .then(() => startClient())
        .catch(reportError);
}

function cleanRun() {
    return goToModuleDir()
        .then(cleanOutput)
        .then(run)
        .catch(reportError);
}

function runDev() {
    return goToModuleDir()
        .then(createOutputDir)
        .then(copyComponents)
        .then(copyElmPackage)
        .then(() => chdirInPromise(outputDir))
        .then(installPackages)
        .then(goBackToOriginalDir)
        .then(() => {
            return Promise.all([ startServer(), startDevClient() ]);
        })
        .catch(reportError);
}

function cleanRunDev() {
    return goToModuleDir()
        .then(cleanOutput)
        .then(runDev)
        .catch(reportError);
}

function test() {
    throw new Error("Error: no test specified");
}

function goToModuleDir() {
    return chdirInPromise(state.ielmModulePath);
}

function goBackToOriginalDir() {
    return chdirInPromise(userDirectory);
}

function createOutputDir() {
    // mkdir ./output
    return logAs(`create output directory ${outputDir}`)
        .then(() => new Promise((resolve, reject) => {
            try {
                if (!fs.existsSync(outputDir)) {
                    fs.mkdirSync(outputDir);
                }
                resolve();
            } catch(e) {
                reject(e);
            }
        }));
}

function cleanOutput() {
    // rm -Rf ./output
    return rimrafInPromise(outputDir);
}

function copyComponents() {
    // cp -R ./src/server/Component ./output
    return logAs('copy components')
        .then(() =>
            copy(`${state.ielmModulePath}/${componentsDir}`,
                 componentsDest, { overwrite: true })
        );
}

function copyElmStuff() {
    // cp -R ./elm-stuff ./output
    return logAs('copy elm-stuff')
        .then(() => new Promise((resolve, reject) => {
            if (!state.runLocally && fs.existsSync('./elm-stuff')) {
                copy('./elm-stuff', elmStuffDest, { overwrite: true }).then(resolve);
            } else {
                resolve();
            }
        }));
}

function copyIElmStaticFiles() {
    // cp ./ielm.js ./output
    // cp ./index.html ./output
    return logAs('copy ielm.js & ielm.html')
        .then(() => new Promise((resolve, reject) => {
            const iElmJsSrc = `${state.ielmModulePath}/ielm.js`;
            const iElmHtmlSrc = `${state.ielmModulePath}/index.html`;
            if (fs.existsSync(iElmJsSrc) && fs.existsSync(iElmHtmlSrc)) {
                copy(iElmJsSrc, iElmJsDest, { overwrite: true })
                    .then(() => copy(iElmHtmlSrc, iElmHtmlDest, { overwrite: true }))
                    .then(resolve);
            } else {
                resolve();
            }
        }));
}

function copyElmPackage() {
    // cp ./src/server/elm-package.sample.json ./output/elm-package.json
    return logAs('copy elm-package.json').then(new Promise((resolve, reject) => {
        const sample = require(`./${elmPackageSource}`);

        if (!sample['source-directories']) sample['source-directories'] = [];

        sample['source-directories'] = sample['source-directories'].map((relPath) => {
            return path.resolve(relPath);
        });
        sample['source-directories'].push('.');
        sample['source-directories'].push(userDirectory);

        sample['source-directories'] = unique(sample['source-directories']);

        let sourceDependencies = sample.dependencies;
        let userDependencies = {};
        try {
            userDependencies = require(`${userDirectory}/elm-package.json`).dependencies || {};
        } catch(e) {}
        Object.keys(userDependencies).forEach((dependencyName) => {
            sourceDependencies[dependencyName] = userDependencies[dependencyName];
        });

        fs.writeFile(elmPackageDest, JSON.stringify(sample, null, '\t'), 'utf8', (err) => {
            if (!err) {
                resolve();
            } else {
                reject(err);
            }
        });
    }));
}

function installPackages() {
    // cd ./output && elm-package install --yes && cd ..
    return logAs('install Elm packages')
        .then(() => {
            return execInPromise('elm-package', [ 'install', '--yes' ])
        });
}

function startServer() {
    // node ./src/server/server.js
    return logAs('start server at http://localhost:3000')
        .then(() => execInPromise('node',
            [ `${state.ielmModulePath}/${serverScript}`, `--path=${outputDir}` ]));
}

function startClient() {
    // ./node_modules/.bin/node-simplehttpserver . 8080
    return logAs('start client at http://localhost:8080')
        .then(() => execInPromise(simpleHttpServerBin, [ outputDir, simpleHttpServerPort ]));
}

function startDevClient() {
    // ./node_modules/.bin/webpack-dev-server
    return logAs('start development client at http://localhost:8080.')
        .then(() => execInPromise(webpackDevServerBin));
}

function buildIfNotExists() {
    return new Promise((resolve, reject) => {
        try {
            if (!fs.existsSync(`${outputDir}/${ielmBinary}`)) {
                resolve(build());
            }
            resolve();
        } catch(e) {
            reject(e);
        }
    });
}

function execInPromise(command, args) {
    //console.log(`:: execute '${command}' with arguments: '${args}'.`);
    const promise = cpp.spawn(command, args || []);
    const childProcess = promise.childProcess;
    childProcess.stdout.on('data', function (data) {
        //console.log(`${command} :: ${data.toString()}`);
    });
    childProcess.stderr.on('data', function (data) {
        console.log(`${command} error :: ${data.toString()}`);
    });
    return promise;
}

function chdirInPromise(path) {
    return new Promise((resolve, reject) => {
        try {
            //console.log(`:: change directory to '${path}'.`);
            //console.log(process.cwd());
            process.chdir(path);
            resolve();
        } catch(e) {
            reject(e);
        }
    });
}

function rimrafInPromise(path) {
    return new Promise((resolve, reject) => {
        console.log(`:: clean '${path}'.`);
        rimraf(path, (error) => {
            if (error) {
                reject(error);
            } else {
                resolve();
            }
        });
    });
}

function logAs(string) {
    return new Promise((resolve, reject) => {
        console.log(`:: ${string}.`);
        resolve();
    });
}

function reportError(err) {
    console.error(`xx Error: ${err}`);
}

function getModulePath(moduleName) {
    try {
        return which.sync(moduleName);
    } catch(e) {
        return moduleName;
    }
}

function runCommand(commandToRun) {
    if (commandToRun === 'build') {
        build();
    } else if (commandToRun === 'run') {
        run();
    } else if (commandToRun === 'clean-run') {
        cleanRun();
    } else if (commandToRun === 'run-dev') {
        runDev();
    } else if (commandToRun === 'clean-run-dev') {
        cleanRunDev();
    } else if (commandToRun === 'test') {
        test();
    }
}

if (state.runLocally || state.ielmUserPath) {
    state.ielmModulePath = state.ielmUserPath || './';
    console.log(`:: iElm module path: ${state.ielmModulePath}.`);
    runCommand(state.commandToRun);
} else {
    modulePath.resolveOne('ielm').then((ielmModulePath) => {
        state.ielmModulePath =
            ielmModulePath.startsWith('/') ? ielmModulePath : `${process.cwd()}/${ielmModulePath}`;
        if (!ielmModulePath) {
            return Promise.reject('iElm module path was not found. Ensure iElm is installed (globally or locally, no matter) or provide custom path with `path=` argument');
        }
        console.log(`:: iElm module path: ${state.ielmModulePath}`);
        runCommand(state.commandToRun);
    }).catch((err) => {
        reportError(err);
    });
}