fusible 0.20.5

Electronic linter: a fuse that blows to block firmware code generation
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

//! `export` invocation: formats the output path and reuses cached exports.

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

use super::command::export_command;
use super::{cache, process, resolve_hardware_context, Runner, RunnerError};

impl Runner {
    /// Runs the tscircuit export command.
    pub fn export(
        &self,
        file: &Path,
        format: &str,
        output: Option<&Path>,
    ) -> Result<(), RunnerError> {
        let abs_output = output.map(absolute_output);
        let cache = abs_output.as_ref().and_then(|_| self.cache_for(file));
        if let (Some(cache), Some(dest)) = (&cache, &abs_output) {
            if cache.restore(format, dest) {
                return Ok(());
            }
        }
        if let Some(parent) = abs_output.as_deref().and_then(Path::parent) {
            std::fs::create_dir_all(parent).ok();
        }

        let mut cmd = export_command(&self.kind, file, format, abs_output.as_deref());
        let out = cmd.output().map_err(|source| RunnerError::Io {
            command: process::format_command(&cmd),
            source,
        })?;

        if !out.status.success() {
            let details = process::extract_output_details(&out);
            return Err(RunnerError::CommandFailed {
                command: process::format_command(&cmd),
                code: out.status.code(),
                stderr: details.clone(),
                help: details,
            });
        }
        if let (Some(cache), Some(dest)) = (&cache, &abs_output) {
            cache.put(format, dest);
        }
        Ok(())
    }

    /// Opens the build cache of the workspace `file` belongs to.
    pub(super) fn cache_for(&self, file: &Path) -> Option<cache::Cache> {
        let (dir, rel) = resolve_hardware_context(file);
        let root = dir.unwrap_or_else(|| match file.parent() {
            Some(parent) if !parent.as_os_str().is_empty() => parent.to_path_buf(),
            _ => PathBuf::from("."),
        });
        cache::Cache::open(&self.kind, &root, &rel)
    }
}

/// Resolves a relative output path against the current directory.
fn absolute_output(p: &Path) -> PathBuf {
    if p.is_absolute() {
        return p.to_path_buf();
    }
    std::env::current_dir()
        .map(|cd| cd.join(p))
        .unwrap_or_else(|_| p.to_path_buf())
}