gulp-haxetool/haxetool/project.js

const gulp = require('gulp');
//const concat = require('gulp-concat');
//const uglify = require('gulp-uglify');
//const babel = require('gulp-babel');
//const template = require('gulp-template');
const Haxe = require('./haxe');
const FlashPlayer = require('./flashplayer');
const Neko = require('./neko');
const Debug = require('./debug');
const webserver = require('gulp-webserver');
const run = require('gulp-run');
const tail = require('./tail');
//const deb = require('gulp-debian');
const {BuildSystem, Platform, Config} = require('./core');
const vfs = require('vinyl-fs');


/**
 *
 */
class Builder {

    constructor(buildSystem) {
        this.buildSystem = buildSystem;
        this.target = 'target';
    }

    prepare() {
        return Promise.resolve();
    }

    call(debug) {
        throw 'Not Implemented';
    }

    static register(buildSystem, builder) {
        Builder.factory[buildSystem] = builder;
    }

    static new(buildSystem, config) {
        return new Builder.factory[buildSystem](buildSystem, config);
    }
}

Builder.factory = {};

/**
 *
 */
class HaxeBuilder extends Builder {

    constructor(buildSystem) {
        super(buildSystem);
        this.haxe = new Haxe();
    }

    prepare() {
        return this.haxe.prepare();
    }

    call(platform, config, debug) {
        switch (this.buildSystem) {
            case BuildSystem.OPENFL:
                return this.haxe.openfl('build', platform, config, debug)
                    .then(result => result.pipe(vfs.dest(`${this.target}/${platform}`)));
        }
    }
}

Builder.register(BuildSystem.HAXE, HaxeBuilder);
Builder.register(BuildSystem.OPENFL, HaxeBuilder);

/**
 *
 */
class Runner {

    constructor(platform, name) {
        this.platform = platform;
        this.name = name;
        this.target = 'target';
    }

    prepare() {
        return Promise.resolve();
    }

    call(debug) {
        throw 'Not Implemented';
    }

    static register(platform, builder) {
        Runner.factory[platform] = builder;
    }

    static new(platform, name) {
        return new Runner.factory[platform](platform, name);
    }
}

Runner.factory = {};

/**
 *
 */
class FlashRunner extends Runner {

    constructor(platform, name) {
        super(platform, name);
        this.player = new FlashPlayer();
    }

    prepare() {
        return this.player.prepare();
    }

    call(debug) {
        return gulp.src(`${this.target}/${this.platform}/${this.name}.swf`)
            .pipe(this.player.run(true))
            .pipe(debug.run());
    }
}

Runner.register(Platform.FLASH, FlashRunner);

/**
 *
 */
class Html5Runner extends Runner {

    call(debug) {
        return gulp.src(`${this.target}/${this.platform}`)
            .pipe(webserver({
                host: 'localhost', port: 3000,
                open: true,
                fallback: 'index.html'
            }));
    }
}

Runner.register(Platform.HTML5, Html5Runner);

/**
 *
 */
class LinuxRunner extends Runner {

    call(debug) {
        return gulp.src(`${this.target}/${this.platform}/${this.name}`)
            .pipe(run(`./${this.name}`, {cwd: `target/${this.platform}`, verbosity: 1}))
            .pipe(tail(Debug.log));
    }
}

Runner.register(Platform.LINUX, LinuxRunner);

/**
 *
 */
class NekoRunner extends Runner {

    call(debug) {
        return gulp.src(`${this.target}/${this.platform}/${this.name}.n`)
            .pipe(new Neko().run())
            .pipe(debug.run());
    }
}

Runner.register(Platform.NEKO, NekoRunner);


/**
 *
 */
class Project {

    constructor(buildSystem, platforms, config) {
        this.buildSystem = buildSystem;
        this.platforms = platforms;
        this.config = config;
    }

    build(platform) {
        const builder = Builder.new(this.buildSystem);
        return [
            () => builder.prepare(),
            () => builder.call(platform, this.config)
        ];
    }

    run(platform) {
        const builder = Builder.new(this.buildSystem);
        const runner = Runner.new(platform, this.config.name);
        const debug = new Debug();
        return [
            () => builder.prepare(),
            () => builder.call(platform, this.config, debug),
            () => runner.prepare(),
            () => runner.call(debug)
        ];
    }

    bind(module, gulp /* ToDo: spike */) {
        for (const platform of this.platforms) {
            module.exports[`${this.config.name}:${platform}:build`] = gulp.series(this.build(platform));
            module.exports[`${this.config.name}:${platform}:run`] = gulp.series(this.run(platform));
        }
        return this;
    }
}

Project.BuildSystem = BuildSystem;
Project.Platform = Platform;
Project.Config = Config;
Project.Builder = Builder;
Project.Runner = Runner;


module.exports = Project;