nativ 0.2.0

Nativ CLI — compile .nativ DSL to real SwiftUI and Jetpack Compose
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use clap::Args;
use nativ_config::NativConfig;
use nativ_pipeline::{self, Target};
use std::path::Path;
use std::time::Instant;

#[derive(Args)]
pub struct BuildArgs {
    /// Build only for iOS
    #[arg(long)]
    pub ios: bool,

    /// Build only for Android
    #[arg(long)]
    pub android: bool,

    /// Project directory (default: current directory)
    #[arg(short, long, default_value = ".")]
    pub dir: String,
}

pub fn run(args: BuildArgs, verbose: bool, quiet: bool) -> Result<(), Box<dyn std::error::Error>> {
    let project_dir = Path::new(&args.dir);
    let config_path = project_dir.join("nativ.toml");

    let config = NativConfig::load(&config_path)?;

    let targets = nativ_pipeline::resolve_targets(args.ios, args.android, &config);

    if targets.is_empty() {
        return Err("No target platform specified. Enable ios or android in nativ.toml".into());
    }

    if !quiet {
        let target_names: Vec<&str> = targets
            .iter()
            .map(|t| match t {
                Target::Ios => "iOS",
                Target::Android => "Android",
            })
            .collect();
        println!(
            "Compiling: {} -> {}",
            config.app.name,
            target_names.join(", ")
        );
    }

    let start = Instant::now();

    let results = nativ_pipeline::build(project_dir, &config, &targets)?;

    let elapsed = start.elapsed();

    if !quiet {
        for result in &results {
            let platform = match result.target {
                Target::Ios => "iOS",
                Target::Android => "Android",
            };
            println!(
                "  {platform}: {} files generated",
                result.generated_files.len()
            );

            if verbose {
                for file in &result.generated_files {
                    println!("    -> {}", file.display());
                }
            }
        }

        let total: usize = results.iter().map(|r| r.generated_files.len()).sum();
        println!(
            "Build complete: {total} files, {:.2}s",
            elapsed.as_secs_f64()
        );
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    fn args_for(dir: &Path, ios: bool, android: bool) -> BuildArgs {
        BuildArgs {
            ios,
            android,
            dir: dir.display().to_string(),
        }
    }

    #[test]
    fn fails_when_config_is_missing() {
        let tmp = tempfile::tempdir().unwrap();

        let err = run(args_for(tmp.path(), true, false), false, true).unwrap_err();
        assert!(err.to_string().contains("nativ.toml"), "{err}");
    }

    #[test]
    fn fails_when_no_target_platform_enabled() {
        let tmp = tempfile::tempdir().unwrap();
        std::fs::write(
            tmp.path().join("nativ.toml"),
            "[app]\nname = \"t\"\n\n[build]\nios = false\nandroid = false\n",
        )
        .unwrap();

        let err = run(args_for(tmp.path(), false, false), false, true).unwrap_err();
        assert!(err.to_string().contains("No target platform"), "{err}");
    }

    #[test]
    fn fails_when_src_dir_is_missing() {
        let tmp = tempfile::tempdir().unwrap();
        std::fs::write(tmp.path().join("nativ.toml"), "[app]\nname = \"t\"\n").unwrap();

        let err = run(args_for(tmp.path(), true, false), false, true).unwrap_err();
        assert!(err.to_string().contains("not found"), "{err}");
    }
}