Separated mist api

2026-05-29 09:04:58 +02:00
parent b74da3255a
commit 371365b8cf
8 changed files with 19 additions and 24 deletions
@@ -0,0 +1,162 @@
+use <std::fs>;
+use <std::path::Path>;
+use <std::path::PathBuf>;
+use <std::process>;
+use <std::time>;
+use <std::env>;
+
+use <mist_parser::error>;
+
+pub PathBuf build(bool force) {
+    var start = time::Instant::now();
+
+    var root = env::current_dir().expect("Unable to find project root");
+
+    PathBuf src = root.join("src");
+    PathBuf out = root.join(".mist/src");
+
+    build_dir(&root, &src, &src, &out, force);
+
+    var elapsed = start.elapsed();
+    
+    println!(
+        "\x1b[32m\nTranspile successful\x1b[0m in \x1b[34m{:.2?}\x1b[0m",
+        elapsed
+    );
+
+    root
+}
+
+void build_dir(Path* root, Path* base_src, Path* current, Path* out, bool force) {
+    var entries = match (fs::read_dir(current)) {
+        Ok[entries] => entries;
+        Err[e] => {
+            eprintln!(
+                "error: failed to read directory {}\n  {}",
+                current.display(),
+                e
+            );
+
+            process::exit(1);
+        }
+    };
+
+    for (entry : entries) {
+        var entry = match (entry) {
+            Ok[entry] => entry;
+            Err[e] => {
+                eprintln!("error: failed to read directory entry\n  {}", e);
+
+                process::exit(1);
+            }
+        };
+
+        PathBuf path = entry.path();
+
+        if (path.is_dir()) {
+            build_dir(root, base_src, &path, out, force);
+            continue;
+        }
+
+        Path* relative = path.strip_prefix(base_src).expect("Failed to strip base src from path");
+
+        if (path.extension().and_then(|var e| e.to_str()) != Some("mist")) {
+            PathBuf dest = out.join(relative);
+
+            Option<Path*> parent = dest.parent();
+
+            if (parent.is_some()) {
+                fs::create_dir_all(parent.unwrap()).expect("failed to create output directory");
+            }
+
+            if (!force && should_skip(&path, &dest)) {
+                continue
+            }
+
+            fs::copy(&path, dest).expect("Failed to copy non-mist file");
+
+            continue;
+        }
+
+        PathBuf output_file = out.join(relative).with_extension("rs");
+
+        if (!force && should_skip(&path, &output_file)) {
+            continue;
+        }
+
+        Option<Path*> parent = output_file.parent();
+
+        if (parent.is_some()) {
+            fs::create_dir_all(parent.unwrap()).expect("failed to create output directory");
+        }
+
+        String source = match (fs::read_to_string(&path)) {
+            Ok[s] => s;
+            Err[e] => {
+                eprintln!("error: failed to read file {}\n  {}", path.display(), e);
+
+                process::exit(1);
+            }
+        };
+
+        var mut gc = mist_codegen::RustCodegen::new();
+
+        String output = gc.generate(match (mist_parser::parse(&source)) {
+            Ok[ast] => ast;
+            Err[e] => {
+                match (e) {
+                    error::ParseError::Ast[e] => {
+                        var start_pos = e.span.start_pos().line_col();
+
+                        var span = e.span.as_str();
+
+                        eprintln!(
+                            "\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}\n\t{}{}\t{}",
+                            path.as_os_str().display(),
+                            start_pos.0,
+                            start_pos.1,
+                            e.error_message,
+                            span,
+                            if span.ends_with("\n") { "" } else { "\n" },
+                            "^".repeat(span.trim().len()),
+                        );
+
+                        process::exit(1);
+                    }
+
+                    error::ParseError::PreAst[e] => {
+                        eprintln!("error: parse failed in {}\n{}", path.display(), e);
+
+                        process::exit(1);
+                    }
+                }
+            }
+        });
+
+        var res = fs::write(&output_file, output);
+
+        if (res.is_err()) {
+            eprintln!(
+                "error: failed to write output {}\n  {}",
+                output_file.display(),
+                res.unwrap_err(),
+            );
+
+            process::exit(1);
+        }
+    }
+}
+
+bool should_skip(Path* source, Path* output) {
+    var src_time = fs::metadata(source)
+        .ok()
+        .and_then(|var v| v.modified().ok());
+
+    var out_time = fs::metadata(output)
+        .ok()
+        .and_then(|var v| v.modified().ok());
+
+    out_time
+        .map(|var out_time| out_time >= src_time.unwrap())
+        .unwrap_or_default()
+}