improved documentation and refactored naming to be more self-explanatory

packages/router-macro/src/route.rs

@@ -144,13 +144,14 @@ impl Route {
             _ => Vec::new(),
         };
 
-        let (route_segments, query) = {
-            parse_route_segments(
-                variant.ident.span(),
-                fields.iter().map(|f| (&f.0, &f.1)),
-                &route,
-            )?
-        };
+        let (route_segments, query) =
+            {
+                parse_route_segments(
+                    variant.ident.span(),
+                    fields.iter().map(|f| (&f.0, &f.1)),
+                    &route,
+                )?
+            };
 
         Ok(Self {
             ty,
@@ -323,10 +324,11 @@ impl Route {
 
     pub fn error_type(&self) -> TokenStream2 {
         let error_name = self.error_ident();
-        let child_type = match &self.ty {
-            RouteType::Child(field) => Some(&field.ty),
-            RouteType::Leaf { .. } => None,
-        };
+        let child_type =
+            match &self.ty {
+                RouteType::Child(field) => Some(&field.ty),
+                RouteType::Leaf { .. } => None,
+            };
 
         create_error_type(error_name, &self.segments, child_type)
     }

packages/router-macro/src/segment.rs

@@ -135,10 +135,11 @@ pub fn parse_route_segments<'a>(
 ) -> syn::Result<(Vec<RouteSegment>, Option<QuerySegment>)> {
     let mut route_segments = Vec::new();
 
-    let (route_string, query) = match route.rsplit_once('?') {
-        Some((route, query)) => (route, Some(query)),
-        None => (route, None),
-    };
+    let (route_string, query) =
+        match route.rsplit_once('?') {
+            Some((route, query)) => (route, Some(query)),
+            None => (route, None),
+        };
     let mut iterator = route_string.split('/');
 
     // skip the first empty segment
@@ -157,11 +158,12 @@ pub fn parse_route_segments<'a>(
         if let Some(segment) = segment.strip_prefix(':') {
             let spread = segment.starts_with("..");
 
-            let ident = if spread {
-                segment[2..].to_string()
-            } else {
-                segment.to_string()
-            };
+            let ident =
+                if spread {
+                    segment[2..].to_string()
+                } else {
+                    segment.to_string()
+                };
 
             let field = fields.find(|(name, _)| **name == ident);
 
@@ -205,14 +207,15 @@ pub fn parse_route_segments<'a>(
                 let query_ident = Ident::new(query, Span::call_site());
                 let field = fields.find(|(name, _)| *name == &query_ident);
 
-                let ty = if let Some((_, ty)) = field {
-                    ty.clone()
-                } else {
-                    return Err(syn::Error::new(
-                        route_span,
-                        format!("Could not find a field with the name '{}'", query_ident),
-                    ));
-                };
+                let ty =
+                    if let Some((_, ty)) = field {
+                        ty.clone()
+                    } else {
+                        return Err(syn::Error::new(
+                            route_span,
+                            format!("Could not find a field with the name '{}'", query_ident),
+                        ));
+                    };
 
                 Some(QuerySegment {
                     ident: query_ident,