refactor: use child scopes for pages (#230)

* refactor: made route setting imperative and set up child scopes

So far, no scope disposer handling yet.

* feat: created full page disposer system

This isn't actually running yet though, since that leads to lifetime
errors I haven't resolved yet.

* feat: added `RouteManager`

This enforces *some* lifetime constraints, but not all those we need
just yet...

* feat: added lifetime bounds for full functionality

Sure, it's a fix, but it feels like a feat!

Author: arctic-hen7

Cargo.toml

@@ -3,7 +3,7 @@ members = [
 	"packages/*",
     "examples/core/*",
     "examples/demos/*",
-    "examples/comprehensive/*",
+    # "examples/comprehensive/*",
     "examples/website/*",
     "website",
     # We have the CLI subcrates as workspace members so we can actively develop on them

examples/core/plugins/src/plugin.rs

@@ -24,7 +24,13 @@ pub fn get_test_plugin<G: perseus::Html>() -> Plugin<G, TestPluginData> {
                     if let Some(plugin_data) = plugin_data.downcast_ref::<TestPluginData>() {
                         let about_page_greeting = plugin_data.about_page_greeting.to_string();
                         vec![Template::new("about").template(
-                            move |cx, _| sycamore::view! { cx,  p { (about_page_greeting) } },
+                            // This is the kind of weird thing we have to do if we don't use the
+                            // macros
+                            move |cx, route_manager, _| {
+                                route_manager.update_view(
+                                    sycamore::view! { cx,  p { (about_page_greeting) } },
+                                )
+                            },
                         )]
                     } else {
                         unreachable!()

examples/core/router_state/src/templates/index.rs

@@ -11,7 +11,10 @@ pub fn router_state_page<G: Html>(cx: Scope) -> View<G> {
         RouterLoadState::Loaded {
             template_name,
             path,
-        } => format!("Loaded {} (template: {}).", path, template_name),
+        } => {
+            perseus::web_log!("Loaded.");
+            format!("Loaded {} (template: {}).", path, template_name)
+        }
         RouterLoadState::Loading {
             template_name,
             path,

packages/perseus-macro/src/template.rs

@@ -154,7 +154,11 @@ pub fn template_impl(input: TemplateFn, is_reactive: bool) -> TokenStream {
         };
         let name_string = name.to_string();
         quote! {
-            #vis fn #name<G: ::sycamore::prelude::Html>(cx: ::sycamore::prelude::Scope, props: ::perseus::template::PageProps) -> ::sycamore::prelude::View<G> {
+            #vis fn #name<'__perseus_cx, G: ::sycamore::prelude::Html>(
+                cx: ::sycamore::prelude::Scope<'__perseus_cx>,
+                mut route_manager: ::perseus::router::RouteManager<'__perseus_cx, G>,
+                props: ::perseus::template::PageProps
+            ) {
                 use ::perseus::state::{MakeRx, MakeRxRef, RxRef};
 
                 // The user's function, with Sycamore component annotations and the like preserved
@@ -185,10 +189,14 @@ pub fn template_impl(input: TemplateFn, is_reactive: bool) -> TokenStream {
                     }
                 };
 
-                #component_name(cx, props.to_ref_struct(cx))
+                let disposer = ::sycamore::reactive::create_child_scope(cx, |child_cx| {
+                    let view = #component_name(child_cx, props.to_ref_struct(cx));
+                    route_manager.update_view(view);
+                });
+                route_manager.update_disposer(disposer);
             }
         }
-    } else if fn_args.len() == 2 && is_reactive == false {
+    } else if fn_args.len() == 2 && !is_reactive {
         // This template takes state that isn't reactive (but it must implement
         // `UnreactiveState`) Get the argument for the reactive scope
         let cx_arg = &fn_args[0];
@@ -205,7 +213,11 @@ pub fn template_impl(input: TemplateFn, is_reactive: bool) -> TokenStream {
         };
         let name_string = name.to_string();
         quote! {
-            #vis fn #name<G: ::sycamore::prelude::Html>(cx: ::sycamore::prelude::Scope, props: ::perseus::template::PageProps) -> ::sycamore::prelude::View<G> {
+            #vis fn #name<'__perseus_cx, G: ::sycamore::prelude::Html>(
+                cx: ::sycamore::prelude::Scope<'__perseus_cx>,
+                mut route_manager: ::perseus::router::RouteManager<'__perseus_cx, G>,
+                props: ::perseus::template::PageProps
+            ) {
                 use ::perseus::state::{MakeRx, MakeRxRef, RxRef, MakeUnrx};
 
                 // The user's function, with Sycamore component annotations and the like preserved
@@ -239,15 +251,24 @@ pub fn template_impl(input: TemplateFn, is_reactive: bool) -> TokenStream {
                 };
 
                 // The `.make_unrx()` function will just convert back to the user's type
-                #component_name(cx, props.make_unrx())
+                let disposer = ::sycamore::reactive::create_child_scope(cx, |child_cx| {
+                    let view = #component_name(child_cx, props.make_unrx());
+                    route_manager.update_view(view);
+                });
+                route_manager.update_disposer(disposer);
             }
         }
     } else if fn_args.len() == 1 {
         // Get the argument for the reactive scope
         let cx_arg = &fn_args[0];
         // There are no arguments except for the scope
         quote! {
-            #vis fn #name<G: ::sycamore::prelude::Html>(cx: ::sycamore::prelude::Scope, props: ::perseus::template::PageProps) -> ::sycamore::prelude::View<G> {
+            // BUG Need to enforce that `cx` and `route_manager` have the same lifetime...
+            #vis fn #name<'__perseus_cx, G: ::sycamore::prelude::Html>(
+                cx: ::sycamore::prelude::Scope<'__perseus_cx>,
+                mut route_manager: ::perseus::router::RouteManager<'__perseus_cx, G>,
+                props: ::perseus::template::PageProps
+            ) {
                 use ::perseus::state::{MakeRx, MakeRxRef};
 
                 // The user's function, with Sycamore component annotations and the like preserved
@@ -262,7 +283,11 @@ pub fn template_impl(input: TemplateFn, is_reactive: bool) -> TokenStream {
                 let render_ctx = ::perseus::RenderCtx::from_ctx(cx);
                 render_ctx.register_page_no_state(&props.path);
 
-                #component_name(cx)
+                let disposer = ::sycamore::reactive::create_child_scope(cx, |child_cx| {
+                    let view = #component_name(child_cx);
+                    route_manager.update_view(view);
+                });
+                route_manager.update_disposer(disposer);
             }
         }
     } else {

packages/perseus/src/client.rs

@@ -70,6 +70,7 @@ pub fn run_client<M: MutableStore, T: TranslationsManager>(
 
     // This top-level context is what we use for everything, allowing page state to
     // be registered and stored for the lifetime of the app
+    // Note: root lifetime creation occurs here
     #[cfg(feature = "hydrate")]
     sycamore::hydrate_to(move |cx| perseus_router(cx, router_props), &root);
     #[cfg(not(feature = "hydrate"))]

packages/perseus/src/lib.rs

@@ -20,7 +20,6 @@ documentation, and this should mostly be used as a secondary reference source. Y
 
 #![deny(missing_docs)]
 // #![deny(missing_debug_implementations)] // TODO Pending sycamore-rs/sycamore#412
-#![forbid(unsafe_code)]
 #![recursion_limit = "256"] // TODO Do we need this anymore?
 
 /// Utilities for working with the engine-side, particularly with regards to

packages/perseus/src/router/get_initial_view.rs

@@ -1,7 +1,7 @@
 use crate::error_pages::ErrorPageData;
 use crate::errors::*;
 use crate::i18n::detect_locale;
-use crate::router::match_route;
+use crate::router::{match_route, RouteManager};
 use crate::router::{RouteInfo, RouteVerdict, RouterLoadState};
 use crate::template::{PageProps, RenderCtx, TemplateNodeType};
 use crate::utils::checkpoint;
@@ -23,9 +23,10 @@ use web_sys::Element;
 /// Note that this will automatically update the router state just before it
 /// returns, meaning that any errors that may occur after this function has been
 /// called need to reset the router state to be an error.
-pub(crate) fn get_initial_view(
-    cx: Scope,
+pub(crate) fn get_initial_view<'a>(
+    cx: Scope<'a>,
     path: String, // The full path, not the template path (but parsed a little)
+    route_manager: &'a RouteManager<'a, TemplateNodeType>,
 ) -> InitialView {
     let render_ctx = RenderCtx::from_ctx(cx);
     let router_state = &render_ctx.router;
@@ -54,7 +55,7 @@ pub(crate) fn get_initial_view(
             // Since we're not requesting anything from the server, we don't need to worry about
             // whether it's an incremental match or not
             was_incremental_match: _,
-        }) => InitialView::View({
+        }) => {
             let path_with_locale = match locale.as_str() {
                 "xx-XX" => path.clone(),
                 locale => format!("{}/{}", locale, &path),
@@ -93,7 +94,7 @@ pub(crate) fn get_initial_view(
                             router_state.set_load_state(RouterLoadState::ErrorLoaded {
                                 path: path_with_locale.clone(),
                             });
-                            return InitialView::View(error_pages.get_view_and_render_head(
+                            return InitialView::Error(error_pages.get_view_and_render_head(
                                 cx,
                                 "*",
                                 500,
@@ -110,7 +111,7 @@ pub(crate) fn get_initial_view(
                             router_state.set_load_state(RouterLoadState::ErrorLoaded {
                                 path: path_with_locale.clone(),
                             });
-                            return InitialView::View(match &err {
+                            return InitialView::Error(match &err {
                                 // These errors happen because we couldn't get a translator, so they
                                 // certainly don't get one
                                 ClientError::FetchError(FetchError::NotOk {
@@ -171,8 +172,11 @@ pub(crate) fn get_initial_view(
                         template_name: path,
                         path: path_with_locale,
                     });
-                    // Return the actual template, for rendering/hydration
-                    template.render_for_template_client(page_props, cx, translator)
+                    // Render the actual template to the root (done imperatively due to child
+                    // scopes)
+                    template.render_for_template_client(page_props, cx, route_manager, translator);
+
+                    InitialView::Success
                 }
                 // We have an error that the server sent down, so we should just return that error
                 // view
@@ -182,7 +186,7 @@ pub(crate) fn get_initial_view(
                         path: path_with_locale.clone(),
                     });
                     // We don't need to replace the head, because the server's handled that for us
-                    error_pages.get_view(cx, &url, status, &err, None)
+                    InitialView::Error(error_pages.get_view(cx, &url, status, &err, None))
                 }
                 // The entire purpose of this function is to work with the initial state, so if this
                 // is true, then we have a problem
@@ -194,17 +198,17 @@ pub(crate) fn get_initial_view(
                     router_state.set_load_state(RouterLoadState::ErrorLoaded {
                         path: path_with_locale.clone(),
                     });
-                    error_pages.get_view_and_render_head(cx, "*", 400, "expected initial state render, found subsequent load (highly likely to be a core perseus bug)", None)
+                    InitialView::Error(error_pages.get_view_and_render_head(cx, "*", 400, "expected initial state render, found subsequent load (highly likely to be a core perseus bug)", None))
                 }
             }
-        }),
+        }
         // If the user is using i18n, then they'll want to detect the locale on any paths
         // missing a locale Those all go to the same system that redirects to the
         // appropriate locale Note that `container` doesn't exist for this scenario
         RouteVerdict::LocaleDetection(path) => {
             InitialView::Redirect(detect_locale(path.clone(), &locales))
         }
-        RouteVerdict::NotFound => InitialView::View({
+        RouteVerdict::NotFound => InitialView::Error({
             checkpoint("not_found");
             if let InitialState::Error(ErrorPageData { url, status, err }) = get_initial_state() {
                 router_state.set_load_state(RouterLoadState::ErrorLoaded { path: url.clone() });
@@ -232,8 +236,14 @@ pub(crate) fn get_initial_view(
 /// A representation of the possible outcomes of getting the view for the
 /// initial load.
 pub(crate) enum InitialView {
-    /// A view is available to be rendered/hydrated.
-    View(View<TemplateNodeType>),
+    /// The page has been successfully rendered and sent through the given
+    /// signal.
+    ///
+    /// Due to the use of child scopes, we can't just return a actual view,
+    /// this has to be done imperatively.
+    Success,
+    /// An error view has been produced, which should replace the current view.
+    Error(View<TemplateNodeType>),
     /// We need to redirect somewhere else, and the path to redirect to is
     /// attached.
     ///

packages/perseus/src/router/get_subsequent_view.rs

@@ -1,6 +1,6 @@
 use crate::errors::*;
 use crate::page_data::PageDataPartial;
-use crate::router::{RouteVerdict, RouterLoadState};
+use crate::router::{RouteManager, RouteVerdict, RouterLoadState};
 use crate::state::PssContains;
 use crate::template::{PageProps, RenderCtx, Template, TemplateNodeType};
 use crate::utils::checkpoint;
@@ -14,6 +14,8 @@ use sycamore::prelude::*;
 pub(crate) struct GetSubsequentViewProps<'a> {
     /// The app's reactive scope.
     pub cx: Scope<'a>,
+    /// The app's route manager.
+    pub route_manager: &'a RouteManager<'a, TemplateNodeType>,
     /// The path we're rendering for (not the template path, the full path,
     /// though parsed a little).
     pub path: String,
@@ -44,13 +46,14 @@ pub(crate) struct GetSubsequentViewProps<'a> {
 pub(crate) async fn get_subsequent_view(
     GetSubsequentViewProps {
         cx,
+        route_manager,
         path,
         template,
         was_incremental_match,
         locale,
         route_verdict,
     }: GetSubsequentViewProps<'_>,
-) -> View<TemplateNodeType> {
+) -> SubsequentView {
     let render_ctx = RenderCtx::from_ctx(cx);
     let router_state = &render_ctx.router;
     let translations_manager = &render_ctx.translations_manager;
@@ -187,7 +190,7 @@ pub(crate) async fn get_subsequent_view(
     // Any errors will be prepared error pages ready for return
     let page_data = match page_data {
         Ok(page_data) => page_data,
-        Err(view) => return view,
+        Err(view) => return SubsequentView::Error(view),
     };
 
     // Interpolate the metadata directly into the document's `<head>`
@@ -208,35 +211,41 @@ pub(crate) async fn get_subsequent_view(
                 // These errors happen because we couldn't get a translator, so they certainly don't
                 // get one
                 ClientError::FetchError(FetchError::NotOk { url, status, .. }) => {
-                    return error_pages.get_view_and_render_head(
+                    return SubsequentView::Error(error_pages.get_view_and_render_head(
                         cx,
                         url,
                         *status,
                         &fmt_err(&err),
                         None,
-                    )
+                    ))
                 }
                 ClientError::FetchError(FetchError::SerFailed { url, .. }) => {
-                    return error_pages.get_view_and_render_head(cx, url, 500, &fmt_err(&err), None)
+                    return SubsequentView::Error(error_pages.get_view_and_render_head(
+                        cx,
+                        url,
+                        500,
+                        &fmt_err(&err),
+                        None,
+                    ))
                 }
                 ClientError::LocaleNotSupported { locale } => {
-                    return error_pages.get_view_and_render_head(
+                    return SubsequentView::Error(error_pages.get_view_and_render_head(
                         cx,
                         &format!("/{}/...", locale),
                         404,
                         &fmt_err(&err),
                         None,
-                    )
+                    ))
                 }
                 // No other errors should be returned, but we'll give any a 400
                 _ => {
-                    return error_pages.get_view_and_render_head(
+                    return SubsequentView::Error(error_pages.get_view_and_render_head(
                         cx,
                         &format!("/{}/...", locale),
                         400,
                         &fmt_err(&err),
                         None,
-                    )
+                    ))
                 }
             }
         }
@@ -255,5 +264,13 @@ pub(crate) async fn get_subsequent_view(
         path: path_with_locale,
     });
     // Now return the view that should be rendered
-    template.render_for_template_client(page_props, cx, translator)
+    template.render_for_template_client(page_props, cx, route_manager, translator);
+    SubsequentView::Success
+}
+
+pub(crate) enum SubsequentView {
+    /// The page view *has been* rendered *and* displayed.
+    Success,
+    /// An error view was rendered, and shoudl now be displayed.
+    Error(View<TemplateNodeType>),
 }

packages/perseus/src/router/mod.rs

@@ -5,6 +5,8 @@ mod get_initial_view;
 #[cfg(target_arch = "wasm32")]
 mod get_subsequent_view;
 mod match_route;
+mod page_disposer;
+mod route_manager;
 mod route_verdict;
 #[cfg(target_arch = "wasm32")]
 mod router_component;
@@ -23,4 +25,7 @@ pub use router_state::{RouterLoadState, RouterState};
 #[cfg(target_arch = "wasm32")]
 pub(crate) use get_initial_view::{get_initial_view, InitialView};
 #[cfg(target_arch = "wasm32")]
-pub(crate) use get_subsequent_view::{get_subsequent_view, GetSubsequentViewProps};
+pub(crate) use get_subsequent_view::{get_subsequent_view, GetSubsequentViewProps, SubsequentView};
+
+pub use page_disposer::PageDisposer;
+pub use route_manager::RouteManager;