working on cli, but not hls

Author: BrettMayson

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "hemtt"
 description = "HEMTT - Arma 3 Build Tool"
-version = "1.18.1"
+version = "1.19.0"
 edition = "2024"
 license = "GPL-2.0"
 authors = ["Brett Mayson <brett@mayson.io>"]

bin/Cargo.toml

@@ -24,6 +24,7 @@ pub mod photoshoot;
 pub fn global_modules(executor: &mut crate::executor::Executor) {
     executor.add_module(Box::<crate::modules::bom::BOMCheck>::default());
     executor.add_module(Box::<crate::modules::fnl::FineNewLineCheck>::default());
+    executor.add_module(Box::<crate::modules::preprocess::PreProcess>::default());
     executor.add_module(Box::<crate::modules::Hooks>::default());
     executor.add_module(Box::<crate::modules::Stringtables>::default());
     executor.add_module(Box::<crate::modules::SQFCompiler>::default());

bin/src/commands/mod.rs

@@ -286,7 +286,7 @@ impl Context {
                 .version()
                 .get(self.workspace_path().vfs())
                 .expect("version config is valid to get to rhai module"),
-            // addons: self.addons().to_vec(),
+            addons: self.addons().to_vec(),
         }
     }
 }

bin/src/context.rs

@@ -39,6 +39,10 @@ pub enum Error {
 
     #[error("Preprocessor not found: {0}")]
     PreprocessorNotFound(String),
+    #[error("Preprocessor did not return a string: {0}")]
+    PreprocessorDidNotReturnString(String),
+    #[error("Preprocessor error in '{0}': {1}")]
+    PreprocessorError(String, String),
 
     #[error("Dialoguer Error: {0}")]
     Dialoguer(#[from] dialoguer::Error),

bin/src/error.rs

@@ -16,7 +16,7 @@ pub struct RuntimeError {
 
 impl Code for RuntimeError {
     fn ident(&self) -> &'static str {
-        "BHE3"
+        "BHE4"
     }
 
     fn message(&self) -> String {

bin/src/modules/hook/error/bhe4_runtime_error.rs

@@ -0,0 +1,54 @@
+use std::sync::Arc;
+
+use hemtt_workspace::{
+    WorkspacePath,
+    reporting::{Code, Diagnostic, Label},
+};
+use rhai::Position;
+
+use super::get_offset;
+
+pub struct RuntimeFatal {
+    script: WorkspacePath,
+    error: String,
+    location: Position,
+}
+
+impl Code for RuntimeFatal {
+    fn ident(&self) -> &'static str {
+        "BHE5"
+    }
+
+    fn message(&self) -> String {
+        format!("Script {} intentionally failed at runtime", self.script)
+    }
+
+    fn diagnostic(&self) -> Option<Diagnostic> {
+        let content = self.script.read_to_string().ok()?;
+        Some(
+            Diagnostic::from_code(self).with_label(
+                Label::primary(
+                    self.script.clone(),
+                    get_offset(&content, self.location)..get_offset(&content, self.location),
+                )
+                .with_message({
+                    let mut chars = self.error.chars();
+                    chars.next().map_or_else(
+                        || self.error.clone(),
+                        |first| first.to_lowercase().collect::<String>() + chars.as_str(),
+                    )
+                }),
+            ),
+        )
+    }
+}
+
+impl RuntimeFatal {
+    pub fn code(script: WorkspacePath, error: String, location: Position) -> Arc<dyn Code> {
+        Arc::new(Self {
+            script,
+            error,
+            location,
+        })
+    }
+}

bin/src/modules/hook/error/bhe5_runtime_fatal.rs

@@ -5,6 +5,7 @@ use rhai::Position;
 pub mod bhe1_script_not_found;
 pub mod bhe3_parse_error;
 pub mod bhe4_runtime_error;
+pub mod bhe5_runtime_fatal;
 
 fn get_offset(content: &str, location: Position) -> usize {
     let mut offset = 0;

bin/src/modules/hook/error/mod.rs

@@ -1,11 +1,14 @@
 use ::rhai::{Engine, Scope, packages::Package};
-use hemtt_rhai::libraries::{RfsPackage, VfsPackage};
+use hemtt_rhai::libraries::VfsPackage;
 use hemtt_workspace::WorkspacePath;
-use rhai::{Dynamic, EvalAltResult};
+use rhai::Dynamic;
 use whoami::Result;
 
 use crate::{
-    context::Context, error::Error, modules::hook::libraries::hemtt::RhaiHemtt, report::Report,
+    context::Context,
+    error::Error,
+    modules::hook::{error::bhe5_runtime_fatal::RuntimeFatal, libraries::hemtt::RhaiHemtt},
+    report::Report,
 };
 
 use self::error::{
@@ -25,34 +28,34 @@ mod libraries;
 ///
 /// # Panics
 /// If the build folder does not exist
-pub fn scope(ctx: &'_ Context, vfs: bool) -> Result<Scope<'_>, Error> {
+pub fn scope(ctx: &'_ Context, hemtt: bool, vfs: bool) -> Result<Scope<'_>, Error> {
     let mut scope = Scope::new();
     if vfs {
         scope.push_constant("HEMTT_VFS", ctx.workspace_path().vfs().clone());
     }
-    scope.push_constant("HEMTT_DIRECTORY", ctx.project_folder().clone());
-    scope.push_constant(
-        "HEMTT_OUTPUT",
-        ctx.build_folder().expect("build folder exists").clone(),
-    );
     scope.push_constant("HEMTT_RFS", ctx.project_folder().clone());
-    scope.push_constant(
-        "HEMTT_OUT",
-        ctx.build_folder().expect("build folder exists").clone(),
-    );
 
-    scope.push_constant("HEMTT", RhaiHemtt::new(ctx));
+    if hemtt {
+        scope.push_constant(
+            "HEMTT_OUTPUT",
+            ctx.build_folder().expect("build folder exists").clone(),
+        );
+        scope.push_constant(
+            "HEMTT_OUT",
+            ctx.build_folder().expect("build folder exists").clone(),
+        );
+        scope.push_constant("HEMTT", RhaiHemtt::new(ctx));
+    }
 
     Ok(scope)
 }
 
-fn engine(vfs: bool) -> Engine {
-    let mut engine = hemtt_rhai::engine();
+fn engine(name: String, vfs: bool) -> Engine {
+    let mut engine = hemtt_rhai::engine(name);
     if vfs {
         let virt = VfsPackage::new();
         engine.register_static_module("hemtt_vfs", virt.as_shared_module());
     }
-    engine.register_static_module("hemtt_rfs", RfsPackage::new().as_shared_module());
     engine.register_static_module("hemtt", libraries::HEMTTPackage::new().as_shared_module());
     engine
 }
@@ -102,6 +105,9 @@ impl Hooks {
             );
             report.merge(Self::run(ctx, file, vfs)?.0);
             ctx.config().version().invalidate();
+            if report.failed() {
+                break;
+            }
         }
         Ok(report)
     }
@@ -132,45 +138,24 @@ impl Hooks {
     #[allow(clippy::needless_pass_by_value)] // rhai things
     fn run(ctx: &Context, path: WorkspacePath, vfs: bool) -> Result<(Report, Dynamic), Error> {
         let mut report = Report::new();
-        let mut engine = engine(vfs);
-        let mut scope = scope(ctx, vfs)?;
         let parts = path.as_str().split('/');
         let name = parts
             .clone()
             .skip(parts.count().saturating_sub(2))
             .collect::<Vec<_>>()
             .join("/");
-        let inner_name = name.clone();
-        engine.on_debug(move |x, _src, _pos| {
-            debug!("[{inner_name}] {x}");
-        });
-        let inner_name = name.clone();
-        engine.on_print(move |s| {
-            info!("[{inner_name}] {s}");
-        });
-        let inner_name = name.clone();
-        engine.register_fn("info", move |s: &str| {
-            info!("[{inner_name}] {s}");
-        });
-        let inner_name = name.clone();
-        engine.register_fn("warn", move |s: &str| {
-            warn!("[{inner_name}] {s}");
-        });
-        let inner_name = name.clone();
-        engine.register_fn("error", move |s: &str| {
-            error!("[{inner_name}] {s}");
-        });
-        let inner_name = name;
-        engine.register_fn("fatal", move |s: &str| -> Result<(), Box<EvalAltResult>> {
-            error!("[{inner_name}] {s}");
-            Err(Box::new(EvalAltResult::ErrorRuntime(
-                "Script called fatal".into(),
-                rhai::Position::NONE,
-            )))
-        });
+        let engine = engine(name, vfs);
+        let mut scope = scope(ctx, true, vfs)?;
         match engine.eval_with_scope(&mut scope, &path.read_to_string()?) {
             Err(e) => {
-                report.push(RuntimeError::code(path, &e));
+                match *e {
+                    rhai::EvalAltResult::ErrorTerminated(message, pos) => {
+                        report.push(RuntimeFatal::code(path, message.to_string(), pos));
+                    }
+                    _ => {
+                        report.push(RuntimeError::code(path, &e));
+                    }
+                }
                 Ok((report, Dynamic::UNIT))
             }
             Ok(ret) => Ok((report, ret)),
@@ -188,7 +173,7 @@ impl Module for Hooks {
         self.0 = ctx.hemtt_folder().join("hooks").exists();
         if self.0 {
             for phase in &["pre_build", "post_build", "pre_release", "post_release"] {
-                let engine = engine(phase != &"post_release");
+                let engine = engine(String::from(*phase), phase != &"post_release");
                 let dir = ctx.hemtt_folder().join("hooks").join(phase);
                 if !dir.exists() {
                     continue;