refactor: reorganize modules in the macros crate

1 files changed, 261 insertions, 0 deletions

diff --git a/macros/src/injectable/implementation.rs b/macros/src/injectable/implementation.rs
new file mode 100644
index 0000000..a84e798
--- /dev/null
+++ b/macros/src/injectable/implementation.rs
@@ -0,0 +1,261 @@
+use std::error::Error;
+
+use quote::{format_ident, quote, ToTokens};
+use syn::parse::{Parse, ParseStream};
+use syn::{parse_str, ExprMethodCall, FnArg, Generics, ItemImpl, Type};
+
+use crate::injectable::dependency::Dependency;
+use crate::util::item_impl::find_impl_method_by_name_mut;
+use crate::util::string::camelcase_to_snakecase;
+use crate::util::syn_path::syn_path_to_string;
+
+const DI_CONTAINER_VAR_NAME: &str = "di_container";
+const DEPENDENCY_HISTORY_VAR_NAME: &str = "dependency_history";
+
+pub struct InjectableImpl
+{
+    pub dependencies: Vec<Dependency>,
+    pub self_type: Type,
+    pub generics: Generics,
+    pub original_impl: ItemImpl,
+}
+
+impl Parse for InjectableImpl
+{
+    fn parse(input: ParseStream) -> syn::Result<Self>
+    {
+        let mut impl_parsed_input = input.parse::<ItemImpl>()?;
+
+        let dependencies = Self::build_dependencies(&mut impl_parsed_input)
+            .map_err(|err| input.error(err))?;
+
+        Ok(Self {
+            dependencies,
+            self_type: impl_parsed_input.self_ty.as_ref().clone(),
+            generics: impl_parsed_input.generics.clone(),
+            original_impl: impl_parsed_input,
+        })
+    }
+}
+
+impl InjectableImpl
+{
+    pub fn expand(&self, no_doc_hidden: bool, is_async: bool)
+        -> proc_macro2::TokenStream
+    {
+        let Self {
+            dependencies,
+            self_type,
+            generics,
+            original_impl,
+        } = self;
+
+        let di_container_var = format_ident!("{}", DI_CONTAINER_VAR_NAME);
+        let dependency_history_var = format_ident!("{}", DEPENDENCY_HISTORY_VAR_NAME);
+
+        let maybe_doc_hidden = if no_doc_hidden {
+            quote! {}
+        } else {
+            quote! {
+                #[doc(hidden)]
+            }
+        };
+
+        let maybe_prevent_circular_deps = if cfg!(feature = "prevent-circular") {
+            quote! {
+                if #dependency_history_var.contains(&self_type_name) {
+                    #dependency_history_var.push(self_type_name);
+
+                    let dependency_trace =
+                        syrette::dependency_trace::create_dependency_trace(
+                            #dependency_history_var.as_slice(),
+                            self_type_name
+                        );
+
+                    return Err(InjectableError::DetectedCircular {dependency_trace });
+                }
+
+                #dependency_history_var.push(self_type_name);
+            }
+        } else {
+            quote! {}
+        };
+
+        let injectable_impl = if is_async {
+            let async_get_dep_method_calls =
+                Self::create_get_dep_method_calls(dependencies, true);
+
+            quote! {
+                #maybe_doc_hidden
+                #[syrette::libs::async_trait::async_trait]
+                impl #generics syrette::interfaces::async_injectable::AsyncInjectable for #self_type
+                {
+                    async fn resolve(
+                        #di_container_var: &std::sync::Arc<syrette::async_di_container::AsyncDIContainer>,
+                        mut #dependency_history_var: Vec<&'static str>,
+                    ) -> Result<
+                        syrette::ptr::TransientPtr<Self>,
+                        syrette::errors::injectable::InjectableError>
+                    {
+                        use std::any::type_name;
+
+                        use syrette::errors::injectable::InjectableError;
+
+                        let self_type_name = type_name::<#self_type>();
+
+                        #maybe_prevent_circular_deps
+
+                        return Ok(syrette::ptr::TransientPtr::new(Self::new(
+                            #(#async_get_dep_method_calls),*
+                        )));
+                    }
+                }
+
+            }
+        } else {
+            let get_dep_method_calls =
+                Self::create_get_dep_method_calls(dependencies, false);
+
+            quote! {
+                #maybe_doc_hidden
+                impl #generics syrette::interfaces::injectable::Injectable for #self_type
+                {
+                    fn resolve(
+                        #di_container_var: &std::rc::Rc<syrette::DIContainer>,
+                        mut #dependency_history_var: Vec<&'static str>,
+                    ) -> Result<
+                        syrette::ptr::TransientPtr<Self>,
+                        syrette::errors::injectable::InjectableError>
+                    {
+                        use std::any::type_name;
+
+                        use syrette::errors::injectable::InjectableError;
+
+                        let self_type_name = type_name::<#self_type>();
+
+                        #maybe_prevent_circular_deps
+
+                        return Ok(syrette::ptr::TransientPtr::new(Self::new(
+                            #(#get_dep_method_calls),*
+                        )));
+                    }
+                }
+            }
+        };
+
+        quote! {
+            #original_impl
+
+            #injectable_impl
+        }
+    }
+
+    fn create_get_dep_method_calls(
+        dependencies: &[Dependency],
+        is_async: bool,
+    ) -> Vec<proc_macro2::TokenStream>
+    {
+        dependencies
+            .iter()
+            .filter_map(|dependency| {
+                let dep_interface_str = match &dependency.interface {
+                    Type::TraitObject(interface_trait) => {
+                        Some(interface_trait.to_token_stream().to_string())
+                    }
+                    Type::Path(path_interface) => {
+                        Some(syn_path_to_string(&path_interface.path))
+                    }
+                    &_ => None,
+                }?;
+
+                let method_call = parse_str::<ExprMethodCall>(
+                    format!(
+                        "{}.get_bound::<{}>({}.clone(), {})",
+                        DI_CONTAINER_VAR_NAME,
+                        dep_interface_str,
+                        DEPENDENCY_HISTORY_VAR_NAME,
+                        dependency.name.as_ref().map_or_else(
+                            || "None".to_string(),
+                            |name| format!("Some(\"{}\")", name.value())
+                        )
+                    )
+                    .as_str(),
+                )
+                .ok()?;
+
+                Some((method_call, dependency))
+            })
+            .map(|(method_call, dep_type)| {
+                let ptr_name = dep_type.ptr.to_string();
+
+                let to_ptr = format_ident!(
+                    "{}",
+                    camelcase_to_snakecase(&ptr_name.replace("Ptr", ""))
+                );
+
+                let do_method_call = if is_async {
+                    quote! { #method_call.await }
+                } else {
+                    quote! { #method_call }
+                };
+
+                let resolve_failed_error = if is_async {
+                    quote! { InjectableError::AsyncResolveFailed }
+                } else {
+                    quote! { InjectableError::ResolveFailed }
+                };
+
+                quote! {
+                    #do_method_call.map_err(|err| #resolve_failed_error {
+                        reason: Box::new(err),
+                        affected: self_type_name
+                    })?.#to_ptr().unwrap()
+                }
+            })
+            .collect()
+    }
+
+    fn build_dependencies(
+        item_impl: &mut ItemImpl,
+    ) -> Result<Vec<Dependency>, Box<dyn Error>>
+    {
+        let new_method_impl_item = find_impl_method_by_name_mut(item_impl, "new")
+            .map_or_else(|| Err("Missing a 'new' method"), Ok)?;
+
+        let new_method_args = &mut new_method_impl_item.sig.inputs;
+
+        let dependencies: Result<Vec<_>, _> =
+            new_method_args.iter().map(Dependency::build).collect();
+
+        for arg in new_method_args {
+            let typed_arg = if let FnArg::Typed(typed_arg) = arg {
+                typed_arg
+            } else {
+                continue;
+            };
+
+            let attrs_to_remove: Vec<_> = typed_arg
+                .attrs
+                .iter()
+                .enumerate()
+                .filter_map(|(index, attr)| {
+                    if syn_path_to_string(&attr.path).as_str() == "syrette::named" {
+                        return Some(index);
+                    }
+
+                    if attr.path.get_ident()?.to_string().as_str() == "named" {
+                        return Some(index);
+                    }
+
+                    None
+                })
+                .collect();
+
+            for attr_index in attrs_to_remove {
+                typed_arg.attrs.remove(attr_index);
+            }
+        }
+
+        dependencies
+    }
+}