mcvm 0.25.0

A fast, extensible, and powerful Minecraft launcher
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

use std::collections::HashSet;
use std::path::PathBuf;

use crate::pkg::reg::CachingStrategy;
use crate::pkg::repo::{PkgRepo, PkgRepoLocation};
use mcvm_core::net::download::validate_url;

use anyhow::{bail, Context};
use mcvm_shared::lang::Language;
#[cfg(feature = "schema")]
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

/// Configured user preferences
#[derive(Debug)]
pub struct ConfigPreferences {
	/// Caching strategy for packages
	pub package_caching_strategy: CachingStrategy,
	/// The global language
	pub language: Language,
}

/// Deserialization struct for user preferences
#[derive(Deserialize, Serialize, Default)]
#[cfg_attr(feature = "schema", derive(JsonSchema))]
#[serde(default)]
pub struct PrefDeser {
	/// The user's configured repositories
	pub repositories: RepositoriesDeser,
	/// The user's configured strategy for package caching
	pub package_caching_strategy: CachingStrategy,
	/// The user's configured language
	pub language: Language,
}

/// Deserialization struct for a package repo
#[derive(Deserialize, Serialize)]
#[cfg_attr(feature = "schema", derive(JsonSchema))]
pub struct RepoDeser {
	/// The ID of the repository
	pub id: String,
	/// The URL to the repository, which may not exist
	#[serde(skip_serializing_if = "Option::is_none")]
	pub url: Option<String>,
	/// The Path to the repository, which may not exist
	#[serde(skip_serializing_if = "Option::is_none")]
	pub path: Option<String>,
	/// Whether to disable the repo and not add it to the list
	#[serde(default)]
	pub disable: bool,
}

/// Deserialization struct for all configured package repositories
#[derive(Deserialize, Serialize)]
#[cfg_attr(feature = "schema", derive(JsonSchema))]
#[serde(default)]
pub struct RepositoriesDeser {
	/// The preferred repositories over the default ones
	#[serde(skip_serializing_if = "Vec::is_empty")]
	pub preferred: Vec<RepoDeser>,
	/// The backup repositories included after the default ones
	#[serde(skip_serializing_if = "Vec::is_empty")]
	pub backup: Vec<RepoDeser>,
	/// Whether to enable the core repository
	pub enable_core: bool,
	/// Whether to enable the std repository
	pub enable_std: bool,
}

impl Default for RepositoriesDeser {
	fn default() -> Self {
		Self {
			preferred: Vec::new(),
			backup: Vec::new(),
			enable_core: true,
			enable_std: true,
		}
	}
}

impl ConfigPreferences {
	/// Convert deserialized preferences to the stored format and returns
	/// a list of repositories to add.
	pub fn read(prefs: &PrefDeser) -> anyhow::Result<(Self, Vec<PkgRepo>)> {
		let mut repositories = Vec::new();
		for repo in prefs.repositories.preferred.iter() {
			if !repo.disable {
				add_repo(&mut repositories, repo)?;
			}
		}
		repositories.extend(PkgRepo::default_repos(
			prefs.repositories.enable_core,
			prefs.repositories.enable_std,
		));
		for repo in prefs.repositories.backup.iter() {
			if !repo.disable {
				add_repo(&mut repositories, repo)?;
			}
		}

		// Check for duplicate IDs
		let mut existing = HashSet::new();
		for repo in &repositories {
			if existing.contains(&repo.id) {
				bail!("Duplicate repository ID '{}'", repo.id);
			}
			existing.insert(&repo.id);
		}

		Ok((
			Self {
				package_caching_strategy: prefs.package_caching_strategy.clone(),
				language: prefs.language,
			},
			repositories,
		))
	}
}

/// Add a repo to the list
fn add_repo(repos: &mut Vec<PkgRepo>, repo: &RepoDeser) -> anyhow::Result<()> {
	let location = if let Some(url) = &repo.url {
		validate_url(url).with_context(|| {
			format!("Invalid url '{}' in package repository '{}'", url, repo.id)
		})?;
		PkgRepoLocation::Remote(url.clone())
	} else if let Some(path) = &repo.path {
		PkgRepoLocation::Local(PathBuf::from(path))
	} else {
		bail!("Niether path nor URL was set for repository {}", repo.id);
	};
	repos.push(PkgRepo::new(&repo.id, location));
	Ok(())
}