From 1782b86d68ec923df965386acd98f80ef6bcaa46 Mon Sep 17 00:00:00 2001 From: bigfoot547 Date: Mon, 20 Jan 2025 00:53:39 -0600 Subject: get rid of wacky closure business --- src/launcher/rules.rs | 2 +- src/launcher/runner.rs | 105 +++++++++++++++++++++++++++++++++++++++++-------- src/launcher/strsub.rs | 83 ++++++++++++++++++-------------------- 3 files changed, 128 insertions(+), 62 deletions(-) (limited to 'src/launcher') diff --git a/src/launcher/rules.rs b/src/launcher/rules.rs index 29da8a2..69c967d 100644 --- a/src/launcher/rules.rs +++ b/src/launcher/rules.rs @@ -31,7 +31,7 @@ mod seal { } pub trait CompatCheck: seal::CompatCheckInner { - fn rules_apply<'a>(&'a self, system: &SystemInfo, feature_matcher: impl FeatureMatcher<'a>) -> Result<(), IncompatibleError> { + fn rules_apply(&self, system: &SystemInfo, feature_matcher: &impl FeatureMatcher) -> Result<(), IncompatibleError> { let Some(rules) = self.get_rules() else { return Ok(()) }; let mut action = RuleAction::Disallow; diff --git a/src/launcher/runner.rs b/src/launcher/runner.rs index 8d12197..4d07f20 100644 --- a/src/launcher/runner.rs +++ b/src/launcher/runner.rs @@ -1,27 +1,34 @@ use std::borrow::Cow; -use crate::launcher::Launch; -use crate::launcher::strsub::SubFunc; +use std::ffi::OsString; +use std::iter; +use crate::version::{CompleteVersion, FeatureMatcher}; +use super::rules::CompatCheck; +use super::strsub::{self, SubFunc}; +use super::LaunchInfo; -impl<'k, 'rep, 'l: 'rep> SubFunc<'k, 'rep> for &'rep Launch<'l> { - fn substitute(self, key: &'k str) -> Option> { +#[derive(Clone, Copy)] +struct LaunchArgSub<'a: 'l, 'l, F: FeatureMatcher>(&'a LaunchInfo<'l, F>); + +impl<'rep, 'l, F: FeatureMatcher> SubFunc<'rep> for LaunchArgSub<'rep, 'l, F> { + fn substitute(&self, key: &str) -> Option> { match key { - "assets_index_name" => self.asset_index_name.as_ref().map(|s| Cow::Borrowed(s.as_str())), - "assets_root" => Some(self.launcher.assets.get_home().to_string_lossy()), + "assets_index_name" => self.0.asset_index_name.as_ref().map(|s| Cow::Borrowed(s.as_str())), + "assets_root" => Some(self.0.launcher.assets.get_home().to_string_lossy()), "auth_access_token" => Some(Cow::Borrowed("-")), // TODO "auth_player_name" => Some(Cow::Borrowed("Player")), // TODO "auth_session" => Some(Cow::Borrowed("-")), // TODO "auth_uuid" => Some(Cow::Borrowed("00000000-0000-0000-0000-000000000000")), // TODO "auth_xuid" => Some(Cow::Borrowed("00000000-0000-0000-0000-000000000000")), // TODO - "classpath" => Some(Cow::Borrowed(self.classpath.as_str())), // TODO + "classpath" => Some(Cow::Borrowed(self.0.classpath.as_str())), // TODO "classpath_separator" => None, // FIXME - "game_assets" => self.virtual_assets_path.as_ref().map(|s| s.to_string_lossy()), - "game_directory" => Some(self.instance_home.to_string_lossy()), + "game_assets" => self.0.virtual_assets_path.as_ref().map(|s| s.to_string_lossy()), + "game_directory" => Some(self.0.instance_home.to_string_lossy()), "language" => Some(Cow::Borrowed("en-us")), // ??? "launcher_name" => Some(Cow::Borrowed("ozone (olauncher 3)")), // TODO "launcher_version" => Some(Cow::Borrowed("yeah")), // TODO - "library_directory" => Some(self.launcher.libraries.home.to_string_lossy()), - "natives_directory" => Some(self.natives_path.to_string_lossy()), - "primary_jar" => self.client_jar.as_ref().map(|p| p.to_string_lossy()), + "library_directory" => Some(self.0.launcher.libraries.home.to_string_lossy()), + "natives_directory" => Some(self.0.natives_path.to_string_lossy()), + "primary_jar" => self.0.client_jar.as_ref().map(|p| p.to_string_lossy()), "quickPlayMultiplayer" => None, // TODO "quickPlayPath" => None, // TODO "quickPlayRealms" => None, // TODO @@ -31,17 +38,81 @@ impl<'k, 'rep, 'l: 'rep> SubFunc<'k, 'rep> for &'rep Launch<'l> { "user_properties" => Some(Cow::Borrowed("{}")), // TODO "user_property_map" => Some(Cow::Borrowed("[]")), // TODO "user_type" => Some(Cow::Borrowed("legacy")), // TODO - "version_name" => Some(Cow::Borrowed(&self.version_id.as_ref())), - "version_type" => self.version_type.as_ref().map(|s| Cow::Borrowed(s.to_str())), + "version_name" => Some(Cow::Borrowed(&self.0.version_id.as_ref())), + "version_type" => self.0.version_type.as_ref().map(|s| Cow::Borrowed(s.to_str())), _ => { if let Some(asset_key) = key.strip_prefix("asset=") { - return self.asset_index.as_ref() + return self.0.asset_index.as_ref() .map_or(None, |idx| idx.objects.get(asset_key)) - .map(|obj| Cow::Owned(self.launcher.assets.get_object_path(obj).to_string_lossy().into_owned())) + .map(|obj| Cow::Owned(self.0.launcher.assets.get_object_path(obj).to_string_lossy().into_owned())) } None } } } -} \ No newline at end of file +} + +#[derive(Clone, Copy)] +pub enum ArgumentType { + JVM, + Game +} + +struct OptionalIterator +where + I: Iterator +{ + opt: Option +} + +impl Iterator for OptionalIterator { + type Item = I::Item; + + fn next(&mut self) -> Option { + match self.opt { + Some(ref mut i) => i.next(), + None => None + } + } +} + +impl From> for OptionalIterator { + fn from(opt: Option) -> Self { + OptionalIterator { + opt: opt.map(IntoIterator::into_iter) + } + } +} + +pub fn build_arguments<'l, F: FeatureMatcher>(launch: &LaunchInfo<'l, F>, version: &CompleteVersion, arg_type: ArgumentType) -> Vec { + let sub = LaunchArgSub(launch); + let system_info = &launch.launcher.system_info; + + if let Some(arguments) = version.arguments.as_ref().map_or(None, |args| match arg_type { + ArgumentType::JVM => args.jvm.as_ref(), + ArgumentType::Game => args.game.as_ref() + }) { + arguments.iter() + .flat_map(|wa| OptionalIterator::from(wa.rules_apply(system_info, launch.feature_matcher).ok().map(|_| &wa.value))) + .map(|s| OsString::from(strsub::replace_string(s, &sub).into_owned())).collect() + } else if let Some(arguments) = version.minecraft_arguments.as_ref() { + match arg_type { + ArgumentType::JVM => { + todo!() + } + ArgumentType::Game => { + arguments.split(' ') + .chain(iter::once("--demo") + .take_while(|_| launch.feature_matcher.matches("is_demo_user"))) + .chain(iter::once(["--width", "${resolution_width}", "--height", "${resolution_height}"]) + .take_while(|_| launch.feature_matcher.matches("has_custom_resolution")) + .flatten()) + .map(|s| OsString::from(strsub::replace_string(s, &sub).into_owned())) + .collect() + } + } + } else { + Vec::default() + } +} diff --git a/src/launcher/strsub.rs b/src/launcher/strsub.rs index c89681e..0d2357d 100644 --- a/src/launcher/strsub.rs +++ b/src/launcher/strsub.rs @@ -8,17 +8,8 @@ const VAR_BEGIN: &str = "${"; const VAR_END: &str = "}"; const VAR_DEFAULT: &str = ":-"; -pub trait SubFunc<'k, 'rep>: Copy { - fn substitute(self, key: &'k str) -> Option>; -} - -impl<'k, 'rep, F> SubFunc<'k, 'rep> for F -where - F: Fn(&'k str) -> Option> + Copy -{ - fn substitute(self, key: &'k str) -> Option> { - self(key) - } +pub trait SubFunc<'rep> { + fn substitute(&self, key: &str) -> Option>; } /* NOTE: the in-place implementation has been replaced for the following reasons: @@ -69,7 +60,7 @@ where } }*/ -pub fn replace_string<'k, 'rep>(input: &'k str, sub: impl SubFunc<'k, 'rep>) -> Cow<'k, str> { +pub fn replace_string<'inp, 'rep>(input: &'inp str, sub: &impl SubFunc<'rep>) -> Cow<'inp, str> { let mut ret: Option = None; let mut cursor = 0usize; @@ -125,73 +116,77 @@ pub fn replace_string<'k, 'rep>(input: &'k str, sub: impl SubFunc<'k, 'rep>) -> mod tests { use super::*; - fn replace_fun(key: &str) -> Option> { - match key { - "exists" => Some(Cow::Borrowed("value123")), - "empty" => None, - "borger" => Some(Cow::Borrowed("\u{1f354}")), - _ => panic!("replace_fun called with unexpected key: {}", key) + #[derive(Clone, Copy)] + struct TestSub; + impl SubFunc<'static> for TestSub { + fn substitute(&self, key: &str) -> Option> { + match key { + "exists" => Some(Cow::Borrowed("value123")), + "empty" => None, + "borger" => Some(Cow::Borrowed("\u{1f354}")), + _ => panic!("replace_fun called with unexpected key: {}", key) + } } } #[test] fn test_standard_replace() { - assert_eq!(replace_string("this has ${exists} and more", replace_fun), "this has value123 and more"); - assert_eq!(replace_string("multiple ${exists} repl${exists}ace", replace_fun), "multiple value123 replvalue123ace"); - assert_eq!(replace_string("${exists}${exists}", replace_fun), "value123value123"); + assert_eq!(replace_string("this has ${exists} and more", &TestSub), "this has value123 and more"); + assert_eq!(replace_string("multiple ${exists} repl${exists}ace", &TestSub), "multiple value123 replvalue123ace"); + assert_eq!(replace_string("${exists}${exists}", &TestSub), "value123value123"); } #[test] fn test_empty_replace() { - assert_eq!(replace_string("this has ${empty} and more", replace_fun), "this has ${empty} and more"); - assert_eq!(replace_string("multiple ${empty} repl${empty}ace", replace_fun), "multiple ${empty} repl${empty}ace"); - assert_eq!(replace_string("${empty}${empty}", replace_fun), "${empty}${empty}"); + assert_eq!(replace_string("this has ${empty} and more", &TestSub), "this has ${empty} and more"); + assert_eq!(replace_string("multiple ${empty} repl${empty}ace", &TestSub), "multiple ${empty} repl${empty}ace"); + assert_eq!(replace_string("${empty}${empty}", &TestSub), "${empty}${empty}"); } #[test] fn test_homogenous_replace() { - assert_eq!(replace_string("some ${exists} and ${empty} ...", replace_fun), "some value123 and ${empty} ..."); - assert_eq!(replace_string("some ${empty} and ${exists} ...", replace_fun), "some ${empty} and value123 ..."); - assert_eq!(replace_string("${exists}${empty}", replace_fun), "value123${empty}"); - assert_eq!(replace_string("${empty}${exists}", replace_fun), "${empty}value123"); + assert_eq!(replace_string("some ${exists} and ${empty} ...", &TestSub), "some value123 and ${empty} ..."); + assert_eq!(replace_string("some ${empty} and ${exists} ...", &TestSub), "some ${empty} and value123 ..."); + assert_eq!(replace_string("${exists}${empty}", &TestSub), "value123${empty}"); + assert_eq!(replace_string("${empty}${exists}", &TestSub), "${empty}value123"); } #[test] fn test_default_replace() { - assert_eq!(replace_string("some ${exists:-def1} and ${empty:-def2} ...", replace_fun), "some value123 and def2 ..."); - assert_eq!(replace_string("some ${empty:-def1} and ${exists:-def2} ...", replace_fun), "some def1 and value123 ..."); - assert_eq!(replace_string("abc${empty:-}def", replace_fun), "abcdef"); - assert_eq!(replace_string("${empty:-}${empty:-}", replace_fun), ""); + assert_eq!(replace_string("some ${exists:-def1} and ${empty:-def2} ...", &TestSub), "some value123 and def2 ..."); + assert_eq!(replace_string("some ${empty:-def1} and ${exists:-def2} ...", &TestSub), "some def1 and value123 ..."); + assert_eq!(replace_string("abc${empty:-}def", &TestSub), "abcdef"); + assert_eq!(replace_string("${empty:-}${empty:-}", &TestSub), ""); } #[test] fn test_escape() { - assert_eq!(replace_string("an $${escaped} replacement (${exists})", replace_fun), "an ${escaped} replacement (value123)"); - assert_eq!(replace_string("${exists}$${escaped}${exists}", replace_fun), "value123${escaped}value123"); + assert_eq!(replace_string("an $${escaped} replacement (${exists})", &TestSub), "an ${escaped} replacement (value123)"); + assert_eq!(replace_string("${exists}$${escaped}${exists}", &TestSub), "value123${escaped}value123"); // make sure this weird behavior is preserved... (the original code seemed to show it) - assert_eq!(replace_string("some $${ else", replace_fun), "some ${ else"); + assert_eq!(replace_string("some $${ else", &TestSub), "some ${ else"); } #[test] fn test_weird() { - assert_eq!(replace_string("${exists}", replace_fun), "value123"); - assert_eq!(replace_string("$${empty}", replace_fun), "${empty}"); - assert_eq!(replace_string("${empty:-a}", replace_fun), "a"); - assert_eq!(replace_string("${empty:-}", replace_fun), ""); + assert_eq!(replace_string("${exists}", &TestSub), "value123"); + assert_eq!(replace_string("$${empty}", &TestSub), "${empty}"); + assert_eq!(replace_string("${empty:-a}", &TestSub), "a"); + assert_eq!(replace_string("${empty:-}", &TestSub), ""); } // these make sure it doesn't chop up multibyte characters illegally #[test] fn test_multibyte_surround() { - assert_eq!(replace_string("\u{1f354}$${}\u{1f354}", replace_fun), "\u{1f354}${}\u{1f354}"); - assert_eq!(replace_string("\u{1f354}${exists}\u{1f354}${empty:-}\u{1f354}", replace_fun), "\u{1f354}value123\u{1f354}\u{1f354}"); + assert_eq!(replace_string("\u{1f354}$${}\u{1f354}", &TestSub), "\u{1f354}${}\u{1f354}"); + assert_eq!(replace_string("\u{1f354}${exists}\u{1f354}${empty:-}\u{1f354}", &TestSub), "\u{1f354}value123\u{1f354}\u{1f354}"); } #[test] fn test_multibyte_replace() { - assert_eq!(replace_string("borger ${borger}", replace_fun), "borger \u{1f354}"); - assert_eq!(replace_string("${exists:-\u{1f354}}${empty:-\u{1f354}}", replace_fun), "value123\u{1f354}"); - assert_eq!(replace_string("${borger}$${}${borger}", replace_fun), "\u{1f354}${}\u{1f354}"); + assert_eq!(replace_string("borger ${borger}", &TestSub), "borger \u{1f354}"); + assert_eq!(replace_string("${exists:-\u{1f354}}${empty:-\u{1f354}}", &TestSub), "value123\u{1f354}"); + assert_eq!(replace_string("${borger}$${}${borger}", &TestSub), "\u{1f354}${}\u{1f354}"); } } -- cgit v1.2.3-70-g09d2