libium 1.30.0

Multi-source backend for managing Minecraft mods and modpacks from Modrinth, CurseForge, and Github Releases
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use super::{check, DistributionDeniedError, Downloadable};
use crate::{
    config::structs::{Mod, ModIdentifier, ModLoader},
    APIs,
};
use ferinth::structures::version::{Version, VersionFile};
use furse::structures::file_structs::File;
use octocrab::models::repos::{Asset, Release};

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error(transparent)]
    DistributionDenied(#[from] DistributionDeniedError),
    #[error("Modrinth: {0}")]
    ModrinthError(#[from] ferinth::Error),
    #[error("CurseForge: {0}")]
    CurseForgeError(#[from] furse::Error),
    #[error("GitHub: {0:#?}")]
    GitHubError(#[from] octocrab::Error),
    #[error("No compatible file was found")]
    NoCompatibleFile,
}
type Result<T> = std::result::Result<T, Error>;

/// Get the latest compatible version and version file from the `versions`
///
/// Also returns whether Fabric backwards compatibility for Quilt was used.
pub(crate) fn get_latest_compatible_version<'a>(
    versions: &'a [Version],
    game_version_to_check: Option<&str>,
    mod_loader_to_check: Option<ModLoader>,
) -> Option<(&'a VersionFile, &'a Version, bool)> {
    match check::modrinth(versions, game_version_to_check, mod_loader_to_check) {
        Some(some) => Some((some.0, some.1, false)),
        None => {
            if mod_loader_to_check == Some(ModLoader::Quilt) {
                check::modrinth(versions, game_version_to_check, Some(ModLoader::Fabric))
                    .map(|some| (some.0, some.1, true))
            } else {
                None
            }
        }
    }
}

/// Get the latest compatible file from the `files`
///
/// Also returns whether Fabric backwards compatibility for Quilt was used.
pub(crate) fn get_latest_compatible_file(
    mut files: Vec<File>,
    game_version_to_check: Option<&str>,
    mod_loader_to_check: Option<ModLoader>,
) -> Option<(File, bool)> {
    match check::curseforge(&mut files, game_version_to_check, mod_loader_to_check) {
        Some(some) => Some((some.clone(), false)),
        None => {
            if mod_loader_to_check == Some(ModLoader::Quilt) {
                check::curseforge(&mut files, game_version_to_check, Some(ModLoader::Fabric))
                    .map(|some| (some.clone(), true))
            } else {
                None
            }
        }
    }
}

/// Get the latest compatible asset of the provided `repo_handler`
///
/// Also returns whether Fabric backwards compatibility for Quilt was used.
pub(crate) fn get_latest_compatible_asset<'a>(
    releases: &'a [Release],
    game_version_to_check: Option<&str>,
    mod_loader_to_check: Option<ModLoader>,
) -> Option<(&'a Asset, bool)> {
    // Combine all the assets of every release
    let assets = releases.iter().flat_map(|r| &r.assets).collect::<Vec<_>>();

    match check::github(
        // Extract just the names of the assets
        &assets.iter().map(|a| &a.name).collect::<Vec<_>>(),
        game_version_to_check,
        mod_loader_to_check,
    ) {
        Some(index) => Some((assets[index], false)),
        None => {
            if mod_loader_to_check == Some(ModLoader::Quilt) {
                get_latest_compatible_asset(
                    releases,
                    game_version_to_check,
                    Some(ModLoader::Fabric),
                )
                .map(|some| (some.0, true))
            } else {
                None
            }
        }
    }
}

/// Get the latest compatible downloadable from the `mod_` provided
///
/// Also returns whether Fabric backwards compatibility for Quilt was used.
pub async fn get_latest_compatible_downloadable(
    apis: APIs<'_>,
    mod_: &Mod,
    game_version_to_check: &str,
    mod_loader_to_check: ModLoader,
) -> Result<(Downloadable, bool)> {
    let game_version_to_check = if mod_.check_game_version {
        Some(game_version_to_check)
    } else {
        None
    };
    let mod_loader_to_check = if mod_.check_mod_loader {
        Some(mod_loader_to_check)
    } else {
        None
    };

    match &mod_.identifier {
        ModIdentifier::CurseForgeProject(project_id) => get_latest_compatible_file(
            apis.cf.get_mod_files(*project_id).await?,
            game_version_to_check,
            mod_loader_to_check,
        )
        .map_or_else(
            || Err(Error::NoCompatibleFile),
            |ok| Ok((ok.0.try_into()?, ok.1)),
        ),
        ModIdentifier::ModrinthProject(project_id) => get_latest_compatible_version(
            &apis.mr.list_versions(project_id).await?,
            game_version_to_check,
            mod_loader_to_check,
        )
        .map_or_else(
            || Err(Error::NoCompatibleFile),
            |ok| Ok((ok.0.clone().into(), ok.2)),
        ),
        ModIdentifier::GitHubRepository(full_name) => get_latest_compatible_asset(
            &apis
                .gh
                .repos(&full_name.0, &full_name.1)
                .releases()
                .list()
                .send()
                .await?
                .items,
            game_version_to_check,
            mod_loader_to_check,
        )
        .map_or_else(
            || Err(Error::NoCompatibleFile),
            |ok| Ok((ok.0.clone().into(), ok.1)),
        ),
    }
}