dmclc5 0.3.2

A minecraft launching library
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

//! Implementation of [ModLoader] for Forge before 1.13.

use std::fs::File;

use serde::Deserialize;
use versions::{Requirement, Versioning};
use zip::ZipArchive;

use crate::{components::mods::ModInfo, utils::parse_maven_version_range};

use super::{ModLoader, VersionBound};

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct McmodInfoItem {
    modid: String,
    name: String,
    description: Option<String>,
    version: Option<Versioning>,
    mcversion: Option<Versioning>,
    #[serde(default)]
    use_dependency_information: bool,
    #[serde(default)]
    required_mods: Vec<String>
}

/// The [ModLoader] implementation for Forge before 1.13.
pub struct OldForgeModLoader {
    pub(in crate::components) version: String
}

impl ModLoader for OldForgeModLoader {
    fn get_builtin_mods(&self) -> Vec<super::ModInfo> {
        vec![
            ModInfo {
                name: None,
                id: "Forge".to_string(),
                version: Some(Versioning::new(&self.version).unwrap()),
                desc: None,
                license: "LGPL-2.1".to_string(),
                depends: vec![],
                recommends: vec![],
                conflicts: vec![],
                suggests: vec![],
                breaks: vec![]
            }
        ]
    }

    fn get_mods_in_file(&self, path: &crate::utils::BetterPath) -> anyhow::Result<Vec<super::ModInfo>> {
        let mut archive = ZipArchive::new(File::open(path)?)?;
        let info: Vec<McmodInfoItem> = serde_json::from_reader(archive.by_name("mcmod.info")?)?;
        let mut ret = vec![];
        for i in info {
            let mut depends = vec![];
            if i.use_dependency_information {
                for dep in i.required_mods {
                    match dep.splitn(2, "@").collect::<Vec<&str>>().as_slice() {
                        [dep, ver] => depends.push(super::DepRequirement { id: dep.to_string(), version: parse_maven_version_range(ver)?, reason: None, unless: vec![] }),
                        [dep] => depends.push(super::DepRequirement { id: dep.to_string(), version: vec![], reason: None, unless: vec![] }),
                        _ => panic!("How???")
                    }
                }
            }
            if let Some(mc) = i.mcversion {
                depends.push(super::DepRequirement {
                    id: "minecraft".to_string(),
                    version: vec![VersionBound::new_one(Requirement {op: versions::Op::Exact, version: Some(mc)})],
                    reason: None,
                    unless: vec![]
                });
            }
            ret.push(ModInfo {
                name: Some(i.name),
                id: i.modid,
                version: i.version,
                desc: i.description,
                license: "Unknown".to_string(),
                depends,
                recommends: vec![],
                suggests: vec![],
                conflicts: vec![],
                breaks: vec![]
            });
        }
        Ok(ret)
    }
}