Lua integration tests with some of the API's working!

Author: makspll

.rustfmt.toml

@@ -1,3 +1,8 @@
 # max_width = 60
 # use_small_heuristics = "Max"
 # format_generated_files = false
+
+reorder_imports = true
+# currently unsupported but want them in when stable
+imports_granularity = "Crate"
+group_imports = "StdExternalCrate"

Cargo.toml

@@ -73,6 +73,7 @@ bevy_script_api = { path = "crates/bevy_script_api", version = "0.8.0-alpha.1",
 bevy = { version = "0.15.0-rc.3", default-features = false }
 bevy_mod_scripting_core = { path = "crates/bevy_mod_scripting_core", version = "0.8.0-alpha.1" }
 bevy_mod_scripting_common = { path = "crates/bevy_mod_scripting_common", version = "0.8.0-alpha.1" }
+test_utils = { path = "crates/test_utils" }
 
 [dev-dependencies]
 bevy = { workspace = true, default-features = true }
@@ -93,6 +94,7 @@ members = [
     "crates/languages/bevy_mod_scripting_rune",
     "crates/bevy_mod_scripting_common",
     "crates/bevy_mod_scripting_derive",
+    "crates/test_utils",
 ]
 resolver = "2"
 exclude = ["crates/bevy_api_gen", "crates/macro_tests"]

crates/bevy_mod_scripting_core/Cargo.toml

@@ -27,3 +27,6 @@ paste = "1.0.7"
 parking_lot = "0.12.1"
 lockable = "0.0.8"
 smallvec = "1.11"
+
+[dev-dependencies]
+test_utils = { workspace = true }

crates/bevy_mod_scripting_core/src/bindings/query.rs

@@ -1,56 +1,60 @@
+use super::{ReflectReference, WorldCallbackAccess};
+use crate::prelude::ScriptResult;
+use bevy::{
+    ecs::{component::ComponentId, entity::Entity},
+    reflect::TypeRegistration,
+};
 use std::{any::TypeId, ops::Deref, sync::Arc};
 
-use bevy::{ecs::entity::Entity, reflect::TypeRegistration};
-
-use super::{ReflectReference, WorldCallbackAccess, STALE_WORLD_MSG};
-use crate::prelude::{ScriptError, ScriptResult};
-
 /// A wrapper around a `TypeRegistration` that provides additional information about the type.
 ///
 /// This is used as a hook to a rust type from a scripting language. We should be able to easily convert between a type name and a [`ScriptTypeRegistration`].
 #[derive(Clone)]
-pub struct ScriptTypeRegistration(pub(crate) Arc<TypeRegistration>);
+pub struct ScriptTypeRegistration {
+    pub(crate) registration: Arc<TypeRegistration>,
+    pub component_id: Option<ComponentId>,
+}
 
 impl ScriptTypeRegistration {
-    pub fn new(arc: Arc<TypeRegistration>) -> Self {
-        Self(arc)
+    pub fn new(registration: Arc<TypeRegistration>, component_id: Option<ComponentId>) -> Self {
+        Self {
+            registration,
+            component_id,
+        }
     }
 
     #[inline(always)]
     pub fn short_name(&self) -> &str {
-        self.0.type_info().type_path_table().short_path()
+        self.registration.type_info().type_path_table().short_path()
     }
 
     #[inline(always)]
     pub fn type_name(&self) -> &'static str {
-        self.0.type_info().type_path_table().path()
+        self.registration.type_info().type_path_table().path()
     }
 
     #[inline(always)]
     pub fn type_id(&self) -> TypeId {
-        self.0.type_info().type_id()
+        self.registration.type_info().type_id()
+    }
+
+    #[inline(always)]
+    pub fn component_id(&self) -> Option<ComponentId> {
+        self.component_id
     }
 }
 
 impl std::fmt::Debug for ScriptTypeRegistration {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_tuple("ScriptTypeRegistration")
-            .field(&self.0.type_info().type_path())
+            .field(&self.registration.type_info().type_path())
             .finish()
     }
 }
 
 impl std::fmt::Display for ScriptTypeRegistration {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.0.type_info().type_path())
-    }
-}
-
-impl Deref for ScriptTypeRegistration {
-    type Target = Arc<TypeRegistration>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
+        f.write_str(self.registration.type_info().type_path())
     }
 }
 

crates/bevy_mod_scripting_core/src/bindings/reference.rs

@@ -28,7 +28,8 @@ use bevy::{
     },
     ptr::Ptr,
     reflect::{
-        Access, ParsedPath, PartialReflect, Reflect, ReflectFromPtr, ReflectPath, ReflectPathError, TypeInfo, TypeRegistry
+        Access, ParsedPath, PartialReflect, Reflect, ReflectFromPtr, ReflectPath, ReflectPathError,
+        TypeInfo, TypeRegistry,
     },
 };
 use smallvec::SmallVec;
@@ -59,7 +60,6 @@ pub struct ReflectReference {
 struct UnregisteredType;
 
 impl ReflectReference {
-
     pub fn new_allocated<T: PartialReflect>(
         value: T,
         allocator: &mut ReflectAllocator,
@@ -269,7 +269,8 @@ impl ReflectReference {
         allocator: Option<&ReflectAllocator>,
     ) -> ScriptResult<&'w mut dyn PartialReflect> {
         if let ReflectBase::Owned(id) = &self.base.base_id {
-            let allocator = allocator.ok_or_else(|| ScriptError::new_reflection_error("Allocator missing"))?;
+            let allocator =
+                allocator.ok_or_else(|| ScriptError::new_reflection_error("Allocator missing"))?;
 
             let arc = allocator
                 .get_mut(*id)
@@ -318,7 +319,10 @@ impl ReflectReference {
         Ok(current)
     }
 
-    fn walk_path_mut<'a>(&self, root: &'a mut dyn PartialReflect) -> ScriptResult<&'a mut dyn PartialReflect> {
+    fn walk_path_mut<'a>(
+        &self,
+        root: &'a mut dyn PartialReflect,
+    ) -> ScriptResult<&'a mut dyn PartialReflect> {
         let mut current = root;
         for elem in self.reflect_path.iter() {
             current = elem
@@ -428,8 +432,12 @@ impl ReflectionPathElem {
 
 impl<A: 'static, B: 'static> From<(A, B)> for DeferredReflection
 where
-    A: Fn(&dyn PartialReflect) -> Result<&dyn PartialReflect, ReflectPathError<'static>> + Send + Sync,
-    B: Fn(&mut dyn PartialReflect) -> Result<&mut dyn PartialReflect, ReflectPathError<'static>> + Send + Sync,
+    A: Fn(&dyn PartialReflect) -> Result<&dyn PartialReflect, ReflectPathError<'static>>
+        + Send
+        + Sync,
+    B: Fn(&mut dyn PartialReflect) -> Result<&mut dyn PartialReflect, ReflectPathError<'static>>
+        + Send
+        + Sync,
 {
     fn from((get, get_mut): (A, B)) -> Self {
         Self {
@@ -476,10 +484,15 @@ impl<'a> ReflectPath<'a> for &'a ReflectionPathElem {
 /// A ReflectPath which can perform arbitrary operations on the root object to produce a sub-reference
 #[derive(Clone)]
 pub struct DeferredReflection {
-    pub get:
-        Arc<dyn Fn(&dyn PartialReflect) -> Result<&dyn PartialReflect, ReflectPathError<'static>> + Send + Sync>,
+    pub get: Arc<
+        dyn Fn(&dyn PartialReflect) -> Result<&dyn PartialReflect, ReflectPathError<'static>>
+            + Send
+            + Sync,
+    >,
     pub get_mut: Arc<
-        dyn Fn(&mut dyn PartialReflect) -> Result<&mut dyn PartialReflect, ReflectPathError<'static>>
+        dyn Fn(
+                &mut dyn PartialReflect,
+            ) -> Result<&mut dyn PartialReflect, ReflectPathError<'static>>
             + Send
             + Sync,
     >,