upstream-rs 1.13.1

Fetch package updates directly from the source.
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

use anyhow::{Context, Result};
use std::path::PathBuf;

/// Root directories for the application
pub struct AppDirs {
    pub user_dir: PathBuf,
    pub config_dir: PathBuf,
    pub data_dir: PathBuf,
    pub metadata_dir: PathBuf,
}

impl Default for AppDirs {
    fn default() -> Self {
        Self::new().expect("failed to determine upstream app directories")
    }
}

impl AppDirs {
    pub fn new() -> Result<Self> {
        let user_dir =
            dirs::home_dir().context("Failed to determine the current user's home directory")?;
        let config_dir = dirs::config_dir()
            .context("Failed to determine the current user's config directory")?
            .join("upstream");

        let data_dir = user_dir.join(".upstream");
        let metadata_dir = data_dir.join("metadata");

        Ok(Self {
            user_dir,
            config_dir,
            data_dir,
            metadata_dir,
        })
    }
}

/// Paths to configuration and metadata files
pub struct ConfigPaths {
    pub config_file: PathBuf,
    pub packages_file: PathBuf,
    pub metadata_file: PathBuf,
    pub paths_file: PathBuf,
}

impl ConfigPaths {
    pub fn new(dirs: &AppDirs) -> Self {
        Self {
            config_file: dirs.config_dir.join("config.toml"),
            packages_file: dirs.metadata_dir.join("packages.json"),
            metadata_file: dirs.metadata_dir.join("metadata.json"),
            paths_file: dirs.metadata_dir.join("paths.sh"),
        }
    }
}

/// Directories where packages are installed
pub struct InstallPaths {
    pub appimages_dir: PathBuf,
    pub binaries_dir: PathBuf,
    pub archives_dir: PathBuf,
}

impl InstallPaths {
    pub fn new(dirs: &AppDirs) -> Self {
        Self {
            appimages_dir: dirs.data_dir.join("appimages"),
            binaries_dir: dirs.data_dir.join("binaries"),
            archives_dir: dirs.data_dir.join("archives"),
        }
    }
}

/// Paths for system integration (symlinks, XDG dirs)
pub struct IntegrationPaths {
    pub symlinks_dir: PathBuf,
    pub xdg_applications_dir: PathBuf,
    pub icons_dir: PathBuf,
}

impl IntegrationPaths {
    pub fn new(dirs: &AppDirs) -> Self {
        Self {
            symlinks_dir: dirs.data_dir.join("symlinks"),
            icons_dir: dirs.data_dir.join("icons"),
            xdg_applications_dir: dirs.user_dir.join(".local/share/applications"),
        }
    }
}

/// Convenience wrapper that holds all path types
pub struct UpstreamPaths {
    pub dirs: AppDirs,
    pub config: ConfigPaths,
    pub install: InstallPaths,
    pub integration: IntegrationPaths,
}

impl Default for UpstreamPaths {
    fn default() -> Self {
        Self::new().expect("failed to determine upstream paths")
    }
}

impl UpstreamPaths {
    pub fn new() -> Result<Self> {
        let dirs = AppDirs::new()?;
        Ok(Self {
            config: ConfigPaths::new(&dirs),
            install: InstallPaths::new(&dirs),
            integration: IntegrationPaths::new(&dirs),
            dirs,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::UpstreamPaths;

    #[test]
    fn upstream_paths_are_composed_from_base_directories() {
        let paths = UpstreamPaths::new().expect("paths");

        assert_eq!(
            paths.config.config_file,
            paths.dirs.config_dir.join("config.toml")
        );
        assert_eq!(
            paths.config.packages_file,
            paths.dirs.metadata_dir.join("packages.json")
        );
        assert_eq!(
            paths.config.metadata_file,
            paths.dirs.metadata_dir.join("metadata.json")
        );
        assert_eq!(
            paths.install.binaries_dir,
            paths.dirs.data_dir.join("binaries")
        );
        assert_eq!(
            paths.integration.symlinks_dir,
            paths.dirs.data_dir.join("symlinks")
        );
    }
}