use elemental_schema::mojang::piston::{
PistonMetaArguments, PistonMetaAssetIndex, PistonMetaData, PistonMetaDownloads,
PistonMetaJavaVersion, PistonMetaLibraries, PistonMetaLogging,
};
use serde::Deserialize;
use crate::{
error::{Error, Result},
families::version_json::merge_piston_meta_arguments,
};
#[derive(Debug, Clone, Deserialize)]
struct EmbeddedVersionData {
#[serde(default)]
arguments: Option<PistonMetaArguments>,
#[serde(rename = "minecraftArguments", default)]
minecraft_arguments: Option<String>,
#[serde(rename = "inheritsFrom", default)]
inherits_from: Option<String>,
#[serde(rename = "clientVersion", default)]
client_version: Option<String>,
#[serde(rename = "assetIndex", default)]
asset_index: Option<PistonMetaAssetIndex>,
#[serde(default)]
assets: Option<String>,
#[serde(rename = "complianceLevel", default)]
compliance_level: Option<usize>,
#[serde(default)]
downloads: Option<PistonMetaDownloads>,
#[serde(default)]
id: Option<String>,
#[serde(rename = "javaVersion", default)]
java_version: Option<PistonMetaJavaVersion>,
#[serde(default)]
libraries: Vec<PistonMetaLibraries>,
#[serde(default)]
logging: Option<PistonMetaLogging>,
#[serde(rename = "mainClass", default)]
main_class: Option<String>,
#[serde(rename = "minimumLauncherVersion", default)]
minimum_launcher_version: Option<usize>,
#[serde(rename = "type", default)]
release_type: Option<String>,
#[serde(default)]
time: Option<String>,
#[serde(rename = "releaseTime", default)]
release_time: Option<String>,
}
pub(super) fn merge_embedded_version<F, M>(
base_metadata: PistonMetaData,
embedded_version: &serde_json::Value,
normalize_libraries: F,
merge_libraries: M,
family_name: &str,
) -> Result<PistonMetaData>
where
F: Fn(Vec<PistonMetaLibraries>) -> Result<Vec<PistonMetaLibraries>>,
M: Fn(Vec<PistonMetaLibraries>, Vec<PistonMetaLibraries>) -> Vec<PistonMetaLibraries>,
{
let mut embedded = serde_json::from_value::<EmbeddedVersionData>(embedded_version.clone())
.map_err(|source| Error::DecodeEmbeddedVersion {
family_name: family_name.to_owned(),
source,
})?;
embedded.libraries = normalize_libraries(embedded.libraries)?;
let PistonMetaData {
arguments: base_arguments,
minecraft_arguments: base_minecraft_arguments,
inherits_from,
client_version,
asset_index,
assets,
compliance_level,
downloads,
id,
java_version,
libraries: base_libraries,
logging,
main_class,
minimum_launcher_version,
release_type,
time,
release_time,
} = base_metadata;
let (arguments, minecraft_arguments) = merge_embedded_arguments(
base_arguments,
base_minecraft_arguments,
embedded.arguments,
embedded.minecraft_arguments,
)?;
Ok(PistonMetaData {
arguments,
minecraft_arguments,
inherits_from: embedded.inherits_from.or(inherits_from),
client_version: embedded.client_version.or(client_version),
asset_index: embedded.asset_index.unwrap_or(asset_index),
assets: embedded.assets.unwrap_or(assets),
compliance_level: embedded.compliance_level.unwrap_or(compliance_level),
downloads: embedded.downloads.unwrap_or(downloads),
id: embedded.id.unwrap_or(id),
java_version: embedded.java_version.unwrap_or(java_version),
libraries: merge_libraries(base_libraries, embedded.libraries),
logging: merge_embedded_logging(logging, embedded.logging),
main_class: embedded.main_class.unwrap_or(main_class),
minimum_launcher_version: embedded
.minimum_launcher_version
.unwrap_or(minimum_launcher_version),
release_type: embedded.release_type.unwrap_or(release_type),
time: embedded.time.unwrap_or(time),
release_time: embedded.release_time.unwrap_or(release_time),
})
}
fn merge_embedded_arguments(
base_arguments: Option<PistonMetaArguments>,
base_minecraft_arguments: Option<String>,
embedded_arguments: Option<PistonMetaArguments>,
embedded_minecraft_arguments: Option<String>,
) -> Result<(Option<PistonMetaArguments>, Option<String>)> {
if embedded_minecraft_arguments.is_some() {
return Ok((None, embedded_minecraft_arguments));
}
Ok((
merge_piston_meta_arguments(base_arguments, base_minecraft_arguments, embedded_arguments)?,
None,
))
}
fn merge_embedded_logging(
base_logging: Option<PistonMetaLogging>,
embedded_logging: Option<PistonMetaLogging>,
) -> Option<PistonMetaLogging> {
match (base_logging, embedded_logging) {
(Some(base), Some(embedded)) => Some(PistonMetaLogging {
client: embedded.client.or(base.client),
}),
(base, embedded) => embedded.or(base),
}
}