Skip to main content

elemental_driver/drivers/fabric/
source.rs

1use elemental_core::minecraft::MinecraftVersionId;
2use elemental_schema::fabric::{GameVersion, LoaderProfile, LoaderVersion, ProfileJson};
3use serde::Deserialize;
4
5use crate::{
6    error::Result,
7    families::version_json::{
8        LoaderMetaEndpoints, LoaderMetaSource, LoaderProfileEndpoints, UpstreamUrlRewriter,
9    },
10    loader_version::LoaderVersionId,
11    url::{Origin, OriginEndpoints},
12};
13
14#[derive(Debug, Clone, PartialEq, Eq, Default)]
15pub enum FabricFlavor {
16    #[default]
17    Fabric,
18    LegacyFabric,
19    Babric,
20}
21
22#[derive(Debug, Clone, PartialEq, Eq)]
23pub struct FabricEndpointOverrides {
24    pub meta_origin: String,
25    pub maven_origin: String,
26}
27
28#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
29pub enum FabricOrigin {
30    Meta,
31    Maven,
32}
33
34impl Origin for FabricOrigin {
35    fn canonical(self) -> &'static str {
36        match self {
37            FabricOrigin::Meta => "https://meta.fabricmc.net",
38            FabricOrigin::Maven => "https://maven.fabricmc.net",
39        }
40    }
41
42    fn all() -> &'static [Self] {
43        const ALL: &[FabricOrigin] = &[FabricOrigin::Meta, FabricOrigin::Maven];
44        ALL
45    }
46}
47
48pub type FabricEndpoints = OriginEndpoints<FabricOrigin>;
49pub type FabricSource = LoaderMetaSource<FabricEndpoints>;
50
51#[derive(Debug, Clone, Deserialize)]
52pub struct FabricLoaderListEntry {
53    pub loader: LoaderVersion,
54}
55
56impl FabricEndpoints {
57    pub fn for_flavor(flavor: FabricFlavor) -> Result<Self> {
58        let spec = super::flavors::flavor_spec(&flavor);
59        OriginEndpoints::with_overrides([
60            (FabricOrigin::Meta, spec.meta_origin().to_owned()),
61            (FabricOrigin::Maven, spec.maven_origin().to_owned()),
62        ])
63    }
64
65    pub fn with_endpoint_overrides(overrides: FabricEndpointOverrides) -> Result<Self> {
66        OriginEndpoints::with_overrides([
67            (FabricOrigin::Meta, overrides.meta_origin),
68            (FabricOrigin::Maven, overrides.maven_origin),
69        ])
70    }
71
72    pub fn game_versions_url(&self) -> Result<String> {
73        self.resolve_meta_segments(["v2", "versions", "game"])
74    }
75
76    pub fn loader_versions_url(&self, game_version: &str) -> Result<String> {
77        self.resolve_meta_segments(["v2", "versions", "loader", game_version])
78    }
79
80    pub fn loader_profile_url(&self, game_version: &str, loader_version: &str) -> Result<String> {
81        self.resolve_meta_segments(["v2", "versions", "loader", game_version, loader_version])
82    }
83
84    pub fn profile_json_url(&self, game_version: &str, loader_version: &str) -> Result<String> {
85        self.resolve_meta_segments([
86            "v2",
87            "versions",
88            "loader",
89            game_version,
90            loader_version,
91            "profile",
92            "json",
93        ])
94    }
95
96    fn resolve_meta_segments<const N: usize>(&self, segments: [&str; N]) -> Result<String> {
97        self.resolve_segments(FabricOrigin::Meta, segments)
98    }
99}
100
101impl LoaderMetaEndpoints for FabricEndpoints {
102    type GameVersion = GameVersion;
103    type LoaderGameVersion = FabricLoaderListEntry;
104    type ProfileJson = ProfileJson;
105
106    const SOURCE_NAME: &'static str = "fabric source";
107
108    fn game_versions_url(&self) -> Result<String> {
109        FabricEndpoints::game_versions_url(self)
110    }
111
112    fn loader_versions_url(&self, game_version: &str) -> Result<String> {
113        FabricEndpoints::loader_versions_url(self, game_version)
114    }
115
116    fn profile_json_url(&self, game_version: &str, loader_version: &str) -> Result<String> {
117        FabricEndpoints::profile_json_url(self, game_version, loader_version)
118    }
119
120    fn game_version(version: Self::GameVersion) -> crate::catalog::GameVersion {
121        crate::catalog::GameVersion {
122            id: MinecraftVersionId::from(version.version),
123            description: None,
124            stream: Some(if version.stable { "stable" } else { "snapshot" }.to_owned()),
125        }
126    }
127
128    fn release(
129        game_version: MinecraftVersionId,
130        version: Self::LoaderGameVersion,
131    ) -> crate::catalog::LoaderRelease {
132        crate::catalog::LoaderRelease::new(
133            game_version,
134            LoaderVersionId::from(version.loader.version),
135        )
136        .with_description(Some(
137            if version.loader.stable {
138                "Stable"
139            } else {
140                "Unstable"
141            }
142            .to_owned(),
143        ))
144    }
145}
146
147impl LoaderProfileEndpoints for FabricEndpoints {
148    type LoaderProfile = LoaderProfile;
149
150    fn loader_profile_url(&self, game_version: &str, loader_version: &str) -> Result<String> {
151        FabricEndpoints::loader_profile_url(self, game_version, loader_version)
152    }
153}
154
155impl UpstreamUrlRewriter for FabricEndpoints {
156    fn rewrite_upstream(&self, raw_url: &str) -> Result<String> {
157        Ok(raw_url.to_owned())
158    }
159}