Fix Routable::parent with hash segments and query params (#3484)

* Fix Routable::parent with hash segments and query params

packages/router/tests/parent.rs

@@ -0,0 +1,184 @@
+#![allow(unused)]
+
+use std::rc::Rc;
+
+use dioxus::prelude::*;
+
+#[derive(Routable, Clone, PartialEq, Debug)]
+#[rustfmt::skip]
+enum Route {
+    #[route("/")]
+    RootIndex {},
+    #[nest("/fixed")]
+        #[layout(Fixed)]
+            #[route("/")]
+            FixedIndex {},
+            #[route("/fixed")]
+            FixedFixed {},
+        #[end_layout]
+    #[end_nest]
+    #[nest("/:id")]
+        #[layout(Parameter)]
+            #[route("/")]
+            ParameterIndex { id: u8 },
+            #[route("/fixed")]
+            ParameterFixed { id: u8 },
+        #[end_layout]
+    #[end_nest]
+    #[nest("/hash")]
+        #[route("/")]
+        HashIndex {},
+        #[nest("/:id")]
+            #[route("/?:query")]
+            HashId { id: u8, query: String },
+            #[layout(Parameter)]
+                #[route("/path/?:query#:hash")]
+                HashQuery { id: u8, query: String, hash: String },
+}
+
+#[test]
+fn get_parent() {
+    assert_eq!(Route::RootIndex {}.parent(), None);
+    assert_eq!(Route::FixedIndex {}.parent(), Some(Route::RootIndex {}));
+    assert_eq!(Route::FixedFixed {}.parent(), Some(Route::FixedIndex {}));
+    assert_eq!(
+        Route::ParameterIndex { id: 0 }.parent(),
+        Some(Route::RootIndex {})
+    );
+    assert_eq!(
+        Route::ParameterFixed { id: 0 }.parent(),
+        Some(Route::ParameterIndex { id: 0 })
+    );
+    assert_eq!(
+        Route::HashQuery {
+            id: 0,
+            query: "query".into(),
+            hash: "hash".into()
+        }
+        .parent(),
+        Some(Route::HashId {
+            id: 0,
+            query: "".into()
+        })
+    );
+    assert_eq!(
+        Route::HashId {
+            id: 0,
+            query: "query".into()
+        }
+        .parent(),
+        Some(Route::HashIndex {})
+    );
+    assert_eq!(Route::HashIndex {}.parent(), Some(Route::RootIndex {}));
+}
+
+#[test]
+fn is_child() {
+    assert!(!Route::RootIndex {}.is_child_of(&Route::RootIndex {}));
+    assert!(Route::FixedIndex {}.is_child_of(&Route::RootIndex {}));
+    assert!(!Route::FixedIndex {}.is_child_of(&Route::FixedIndex {}));
+    assert!(Route::FixedFixed {}.is_child_of(&Route::FixedIndex {}));
+    assert!(!Route::FixedFixed {}.is_child_of(&Route::FixedFixed {}));
+    assert!(Route::ParameterIndex { id: 0 }.is_child_of(&Route::RootIndex {}));
+    assert!(!Route::ParameterIndex { id: 0 }.is_child_of(&Route::ParameterIndex { id: 0 }));
+    assert!(Route::ParameterFixed { id: 0 }.is_child_of(&Route::ParameterIndex { id: 0 }));
+    assert!(!Route::ParameterFixed { id: 0 }.is_child_of(&Route::ParameterFixed { id: 0 }));
+    assert!(Route::HashQuery {
+        id: 0,
+        query: "query".into(),
+        hash: "hash".into()
+    }
+    .is_child_of(&Route::HashId {
+        id: 0,
+        query: "query".into()
+    }));
+    assert!(!Route::HashQuery {
+        id: 0,
+        query: "query".into(),
+        hash: "hash".into()
+    }
+    .is_child_of(&Route::HashQuery {
+        id: 0,
+        query: "query".into(),
+        hash: "hash".into()
+    }));
+    assert!(Route::HashId {
+        id: 0,
+        query: "query".into()
+    }
+    .is_child_of(&Route::HashIndex {}));
+    assert!(!Route::HashId {
+        id: 0,
+        query: "query".into()
+    }
+    .is_child_of(&Route::HashId {
+        id: 0,
+        query: "query".into()
+    }));
+    assert!(Route::HashIndex {}.is_child_of(&Route::RootIndex {}));
+    assert!(!Route::HashIndex {}.is_child_of(&Route::HashIndex {}));
+}
+
+#[component]
+fn RootIndex() -> Element {
+    rsx! { h2 { "Root Index" } }
+}
+
+#[component]
+fn Fixed() -> Element {
+    rsx! {
+        h2 { "Fixed" }
+        Outlet::<Route> { }
+    }
+}
+
+#[component]
+fn FixedIndex() -> Element {
+    rsx! { h3 { "Fixed - Index" } }
+}
+
+#[component]
+fn FixedFixed() -> Element {
+    rsx! { h3 { "Fixed - Fixed"} }
+}
+
+#[component]
+fn Parameter(id: u8) -> Element {
+    rsx! {
+        h2 { "Parameter {id}" }
+        Outlet::<Route> { }
+    }
+}
+
+#[component]
+fn ParameterIndex(id: u8) -> Element {
+    rsx! { h3 { "Parameter - Index" } }
+}
+
+#[component]
+fn ParameterFixed(id: u8) -> Element {
+    rsx! { h3 { "Parameter - Fixed" } }
+}
+
+#[component]
+fn HashQuery(id: u8, query: String, hash: String) -> Element {
+    rsx! {
+        h2 { "Hash Query" }
+        h3 { "id: {id}" }
+        h3 { "query: {query}" }
+        h3 { "hash: {hash}" }
+    }
+}
+
+#[component]
+fn HashIndex() -> Element {
+    rsx! { h3 { "Hash Index" } }
+}
+
+#[component]
+fn HashId(id: u8, query: String) -> Element {
+    rsx! {
+        h3 { "Hash Id {id}" }
+        h3 { "query: {query}" }
+    }
+}