origin-manifest 0.1.0

The Origin app manifest: what a product is, parsed and validated.
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use crate::{Manifest, SecurityProfile};
use serde::Serialize;
use std::collections::BTreeMap;

/// A Tauri capability file, as generated from the manifest.
#[derive(Debug, Clone, Serialize)]
pub struct Capability {
    #[serde(rename = "$schema")]
    pub schema: String,
    pub identifier: String,
    pub description: String,
    pub windows: Vec<String>,
    pub permissions: Vec<String>,
}

impl Capability {
    /// One capability file per profile, listing the windows that use it.
    ///
    /// Grouped by profile rather than per window: two windows with the same profile
    /// should visibly share one grant, so widening it is one obvious diff instead of
    /// two that can drift apart.
    pub fn from_manifest(manifest: &Manifest) -> Vec<Self> {
        let mut by_profile: BTreeMap<SecurityProfile, Vec<String>> = BTreeMap::new();

        for (window, security) in &manifest.security.windows {
            by_profile
                .entry(security.profile)
                .or_default()
                .push(window.clone());
        }

        by_profile
            .into_iter()
            .map(|(profile, mut windows)| {
                windows.sort();
                Self {
                    schema: "../gen/schemas/desktop-schema.json".to_owned(),
                    identifier: profile.identifier().to_owned(),
                    description: format!(
                        "{} Generated from app.toml — do not edit.",
                        profile.description()
                    ),
                    windows,
                    permissions: profile
                        .permissions()
                        .iter()
                        .map(|permission| (*permission).to_owned())
                        .collect(),
                }
            })
            .collect()
    }

    /// File name this capability is written to.
    pub fn file_name(&self) -> String {
        format!("{}.json", self.identifier)
    }
}

// `SecurityProfile` is used as a map key above, so it needs a total order.
impl PartialOrd for SecurityProfile {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for SecurityProfile {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.identifier().cmp(other.identifier())
    }
}

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

    fn manifest(windows: &str) -> Manifest {
        let contents = format!(
            r#"
[origin]
version = "0.1.0"

[product]
id = "dev.origin.demo"
name = "Demo"
version = "0.1.0"
{windows}
"#
        );
        toml::from_str(&contents).unwrap()
    }

    #[test]
    fn windows_sharing_a_profile_share_one_capability_file() {
        let manifest = manifest(
            "\n[security.windows.main]\nprofile = \"standard-dashboard\"\n\
             \n[security.windows.detail]\nprofile = \"standard-dashboard\"\n",
        );

        let capabilities = Capability::from_manifest(&manifest);

        assert_eq!(capabilities.len(), 1);
        assert_eq!(capabilities[0].windows, vec!["detail", "main"]);
    }

    #[test]
    fn different_profiles_produce_separate_files() {
        let manifest = manifest(
            "\n[security.windows.main]\nprofile = \"standard-dashboard\"\n\
             \n[security.windows.settings]\nprofile = \"account-settings\"\n",
        );

        let capabilities = Capability::from_manifest(&manifest);

        assert_eq!(capabilities.len(), 2);
        assert_eq!(capabilities[0].file_name(), "account-settings.json");
        assert_eq!(capabilities[1].file_name(), "standard-dashboard.json");
    }

    #[test]
    fn the_generated_file_says_it_is_generated() {
        let manifest = manifest("\n[security.windows.main]\nprofile = \"readonly-dashboard\"\n");

        let capability = &Capability::from_manifest(&manifest)[0];

        assert!(
            capability.description.contains("do not edit"),
            "someone opening this file must see where it comes from"
        );
    }
}