switch to :field for dynamic segments

packages/router-core/tests/macro.rs

@@ -72,20 +72,20 @@ fn Nested(cx: Scope, nested: String) -> Element {
 #[routable]
 #[derive(Clone, Debug, PartialEq)]
 enum Route {
-    #[route("/(dynamic)" Route1)]
+    #[route("/:dynamic" Route1)]
     Route1 { dynamic: String },
-    #[nest("/(nested)" nested { nested: String } Nested)]
+    #[route("/:number1/:number2" Route4)]
+    Route4 { number1: u32, number2: u32 },
+    #[nest("/:nested" nested { nested: String } Nested)]
         #[route("/" Route2)]
         Route2 {},
-        // #[redirect("/(dynamic)/hello_world")]
+        // #[redirect("/:dynamic/hello_world")]
-        #[route("/(dynamic)" Route3)]
+        #[route("/:dynamic" Route3)]
         Route3 { dynamic: u32 },
     #[end_nest]
-    #[route("/(number1)/(number2)" Route4)]
+    #[route("/?:query" Route5)]
-    Route4 { number1: u32, number2: u32 },
-    #[route("/?(query)" Route5)]
     Route5 { query: String },
-    #[route("/(...extra)" Route6)]
+    #[route("/:...extra" Route6)]
     Route6 { extra: Vec<String> },
 }
 
@@ -97,7 +97,10 @@ fn display_works() {
 
     assert_eq!(route.to_string(), "/hello");
 
-    let route = Route::Route3 { dynamic: 1234 };
+    let route = Route::Route3 {
+        nested: "hello_world".to_string(),
+        dynamic: 1234,
+    };
 
     assert_eq!(route.to_string(), "/hello_world/1234");
 
@@ -145,9 +148,21 @@ fn from_string_works() {
     );
 
     let w = "/hello_world/1234";
-    assert_eq!(Route::from_str(w), Ok(Route::Route3 { dynamic: 1234 }));
+    assert_eq!(
+        Route::from_str(w),
+        Ok(Route::Route3 {
+            nested: "hello_world".to_string(),
+            dynamic: 1234
+        })
+    );
     let w = "/hello_world/1234/";
-    assert_eq!(Route::from_str(w), Ok(Route::Route3 { dynamic: 1234 }));
+    assert_eq!(
+        Route::from_str(w),
+        Ok(Route::Route3 {
+            nested: "hello_world".to_string(),
+            dynamic: 1234
+        })
+    );
 
     let w = "/hello_world2";
     assert_eq!(
@@ -188,9 +203,14 @@ fn round_trip() {
     assert_eq!(Route::from_str(&route.to_string()), Ok(route));
 
     // Route2
-    for num in 0..100 {
+    for num1 in 0..100 {
-        let route = Route::Route3 { dynamic: num };
+        for num2 in 0..100 {
-        assert_eq!(Route::from_str(&route.to_string()), Ok(route));
+            let route = Route::Route3 {
+                nested: format!("number{num1}"),
+                dynamic: num2,
+            };
+            assert_eq!(Route::from_str(&route.to_string()), Ok(route));
+        }
     }
 
     // Route3

packages/router-core/tests/nested.rs

@@ -1,35 +0,0 @@
-#![allow(non_snake_case)]
-
-use dioxus::prelude::*;
-use dioxus_router_core::*;
-use dioxus_router_macro::*;
-
-#[inline_props]
-fn Route1(cx: Scope, dynamic: String) -> Element {
-    render! {
-        div{
-            "Route1: {dynamic}"
-        }
-    }
-}
-
-#[inline_props]
-fn Nested(cx: Scope, nested: String) -> Element {
-    render! {
-        div{
-            "Nested: {nested:?}"
-        }
-    }
-}
-
-#[rustfmt::skip]
-#[routable]
-#[derive(Clone, Debug, PartialEq)]
-enum Route {
-    #[nest("/(nested)" nested { nested: String } Nested)]
-        #[route("/(dynamic)" Route1)]
-        Route1 { dynamic: String },
-    #[end_nest]
-    #[route("/(dynamic)" Route1)]
-    Route2 { dynamic: String },
-}

packages/router-macro/src/segment.rs

@@ -156,13 +156,13 @@ pub fn parse_route_segments(
     }
 
     while let Some(segment) = iterator.next() {
-        if segment.starts_with('(') && segment.ends_with(')') {
+        if let Some(segment) = segment.strip_prefix(':') {
-            let spread = segment.starts_with("(...");
+            let spread = segment.starts_with("...");
 
             let ident = if spread {
-                segment[4..segment.len() - 1].to_string()
+                segment[3..].to_string()
             } else {
-                segment[1..segment.len() - 1].to_string()
+                segment.to_string()
             };
 
             let field = fields.named.iter().find(|field| match field.ident {
@@ -209,8 +209,8 @@ pub fn parse_route_segments(
     // check if the route has a query string
     let parsed_query = match query {
         Some(query) => {
-            if query.starts_with('(') && query.ends_with(')') {
+            if let Some(query) = query.strip_prefix(':') {
-                let query_ident = Ident::new(&query[1..query.len() - 1], Span::call_site());
+                let query_ident = Ident::new(query, Span::call_site());
                 let field = fields.named.iter().find(|field| match field.ident {
                     Some(ref field_ident) => field_ident == &query_ident,
                     None => false,