Namespacing same types (#187)

Implement namespacing for components according #186. This PR 
adds support to use multiple components with same name but in 
different module with optional casting support as seen below. 
Component name used in OpenAPI spec is the full path to the 
component where `::` is replaced with `.`. Previously mutliple 
components with same name was not possible.

```rust
components(
    crate::mod1::SomeType,
    crate::mod2::SomeType as mod3::SomeType
)
```

This work was sponsored by [Arctoris](https://www.arctoris.com/).

tests/component_derive_test.rs

@@ -1111,6 +1111,24 @@ fn derive_struct_component_field_type_override() {
     }
 }
 
+#[test]
+fn derive_struct_component_field_type_path_override() {
+    let post = api_doc! {
+        struct Post {
+            id: i32,
+            #[component(value_type = path::to::Foo)]
+            value: i64,
+        }
+    };
+
+    let component_ref: &str = post
+        .pointer("/properties/value/$ref")
+        .unwrap()
+        .as_str()
+        .unwrap();
+    assert_eq!(component_ref, "#/components/schemas/path.to.Foo");
+}
+
 #[test]
 fn derive_struct_component_field_type_override_with_format() {
     let post = api_doc! {
@@ -1205,7 +1223,7 @@ fn derive_struct_override_type_with_a_reference() {
 
     let value = api_doc! {
         struct Value {
-            #[component(value_type = custom::NewBar)]
+            #[component(value_type = NewBar)]
             field: String,
         }
     };
@@ -1364,11 +1382,20 @@ fn derive_component_with_generic_types_having_path_expression() {
         }
     };
 
-    assert_value! {ty=>
-        "properties.args.items.items.type" = r#""string""#, "Args items items type"
-        "properties.args.items.type" = r#""array""#, "Args items type"
-        "properties.args.type" = r#""array""#, "Args type"
-    }
+    let args = ty.pointer("/properties/args").unwrap();
+
+    assert_json_eq!(
+        args,
+        json!({
+            "items": {
+                "items": {
+                    "type": "string"
+                },
+                "type": "array"
+            },
+            "type": "array"
+        })
+    );
 }
 
 #[test]

tests/path_derive_rocket.rs

@@ -1,6 +1,7 @@
 #![cfg(feature = "rocket_extras")]
 
-use serde_json::Value;
+use assert_json_diff::assert_json_eq;
+use serde_json::{json, Value};
 use utoipa::OpenApi;
 
 mod common;
@@ -89,7 +90,7 @@ fn resolve_get_with_multiple_args() {
 }
 
 #[test]
-fn resolve_get_with_optinal_query_args() {
+fn resolve_get_with_optional_query_args() {
     mod rocket_get_operation {
         use rocket::get;
 
@@ -118,16 +119,23 @@ fn resolve_get_with_optinal_query_args() {
         "expected paths.hello.get.parameters not null"
     );
 
-    assert_value! {parameters=>
-        "[0].schema.type" = r#""array""#, "Query parameter type"
-        "[0].schema.format" = r#"null"#, "Query parameter format"
-        "[0].schema.items.type" = r#""string""#, "Query items parameter type"
-        "[0].schema.items.format" = r#"null"#, "Query items parameter format"
-        "[0].name" = r#""colors""#, "Query parameter name"
-        "[0].required" = r#"false"#, "Query parameter required"
-        "[0].deprecated" = r#"false"#, "Query parameter required"
-        "[0].in" = r#""query""#, "Query parameter in"
-    }
+    assert_json_eq!(
+        parameters,
+        json!([
+            {
+                "deprecated": false,
+                "in": "query",
+                "name": "colors",
+                "required": false,
+                "schema": {
+                    "items": {
+                        "type": "string",
+                    },
+                    "type": "array"
+                }
+            }
+        ])
+    );
 }
 
 #[test]

tests/request_body_derive_test.rs

@@ -11,7 +11,7 @@ macro_rules! test_fn {
         mod $name {
             #[derive(utoipa::Component)]
             /// Some struct
-            struct Foo {
+            pub struct Foo {
                 /// Some name
                 name: String,
             }
@@ -94,6 +94,7 @@ fn derive_request_body_option_array_success() {
         "paths.~1foo.post.requestBody.description" = r###"null"###, "Request body description"
     }
 }
+
 test_fn! {
     module: derive_request_body_primitive_simple,
     body: = String
@@ -374,3 +375,29 @@ fn derive_request_body_complex_primitive_array_success() {
         "paths.~1foo.post.requestBody.description" = r###""Create new foo references""###, "Request body description"
     }
 }
+
+test_fn! {
+    module: derive_request_body_primitive_ref_path,
+    body: = path::to::Foo
+}
+
+#[test]
+fn derive_request_body_primitive_ref_path_success() {
+    #[derive(OpenApi, Default)]
+    #[openapi(
+        handlers(derive_request_body_primitive_ref_path::post_foo),
+        components(derive_request_body_primitive_ref_path::Foo as path::to::Foo)
+    )]
+    struct ApiDoc;
+
+    let doc = serde_json::to_value(&ApiDoc::openapi()).unwrap();
+    let schemas = doc.pointer("/components/schemas").unwrap();
+    assert!(schemas.get("path.to.Foo").is_some());
+
+    let component_ref: &str = doc
+        .pointer("/paths/~1foo/post/requestBody/content/application~1json/schema/$ref")
+        .unwrap()
+        .as_str()
+        .unwrap();
+    assert_eq!(component_ref, "#/components/schemas/path.to.Foo");
+}

utoipa-gen/Cargo.toml

@@ -37,4 +37,4 @@ chrono_with_format = []
 json = []
 decimal = []
 rocket_extras = ["regex", "lazy_static"]
-uuid = ["dep:uuid"]
+uuid = ["dep:uuid"]

utoipa-gen/src/component_type.rs

@@ -1,17 +1,17 @@
-use std::fmt::Display;
-
+use proc_macro_error::abort_call_site;
 use quote::{quote, ToTokens};
 
 /// Tokenizes OpenAPI data type correctly according to the Rust type
-pub struct ComponentType<'a, T: Display>(pub &'a T);
+pub struct ComponentType<'a>(pub &'a syn::TypePath);
 
-impl<'a, T> ComponentType<'a, T>
-where
-    T: Display,
-{
+impl ComponentType<'_> {
     /// Check whether type is known to be primitive in wich case returns true.
     pub fn is_primitive(&self) -> bool {
-        let name = &*self.0.to_string();
+        let last_segment = match self.0.path.segments.last() {
+            Some(segment) => segment,
+            None => return false,
+        };
+        let name = &*last_segment.ident.to_string();
 
         #[cfg(not(any(
             feature = "chrono",
@@ -96,12 +96,12 @@ fn is_primitive_rust_decimal(name: &str) -> bool {
     matches!(name, "Decimal")
 }
 
-impl<'a, T> ToTokens for ComponentType<'a, T>
-where
-    T: Display,
-{
+impl ToTokens for ComponentType<'_> {
     fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        let name = &*self.0.to_string();
+        let last_segment = self.0.path.segments.last().unwrap_or_else(|| {
+            abort_call_site!("expected there to be at least one segment in the path")
+        });
+        let name = &*last_segment.ident.to_string();
 
         match name {
             "String" | "str" | "char" => {
@@ -127,12 +127,16 @@ where
 }
 
 /// Tokenizes OpenAPI data type format correctly by given Rust type.
-pub struct ComponentFormat<T: Display>(pub(crate) T);
+pub struct ComponentFormat<'a>(pub(crate) &'a syn::TypePath);
 
-impl<T: Display> ComponentFormat<T> {
+impl ComponentFormat<'_> {
     /// Check is the format know format. Known formats can be used within `quote! {...}` statements.
     pub fn is_known_format(&self) -> bool {
-        let name = &*self.0.to_string();
+        let last_segment = match self.0.path.segments.last() {
+            Some(segment) => segment,
+            None => return false,
+        };
+        let name = &*last_segment.ident.to_string();
 
         #[cfg(not(any(feature = "chrono_with_format", feature = "uuid")))]
         {
@@ -166,9 +170,12 @@ fn is_known_format(name: &str) -> bool {
     )
 }
 
-impl<T: Display> ToTokens for ComponentFormat<T> {
+impl ToTokens for ComponentFormat<'_> {
     fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        let name = &*self.0.to_string();
+        let last_segment = self.0.path.segments.last().unwrap_or_else(|| {
+            abort_call_site!("expected there to be at least one segment in the path")
+        });
+        let name = &*last_segment.ident.to_string();
 
         match name {
             "i8" | "i16" | "i32" | "u8" | "u16" | "u32" => {

utoipa-gen/src/ext.rs

@@ -2,7 +2,7 @@
 use std::{borrow::Cow, cmp::Ordering};
 
 use proc_macro2::{Ident, TokenStream};
-use syn::{punctuated::Punctuated, token::Comma, Attribute, FnArg, ItemFn};
+use syn::{punctuated::Punctuated, token::Comma, Attribute, FnArg, ItemFn, TypePath};
 
 use crate::path::PathOperation;
 
@@ -21,7 +21,7 @@ pub enum Argument<'a> {
 pub struct ArgumentValue<'a> {
     pub name: Option<Cow<'a, str>>,
     pub argument_in: ArgumentIn,
-    pub ident: Option<&'a Ident>,
+    pub type_path: Option<Cow<'a, TypePath>>,
     pub is_array: bool,
     pub is_option: bool,
 }

utoipa-gen/src/ext/actix.rs

@@ -35,7 +35,7 @@ impl ArgumentResolver for PathOperations {
         resolved_path_args: Option<Vec<ResolvedArg>>,
     ) -> Option<Vec<Argument<'_>>> {
         let (primitive_args, non_primitive_args): (Vec<Arg>, Vec<Arg>) = Self::get_fn_args(fn_args)
-            .partition(|arg| matches!(arg, Arg::Path(ty) if ComponentType(get_last_ident(ty).unwrap()).is_primitive()));
+            .partition(|arg| matches!(arg, Arg::Path(ty) if ComponentType(ty).is_primitive()));
 
         if let Some(resolved_args) = resolved_path_args {
             let primitive = Self::to_value_args(resolved_args, primitive_args);
@@ -89,8 +89,8 @@ impl PathOperations {
                             "ResolvedArg::Query is not reachable with primitive path type"
                         ),
                     },
-                    ident: match primitive_arg {
-                        Arg::Path(arg_type) => get_last_ident(arg_type),
+                    type_path: match primitive_arg {
+                        Arg::Path(arg_type) => Some(Cow::Borrowed(arg_type)),
                         _ => {
                             unreachable!("Arg::Query is not reachable with primitive type")
                         }

utoipa-gen/src/ext/rocket.rs

@@ -47,7 +47,7 @@ impl ArgumentResolver for PathOperations {
                     Argument::Value(ArgumentValue {
                         name: Some(Cow::Owned(name)),
                         argument_in,
-                        ident: Some(arg.ty),
+                        type_path: Some(arg.ty),
                         is_array: arg.is_array,
                         is_option: arg.is_option,
                     })
@@ -61,7 +61,7 @@ impl ArgumentResolver for PathOperations {
                     Argument::Value(ArgumentValue {
                         name: Some(Cow::Owned(name)),
                         argument_in,
-                        ident: None,
+                        type_path: None,
                         is_array: false,
                         is_option: false,
                     })
@@ -74,7 +74,7 @@ impl ArgumentResolver for PathOperations {
 #[cfg_attr(feature = "debug", derive(Debug))]
 struct Arg<'a> {
     name: &'a Ident,
-    ty: &'a Ident,
+    ty: Cow<'a, TypePath>,
     is_array: bool,
     is_option: bool,
 }
@@ -115,28 +115,34 @@ impl PathOperations {
         ordered_args.into_iter()
     }
 
-    fn get_type_ident(ty: &Type) -> (&Ident, bool, bool) {
+    fn get_type_ident<'t>(ty: &'t Type) -> (Cow<'t, TypePath>, bool, bool) {
         match ty {
             Type::Path(path) => {
-                let segment = &path.path.segments.first().unwrap();
+                let first_segment: syn::PathSegment = path.path.segments.first().unwrap().clone();
+                let mut path: Cow<'t, TypePath> = Cow::Borrowed(path);
 
-                if segment.arguments.is_empty() {
-                    (&segment.ident, false, false)
+                if first_segment.arguments.is_empty() {
+                    return (path, false, false);
                 } else {
-                    let is_array = segment.ident == "Vec";
-                    let is_option = segment.ident == "Option";
+                    let is_array = first_segment.ident == "Vec";
+                    let is_option = first_segment.ident == "Option";
 
-                    match segment.arguments {
+                    match first_segment.arguments {
                         syn::PathArguments::AngleBracketed(ref angle_bracketed) => {
                             match angle_bracketed.args.first() {
                                 Some(syn::GenericArgument::Type(arg)) => {
                                     let child_type = Self::get_type_ident(arg);
 
-                                    (
-                                        child_type.0,
-                                        is_array || child_type.1,
-                                        is_option || child_type.2,
-                                    )
+                                    let is_array = is_array || child_type.1;
+                                    let is_option = is_option || child_type.2;
+
+                                    // Discard the current segment if we are one of the special
+                                    // types recognised as array or option
+                                    if is_array || is_option {
+                                        path = Cow::Owned(child_type.0.into_owned());
+                                    }
+
+                                    (path, is_array, is_option)
                                 }
                                 _ => abort_call_site!(
                                     "unexpected generic type, expected GenericArgument::Type"
@@ -170,7 +176,7 @@ impl PathOperations {
                 let path = Self::get_type_path(pat_type.ty.as_ref());
                 let segment = &path.path.segments.first().unwrap();
 
-                let mut is_supported = ComponentType(&segment.ident).is_primitive();
+                let mut is_supported = ComponentType(path).is_primitive();
 
                 if !is_supported {
                     is_supported = matches!(&*segment.ident.to_string(), "Vec" | "Option")