move namespace stuff into core

Author: makspll

crates/bevy_api_gen/templates/header.tera

@@ -14,7 +14,7 @@ use bevy_mod_scripting_core::{
     StoreDocumentation, 
     bindings::{
         ReflectReference, 
-        function::from::{Ref, Mut, Val}
+        function::{from::{Ref, Mut, Val}, namespace::{NamespaceBuilder}}
     }
 };
 {% if args.self_is_bms_lua %}

crates/bevy_mod_scripting_core/src/bindings/function/mod.rs

@@ -2,6 +2,7 @@ pub mod from;
 pub mod from_ref;
 pub mod into;
 pub mod into_ref;
+pub mod namespace;
 pub mod script_function;
 
 use script_function::{CallerContext, DynamicScriptFunction, DynamicScriptFunctionMut};

crates/bevy_mod_scripting_functions/src/namespaced_register.rs renamed to crates/bevy_mod_scripting_core/src/bindings/function/namespace.rs

@@ -1,11 +1,11 @@
+use crate::bindings::function::script_function::{
+    AppScriptFunctionRegistry, DynamicScriptFunction, GetFunctionTypeDependencies, ScriptFunction,
+    ScriptFunctionRegistry,
+};
 use bevy::{
     prelude::{AppTypeRegistry, World},
     reflect::GetTypeRegistration,
 };
-use bevy_mod_scripting_core::bindings::function::script_function::{
-    AppScriptFunctionRegistry, DynamicScriptFunction, GetFunctionTypeDependencies, ScriptFunction,
-    ScriptFunctionRegistry,
-};
 use std::{any::TypeId, borrow::Cow, marker::PhantomData};
 
 pub trait RegisterNamespacedFunction {

crates/bevy_mod_scripting_core/src/bindings/function/script_function.rs

@@ -123,11 +123,29 @@ pub struct CallerContext {
     pub self_type: Option<TypeId>,
 }
 
+#[derive(Clone, Debug, PartialEq, Default)]
+pub struct FunctionInfo {
+    pub name: Cow<'static, str>,
+    pub on_type: Option<TypeId>,
+}
+
+impl FunctionInfo {
+    /// The name of the function
+    pub fn name(&self) -> &Cow<'static, str> {
+        &self.name
+    }
+
+    /// If the function is namespaced to a specific type, this will return the type id of that type
+    pub fn on_type(&self) -> Option<TypeId> {
+        self.on_type
+    }
+}
+
 /// The Script Function equivalent for dynamic functions. Currently unused
 #[derive(Clone, Reflect)]
 #[reflect(opaque)]
 pub struct DynamicScriptFunction {
-    name: Cow<'static, str>,
+    pub info: FunctionInfo,
     // TODO: info about the function, this is hard right now because of non 'static lifetimes in wrappers, we can't use TypePath etc
     func: Arc<
         dyn Fn(CallerContext, WorldCallbackAccess, Vec<ScriptValue>) -> ScriptValue
@@ -139,14 +157,14 @@ pub struct DynamicScriptFunction {
 
 impl PartialEq for DynamicScriptFunction {
     fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
+        self.info == other.info
     }
 }
 
 #[derive(Clone, Reflect)]
 #[reflect(opaque)]
 pub struct DynamicScriptFunctionMut {
-    name: Cow<'static, str>,
+    pub info: FunctionInfo,
     func: Arc<
         RwLock<
             // I'd rather consume an option or something instead of having the RWLock but I just wanna get this release out
@@ -160,7 +178,7 @@ pub struct DynamicScriptFunctionMut {
 
 impl PartialEq for DynamicScriptFunctionMut {
     fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
+        self.info == other.info
     }
 }
 
@@ -175,20 +193,33 @@ impl DynamicScriptFunction {
     }
 
     pub fn name(&self) -> &Cow<'static, str> {
-        &self.name
+        &self.info.name
     }
 
     pub fn with_name<N: Into<Cow<'static, str>>>(self, name: N) -> Self {
         Self {
-            name: name.into(),
+            info: FunctionInfo {
+                name: name.into(),
+                ..self.info
+            },
+            func: self.func,
+        }
+    }
+
+    pub fn with_on_type(self, on_type: Option<TypeId>) -> Self {
+        Self {
+            info: FunctionInfo {
+                on_type,
+                ..self.info
+            },
             func: self.func,
         }
     }
 }
 
 impl DynamicScriptFunctionMut {
     pub fn call(
-        &mut self,
+        &self,
         context: CallerContext,
         world: WorldCallbackAccess,
         args: Vec<ScriptValue>,
@@ -198,12 +229,25 @@ impl DynamicScriptFunctionMut {
     }
 
     pub fn name(&self) -> &Cow<'static, str> {
-        &self.name
+        &self.info.name
     }
 
     pub fn with_name<N: Into<Cow<'static, str>>>(self, name: N) -> Self {
         Self {
-            name: name.into(),
+            info: FunctionInfo {
+                name: name.into(),
+                ..self.info
+            },
+            func: self.func,
+        }
+    }
+
+    pub fn with_on_type(self, on_type: Option<TypeId>) -> Self {
+        Self {
+            info: FunctionInfo {
+                on_type,
+                ..self.info
+            },
             func: self.func,
         }
     }
@@ -234,9 +278,10 @@ where
 {
     fn from(fn_: F) -> Self {
         DynamicScriptFunction {
-            name: std::any::type_name::<F>().into(),
+            info: FunctionInfo::default(),
             func: Arc::new(fn_),
         }
+        .with_name(std::any::type_name::<F>())
     }
 }
 
@@ -249,9 +294,10 @@ where
 {
     fn from(fn_: F) -> Self {
         DynamicScriptFunctionMut {
-            name: std::any::type_name::<F>().into(),
+            info: FunctionInfo::default(),
             func: Arc::new(RwLock::new(fn_)),
         }
+        .with_name(std::any::type_name::<F>())
     }
 }
 
@@ -301,7 +347,7 @@ impl ScriptFunctionRegistry {
         self.register_overload(name, func);
     }
 
-    pub fn register_overload<F, M>(&mut self, name: impl Into<Cow<'static, str>>, func: F)
+    fn register_overload<F, M>(&mut self, name: impl Into<Cow<'static, str>>, func: F)
     where
         F: ScriptFunction<'static, M>,
     {

crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_reflect.rs

@@ -4,7 +4,7 @@
 #![cfg_attr(rustfmt, rustfmt_skip)]
 use bevy_mod_scripting_core::{
     AddContextInitializer, StoreDocumentation,
-    bindings::{ReflectReference, function::from::{Ref, Mut, Val}},
+    bindings::{ReflectReference, function::{namespace::NamespaceBuilder,from::{Ref, Mut, Val}}},
 };
 use crate::*;
 pub struct BevyReflectScriptingPlugin;

crates/bevy_mod_scripting_functions/src/core.rs

@@ -1,6 +1,5 @@
 //! Contains functions defined by the [`bevy_mod_scripting_core`] crate
 
-use crate::NamespaceBuilder;
 use bevy::{
     prelude::*,
     reflect::{func::FunctionRegistrationError, ParsedPath},
@@ -12,6 +11,7 @@ use bindings::{
         from::{Ref, Val},
         from_ref::FromScriptRef,
         into_ref::IntoScriptRef,
+        namespace::NamespaceBuilder,
         script_function::{CallerContext, ScriptFunctionMut},
     },
     pretty_print::DisplayWithWorld,

crates/bevy_mod_scripting_functions/src/lib.rs

@@ -7,10 +7,7 @@ pub mod core;
 #[cfg(feature = "test_functions")]
 pub mod test_functions;
 
-pub mod namespaced_register;
-
 pub use core::*;
-pub use namespaced_register::*;
 
 pub struct ScriptFunctionsPlugin;
 

crates/bevy_mod_scripting_functions/src/test_functions.rs

@@ -1,6 +1,5 @@
 use std::sync::Arc;
 
-use crate::NamespaceBuilder;
 use bevy::{
     app::App,
     prelude::{Entity, World},
@@ -9,6 +8,7 @@ use bevy::{
 use bevy_mod_scripting_core::{
     bindings::{
         function::{
+            namespace::NamespaceBuilder,
             script_function::{CallerContext, DynamicScriptFunctionMut},
             CallScriptFunction,
         },

crates/languages/bevy_mod_scripting_rhai/src/bindings/reference.rs

@@ -1,7 +1,15 @@
-use std::ops::{Deref, DerefMut};
-
-use bevy_mod_scripting_core::bindings::{ReflectReference, ThreadWorldContainer, WorldContainer};
-use rhai::{CustomType, Dynamic};
+use super::script_value::FromDynamic;
+use bevy_mod_scripting_core::bindings::{
+    function::script_function::{AppScriptFunctionRegistry, DynamicScriptFunction},
+    script_value::ScriptValue,
+    ReflectReference, ThreadWorldContainer, WorldContainer, WorldGuard,
+};
+use bevy_mod_scripting_functions::{GetNamespacedFunction, Namespace};
+use rhai::{CustomType, Dynamic, EvalAltResult};
+use std::{
+    any::TypeId,
+    ops::{Deref, DerefMut},
+};
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct RhaiReflectReference(pub ReflectReference);
@@ -38,12 +46,30 @@ impl DerefMut for RhaiReflectReference {
     }
 }
 
+fn lookup_dynamic_function(
+    world: WorldGuard,
+    name: &str,
+    on: TypeId,
+) -> Option<DynamicScriptFunction> {
+    let registry = world.with_resource(|registry: &AppScriptFunctionRegistry| registry.clone());
+    let registry = registry.read();
+
+    registry
+        .get_namespaced_function(name.to_string(), Namespace::OnType(on))
+        .cloned()
+}
+
 impl CustomType for RhaiReflectReference {
     fn build(mut builder: rhai::TypeBuilder<Self>) {
         builder
             .with_name(std::any::type_name::<ReflectReference>())
             .with_indexer_get(|_obj: &mut Self, _index: Dynamic| {
                 let _world = ThreadWorldContainer.get_world();
+                let key: ScriptValue = ScriptValue::from_dynamic(_index)?;
+                if let ScriptValue::String(key) = key {
+                    // lookup function
+                }
+                Ok::<_, Box<EvalAltResult>>(())
             });
     }
 }