build_app

#!/usr/bin/env python3
"""
Build Script for Julius

This script builds Julius and dependencies, then packages.
"""
# Copyright 2018 Christopher Antila

from datetime import datetime
import pathlib
import shutil
import subprocess

APP_NAME = 'nCoda'
APP_VERSION = datetime.utcnow().strftime('%y%m-%d.%H%M')
EXECUTABLE_NAME = 'julius'
OUTPUT_DIRECTORY = 'build'


# list of the JS files to compile with Browserify; it's input filename, then output filename
_COMPILE_WITH_BROWSERIFY = [
    ('js/ncoda-init.js', 'js/ncoda-compiled.js'),
]

# list of the CSS files that must be compiled from LESS; it's the shell path we should ask Watchman
# to watch, then the input and output filenames for lessc.
_COMPILE_WITH_LESSC = [
    ('css/ncoda/main.less', 'css/ncoda/main.css'),
]

_PATH_TO_BROWSERIFY = 'node_modules/.bin/browserify'
_PATH_TO_LESSC = 'node_modules/.bin/lessc'
_PATH_TO_PACKAGER_1 = '/usr/bin/electron-packager'
_PATH_TO_PACKAGER_2 = 'node_modules/.bin/electron-packager'


def the_script():
    """
    Do the build.
    """
    # see if we can find/use Browserify
    watchify = pathlib.Path(_PATH_TO_BROWSERIFY)
    if not watchify.exists():
        print('Could not find Browserify. Is it installed?')
        raise SystemExit(1)

    # see if we can find/use lessc
    lessc = pathlib.Path(_PATH_TO_LESSC)
    if not lessc.exists():
        print('Could not find lessc. Is it installed?')
        raise SystemExit(1)

    # see if we can find/use electron-packager
    packager = pathlib.Path(_PATH_TO_PACKAGER_1)
    if not packager.exists():
        packager = pathlib.Path(_PATH_TO_PACKAGER_2)
        if not packager.exists():
            print('Could not find "electron-packager" so we will not run it.')

    # make sure we delete the previously-generated files
    for _, js_asset_path in _COMPILE_WITH_BROWSERIFY:
        js_asset = pathlib.Path(js_asset_path)
        if js_asset.exists():
            js_asset.unlink()
    for _, css_asset_path in _COMPILE_WITH_LESSC:
        css_asset = pathlib.Path(css_asset_path)
        if css_asset.exists():
            css_asset.unlink()

    # hold the Popen instances
    subprocesses = []

    try:
        # compile JS
        for each_file in _COMPILE_WITH_BROWSERIFY:
            try:
                kummand = [
                    _PATH_TO_BROWSERIFY,
                    each_file[0],
                    '-o',
                    each_file[1],
                    '--ignore-missing',
                ]
                subprocesses.append(subprocess.Popen(kummand))
            except subprocess.CalledProcessError as cperr:
                print(
                    'Encountered the following error while starting Browserify:\n%s' % cperr
                )
                raise SystemExit(1)

        # compile CSS
        for each_file in _COMPILE_WITH_LESSC:
            try:
                kummand = [
                    _PATH_TO_LESSC,
                    '--clean-css',
                    '--source-map',
                    each_file[0],
                    each_file[1],
                ]
                subprocesses.append(subprocess.Popen(kummand))
            except subprocess.CalledProcessError as cperr:
                print(
                    'Encountered the following error while starting lessc:\n%s' % cperr
                )
                raise SystemExit(1)

    finally:
        print('Waiting for {} build subprocesses.'.format(len(subprocesses)))
        for proc in subprocesses:
            proc.wait(60)
            if proc.returncode:
                raise SystemExit(1)

    if packager.exists():
        build_dir = pathlib.Path(OUTPUT_DIRECTORY)
        if build_dir.exists():
            shutil.rmtree(OUTPUT_DIRECTORY)

        result = subprocess.call(
            [
                str(packager),
                '.',
                APP_NAME,
                '--app-version', APP_VERSION,
                '--executable-name', EXECUTABLE_NAME,
                '--out', OUTPUT_DIRECTORY,
            ]
        )
        if result:
            raise SystemExit(result)


if __name__ == '__main__':
    the_script()
else:
    print('This script is only intended to be run from a commandline.')