labt 0.1.0

Lab-t Lightweight Android build tool
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

use std::{
    fmt::Display,
    io::{Read, Write},
};

use anyhow::Context;
use toml_edit::{value, Document};

use crate::{
    config::lock::strings::{ARTIFACT_ID, DEPENDENCIES, GROUP_ID, PACKAGING, URL, VERSION},
    submodules::resolve::ProjectDep,
};

use super::Cache;

#[derive(Debug)]
pub enum PropertiesError {
    ParseError,
    IOError(String),
    LabtHomeError,
}

impl Display for PropertiesError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::LabtHomeError => {
                writeln!(
                    f,
                    "Labt home not initialized therefore missing cache folder"
                )
            }
            Self::ParseError => writeln!(f, "Failed to parse properties toml file"),
            Self::IOError(msg) => writeln!(f, "{}", msg),
        }
    }
}

pub fn write_properties(project: &ProjectDep) -> anyhow::Result<()> {
    let mut cache = Cache::new(
        project.group_id.clone(),
        project.artifact_id.clone(),
        project.version.clone(),
        super::CacheType::PROPERTIES,
    );
    cache
        .use_labt_home()
        .with_context(|| PropertiesError::LabtHomeError)?;
    // create .toml properties file
    let mut cache = cache.create().with_context(|| {
        PropertiesError::IOError("Failed to create properties toml file".to_string())
    })?;

    let mut table = toml_edit::table();
    table[GROUP_ID] = value(&project.group_id);
    table[ARTIFACT_ID] = value(&project.artifact_id);
    table[VERSION] = value(&project.version);
    table[URL] = value(&project.base_url);
    table[PACKAGING] = value(&project.packaging);

    let mut deps_array = toml_edit::Array::new();
    deps_array.extend(project.dependencies.iter());
    table[DEPENDENCIES] = value(deps_array);

    cache
        .write_all(table.to_string().as_bytes())
        .context(PropertiesError::IOError(
            "Failed to write properties file".to_string(),
        ))?;

    Ok(())
}

pub fn read_properties(project: &mut ProjectDep) -> anyhow::Result<()> {
    let mut cache = Cache::new(
        project.group_id.clone(),
        project.artifact_id.clone(),
        project.version.clone(),
        super::CacheType::PROPERTIES,
    );
    cache
        .use_labt_home()
        .context(PropertiesError::LabtHomeError)?;
    // create .toml properties file
    let mut cache = cache.open()?;
    let mut toml = String::new();
    cache
        .read_to_string(&mut toml)
        .context(PropertiesError::IOError(
            "Failed to read cache properties file".to_string(),
        ))?;

    let toml = toml
        .parse::<Document>()
        .context(PropertiesError::ParseError)?;

    if let Some(url) = toml.get(URL) {
        project.base_url = url
            .as_value()
            .unwrap_or(&toml_edit::Value::from(""))
            .as_str()
            .unwrap_or("")
            .to_string();
    }

    if let Some(url) = toml.get(PACKAGING) {
        project.packaging = url
            .as_value()
            .unwrap_or(&toml_edit::Value::from("jar"))
            .as_str()
            .unwrap_or("jar")
            .to_string();
    }

    if let Some(dependencies) = toml.get(DEPENDENCIES) {
        if let Some(array) = dependencies.as_array() {
            let mut deps = Vec::new();
            deps.extend(array.iter().map(|d| d.as_str().unwrap_or("").to_string()));
            project.dependencies = deps;
        }
    }

    Ok(())
}