whisker-cng 0.6.0

Whisker Continuous Native Generation — declarative Android/iOS project generation from whisker.rs.
Documentation 
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

//! `whisker-gradle-dependencies` — append raw Gradle dependency
//! lines to `app/build.gradle.kts`'s `dependencies { }` block.
//!
//! ## Usage in `whisker.rs`
//!
//! ```ignore
//! app.plugin::<GradleDependencies>(|c| c
//!     .add("implementation(\"com.google.firebase:firebase-analytics:21.5.0\")")
//!     .add("kapt(\"androidx.room:room-compiler:2.6.0\")"));
//! ```
//!
//! Each entry is a raw DSL line. The renderer emits it verbatim
//! inside `dependencies { }`. Letting users pass the full line
//! keeps `implementation` / `api` / `kapt` / `runtimeOnly` / etc.
//! distinctions expressible without modelling Gradle's full
//! configuration grammar.

use serde::{Deserialize, Serialize};
use whisker_plugin::{GenerateContext, Operation, Plugin, PluginConfig, Target};

#[derive(Default, Serialize, Deserialize)]
pub struct GradleDependenciesConfig {
    /// Raw `<configuration>("coordinate")` lines, e.g.
    /// `"implementation(\"com.google.firebase:firebase-analytics:21.5.0\")"`.
    /// Renderer emits each verbatim inside `dependencies { }`.
    #[serde(default)]
    pub entries: Vec<String>,
}

impl GradleDependenciesConfig {
    pub fn add(&mut self, line: impl Into<String>) -> &mut Self {
        self.entries.push(line.into());
        self
    }
}

impl PluginConfig for GradleDependenciesConfig {
    const NAME: &'static str = "whisker-gradle-dependencies";
}

pub struct GradleDependencies;

impl Plugin for GradleDependencies {
    type Config = GradleDependenciesConfig;
    fn apply(
        &self,
        ctx: &mut GenerateContext,
        cfg: &GradleDependenciesConfig,
    ) -> anyhow::Result<()> {
        let Some(android) = ctx.android.as_mut() else {
            return Ok(());
        };
        if cfg.entries.is_empty() {
            return Ok(());
        }
        let count = cfg.entries.len();
        android.gradle.dependencies.extend(cfg.entries.clone());
        ctx.journal.record(
            GradleDependenciesConfig::NAME,
            Target::Android,
            "gradle.dependencies",
            Operation::ArrayPush { count },
        );
        Ok(())
    }
}

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

    fn ctx_with_android() -> GenerateContext {
        GenerateContext {
            android: Some(AndroidProjectIr::default()),
            ..Default::default()
        }
    }

    #[test]
    fn default_config_contributes_nothing() {
        let mut ctx = ctx_with_android();
        GradleDependencies
            .apply(&mut ctx, &GradleDependenciesConfig::default())
            .unwrap();
        assert!(ctx.android.unwrap().gradle.dependencies.is_empty());
        assert!(ctx.journal.records.is_empty());
    }

    #[test]
    fn populated_config_appends_each_entry_preserving_order() {
        let mut cfg = GradleDependenciesConfig::default();
        cfg.add("implementation(\"com.google.firebase:firebase-analytics:21.5.0\")")
            .add("kapt(\"androidx.room:room-compiler:2.6.0\")");
        let mut ctx = ctx_with_android();
        GradleDependencies.apply(&mut ctx, &cfg).unwrap();
        let deps = ctx.android.unwrap().gradle.dependencies;
        assert_eq!(deps.len(), 2);
        assert!(deps[0].starts_with("implementation("));
        assert!(deps[1].starts_with("kapt("));
    }

    #[test]
    fn one_array_push_event_per_invocation() {
        let mut cfg = GradleDependenciesConfig::default();
        cfg.add("implementation(\"a:b:1\")")
            .add("implementation(\"c:d:1\")");
        let mut ctx = ctx_with_android();
        GradleDependencies.apply(&mut ctx, &cfg).unwrap();
        assert_eq!(ctx.journal.records.len(), 1);
        let r = &ctx.journal.records[0];
        assert_eq!(r.plugin, "whisker-gradle-dependencies");
        assert!(matches!(r.operation, Operation::ArrayPush { count: 2 }));
    }
}