redskull 0.1.0

A conda recipe generator for Rust crates.
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

//! Recipe data model for conda meta.yaml / recipe.yaml.

/// Jinja2 preamble with name and version variables.
pub struct Preamble {
    pub name: String,
    pub version: String,
}

pub struct Package {}

pub struct Source {
    pub url: String,
    pub filename: String,
    pub sha256: String,
}

pub struct Build {
    pub name: String,
    pub with_run_exports: bool,
    pub max_pin: String,
    /// If Some, use inline script instead of build.sh.
    pub script: Option<String>,
}

pub struct Requirement {
    pub name: String,
    pub version: Option<String>,
    /// Platform selector, e.g. "not osx", "not win", "not arm64".
    pub selector: Option<String>,
}

pub struct Requirements {
    pub build: Vec<Requirement>,
    pub host: Vec<Requirement>,
    pub run: Vec<Requirement>,
}

pub struct Test {
    pub commands: Vec<String>,
}

pub struct About {
    pub home: Option<String>,
    pub license: Option<String>,
    pub license_family: Option<String>,
    /// List of license files (rendered as YAML list when multiple).
    pub license_file: Vec<String>,
    pub summary: Option<String>,
    pub dev_url: Option<String>,
    pub doc_url: Option<String>,
}

pub struct Extra {
    pub additional_platforms: Vec<String>,
    pub recipe_maintainers: Vec<String>,
    pub identifiers: Vec<String>,
    pub skip_platforms: Vec<String>,
}

pub struct Recipe {
    pub preamble: Preamble,
    pub package: Package,
    pub source: Source,
    pub build: Build,
    pub requirements: Requirements,
    pub test: Test,
    pub about: About,
    pub extra: Extra,
}

impl Test {
    pub fn from_binaries(binaries: &[&str]) -> Self {
        Self { commands: binaries.iter().map(|b| format!("{b} --help")).collect() }
    }

    pub fn from_binaries_version(binaries: &[&str]) -> Self {
        Self { commands: binaries.iter().map(|b| format!("{b} --version")).collect() }
    }
}

impl Requirement {
    pub fn simple(name: &str) -> Self {
        Self { name: name.to_string(), version: None, selector: None }
    }
}

/// Configuration for which build tools to include in requirements.
pub struct BuildToolNeeds {
    pub pkg_config: bool,
    pub make: bool,
    pub cmake: bool,
}

impl Requirements {
    /// Create requirements for a Rust crate.
    ///
    /// * `cargo_bundle_licenses` - include CBL in build deps
    /// * `has_c_deps` - crate links C code (adds compiler('c'))
    /// * `has_cxx_deps` - crate links C++ code (adds compiler('cxx'))
    /// * `has_bindgen` - crate uses bindgen (adds clangdev)
    /// * `build_tools` - which build tools to include (pkg-config, make, cmake)
    pub fn for_rust_crate(
        cargo_bundle_licenses: bool,
        has_c_deps: bool,
        has_cxx_deps: bool,
        has_bindgen: bool,
        build_tools: &BuildToolNeeds,
    ) -> Self {
        let mut build = vec![];

        if has_c_deps {
            build.push(Requirement::simple("{{ compiler('c') }}"));
        }
        if has_cxx_deps {
            build.push(Requirement::simple("{{ compiler('cxx') }}"));
        }
        build.push(Requirement::simple("{{ compiler('rust') }}"));

        if cargo_bundle_licenses {
            build.push(Requirement::simple("cargo-bundle-licenses"));
        }

        if has_bindgen {
            build.push(Requirement::simple("clangdev"));
        }

        if build_tools.pkg_config {
            build.push(Requirement::simple("pkg-config"));
        }
        if build_tools.make {
            build.push(Requirement::simple("make"));
        }
        if build_tools.cmake {
            build.push(Requirement::simple("cmake"));
        }

        Self { build, host: vec![], run: vec![] }
    }

    pub fn add_host(&mut self, name: &str, selector: Option<&str>) {
        self.host.push(Requirement {
            name: name.to_string(),
            version: None,
            selector: selector.map(String::from),
        });
    }

    pub fn add_run(&mut self, name: &str, selector: Option<&str>) {
        self.run.push(Requirement {
            name: name.to_string(),
            version: None,
            selector: selector.map(String::from),
        });
    }
}