remove some unnecessary optionals

Author: makspll

crates/bevy_mod_scripting_core/src/commands.rs

@@ -35,8 +35,7 @@ impl<P: IntoScriptPluginParams> Command for DeleteScript<P> {
         let runner = world
             .get_resource::<CallbackSettings<P>>()
             .expect("No CallbackSettings resource found")
-            .callback_handler
-            .expect("No callback handler set");
+            .callback_handler;
 
         let mut ctxts = world
             .remove_non_send_resource::<ScriptContexts<P>>()
@@ -132,7 +131,7 @@ impl<P: IntoScriptPluginParams> Command for CreateOrUpdateScript<P> {
         // assign context
         let assigner = settings.assigner.clone();
         let builder = settings.loader.clone();
-        let runner = runner.callback_handler.expect("No callback handler set");
+        let runner = runner.callback_handler;
 
         world.resource_scope(|world, mut scripts: Mut<Scripts>| {
 

crates/bevy_mod_scripting_core/src/handler.rs

@@ -38,15 +38,7 @@ pub type HandlerFn<P> = fn(
 /// A resource that holds the settings for the callback handler for a specific combination of type parameters
 #[derive(Resource)]
 pub struct CallbackSettings<P: IntoScriptPluginParams> {
-    pub callback_handler: Option<HandlerFn<P>>,
-}
-
-impl<P: IntoScriptPluginParams> Default for CallbackSettings<P> {
-    fn default() -> Self {
-        Self {
-            callback_handler: None,
-        }
-    }
+    pub callback_handler: HandlerFn<P>,
 }
 
 macro_rules! push_err_and_continue {
@@ -88,16 +80,7 @@ pub fn event_handler<L: IntoCallbackLabel, P: IntoScriptPluginParams>(
     let (mut script_events, callback_settings, context_settings, scripts, entities) =
         params.get_mut(world);
 
-    let handler = *callback_settings
-        .callback_handler
-        .as_ref()
-        .unwrap_or_else(|| {
-            panic!(
-                "No handler registered for - Runtime: {}, Context: {}",
-                type_name::<P::R>(),
-                type_name::<P::C>()
-            )
-        });
+    let handler = callback_settings.callback_handler;
     let pre_handling_initializers = context_settings.context_pre_handling_initializers.clone();
     let scripts = scripts.clone();
     let mut errors = Vec::default();
@@ -253,7 +236,7 @@ mod test {
         app.add_event::<ScriptCallbackEvent>();
         app.add_event::<ScriptErrorEvent>();
         app.insert_resource::<CallbackSettings<P>>(CallbackSettings {
-            callback_handler: Some(handler_fn),
+            callback_handler: handler_fn,
         });
         app.add_systems(Update, event_handler::<L, P>);
         app.insert_resource::<Scripts>(Scripts { scripts });

crates/bevy_mod_scripting_core/src/lib.rs

@@ -53,21 +53,20 @@ pub trait IntoScriptPluginParams: 'static {
     type R: Runtime;
 
     fn build_runtime() -> Self::R;
-
-    // fn supported_language() -> Language;
 }
 
 /// Bevy plugin enabling scripting within the bevy mod scripting framework
 pub struct ScriptingPlugin<P: IntoScriptPluginParams> {
     /// Settings for the runtime
-    pub runtime_settings: Option<RuntimeSettings<P>>,
+    pub runtime_settings: RuntimeSettings<P>,
     /// The handler used for executing callbacks in scripts
-    pub callback_handler: Option<HandlerFn<P>>,
+    pub callback_handler: HandlerFn<P>,
     /// The context builder for loading contexts
     pub context_builder: ContextBuilder<P>,
     /// The context assigner for assigning contexts to scripts.
     pub context_assigner: ContextAssigner<P>,
-    pub language_mapper: Option<AssetPathToLanguageMapper>,
+
+    pub language_mapper: AssetPathToLanguageMapper,
 
     /// initializers for the contexts, run when loading the script
     pub context_initializers: Vec<ContextInitializer<P>>,
@@ -77,7 +76,7 @@ pub struct ScriptingPlugin<P: IntoScriptPluginParams> {
 
 impl<P: IntoScriptPluginParams> Plugin for ScriptingPlugin<P> {
     fn build(&self, app: &mut bevy::prelude::App) {
-        app.insert_resource(self.runtime_settings.as_ref().cloned().unwrap_or_default())
+        app.insert_resource(self.runtime_settings.clone())
             .insert_non_send_resource::<RuntimeContainer<P>>(RuntimeContainer {
                 runtime: P::build_runtime(),
             })
@@ -95,13 +94,11 @@ impl<P: IntoScriptPluginParams> Plugin for ScriptingPlugin<P> {
         register_script_plugin_systems::<P>(app);
         once_per_app_init(app);
 
-        if let Some(language_mapper) = &self.language_mapper {
-            app.world_mut()
-                .resource_mut::<ScriptAssetSettings>()
-                .as_mut()
-                .script_language_mappers
-                .push(*language_mapper);
-        }
+        app.world_mut()
+            .resource_mut::<ScriptAssetSettings>()
+            .as_mut()
+            .script_language_mappers
+            .push(self.language_mapper);
 
         register_types(app);
     }
@@ -131,10 +128,7 @@ impl<P: IntoScriptPluginParams> ScriptingPlugin<P> {
     ///
     /// Initializers will be run after the runtime is created, but before any contexts are loaded.
     pub fn add_runtime_initializer(&mut self, initializer: RuntimeInitializer<P>) -> &mut Self {
-        self.runtime_settings
-            .get_or_insert_with(Default::default)
-            .initializers
-            .push(initializer);
+        self.runtime_settings.initializers.push(initializer);
         self
     }
 }

crates/languages/bevy_mod_scripting_lua/src/lib.rs

@@ -12,6 +12,7 @@ use bevy_mod_scripting_core::{
     error::ScriptError,
     event::CallbackLabel,
     reflection_extensions::PartialReflectExt,
+    runtime::RuntimeSettings,
     script::ScriptId,
     IntoScriptPluginParams, ScriptingPlugin,
 };
@@ -47,15 +48,15 @@ impl Default for LuaScriptingPlugin {
         LuaScriptingPlugin {
             scripting_plugin: ScriptingPlugin {
                 context_assigner: Default::default(),
-                runtime_settings: None,
-                callback_handler: Some(lua_handler),
+                runtime_settings: RuntimeSettings::default(),
+                callback_handler: lua_handler,
                 context_builder: ContextBuilder::<LuaScriptingPlugin> {
                     load: lua_context_load,
                     reload: lua_context_reload,
                 },
-                language_mapper: Some(AssetPathToLanguageMapper {
+                language_mapper: AssetPathToLanguageMapper {
                     map: lua_language_mapper,
-                }),
+                },
                 context_initializers: vec![
                     |_script_id, context| {
                         // set the world global

crates/script_integration_test_harness/src/lib.rs

@@ -81,7 +81,7 @@ pub fn execute_integration_test<
     })?;
 
     // call on_script_loaded as normal
-    let val = (callback_settings.callback_handler.unwrap())(
+    let val = (callback_settings.callback_handler)(
         vec![],
         Entity::from_raw(0),
         &(script_id.to_owned()).into(),
@@ -98,7 +98,7 @@ pub fn execute_integration_test<
     }
 
     // call on_test callback
-    let val = (callback_settings.callback_handler.unwrap())(
+    let val = (callback_settings.callback_handler)(
         vec![],
         Entity::from_raw(0),
         &(script_id.to_owned()).into(),