From 3a5b417ad1639a31e9aac9f41b05d8b3f074b128 Mon Sep 17 00:00:00 2001
From: Dave Rolsky <autarch@urth.org>
Date: Sat, 8 Jan 2022 13:55:13 -0600
Subject: [PATCH] Add more trace messages to the RouterService code

I was trying to debug some issues with my routes and this additional tracing
was quite helpful.
---
 packages/router/src/components/route.rs |  1 +
 packages/router/src/service.rs          | 17 +++++++++++++++--
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/packages/router/src/components/route.rs b/packages/router/src/components/route.rs
index 2d9a270b8..129953eea 100644
--- a/packages/router/src/components/route.rs
+++ b/packages/router/src/components/route.rs
@@ -30,6 +30,7 @@ pub fn Route<'a>(cx: Scope<'a, RouteProps<'a>>) -> Element {
             Some(ctx) => ctx.total_route.to_string(),
             None => cx.props.to.to_string(),
         };
+        log::trace!("total route for {} is {}", cx.props.to, total_route);
 
         // provide our route context
         let route_context = cx.provide_context(RouteContext {
diff --git a/packages/router/src/service.rs b/packages/router/src/service.rs
index ae7c1ff05..7eddeb69d 100644
--- a/packages/router/src/service.rs
+++ b/packages/router/src/service.rs
@@ -46,8 +46,8 @@ impl RouterService {
         let listener = history.listen(move || {
             _root_found.set(false);
             // checking if the route is valid is cheap, so we do it
-            for (slot, _) in _slots.borrow_mut().iter().rev() {
-                log::trace!("regenerating slot {:?}", slot);
+            for (slot, root) in _slots.borrow_mut().iter().rev() {
+                log::trace!("regenerating slot {:?} for root '{}'", slot, root);
                 regen(*slot);
             }
         });
@@ -68,20 +68,25 @@ impl RouterService {
     }
 
     pub fn push_route(&self, route: &str) {
+        log::trace!("Pushing route: {}", route);
         self.history.borrow_mut().push(route);
     }
 
     pub fn register_total_route(&self, route: String, scope: ScopeId, fallback: bool) {
+        log::trace!("Registered route '{}' with scope id {:?}", route, scope);
         self.slots.borrow_mut().push((scope, route));
     }
 
     pub fn should_render(&self, scope: ScopeId) -> bool {
+        log::trace!("Should render scope id {:?}?", scope);
         if self.root_found.get() {
+            log::trace!("  no - because root_found is true");
             return false;
         }
 
         let location = self.history.borrow().location();
         let path = location.path();
+        log::trace!("  current path is '{}'", path);
 
         let roots = self.slots.borrow();
 
@@ -90,14 +95,22 @@ impl RouterService {
         // fallback logic
         match root {
             Some((_id, route)) => {
+                log::trace!(
+                    "  matched given scope id {:?} with route root '{}'",
+                    scope,
+                    route,
+                );
                 if route == path {
+                    log::trace!("    and it matches the current path '{}'", path);
                     self.root_found.set(true);
                     true
                 } else {
                     if route == "" {
+                        log::trace!("    and the route is the root, so we will use that without a better match");
                         self.root_found.set(true);
                         true
                     } else {
+                        log::trace!("    and the route '{}' is not the root nor does it match the current path", route);
                         false
                     }
                 }