quilt-rs 0.9.1

Rust library for accessing Quilt data packages.
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

use std::path::PathBuf;
use tempfile::TempDir;

use crate::cli::benchmark;
use crate::cli::browse;
use crate::cli::commit;
use crate::cli::install;
use crate::cli::list;
use crate::cli::login;
use crate::cli::package;
use crate::cli::pull;
use crate::cli::push;
use crate::cli::status;
use crate::cli::uninstall;
use crate::cli::Error;

pub struct Model {
    local_domain: quilt_rs::LocalDomain,
}

pub trait Commands {
    fn get_local_domain(&self) -> &quilt_rs::LocalDomain;

    async fn browse(&self, args: browse::Input) -> Result<browse::Output, Error> {
        let local_domain = self.get_local_domain();
        browse::model(local_domain, args).await
    }

    async fn commit(&self, args: commit::Input) -> Result<commit::Output, Error> {
        let local_domain = self.get_local_domain();
        commit::model(local_domain, args).await
    }

    async fn install(&self, args: install::Input) -> Result<install::Output, Error> {
        let local_domain = self.get_local_domain();
        install::model(local_domain, args).await
    }

    async fn list(&self) -> Result<list::Output, Error> {
        let local_domain = self.get_local_domain();
        list::model(local_domain).await
    }

    async fn login(&self, args: login::Input) -> Result<login::Output, Error> {
        let local_domain = self.get_local_domain();
        login::model(local_domain, args).await
    }

    async fn package(&self, args: package::Input) -> Result<package::Output, Error> {
        let local_domain = self.get_local_domain();
        package::model(local_domain, args).await
    }

    async fn pull(&self, args: pull::Input) -> Result<pull::Output, Error> {
        let local_domain = self.get_local_domain();
        pull::model(local_domain, args).await
    }

    async fn push(&self, args: push::Input) -> Result<push::Output, Error> {
        let local_domain = self.get_local_domain();
        push::model(local_domain, args).await
    }

    async fn status(&self, args: status::Input) -> Result<status::Output, Error> {
        let local_domain = self.get_local_domain();
        status::model(local_domain, args).await
    }

    async fn benchmark(&self, args: benchmark::Input) -> Result<benchmark::Output, Error> {
        let local_domain = self.get_local_domain();
        benchmark::model(local_domain, args).await
    }

    async fn uninstall(&self, args: uninstall::Input) -> Result<uninstall::Output, Error> {
        let local_domain = self.get_local_domain();
        uninstall::model(local_domain, args).await
    }
}

impl Commands for Model {
    fn get_local_domain(&self) -> &quilt_rs::LocalDomain {
        &self.local_domain
    }
}

impl Model {
    fn new(local_domain: quilt_rs::LocalDomain) -> Self {
        Model { local_domain }
    }

    #[cfg(test)]
    pub fn from_temp_dir() -> Result<(Self, TempDir), Error> {
        let temp_dir = TempDir::new()?;
        Ok((Model::from(&temp_dir), temp_dir))
    }
}

impl From<PathBuf> for Model {
    fn from(root: PathBuf) -> Self {
        let local_domain = quilt_rs::LocalDomain::new(root);
        Model::new(local_domain)
    }
}

impl From<&TempDir> for Model {
    #[must_use]
    fn from(temp_dir: &TempDir) -> Self {
        Model::from(temp_dir.path().to_path_buf())
    }
}

#[cfg(test)]
pub async fn install_package_into_temp_dir(
    uri_str: &str,
) -> Result<(Model, quilt_rs::InstalledPackage, TempDir), Error> {
    let (model, temp_dir) = Model::from_temp_dir()?;

    let output = model
        .install(install::Input {
            namespace: None,
            paths: None,
            uri: uri_str.to_string(),
        })
        .await?;

    let installed_package = output.get_installed_package();

    tracing::log::debug!(
        "Installed package manifest: {:?}",
        installed_package.manifest().await?
    );

    // We must return `temp_dir` because otherwise it will be dropped and removed
    Ok((model, installed_package, temp_dir))
}