huber 1.0.11

Huber, simplify GitHub package management
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

use anyhow::anyhow;
use async_trait::async_trait;
use clap::{Args, ValueHint};
use log::info;
use semver::Version;
use simpledi_rs::di::{DIContainer, DIContainerTrait};

use crate::cmd::{get_updated_package_version, CommandTrait};
use crate::error::HuberError::PackageNotInstalled;
use crate::lock_huber_ops;
use crate::model::config::Config;
use crate::parse::parse_pkg_name_optional_semver;
use crate::service::package::PackageService;
use crate::service::release::{ReleaseAsyncTrait, ReleaseService};
use crate::service::{ItemOperationAsyncTrait, ItemOperationTrait};

#[derive(Args)]
pub struct CurrentArgs {
    #[arg(
        help = "Package name with version (e.g. 'package-name@version')",
        num_args = 1,
        value_hint = ValueHint::Unknown,
        value_parser = parse_pkg_name_optional_semver,
        required = true,
    )]
    name_version: Vec<(String, String)>,
}

#[async_trait]
impl CommandTrait for CurrentArgs {
    async fn run(&self, config: &Config, container: &DIContainer) -> anyhow::Result<()> {
        lock_huber_ops!(config);

        let release_service = container.get::<ReleaseService>().unwrap();
        let pkg_service = container.get::<PackageService>().unwrap();

        for (name, version) in self.name_version.iter() {
            if !pkg_service.has(name)? {
                return Err(anyhow!(PackageNotInstalled(name.clone())));
            }

            let pkg = pkg_service.get(name)?;
            let releases = release_service.find(&pkg).await?;

            if Version::parse(version.trim_start_matches('v')).is_err() {
                if let Some(mut r) = releases.clone().into_iter().find(|r| r.version.eq(version)) {
                    info!("Updating the current version of {} to {}", name, version);
                    release_service.set_current(&mut r).await?;
                    info!("{}@{} is now the current version", name, version);

                    return Ok(());
                } else {
                    anyhow::bail!("No installed version '{}' found for {}", version, name);
                }
            }

            let mut latest_release = release_service.get_latest(&pkg).await?;
            let version = get_updated_package_version(version, &latest_release.version);

            if let Some(mut r) = releases.into_iter().find(|r| r.version == version) {
                info!("Updating the current version of {} to {}", name, version);
                release_service.set_current(&mut r).await?;
                info!("{}@{} is now the current version", name, version);
            } else if !version.is_empty() {
                anyhow::bail!("No installed version {} found for {}", version, name);
            } else {
                info!(
                    "No version provided, trying to find the latest version of {}",
                    name
                );
                release_service.set_current(&mut latest_release).await?;
                info!(
                    "{}@{} is now the current version",
                    latest_release.package.name, latest_release.version
                );
            }
        }

        Ok(())
    }
}