elemental_core/minecraft/
version.rs1use 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#[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;