use full path

Signed-off-by: Teo Koon Peng <[email protected]>

Author: koonpeng

macros/src/buffers.rs renamed to macros/src/buffer.rs

@@ -4,7 +4,7 @@ use syn::{DeriveInput, Ident, Type};
 
 use crate::Result;
 
-pub(crate) fn impl_buffer_map_layout(ast: DeriveInput) -> Result<TokenStream> {
+pub(crate) fn impl_joined_value(ast: DeriveInput) -> Result<TokenStream> {
     let struct_ident = ast.ident;
     let (field_ident, field_type) = match ast.data {
         syn::Data::Struct(data) => get_fields_map(data.fields)?,
@@ -15,19 +15,21 @@ pub(crate) fn impl_buffer_map_layout(ast: DeriveInput) -> Result<TokenStream> {
 
     let gen = quote! {
         impl BufferMapLayout for #struct_ident {
-            fn is_compatible(buffers: &BufferMap) -> Result<(), IncompatibleLayout> {
-                let mut compatibility = IncompatibleLayout::default();
+            fn is_compatible(buffers: &BufferMap) -> Result<(), ::bevy_impulse::IncompatibleLayout> {
+                let mut compatibility = ::bevy_impulse::IncompatibleLayout::default();
                 #(
                     compatibility.require_buffer::<#field_type>(#map_key, buffers);
                 )*
                 compatibility.into_result()
             }
 
             fn buffered_count(
-                buffers: &BufferMap,
-                session: Entity,
-                world: &World,
-            ) -> Result<usize, OperationError> {
+                buffers: &::bevy_impulse::BufferMap,
+                session: ::bevy_ecs::prelude::Entity,
+                world: &::bevy_ecs::prelude::World,
+            ) -> Result<usize, ::bevy_impulse::OperationError> {
+                use ::bevy_impulse::{InspectBuffer, OrBroken};
+
                 #(
                     let #field_ident = world
                         .get_entity(buffers.get(#map_key).or_broken()?.id())
@@ -43,10 +45,12 @@ pub(crate) fn impl_buffer_map_layout(ast: DeriveInput) -> Result<TokenStream> {
             }
 
             fn ensure_active_session(
-                buffers: &BufferMap,
-                session: Entity,
-                world: &mut World,
-            ) -> OperationResult {
+                buffers: &::bevy_impulse::BufferMap,
+                session: ::bevy_ecs::prelude::Entity,
+                world: &mut ::bevy_ecs::prelude::World,
+            ) -> ::bevy_impulse::OperationResult {
+                use ::bevy_impulse::{ManageBuffer, OrBroken};
+
                 #(
                     world
                         .get_entity_mut(buffers.get(#map_key).or_broken()?.id())
@@ -58,14 +62,16 @@ pub(crate) fn impl_buffer_map_layout(ast: DeriveInput) -> Result<TokenStream> {
             }
         }
 
-        impl JoinedValue for #struct_ident {
+        impl ::bevy_impulse::JoinedValue for #struct_ident {
             type Buffers = #struct_buffer_ident;
 
             fn pull(
-                buffers: &BufferMap,
-                session: Entity,
-                world: &mut World,
-            ) -> Result<Self, OperationError> {
+                buffers: &::bevy_impulse::BufferMap,
+                session: ::bevy_ecs::prelude::Entity,
+                world: &mut ::bevy_ecs::prelude::World,
+            ) -> Result<Self, ::bevy_impulse::OperationError> {
+                use ::bevy_impulse::{ManageBuffer, OrBroken};
+
                 #(
                     let #field_ident = world
                         .get_entity_mut(buffers.get(#map_key).or_broken()?.id())
@@ -83,15 +89,15 @@ pub(crate) fn impl_buffer_map_layout(ast: DeriveInput) -> Result<TokenStream> {
 
         struct #struct_buffer_ident {
             #(
-                #field_ident: Buffer<#field_type>
+                #field_ident: ::bevy_impulse::Buffer<#field_type>
             ),*
         }
 
-        impl From<#struct_buffer_ident> for BufferMap {
+        impl From<#struct_buffer_ident> for ::bevy_impulse::BufferMap {
             fn from(value: #struct_buffer_ident) -> Self {
-                let mut buffers = BufferMap::default();
+                let mut buffers = ::bevy_impulse::BufferMap::default();
                 #(
-                    buffers.insert(Cow::Borrowed(#map_key), value.#field_ident);
+                    buffers.insert(std::borrow::Cow::Borrowed(#map_key), value.#field_ident);
                 )*
                 buffers
             }

macros/src/lib.rs

@@ -15,8 +15,8 @@
  *
 */
 
-mod buffers;
-use buffers::impl_buffer_map_layout;
+mod buffer;
+use buffer::impl_joined_value;
 
 use proc_macro::TokenStream;
 use quote::quote;
@@ -65,10 +65,10 @@ pub fn delivery_label_macro(item: TokenStream) -> TokenStream {
 // The result error is the compiler error message to be displayed.
 type Result<T> = std::result::Result<T, String>;
 
-#[proc_macro_derive(Joined)]
-pub fn derive_joined(input: TokenStream) -> TokenStream {
+#[proc_macro_derive(JoinedValue)]
+pub fn derive_joined_value(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
-    match impl_buffer_map_layout(input) {
+    match impl_joined_value(input) {
         Ok(tokens) => tokens,
         Err(msg) => quote! {
             compile_error!(#msg);

src/buffer/buffer_map.rs

@@ -29,6 +29,8 @@ use crate::{
     OperationRoster, Output, UnusedTarget,
 };
 
+pub use bevy_impulse_derive::JoinedValue;
+
 #[derive(Clone, Default)]
 pub struct BufferMap {
     inner: HashMap<Cow<'static, str>, AnyBuffer>,
@@ -359,15 +361,9 @@ impl BufferMapLayout for AnyBufferKeyMap {
 mod tests {
     use std::borrow::Cow;
 
-    use crate::{
-        prelude::*, testing::*, BufferMap, InspectBuffer, ManageBuffer, OperationError,
-        OperationResult, OrBroken,
-    };
-
-    use bevy_ecs::prelude::World;
-    use bevy_impulse_derive::Joined;
+    use crate::{prelude::*, testing::*, BufferMap};
 
-    #[derive(Clone, Joined)]
+    #[derive(Clone, JoinedValue)]
     struct TestJoinedValue {
         integer: i64,
         float: f64,
@@ -379,6 +375,7 @@ mod tests {
         let mut context = TestingContext::minimal_plugins();
 
         let workflow = context.spawn_io_workflow(|scope, builder| {
+            // ::bevy_impulse::OrBroken::or_broken(self)
             let buffer_i64 = builder.create_buffer(BufferSettings::default());
             let buffer_f64 = builder.create_buffer(BufferSettings::default());
             let buffer_string = builder.create_buffer(BufferSettings::default());

src/lib.rs

@@ -148,6 +148,8 @@ pub use trim::*;
 use bevy_app::prelude::{App, Plugin, Update};
 use bevy_ecs::prelude::{Entity, In};
 
+extern crate self as bevy_impulse;
+
 /// Use `BlockingService` to indicate that your system is a blocking [`Service`].
 ///
 /// A blocking service will have exclusive world access while it runs, which