scarb 0.5.2

The Cairo package manager
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

use std::hash::{Hash, Hasher};
use std::ops::Deref;
use std::sync::Arc;

use anyhow::Result;
use camino::{Utf8Path, Utf8PathBuf};
use serde::{Deserialize, Serialize};
use smol_str::SmolStr;

use crate::internal::serdex::toml_merge;

/// See [`TargetInner`] for public fields reference.
#[derive(Clone, Debug, Hash)]
pub struct Target(Arc<TargetInner>);

#[derive(Debug)]
#[non_exhaustive]
pub struct TargetInner {
    pub kind: SmolStr,
    pub name: SmolStr,
    pub source_path: Utf8PathBuf,
    pub params: toml::Value,
}

impl Deref for Target {
    type Target = TargetInner;

    fn deref(&self) -> &Self::Target {
        self.0.deref()
    }
}

impl Target {
    pub const LIB: &'_ str = "lib";
    pub const CAIRO_PLUGIN: &'_ str = "cairo-plugin";

    pub fn new(
        kind: impl Into<SmolStr>,
        name: impl Into<SmolStr>,
        source_path: impl Into<Utf8PathBuf>,
        params: toml::Value,
    ) -> Self {
        assert!(params.is_table(), "params must be a TOML table");
        Self(Arc::new(TargetInner {
            kind: kind.into(),
            name: name.into(),
            source_path: source_path.into(),
            params,
        }))
    }

    pub fn without_params(
        kind: impl Into<SmolStr>,
        name: impl Into<SmolStr>,
        source_path: impl Into<Utf8PathBuf>,
    ) -> Self {
        Self::new(
            kind,
            name,
            source_path,
            toml::Value::Table(toml::Table::new()),
        )
    }

    pub fn try_from_structured_params(
        kind: impl Into<SmolStr>,
        name: impl Into<SmolStr>,
        source_path: impl Into<Utf8PathBuf>,
        params: impl Serialize,
    ) -> Result<Self> {
        let params = toml::Value::try_from(params)?;
        Ok(Self::new(kind, name, source_path, params))
    }

    pub fn is_lib(&self) -> bool {
        self.kind == Self::LIB
    }

    pub fn is_cairo_plugin(&self) -> bool {
        self.kind == Self::CAIRO_PLUGIN
    }

    pub fn source_root(&self) -> &Utf8Path {
        self.source_path
            .parent()
            .expect("Source path is guaranteed to point to a file.")
    }

    pub fn props<'de, P>(&self) -> Result<P>
    where
        P: Default + Serialize + Deserialize<'de>,
    {
        toml_merge(&P::default(), &self.params)
    }
}

impl Hash for TargetInner {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.kind.hash(state);
        self.name.hash(state);
        self.source_path.hash(state);
        self.params.to_string().hash(state);
    }
}