installer task, built-in module, runner arguments enum, dce FULL for runner and alias

Author: ilya-ku

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 - Resolve tasks according to module dependencies
 - Drop Haxe 3.2.X support, switch CI to Haxe 3.4.X
+- Installer code moved to built-in task and will be run in make context
+- Built-in Module allows to run default tasks without modules context
 
 # v0.1.7
 

build.hxml

@@ -1,6 +1,6 @@
 -cp tool
 -cp src
-#-debug
+-dce full
 --each
 
 -main hxmake.tool.RunScript

run.n

@@ -0,0 +1,21 @@
+package hxmake.core;
+
+import hxmake.tasks.InstallTask;
+import hxmake.tasks.ListModules;
+import hxmake.tasks.ListTask;
+
+/**
+	Built in module is module for default tasks,
+	it's required to run default tasks in any folder,
+	even where make modules are not defined
+**/
+@:root
+class BuiltInModule extends Module {
+	function new() {
+		// TODO: better naming
+		name = "__internal";
+		task("tasks", new ListTask());
+		task("modules", new ListModules());
+		task("_", new InstallTask());
+	}
+}

src/hxmake/core/BuiltInModule.hx

@@ -0,0 +1,21 @@
+package hxmake.core;
+
+@:enum abstract MakeArgument(String) to String from String {
+	// Enables `debug` and `trace` log levels
+	var VERBOSE = "--verbose";
+
+	// Mute logger output
+	var SILENT = "--silent";
+
+	// Enables compile-time logging from `CompileTime.log`
+	var MAKE_COMPILER_LOG = "--make-compiler-log";
+
+	// Run make in haxe compiler-mode `--interp` (EXPEREMENTAL)
+	var MAKE_COMPILER_MODE = "--make-compiler-mode";
+
+	// Show Haxe compiler time statistics, adds `--times -D macro-times`
+	var MAKE_COMPILER_TIME = "--make-compiler-time";
+
+	// Rebuild `hxmake` binary and re-install alias-script
+	var TASK_REBUILD = "_";
+}

src/hxmake/core/MakeArgument.hx

@@ -33,10 +33,5 @@ class ModuleGraph {
 		if (module.name != "hxmake" && module.config.devDependencies.get("hxmake") == null) {
 			module.config.devDependencies.set("hxmake", "haxelib;global");
 		}
-
-		if (module.isMain) {
-			module.task("tasks", new hxmake.tasks.ListTask());
-			module.task("modules", new hxmake.tasks.ListModules());
-		}
 	}
 }

src/hxmake/core/ModuleGraph.hx

@@ -16,7 +16,7 @@ class CompileTime {
 	}
 
 	public static function log(message:String) {
-		#if hxmake_macrolog
+		#if hxmake_compiler_log
 		Sys.println('[MACRO] $message');
 		#end
 	}

src/hxmake/macr/CompileTime.hx

@@ -12,7 +12,7 @@ class InitMacro {
 	public static function generateMainClass(initialMakeDir:String, isCompiler:Bool, args:Array<String>) {
 		PluginInclude.scan(initialMakeDir);
 		CompileTime.addMakePath(initialMakeDir);
-
+		Context.getType("hxmake.core.BuiltInModule");
 		var pos = Context.currentPos();
 		var fields:Array<Field> = Context.getBuildFields();
 		var mainFun:Function = {

src/hxmake/macr/InitMacro.hx

@@ -1,67 +1,76 @@
-package hxmake.tool;
+package hxmake.tasks;
 
 import haxe.io.Path;
 import hxmake.cli.CL;
-import hxmake.cli.MakeLog;
+import hxmake.cli.logging.Logger;
 import hxmake.utils.Haxe;
 import hxmake.utils.Haxelib;
 import sys.FileSystem;
 import sys.io.File;
 
-using StringTools;
-
 @:final
-class Installer {
+class InstallTask extends Task {
+
+	public function new() {
+		name = "_";
+		description = "Rebuild and install `hxmake` binary";
+	}
 
-	public static function run(library:String, ?alias:String):Bool {
+	override public function run() {
+		if (!install(project.logger, "hxmake")) {
+			project.logger.error("hxmake installation FAILED");
+			throw "stop execution";
+		}
+	}
 
+	static function install(logger:Logger, library:String, ?alias:String):Bool {
 		if (alias == null) {
 			alias = library;
 		}
 
 		var libPath = Haxelib.libPath(library);
 		if (libPath == null) {
-			MakeLog.error('"$library" is not installed');
+			logger.error('"$library" is not installed');
 			return false;
 		}
 
 		if (!FileSystem.exists(libPath)) {
-			MakeLog.error('"$library" not found at $libPath');
+			logger.error('"$library" not found at $libPath');
 			return false;
 		}
 
-		MakeLog.trace('Use "$library" from "$libPath"');
+		logger.trace('Use "$library" from "$libPath"');
 
 		return CL.workingDir.with(libPath, function() {
 
 			// COMPILATION
 			if (!Haxe.exec(["build.hxml"])) {
-				MakeLog.error("HxMake library build failed");
+				logger.error("HxMake library build failed");
 				return false;
 			}
 
 			if (CL.platform.isWindows && FileSystem.exists('$alias.exe')) {
-				MakeLog.info('Alias should be installed already');
-				MakeLog.info('If you need to reinstall alias script use:');
-				MakeLog.info('> haxelib run $library _');
+				logger.info('Alias should be installed already');
+				logger.info('If you need to reinstall alias script use:');
+				logger.info('> haxelib run $library _');
 				return true;
 			}
 
 			if (CL.command('nekotools', ['boot', '$library.n']) != 0) {
-				MakeLog.error('Failed to create alias-script executable');
+				logger.error('Failed to create alias-script executable');
 				return false;
 			}
 
 			// INSTALL
-			MakeLog.info('We`re going to install ${alias.toUpperCase()} command');
-			MakeLog.info('Please enter password if required...');
+			logger.info('We`re going to install ${alias.toUpperCase()} command');
+			logger.warning('Please enter password if required...');
 			try {
 				if (CL.platform.isWindows) {
 					var haxePath = Haxe.path();
 					var pn = '$alias.exe';
 					var src = Path.join([libPath, pn]);
 					var dst = Path.join([haxePath, pn]);
-					MakeLog.trace('Copy hxmake.exe to $haxePath');
+					logger.trace('Copy hxmake.exe to $haxePath');
 					File.copy(src, dst);
 
 					// TODO: windows replace .exe issue
@@ -77,8 +86,8 @@ class Installer {
 				}
 			}
 			catch (e:Dynamic) {
-				MakeLog.error(e);
-				MakeLog.error("Error while installing system command-line");
+				logger.error(e);
+				logger.error("Error while installing system command-line");
 				return false;
 			}
 

tool/hxmake/tool/Installer.hx src/hxmake/tasks/InstallTask.hx

@@ -5,15 +5,15 @@ import haxe.macro.Compiler;
 import hxmake.cli.CL;
 import hxmake.cli.MakeLog;
 import hxmake.core.Arguments;
+import hxmake.core.MakeArgument;
 import hxmake.utils.Haxelib;
 
 class AliasScript {
 	public static function main() {
 		var args = new Arguments(Sys.args());
-		var logger = MakeLog.logger;
-		logger.setupFilter(
-			args.hasProperty("--silent"),
-			args.hasProperty("--verbose")
+		MakeLog.logger.setupFilter(
+			args.hasProperty(MakeArgument.SILENT),
+			args.hasProperty(MakeArgument.VERBOSE)
 		);
 		var library = Compiler.getDefine("library");
 		var toolPath = Haxelib.libPath(library, true);

tool/hxmake/tool/AliasScript.hx

@@ -1,27 +1,31 @@
 package hxmake.tool;
 
+import haxe.io.Path;
 import haxe.Timer;
+import hxmake.cli.CL;
 import hxmake.cli.MakeLog;
 import hxmake.core.Arguments;
+import hxmake.core.MakeArgument;
+import hxmake.utils.Haxe;
+import hxmake.utils.Haxelib;
+import hxmake.utils.HaxeTarget;
+import hxmake.utils.Hxml;
 
 class RunScript {
 
+	static inline var INIT_MACRO_METHOD:String = "hxmake.macr.InitMacro.generateMainClass";
+
 	public static function main() {
 		var args = new Arguments(popRunCwd(Sys.args()));
 		var logger = MakeLog.logger;
 
 		logger.setupFilter(
-			args.hasProperty("--silent"),
-			args.hasProperty("--verbose")
-		);
-
-		var success = measure(
-			function() { return args.hasTask("_") ? Installer.run("hxmake") : MakeRunner.make(Sys.getCwd(), args.args); },
-			args.hasProperty("--times") ? function(totalTime:Float) { logger.info('Total time: $totalTime sec.'); } : null
+			args.hasProperty(MakeArgument.SILENT),
+			args.hasProperty(MakeArgument.VERBOSE)
 		);
 
-		if (!success) {
-			logger.error("hxmake FAILED");
+		if (!make(Sys.getCwd(), args)) {
+			logger.error("Make compilation FAILED");
 			Sys.exit(-1);
 		}
 	}
@@ -45,4 +49,49 @@ class RunScript {
 		}
 		return result;
 	}
+
+	// TODO: path exists (cwd, make, lib)
+	static function make(path:String, arguments:Arguments):Bool {
+
+		Sys.setCwd(path);
+
+		var makePath = Path.join([path, "make"]);
+		var libPath = Haxelib.classPath("hxmake", true);
+		var isCompiler = arguments.hasProperty(MakeArgument.MAKE_COMPILER_MODE);
+
+		var hxml = new Hxml();
+		hxml.main = "HxMakeMain";
+		hxml.libraries = [];
+		hxml.classPath.push(libPath);
+		hxml.defines.push("hxmake");
+		if (arguments.hasProperty(MakeArgument.MAKE_COMPILER_LOG)) {
+			hxml.defines.push("hxmake_compiler_log");
+		}
+
+		if (isCompiler) {
+			// TODO: EVAL instead of --interp
+			hxml.target = HaxeTarget.Interp;
+		}
+		else {
+			// TODO: try Node.js instead of Neko?
+			hxml.target = HaxeTarget.Neko;
+			hxml.output = "make.n";
+		}
+
+		hxml.macros.push('$INIT_MACRO_METHOD("$makePath",$isCompiler,[${toLiteralsArrayString(arguments.args)}])');
+
+		hxml.showMacroTimes =
+		hxml.showTimes = arguments.hasProperty(MakeArgument.MAKE_COMPILER_TIME);
+
+		var result = Haxe.compile(hxml);
+		if (!result || isCompiler) {
+			return result;
+		}
+
+		return CL.command("neko", ["make.n"]) == 0;
+	}
+
+	static function toLiteralsArrayString(values:Array<String>):String {
+		return values != null ? values.map(function(v:String) return '"$v"').join(",") : "";
+	}
 }