Skip to main content

elemental_core/minecraft/
version.rs

1use std::{fmt::Display, str::FromStr};
2
3use crate::version::Version;
4
5mod error;
6mod kind;
7mod parse;
8
9pub use error::MinecraftVersionParseError;
10pub use kind::{
11    AlphaBetaVersion, LegacyReleaseVersion, LegacySnapshotVersion, MinecraftVersionKey,
12    MinecraftVersionKind, VersionStage, YearReleaseVersion, YearSnapshotVersion,
13};
14
15use parse::{normalize_year, parse_alpha_beta, parse_legacy_snapshot, parse_release};
16
17#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
18pub struct MinecraftVersionTag;
19
20pub type MinecraftVersionId = Version<MinecraftVersionTag>;
21
22/// A parsed Minecraft version.
23///
24/// The identifier keeps the exact upstream string, while [`MinecraftVersion::key`]
25/// provides a stable semantic ordering across legacy and year-based version schemes.
26#[derive(Debug, Clone, PartialEq, Eq, Hash)]
27pub struct MinecraftVersion {
28    id: MinecraftVersionId,
29    kind: MinecraftVersionKind,
30    key: MinecraftVersionKey,
31}
32
33impl MinecraftVersion {
34    pub fn parse(raw: &str) -> Result<Self, MinecraftVersionParseError> {
35        validate_non_empty(raw)?;
36        parse_known_format(raw)
37    }
38
39    pub fn parse_id(id: &MinecraftVersionId) -> Result<Self, MinecraftVersionParseError> {
40        Self::parse(id.as_str())
41    }
42
43    pub fn legacy_release(major: u32, minor: u32, patch: u32) -> Self {
44        let raw = format!("{major}.{minor}.{patch}");
45        let kind = MinecraftVersionKind::LegacyRelease(LegacyReleaseVersion {
46            major,
47            minor,
48            patch,
49            stage: VersionStage::Release,
50            stage_number: 0,
51        });
52        Self::from_kind(&raw, kind)
53    }
54
55    pub fn year_release(year: u32, release: u32, patch: u32) -> Self {
56        let full_year = normalize_year(year);
57        let raw = canonical_year_id(full_year, release, patch);
58        let kind = MinecraftVersionKind::YearRelease(YearReleaseVersion {
59            year: full_year,
60            release,
61            patch,
62            stage: VersionStage::Release,
63            stage_number: 0,
64        });
65        Self::from_kind(&raw, kind)
66    }
67
68    pub fn id(&self) -> &MinecraftVersionId {
69        &self.id
70    }
71
72    pub fn into_id(self) -> MinecraftVersionId {
73        self.id
74    }
75
76    pub fn raw(&self) -> &str {
77        self.id.as_str()
78    }
79
80    pub fn kind(&self) -> &MinecraftVersionKind {
81        &self.kind
82    }
83
84    pub fn key(&self) -> MinecraftVersionKey {
85        self.key
86    }
87
88    fn from_kind(raw: &str, kind: MinecraftVersionKind) -> Self {
89        Self {
90            id: MinecraftVersionId::from(raw),
91            key: kind.into(),
92            kind,
93        }
94    }
95}
96
97fn validate_non_empty(raw: &str) -> Result<(), MinecraftVersionParseError> {
98    if raw.is_empty() {
99        Err(MinecraftVersionParseError::Empty)
100    } else {
101        Ok(())
102    }
103}
104
105fn parse_known_format(raw: &str) -> Result<MinecraftVersion, MinecraftVersionParseError> {
106    if let Some(version) = parse_alpha_beta(raw)? {
107        return Ok(version);
108    }
109
110    match parse_legacy_snapshot(raw)? {
111        Some(version) => Ok(version),
112        None => parse_release(raw),
113    }
114}
115
116fn canonical_year_id(year: u32, release: u32, patch: u32) -> String {
117    let display_year = if (2000..=2099).contains(&year) {
118        year - 2000
119    } else {
120        year
121    };
122
123    if patch == 0 {
124        format!("{display_year}.{release}")
125    } else {
126        format!("{display_year}.{release}.{patch}")
127    }
128}
129
130impl Display for MinecraftVersion {
131    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
132        f.write_str(self.raw())
133    }
134}
135
136impl FromStr for MinecraftVersion {
137    type Err = MinecraftVersionParseError;
138
139    fn from_str(s: &str) -> Result<Self, Self::Err> {
140        Self::parse(s)
141    }
142}
143
144impl TryFrom<&str> for MinecraftVersion {
145    type Error = MinecraftVersionParseError;
146
147    fn try_from(value: &str) -> Result<Self, Self::Error> {
148        Self::parse(value)
149    }
150}
151
152impl TryFrom<String> for MinecraftVersion {
153    type Error = MinecraftVersionParseError;
154
155    fn try_from(value: String) -> Result<Self, Self::Error> {
156        Self::parse(value.as_str())
157    }
158}
159
160impl TryFrom<&MinecraftVersionId> for MinecraftVersion {
161    type Error = MinecraftVersionParseError;
162
163    fn try_from(value: &MinecraftVersionId) -> Result<Self, Self::Error> {
164        Self::parse_id(value)
165    }
166}
167
168impl TryFrom<MinecraftVersionId> for MinecraftVersion {
169    type Error = MinecraftVersionParseError;
170
171    fn try_from(value: MinecraftVersionId) -> Result<Self, Self::Error> {
172        Self::parse_id(&value)
173    }
174}
175
176#[cfg(test)]
177mod tests;