stout-install 0.2.0

Package installation for stout
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

//! INSTALL_RECEIPT.json handling

use crate::error::Result;
use serde::{Deserialize, Serialize};
use std::path::Path;

/// INSTALL_RECEIPT.json structure (Homebrew compatible)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InstallReceipt {
    pub homebrew_version: String,
    pub installed_as_dependency: bool,
    pub installed_on_request: bool,
    pub install_time: u64,
    pub source: ReceiptSource,
    #[serde(default)]
    pub runtime_dependencies: Vec<RuntimeDependency>,
    #[serde(default)]
    pub poured_from_bottle: bool,
    #[serde(default)]
    pub changed_files: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ReceiptSource {
    pub tap: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RuntimeDependency {
    pub full_name: String,
    pub version: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<u32>,
}

impl InstallReceipt {
    /// Create a new receipt for a bottle installation
    pub fn new_bottle(
        tap: &str,
        on_request: bool,
        dependencies: Vec<RuntimeDependency>,
    ) -> Self {
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();

        Self {
            homebrew_version: "4.0.0".to_string(), // Compatible version
            installed_as_dependency: !on_request,
            installed_on_request: on_request,
            install_time: now,
            source: ReceiptSource {
                tap: tap.to_string(),
                path: None,
            },
            runtime_dependencies: dependencies,
            poured_from_bottle: true,
            changed_files: Vec::new(),
        }
    }

    /// Create a new receipt for a source-built installation
    pub fn new_source(
        tap: &str,
        on_request: bool,
        dependencies: Vec<RuntimeDependency>,
    ) -> Self {
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();

        Self {
            homebrew_version: "4.0.0".to_string(),
            installed_as_dependency: !on_request,
            installed_on_request: on_request,
            install_time: now,
            source: ReceiptSource {
                tap: tap.to_string(),
                path: None,
            },
            runtime_dependencies: dependencies,
            poured_from_bottle: false, // Built from source
            changed_files: Vec::new(),
        }
    }
}

/// Write an INSTALL_RECEIPT.json file
pub fn write_receipt(install_path: impl AsRef<Path>, receipt: &InstallReceipt) -> Result<()> {
    let path = install_path.as_ref().join("INSTALL_RECEIPT.json");
    let json = serde_json::to_string_pretty(receipt)?;
    std::fs::write(&path, json)?;
    Ok(())
}

/// Read an existing INSTALL_RECEIPT.json
pub fn read_receipt(install_path: impl AsRef<Path>) -> Result<InstallReceipt> {
    let path = install_path.as_ref().join("INSTALL_RECEIPT.json");
    let json = std::fs::read_to_string(&path)?;
    let receipt: InstallReceipt = serde_json::from_str(&json)?;
    Ok(receipt)
}