feat: ✨ built subcrate tro underlie cli functionality

This is very WIP!

Author: arctic-hen7

Cargo.toml

@@ -4,5 +4,9 @@ members = [
 	"packages/perseus-actix-web",
 	"packages/perseus-cli",
 	"examples/showcase/app",
-	"examples/showcase/server-actix-web"
-]
+	"examples/showcase/server-actix-web",
+    "examples/basic",
+    # FIXME
+    "examples/basic/.perseus",
+    "examples/basic/.perseus/server"
+]

examples/basic/.perseus/.gitignore

@@ -0,0 +1 @@
+dist/

examples/basic/.perseus/Cargo.toml

@@ -0,0 +1,32 @@
+# This crate defines the user's app in terms that WASM can understand, making development significantly simpler.
+
+[package]
+name = "perseus-cli-builder"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# We alias here because the package name will change based on whatever's in the user's manifest
+app = { package = "perseus-basic", path = "../" }
+
+perseus = { path = "../../../packages/perseus" }
+sycamore = { version = "0.5.1", features = ["ssr"] }
+sycamore-router = "0.5.1"
+web-sys = { version = "0.3", features = ["Headers", "Request", "RequestInit", "RequestMode", "Response", "ReadableStream", "Window"] }
+wasm-bindgen = { version = "0.2", features = ["serde-serialize"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1" # Possibly don't need?
+console_error_panic_hook = "0.1.6"
+urlencoding = "2.1"
+futures = "0.3"
+
+# This section is needed for WASM Pack (which we use instead of Trunk for flexibility)
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+# We define a binary for building, serving, and doing both
+[[bin]]
+name = "perseus-internal"
+path = "src/bin/build.rs"

examples/basic/.perseus/bonnie.toml

@@ -0,0 +1,16 @@
+# This file is temporary until the CLI is ready!
+
+version="0.3.1"
+
+[scripts]
+build = [
+    "cargo run",
+    "wasm-pack build --target web",
+    "rm -rf dist/pkg",
+    "mv pkg/ dist/",
+    "rollup main.js --format iife --file dist/pkg/bundle.js"
+]
+serve = [
+    "cd server",
+    "cargo run"
+]

examples/basic/.perseus/main.js

@@ -0,0 +1,6 @@
+import init, { run } from "./dist/pkg/perseus_cli_builder.js";
+async function main() {
+    await init("/.perseus/bundle.wasm");
+    run();
+}
+main();

examples/basic/.perseus/server/Cargo.toml

@@ -0,0 +1,16 @@
+# This crate defines the user's app in terms that WASM can understand, making development significantly simpler.
+
+[package]
+name = "perseus-cli-server"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# We alias here because the package name will change based on whatever's in the user's manifest
+app = { package = "perseus-basic", path = "../../" }
+
+perseus-actix-web = { path = "../../../../packages/perseus-actix-web" }
+actix-web = "3.3"
+futures = "0.3"

examples/basic/.perseus/server/src/main.rs

@@ -0,0 +1,39 @@
+use perseus_actix_web::{configurer, Options};
+use actix_web::{HttpServer, App};
+use futures::executor::block_on;
+use app::{get_templates_map, get_config_manager};
+use std::env;
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    // So we don't have to define a different `FsConfigManager` just for the server, we shift the execution context to the same level as everything else
+    // The server has to be a separate crate because otherwise the dependencies don't work with WASM bundling
+    env::set_current_dir("../").unwrap();
+
+    let host = env::var("HOST").unwrap_or_else(|_| "localhost".to_string());
+    let port = env::var("PORT").unwrap_or_else(|_| "8080".to_string()).parse::<u16>();
+    if let Ok(port) = port {
+        HttpServer::new(|| {
+            App::new()
+            	.configure(
+	    			block_on(configurer(
+	    				Options {
+	    					index: "../index.html".to_string(), // The user must define their own `index.html` file
+	    					js_bundle: "dist/pkg/bundle.js".to_string(),
+                            // Our crate has the same name, so this will be predictable
+	    					wasm_bundle: "dist/pkg/perseus_cli_builder_bg.wasm".to_string(),
+	    					templates_map: get_templates_map()
+	    				},
+	    				get_config_manager()
+	    			))
+	    		)
+        })
+        	.bind((host, port))?
+        	.run()
+        	.await
+    } else {
+        eprintln!("Port must be a number.");
+        Ok(())
+    }
+
+}

examples/basic/.perseus/src/bin/build.rs

@@ -0,0 +1,18 @@
+use futures::executor::block_on;
+use perseus::{build_templates, SsrNode};
+use app::{get_templates_vec, get_config_manager};
+
+fn main() {
+    let config_manager = get_config_manager();
+
+    let fut = build_templates(
+        get_templates_vec::<SsrNode>(),
+        &config_manager,
+    );
+    let res = block_on(fut);
+    if let Err(err) = res {
+        eprintln!("Static generation failed: '{}'", err);
+    } else {
+        println!("Static generation successfully completed!");
+    }
+}

examples/basic/.perseus/src/build.rs

@@ -0,0 +1,55 @@
+use app::{
+    AppRoute,
+    APP_ROUTE,
+    get_error_pages,
+    match_route
+};
+use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
+use sycamore::prelude::template;
+use sycamore_router::BrowserRouter;
+use perseus::{
+    app_shell
+};
+
+/// The entrypoint into the app itself. This will be compiled to WASM and actually executed, rendering the rest of the app.
+#[wasm_bindgen]
+pub fn run() -> Result<(), JsValue> {
+    // If we're in development, panics should go to the console
+    if cfg!(debug_assertions) {
+        std::panic::set_hook(Box::new(console_error_panic_hook::hook));
+    }
+    // Get the root (for the router) we'll be injecting page content into
+    let root = web_sys::window()
+        .unwrap()
+        .document()
+        .unwrap()
+        .query_selector(APP_ROUTE)
+        .unwrap()
+        .unwrap();
+
+    sycamore::render_to(
+        || {
+            template! {
+                BrowserRouter(|route: AppRoute| {
+                    // TODO improve performance rather than naively copying error pages for every template
+                    match route {
+                        // We handle the 404 for the user for convenience
+                        AppRoute::NotFound => get_error_pages().get_template_for_page("", &404, "not found"),
+                        // All other routes are based on the user's given statements
+                        _ => {
+                            let (name, render_fn) = match_route(route);
+                            app_shell(
+                                name,
+                                render_fn,
+                                get_error_pages()
+                            )
+                        }
+                    }
+                })
+            }
+        },
+        &root,
+    );
+
+    Ok(())
+}

examples/basic/.perseus/src/lib.rs

@@ -0,0 +1,17 @@
+[package]
+name = "perseus-basic"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+perseus = { path = "../../packages/perseus" }
+sycamore = { version = "0.5.1", features = ["ssr"] }
+sycamore-router = "0.5.1"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1" # Possibly don't need?
+
+# This section is needed for WASM Pack (which we use instead of Trunk for flexibility)
+[lib]
+crate-type = ["cdylib", "rlib"]

examples/basic/.perseus/src/serve.rs

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Perseus Starter App</title>
+        <!-- Importing this runs Perseus -->
+        <script src="/.perseus/bundle.js" defer></script>
+    </head>
+    <body>
+        <div id="root"></div>
+    </body>
+</html>

examples/basic/Cargo.toml

@@ -0,0 +1,28 @@
+use perseus::{ErrorPages};
+use sycamore::template;
+
+pub fn get_error_pages() -> ErrorPages {
+    let mut error_pages = ErrorPages::new(Box::new(|_, _, _| {
+        template! {
+            p { "Another error occurred." }
+        }
+    }));
+    error_pages.add_page(
+        404,
+        Box::new(|_, _, _| {
+            template! {
+                p { "Page not found." }
+            }
+        }),
+    );
+    error_pages.add_page(
+        400,
+        Box::new(|_, _, _| {
+            template! {
+                p { "Client error occurred..." }
+            }
+        }),
+    );
+
+    error_pages
+}

examples/basic/index.html

@@ -0,0 +1,34 @@
+mod pages;
+mod error_pages;
+
+use perseus::define_app;
+
+#[derive(perseus::Route)]
+pub enum Route {
+    #[to("/")]
+    Index,
+    #[to("/about")]
+    About,
+    #[not_found]
+    NotFound,
+}
+define_app!{
+    root: "#root",
+    route: Route,
+    router: [
+        Route::Index => [
+            "index".to_string(),
+            pages::index::template_fn()
+        ],
+        Route::About => [
+            "about".to_string(),
+            pages::about::template_fn()
+        ]
+    ],
+    error_pages: crate::error_pages::get_error_pages(),
+    templates: [
+        crate::pages::index::get_page::<G>(),
+        crate::pages::about::get_page::<G>()
+    ]
+    // config_manager: perseus::FsConfigManager::new()
+}

examples/basic/src/error_pages.rs

@@ -0,0 +1,22 @@
+use perseus::Template;
+use sycamore::prelude::{component, template, GenericNode, Template as SycamoreTemplate};
+use std::sync::Arc;
+
+#[component(AboutPage<G>)]
+pub fn about_page() -> SycamoreTemplate<G> {
+    template! {
+        p { "About." }
+    }
+}
+
+pub fn get_page<G: GenericNode>() -> Template<G> {
+    Template::new("about").template(template_fn())
+}
+
+pub fn template_fn<G: GenericNode>() -> perseus::template::TemplateFn<G> {
+    Arc::new(|_| {
+        template! {
+            AboutPage()
+        }
+    })
+}

examples/basic/src/lib.rs

@@ -0,0 +1,40 @@
+use perseus::{Template, StringResultWithCause};
+use serde::{Deserialize, Serialize};
+use sycamore::prelude::{component, template, GenericNode, Template as SycamoreTemplate};
+use std::sync::Arc;
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct IndexPageProps {
+    pub greeting: String,
+}
+
+#[component(IndexPage<G>)]
+pub fn index_page(props: IndexPageProps) -> SycamoreTemplate<G> {
+    template! {
+        p {(props.greeting)}
+        a(href = "/about") { "About!" }
+    }
+}
+
+pub fn get_page<G: GenericNode>() -> Template<G> {
+    Template::new("index")
+        .build_state_fn(Arc::new(get_static_props))
+        .template(template_fn())
+}
+
+pub async fn get_static_props(_path: String) -> StringResultWithCause<String> {
+    Ok(serde_json::to_string(&IndexPageProps {
+        greeting: "Hello World!".to_string(),
+    })
+    .unwrap())
+}
+
+pub fn template_fn<G: GenericNode>() -> perseus::template::TemplateFn<G> {
+    Arc::new(|props: Option<String>| {
+        template! {
+            IndexPage(
+                serde_json::from_str::<IndexPageProps>(&props.unwrap()).unwrap()
+            )
+        }
+    })
+}

examples/basic/src/pages/about.rs

@@ -0,0 +1,2 @@
+pub mod about;
+pub mod index;

examples/basic/src/pages/index.rs

@@ -3,7 +3,7 @@ use perseus::{build_templates, FsConfigManager, SsrNode};
 use perseus_showcase_app::pages;
 
 fn main() {
-    let config_manager = FsConfigManager::new();
+    let config_manager = FsConfigManager::new("./dist".to_string());
 
     let fut = build_templates(
         vec![

examples/basic/src/pages/mod.rs

@@ -16,11 +16,11 @@ async fn main() -> std::io::Result<()> {
 						wasm_bundle: "../app/pkg/perseus_showcase_app_bg.wasm".to_string(),
 						templates_map: pages::get_templates_map::<SsrNode>()
 					},
-					FsConfigManager::new()
+					FsConfigManager::new("../app/dist".to_string())
 				))
 			)
     })
     	.bind(("localhost", 8080))?
     	.run()
     	.await
-}
+}