cup-cli 0.1.6

A Cargo-like tool for C++ Project Building and Package Management
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

use std::path::{Path, PathBuf};

use crate::config::{Expand, Shelling};

#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
pub struct TableConfig {
    pub defines: Option<Vec<String>>,
    pub includes: Option<Vec<String>>,
    pub sources: Option<Vec<String>>,
    pub link_paths: Option<Vec<String>>,
    pub link_libraires: Option<Vec<String>>,
    pub link_options: Option<Vec<String>>,
    pub compile_options: Option<Vec<String>>,
    pub compile_features: Option<Vec<String>>,
}

impl<P: AsRef<Path>> Shelling<anyhow::Result<Table>, P> for TableConfig {
    fn shelling(self, base: P) -> anyhow::Result<Table> {
        Ok(Table {
            defines: self.defines.unwrap_or_default(),
            includes: self.includes.unwrap_or_default().expand(&base)?,
            sources: self.sources.unwrap_or_default().expand(&base)?,
            link_paths: self.link_paths.unwrap_or_default().expand(&base)?,
            link_libraires: self.link_libraires.unwrap_or_default(),
            link_options: self.link_options.unwrap_or_default(),
            compile_options: self.compile_options.unwrap_or_default(),
            compile_features: self.compile_features.unwrap_or_default(),
        })
    }
}

#[derive(Debug, Clone)]
pub struct Table {
    pub defines: Vec<String>,
    pub includes: Vec<PathBuf>,
    pub sources: Vec<PathBuf>,
    pub link_paths: Vec<PathBuf>,
    pub link_libraires: Vec<String>,
    pub link_options: Vec<String>,
    pub compile_options: Vec<String>,
    pub compile_features: Vec<String>,
}

#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
pub struct ModeTableConfig {
    pub debug: Option<TableConfig>,
    pub release: Option<TableConfig>,
}

impl<P: AsRef<Path>> Shelling<anyhow::Result<ModeTable>, P> for ModeTableConfig {
    fn shelling(self, base: P) -> anyhow::Result<ModeTable> {
        Ok(ModeTable {
            debug: self.debug.unwrap_or_default().shelling(&base)?,
            release: self.release.unwrap_or_default().shelling(&base)?,
        })
    }
}

#[derive(Debug, Clone)]
pub struct ModeTable {
    pub debug: Table,
    pub release: Table,
}