Improve UI for adding intiializers and add docs, correct initialization of lua plugins

Author: makspll

crates/bevy_mod_scripting_core/src/lib.rs

@@ -65,7 +65,7 @@ pub struct ScriptingPlugin<P: IntoScriptPluginParams> {
     pub callback_handler: Option<HandlerFn<P>>,
     /// The context builder for loading contexts
     pub context_builder: ContextBuilder<P>,
-    /// The context assigner for assigning contexts to scripts, if not provided default strategy of keeping each script in its own context is used
+    /// The context assigner for assigning contexts to scripts.
     pub context_assigner: ContextAssigner<P>,
     pub language_mapper: Option<AssetPathToLanguageMapper>,
 
@@ -139,6 +139,40 @@ impl<P: IntoScriptPluginParams> ScriptingPlugin<P> {
     }
 }
 
+/// Utility trait for configuring all scripting plugins.
+pub trait ConfigureScriptPlugin {
+    type P: IntoScriptPluginParams;
+    fn add_context_initializer(self, initializer: ContextInitializer<Self::P>) -> Self;
+    fn add_context_pre_handling_initializer(
+        self,
+        initializer: ContextPreHandlingInitializer<Self::P>,
+    ) -> Self;
+    fn add_runtime_initializer(self, initializer: RuntimeInitializer<Self::P>) -> Self;
+}
+
+impl<P: IntoScriptPluginParams + AsMut<ScriptingPlugin<P>>> ConfigureScriptPlugin for P {
+    type P = P;
+
+    fn add_context_initializer(mut self, initializer: ContextInitializer<Self::P>) -> Self {
+        self.as_mut().add_context_initializer(initializer);
+        self
+    }
+
+    fn add_context_pre_handling_initializer(
+        mut self,
+        initializer: ContextPreHandlingInitializer<Self::P>,
+    ) -> Self {
+        self.as_mut()
+            .add_context_pre_handling_initializer(initializer);
+        self
+    }
+
+    fn add_runtime_initializer(mut self, initializer: RuntimeInitializer<Self::P>) -> Self {
+        self.as_mut().add_runtime_initializer(initializer);
+        self
+    }
+}
+
 // One of registration of things that need to be done only once per app
 fn once_per_app_init(app: &mut App) {
     #[derive(Resource)]

crates/languages/bevy_mod_scripting_lua/src/lib.rs

@@ -31,6 +31,13 @@ impl IntoScriptPluginParams for LuaScriptingPlugin {
     fn build_runtime() -> Self::R {}
 }
 
+// necessary for automatic config goodies
+impl AsMut<ScriptingPlugin<Self>> for LuaScriptingPlugin {
+    fn as_mut(&mut self) -> &mut ScriptingPlugin<LuaScriptingPlugin> {
+        &mut self.scripting_plugin
+    }
+}
+
 pub struct LuaScriptingPlugin {
     pub scripting_plugin: ScriptingPlugin<Self>,
 }
@@ -39,13 +46,13 @@ impl Default for LuaScriptingPlugin {
     fn default() -> Self {
         LuaScriptingPlugin {
             scripting_plugin: ScriptingPlugin {
-                context_assigner: None,
+                context_assigner: Default::default(),
                 runtime_settings: None,
                 callback_handler: Some(lua_handler),
-                context_builder: Some(ContextBuilder::<LuaScriptingPlugin> {
+                context_builder: ContextBuilder::<LuaScriptingPlugin> {
                     load: lua_context_load,
                     reload: lua_context_reload,
-                }),
+                },
                 language_mapper: Some(AssetPathToLanguageMapper {
                     map: lua_language_mapper,
                 }),

crates/languages/bevy_mod_scripting_lua/tests/lua_tests.rs

@@ -1,7 +1,7 @@
 use bevy_mod_scripting_core::{
     bindings::{pretty_print::DisplayWithWorld, ThreadWorldContainer, WorldContainer},
     error::ScriptError,
-    AddContextInitializer,
+    ConfigureScriptPlugin,
 };
 use bevy_mod_scripting_lua::LuaScriptingPlugin;
 use libtest_mimic::{Arguments, Failed, Trial};
@@ -26,8 +26,7 @@ impl Test {
                 let _ = type_registry;
             },
             |app| {
-                app.add_plugins(LuaScriptingPlugin::default());
-                app.add_context_initializer::<LuaScriptingPlugin>(|_,ctxt: &mut Lua| {
+                app.add_plugins(LuaScriptingPlugin::default().add_context_initializer(|_,ctxt: &mut Lua| {
                     let globals = ctxt.globals();
                     globals.set(
                         "assert_throws",
@@ -60,7 +59,7 @@ impl Test {
                         })?,
                     )?;
                     Ok(())
-                });
+                }));
             },
             self.path.as_os_str().to_str().unwrap(),
             self.code.as_bytes(),

crates/script_integration_test_harness/src/lib.rs

@@ -66,7 +66,7 @@ pub fn execute_integration_test<
         });
 
     // load the context as normal
-    let mut loaded_context = (context_settings.loader.unwrap().load)(
+    let mut loaded_context = (context_settings.loader.load)(
         &(script_id.to_owned()).into(),
         code,
         &context_settings.context_initializers,

docs/src/Summary/customizing-script-contexts.md

@@ -11,8 +11,7 @@ For example, let's say you want to set a dynamic amount of globals in your scrip
 
 You could do this by customizing the scripting plugin:
 ```rust,ignore
-let plugin = LuaScriptingPlugin::default();
-plugin.add_context_initializer(|script_id: &str, context: &mut Lua| {
+let plugin = LuaScriptingPlugin::default().add_context_initializer(|script_id: &str, context: &mut Lua| {
     let globals = context.globals();
     for i in 0..10 {
         globals.set(i, i);
@@ -29,8 +28,7 @@ The above will run every time the script is loaded or re-loaded.
 
 If you want to customize your context before every time it's about to handle events, you can use `Context Pre Handling Initializers`:
 ```rust,ignore
-let plugin = LuaScriptingPlugin::default();
-plugin.add_context_pre_handling_initializer(|script_id: &str, entity: Entity, context: &mut Lua| {
+let plugin = LuaScriptingPlugin::default().add_context_pre_handling_initializer(|script_id: &str, entity: Entity, context: &mut Lua| {
     let globals = context.globals();
     globals.set("script_name", script_id.to_owned());
     Ok(())
@@ -40,8 +38,7 @@ plugin.add_context_pre_handling_initializer(|script_id: &str, entity: Entity, co
 
 Some scripting languages, have the concept of a `runtime`. This is a global object which is shared between all contexts. You can customize this object using `Runtime Initializers`:
 ```rust,ignore
-let plugin = SomeScriptingPlugin::default();
-plugin.add_runtime_initializer(|runtime: &mut Runtime| {
+let plugin = SomeScriptingPlugin::default().add_runtime_initializer(|runtime: &mut Runtime| {
     runtime.set_max_stack_size(1000);
     Ok(())
 });

examples/game_of_life.rs

@@ -18,8 +18,8 @@ use bevy_mod_scripting_core::{
     bindings::{function::namespace::NamespaceBuilder, script_value::ScriptValue},
     callback_labels,
     event::ScriptCallbackEvent,
+    handler::event_handler,
     script::ScriptComponent,
-    systems::event_handler,
 };
 use bevy_mod_scripting_lua::LuaScriptingPlugin;
 // use bevy_mod_scripting_rhai::RhaiScriptingPlugin;