creeper 1.0.0-alpha.5

Minecraft Package 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
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

use clap::Parser;
use colored::Colorize;
use tracing::error;
use url::Url;

use crate::{
    Id, Install, Package,
    cmd::Execute,
    fabric::FabricMod,
    pack::{PackMeta, PackNode},
    util::{parse_or_prompt, prompt_save},
    zip::extract_zip,
};

#[derive(Clone, Debug, Parser)]
pub struct PackageFabricMod {
    pub url: Url,
}

impl Execute for PackageFabricMod {
    async fn execute(self, lib: &crate::Creeper) -> anyhow::Result<()> {
        let art = lib
            .download(self.url.to_string(), self.url.to_string(), None, None)
            .await?;

        let jar = lib.retrieve_artifact(&art).await?;

        let json = extract_zip(jar, "fabric.mod.json").await?;

        let metadata = serde_json::from_str::<FabricMod>(&json)?;

        let id = parse_or_prompt::<Id>(&metadata.id, "package id").await?;

        let license = match metadata.license {
            Some(x) if let Ok(x) = x.parse() => Some(x),
            Some(x) if let Ok(x) = format!("LicenseRef-{x}").parse() => Some(x),
            Some(x) => Some(parse_or_prompt(&x, "SPDX license expression").await?),
            None => None,
        };

        let mut node = PackNode::default();

        for (id, dep) in metadata.depends {
            let id = match id.parse() {
                Ok(id) => id,
                Err(_) => parse_or_prompt(&id, "package id").await?,
            };

            let req = dep.prompt_normalize().await?;

            node.dep.insert(id, req);
        }

        for (id, dep) in metadata.breaks {
            let id = match id.parse() {
                Ok(id) => id,
                Err(_) => parse_or_prompt(&id, "package id").await?,
            };

            let req = dep.prompt_normalize().await?;

            node.conflict.insert(id, req);
        }

        if !metadata.recommends.is_empty() {
            error!("does not support recommended dependencies in fabric.mod.json");
        }

        if !metadata.suggests.is_empty() {
            error!("does not support suggested dependencies in fabric.mod.json");
        }

        if !metadata.conflicts.is_empty() {
            error!("does not support conflict dependencies in fabric.mod.json");
        }

        if !metadata.provides.is_empty() {
            error!("does not support provided dependencies in fabric.mod.json");
        }

        let pack = Package {
            id,
            version: metadata.version,
            rev: 0,
            node,
            meta: PackMeta {
                name: metadata.name.unwrap_or(metadata.id),
                authors: metadata.authors.into_iter().map(|x| x.name()).collect(),
                desc: metadata.description,
                license,
            },
            install: Install {
                mc_mod: vec![art],
                ..Default::default()
            },
        };

        let toml = toml::to_string(&pack)?;

        eprintln!("{} {}@{}", "Packaged".bold().green(), pack.id, pack.version);

        println!("{toml}");

        let path = pack
            .id
            .indexed_path()
            .as_ref()
            .join(pack.version.to_string())
            .join("0.toml");

        prompt_save(toml, path).await?;

        Ok(())
    }
}