sccmod 0.6.4

A mediocre module manager for handling multiple versions of self-compiled modules
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

use std::{fmt::Debug, path::Path};

use pyo3::{
    prelude::{PyAnyMethods, PyTypeMethods},
    Bound, PyAny,
};

use crate::builders::{cmake::CMake, make::Make};

pub trait BuilderImpl: Sized + Clone {
    /// Generate a builder object from a python object.
    ///
    /// Returns [`Ok(obj)`] if the operation was successful, otherwise
    /// [`Err(string)`]
    ///
    /// # Errors
    /// Errors if any attribute cannot be extracted or converted, or if the
    /// provided object is invalid.
    fn from_py(object: &Bound<PyAny>) -> Result<Self, String>;

    /// Perform the build operation specified by the struct.
    ///
    /// For example, if this is a [`CMake`] instance, `cmake` is run on the
    /// `source_path` and the resulting build files are written to
    /// `output_path`.
    ///
    /// # Errors
    ///
    /// Returns [`Err(string)`] if the build script fails to run. This could
    /// happen for many reasons, including:
    ///  - Source directory does not exist
    ///  - Source directory does not contain a valid build script configuration
    ///  - The code fails to compile
    ///  - The build files cannot be written to the build directory
    fn build<
        P0: AsRef<Path> + Debug,
        P1: AsRef<Path> + Debug,
        P2: AsRef<Path>,
    >(
        &self,
        source_path: &P0,
        build_path: &P1,
        install_path: &P2, // Necessary for make
        dependencies: &[String],
    ) -> Result<(), String>;

    /// Perform the install operation specified by the struct.
    ///
    /// For example, if this is a [`CMake`] instance, `cmake --install ...` is
    /// run on the `build_path` and the install files are installed in
    /// `install_path`.
    ///
    /// # Errors
    ///
    /// Returns [`Err(string)`] if the install script fails to run. This could
    /// happen for many reasons, including:
    ///  - Build directory does not exist
    ///  - Build directory does not contain valid installation information
    ///  - The install files cannot be written to `install_path`
    fn install<P0: AsRef<Path>, P1: AsRef<Path>, P2: AsRef<Path>>(
        &self,
        source_path: &P0,
        build_path: &P1,
        install_path: &P2,
        dependencies: &[String],
    ) -> Result<(), String>;
}

#[derive(Debug, Clone)]
pub enum Builder {
    CMake(CMake),
    Make(Make),
}

impl BuilderImpl for Builder {
    fn from_py(object: &Bound<PyAny>) -> Result<Self, String> {
        let name = object.get_type().name().unwrap().to_string();

        match name.as_str() {
            "CMake" => Ok(Self::CMake(CMake::from_py(object)?)),
            "Make" => Ok(Self::Make(Make::from_py(object)?)),
            _ => Err("Invalid builder type".to_string()),
        }
    }

    fn build<
        P0: AsRef<Path> + Debug,
        P1: AsRef<Path> + Debug,
        P2: AsRef<Path>,
    >(
        &self,
        source_path: &P0,
        build_path: &P1,
        install_path: &P2,
        dependencies: &[String],
    ) -> Result<(), String> {
        match self {
            Self::CMake(cmake) => {
                cmake.build(source_path, build_path, install_path, dependencies)
            }
            Self::Make(make) => {
                make.build(source_path, build_path, install_path, dependencies)
            }
        }
    }

    fn install<P0: AsRef<Path>, P1: AsRef<Path>, P2: AsRef<Path>>(
        &self,
        source_path: &P0,
        build_path: &P1,
        install_path: &P2,
        dependencies: &[String],
    ) -> Result<(), String> {
        match self {
            Self::CMake(cmake) => cmake.install(
                source_path,
                build_path,
                install_path,
                dependencies,
            ),
            Self::Make(make) => make.install(
                source_path,
                build_path,
                install_path,
                dependencies,
            ),
        }
    }
}