cargo-workspaces 0.4.2

Cargo workspace manager
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

use crate::utils::{
    create_http_client, dag, filter_private, get_pkgs, is_published, list, package_registry,
    ListOpt, ListPublicOpt, RegistryOpt, Result, INTERNAL_ERR,
};

use cargo_metadata::Metadata;
use clap::Parser;

/// List the crates in publishing order
#[derive(Debug, Parser)]
pub struct Plan {
    /// Skip already published crate versions
    #[clap(long)]
    skip_published: bool,

    #[clap(flatten)]
    registry: RegistryOpt,

    #[clap(flatten)]
    list: ListPublicOpt,
}

impl Plan {
    pub fn run(self, metadata: Metadata) -> Result {
        let pkgs = metadata
            .packages
            .iter()
            .map(|x| (x.clone(), x.version.to_string()))
            .collect::<Vec<_>>();

        let (names, visited) = dag(&pkgs);

        let http_client = create_http_client(&metadata.workspace_root, &self.registry.token)?;

        let pkg_ids = filter_private(visited, &pkgs)
            .into_iter()
            .map(|p| {
                let (pkg, version) = names.get(&p).expect(INTERNAL_ERR);

                let published = if self.skip_published {
                    let index_url =
                        package_registry(&metadata, self.registry.registry.as_ref(), pkg)?;
                    is_published(&http_client, index_url, &pkg.name, version)?
                } else {
                    false
                };

                Ok((pkg.id.clone(), published))
            })
            .collect::<Result<Vec<_>>>()?
            .into_iter()
            .filter_map(|(id, published)| (!published).then_some(id));

        let pkgs = get_pkgs(&metadata, false)?;

        let ordered_pkgs = pkg_ids
            .into_iter()
            .filter_map(|id| pkgs.iter().find(|p| p.id == id))
            .cloned()
            .collect::<Vec<_>>();

        list(
            &ordered_pkgs,
            ListOpt {
                all: false,
                list: self.list,
            },
        )
    }
}