feat: Workspace-Liste laden und speichern

Die anwendungsweite Liste bekannter Workspaces, so wie sie in den Issues #3
und #4 festgelegt wurde. Bewusst ohne Oberfläche, damit dieser Teil sich mit
echten Tests pruefen laesst statt nur mit cargo check.

Ablageort ueber einen einzigen Ausdruck fuer alle Plattformen:
state_dir().or_else(config_local_dir) - state_dir() liefert nur unter Linux
Some, wo die XDG-Spec "recently used files" ausdruecklich als State fuehrt,
also nach $XDG_STATE_HOME und nicht nach ~/.config. Unter Windows faellt es
auf %LOCALAPPDATA% durch, bewusst nicht Roaming: absolute Workspace-Pfade
sind maschinenspezifisch und zeigten auf einem anderen Rechner ins Leere.
Verifiziert, ein Test haelt den Ort fest.

Die Liste enthaelt nur Pfade. Kein Anzeigename, weil der Ordnername ihn
liefert und ein eigenes Feld nach dem ersten Umbenennen falsch waere. Kein
Zeitstempel, weil die Reihenfolge selbst die Sortierung ist - promote() hebt
einen Eintrag an die Spitze und entfernt ihn vorher aus der Liste, wodurch
Duplikate gar nicht erst entstehen koennen.

Eine unlesbare Datei ergibt eine leere Liste statt eines Fehlers: Sie
enthaelt nichts Unwiederbringliches, der Nutzer waehlt seine Ordner einmal
neu. Genau deshalb braucht sie auch keine Schema-Version.

Neu im Abhaengigkeitsgraph ist allein ron; dirs und serde lagen bereits
transitiv vor. directories waere die teurere Variante gewesen - sein einziger
Mehrwert waere die Kleinschreibung des Ordnernamens, die hier eine Konstante
erledigt.

Cargo.lock

@@ -2329,8 +2329,10 @@ dependencies = [
  "dioxus",
  "dioxus-code",
  "dioxus-code-editor",
+ "dirs",
+ "ron",
+ "serde",
  "strum",
- "strum_macros",
 ]
 
 [[package]]
@@ -5887,6 +5889,20 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "ron"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81116b9531d61eabc41aeb228e4b6b2435bcca3233b98cf3b3077d4e6e9debb3"
+dependencies = [
+ "bitflags 2.13.1",
+ "once_cell",
+ "serde",
+ "serde_derive",
+ "typeid",
+ "unicode-ident",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"
@@ -7013,6 +7029,12 @@ dependencies = [
  "utf-8",
 ]
 
+[[package]]
+name = "typeid"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
+
 [[package]]
 name = "typenum"
 version = "1.20.1"

Cargo.toml

@@ -10,8 +10,10 @@ edition = "2021"
 dioxus = { version = "0.7.1", features = ["router"] }
 dioxus-code = "0.1.2"
 dioxus-code-editor = { version = "0.1.2", features = ["all-languages"] }
-strum = { version = "0.28.0", features = ["strum_macros", "derive"] }
-strum_macros = "0.28.0"
+dirs = "6.0.0"
+ron = "0.12.2"
+serde = { version = "1.0.229", features = ["derive"] }
+strum = { version = "0.28.0", features = ["derive"] }
 
 [features]
 default = ["desktop"]

assets/css/components.css

@@ -49,30 +49,6 @@
     transform: scaleY(1);
 }
 
-/* --- Workspace selector tab ------------------------------------------------- */
-
-.workspace-selector {
-    padding: var(--dn-space-2) var(--dn-space-4);
-    border-radius: var(--dn-radius);
-    color: var(--dn-fg-muted);
-    font-size: var(--dn-text-base);
-    font-weight: 500;
-    text-decoration: none;
-    white-space: nowrap;
-    transition: color var(--dn-dur-fast) var(--dn-ease),
-                background-color var(--dn-dur-fast) var(--dn-ease);
-}
-
-.workspace-selector:hover {
-    color: var(--dn-fg);
-    background: var(--dn-bg-raised);
-}
-
-.workspace-selector.active {
-    color: var(--dn-fg-on-accent);
-    background: var(--dn-accent);
-}
-
 /* --- Buttons ---------------------------------------------------------------- */
 
 .btn {

assets/css/layout.css

@@ -25,15 +25,6 @@
     padding: var(--dn-space-6);
 }
 
-.workspace-selector-links {
-    display: flex;
-    gap: var(--dn-space-1);
-    padding: var(--dn-space-1);
-    background: var(--dn-bg-sunken);
-    border: 1px solid var(--dn-border);
-    border-radius: var(--dn-radius-lg);
-}
-
 .workspace-selector-view {
     width: 100%;
     max-width: 34rem;

assets/tailwind.css

@@ -171,6 +171,9 @@
   .visible {
     visibility: visible;
   }
+  .absolute {
+    position: absolute;
+  }
   .relative {
     position: relative;
   }
@@ -198,9 +201,18 @@
   .flex {
     display: flex;
   }
+  .table {
+    display: table;
+  }
+  .border-collapse {
+    border-collapse: collapse;
+  }
   .transform {
     transform: var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,);
   }
+  .resize {
+    resize: both;
+  }
   .border {
     border-style: var(--tw-border-style);
     border-width: 1px;
@@ -208,6 +220,9 @@
   .text-wrap {
     text-wrap: wrap;
   }
+  .underline {
+    text-decoration-line: underline;
+  }
   .outline {
     outline-style: var(--tw-outline-style);
     outline-width: 1px;

src/main.rs

@@ -1,9 +1,13 @@
-mod views;
 mod components;
+mod route;
+mod views;
+mod workspace;
+mod workspace_list;
 
 use dioxus::prelude::*;
-use crate::views::editor::dionotes_editor::EditorRoute;
-use crate::views::workspace_selector::selector::WorkspaceRoute;
+
+use crate::route::Route;
+use crate::workspace::Workspace;
 
 const FAVICON: Asset = asset!("/assets/favicon.ico");
 
@@ -22,7 +26,11 @@ fn main() {
 
 #[component]
 fn App() -> Element {
-    let workspace_selected: Signal<bool> = use_signal(|| false);
+    // Der offene Workspace als Context, nicht als Prop: Er wird im Selector
+    // gesetzt und in der Datei-Leiste gelesen — beide hängen unter einem
+    // Outlet, durch das sich keine Props durchreichen lassen.
+    use_context_provider(|| Signal::new(None::<Workspace>));
+
     rsx! {
         document::Link { rel: "icon", href: FAVICON }
         // Tailwind first: its preflight lives in @layer base, our unlayered
@@ -32,12 +40,6 @@ fn App() -> Element {
         document::Link { rel: "stylesheet", href: BASE_CSS }
         document::Link { rel: "stylesheet", href: LAYOUT_CSS }
         document::Link { rel: "stylesheet", href: COMPONENTS_CSS }
-        if workspace_selected() {
-            Router::<EditorRoute> {}
-        } else {
-            Router::<WorkspaceRoute> {}
-        }
+        Router::<Route> {}
     }
 }
-
-

src/route.rs

@@ -0,0 +1,36 @@
+use dioxus::prelude::*;
+use strum::EnumMessage;
+
+use crate::views::editor::dionotes_editor::{Editor, EditorShell, Home};
+use crate::views::workspace_selector::selector::Selector;
+
+/// Alle Routen der App in einem Enum.
+///
+/// Bewusst *ein* Router statt zweier: Zwei Routable-Enums teilen sich dieselbe
+/// History, und beide hatten `/` belegt — beim Umschalten hätte der Editor eine
+/// URL zu sehen bekommen, die er nicht kennt.
+#[derive(Debug, Clone, Routable, PartialEq, EnumMessage)]
+#[rustfmt::skip]
+pub enum Route {
+    #[nest("/workspace")]
+        #[layout(EditorShell)]
+            #[route("/")]
+            #[strum(message = "Home")]
+            Home {},
+            #[route("/editor")]
+            #[strum(message = "Editor")]
+            Editor {},
+        #[end_layout]
+    #[end_nest]
+    #[route("/")]
+    Selector {},
+}
+
+impl Route {
+    /// Die Einträge der Datei-Leiste im Editor.
+    ///
+    /// Explizit statt über `EnumIter`, weil das Enum jetzt auch den Selector
+    /// enthält und der in dieser Leiste nichts zu suchen hat. Wermutstropfen:
+    /// eine neue Editor-Route hier einzutragen erzwingt der Compiler nicht.
+    pub const EDITOR_TABS: [Self; 2] = [Self::Home {}, Self::Editor {}];
+}

src/views/editor/dionotes_editor.rs

@@ -1,32 +1,24 @@
 use dioxus::prelude::*;
 use dioxus_code::Theme;
 use dioxus_code_editor::{CodeEditor, Language};
+use strum::EnumMessage;
+
 use crate::components::custom_link::custom_link_component::CustomLink;
-use strum::{EnumMessage, IntoEnumIterator};
-use strum_macros::EnumIter;
+use crate::route::Route;
+use crate::workspace::Workspace;
 
 const HEADER_SVG: Asset = asset!("/assets/header.svg");
 
-#[derive(Debug, Clone, Routable, PartialEq, EnumIter, EnumMessage)]
-#[rustfmt::skip]
-pub enum EditorRoute {
-    #[layout(Navbar)]
-    #[route("/")]
-    #[strum(message = "Home")]
-    Home {},
-    #[route("/editor")]
-    #[strum(message = "Editor")]
-    Editor {},
-}
-
 /// Home page
 #[component]
-fn Home() -> Element {
+pub fn Home() -> Element {
     rsx! {
         Hero {}
     }
 }
 
+// TODO: Unveränderter Dioxus-Vorlagentext. Ersetzen, sobald klar ist, was
+// beim Öffnen eines Workspace angezeigt wird, bevor eine Notiz gewählt wurde.
 #[component]
 pub fn Hero() -> Element {
     rsx! {
@@ -46,7 +38,7 @@ pub fn Hero() -> Element {
 }
 
 #[component]
-fn Editor() -> Element {
+pub fn Editor() -> Element {
     let mut source = use_signal(String::new);
 
     rsx! {
@@ -60,15 +52,34 @@ fn Editor() -> Element {
     }
 }
 
-/// Shared navbar component.
+/// Die Editor-Hülle: Datei-Leiste links, Editorfläche rechts.
+///
+/// Trägt zugleich den Zustands-Guard — ohne offenen Workspace hat der Editor
+/// nichts anzuzeigen. Der Fall ist real: Hot-Reload setzt den Context zurück,
+/// während die Route bestehen bleibt.
 #[component]
-fn Navbar() -> Element {
+pub fn EditorShell() -> Element {
+    let workspace = use_context::<Signal<Option<Workspace>>>();
+    let navigator = use_navigator();
+
+    use_effect(move || {
+        if workspace.read().is_none() {
+            navigator.replace(Route::Selector {});
+        }
+    });
+
+    if workspace.read().is_none() {
+        return rsx! {};
+    }
+
     rsx! {
         div {
             class: "layout-container",
             div {
                 class: "files-bar",
-                for entry in EditorRoute::iter() {
+                // TODO: Durch den Notiz-Baum des offenen Workspace ersetzen
+                // (rekursiv eingelesen, aufklappbar). Bis dahin die Routen.
+                for entry in Route::EDITOR_TABS {
                     CustomLink {
                         key: "{entry}",
                         label: entry.get_message().unwrap_or_default(),
@@ -79,8 +90,8 @@ fn Navbar() -> Element {
             }
             div {
                 class: "editor-container",
-                Outlet::<EditorRoute> {  }
+                Outlet::<Route> {  }
             }
         }
     }
-}
+}

src/views/workspace_selector/create_new_workspace.rs

@@ -1,11 +0,0 @@
-use dioxus::prelude::*;
-
-/// Create new Workspace Layout
-// TODO: Platzhalter — Formular zum Anlegen eines Workspace (Name, Pfad) und
-// Verdrahtung als Ziel von WorkspaceRoute::NewWorkspace fehlen noch.
-#[component]
-fn NewWorkspaceLayout() -> Element {
-    rsx! {
-        div {}
-    }
-}

src/views/workspace_selector/mod.rs

@@ -1,2 +1 @@
 pub mod selector;
-pub mod create_new_workspace;

src/views/workspace_selector/selector.rs

@@ -1,61 +1,26 @@
 use dioxus::prelude::*;
-use strum::{EnumMessage, IntoEnumIterator};
-use strum_macros::EnumIter;
-use crate::components::custom_link::custom_link_component::CustomLink;
 
-#[derive(Debug, Clone, Routable, PartialEq, EnumIter, EnumMessage)]
-#[rustfmt::skip]
-pub enum WorkspaceRoute {
-    #[layout(Workspace)]
-    #[route("/")]
-    #[strum(message = "Create new Workspace")]
-    NewWorkspace {},
-    #[route("/ws_open")]
-    #[strum(message = "Open Workspace")]
-    OpenWorkspace {},
-}
-
-/// Page to create new Workspace
+/// Der Bildschirm vor dem Editor: einen bekannten Workspace öffnen oder einen
+/// hinzufügen. Eine einzige Route, keine Reiter — die Workspace-Liste führt,
+/// das Hinzufügen ist Nebenaktion.
 #[component]
-fn NewWorkspace() -> Element {
+pub fn Selector() -> Element {
     rsx! {
-        div {
-            "New Workspace",
-        }
-    }
-}
-
-/// Page to open available Workspaces
-#[component]
-fn OpenWorkspace() -> Element {
-    rsx! {
-        div {
-            "Open Workspace",
-        }
-    }
-}
-
-/// Workspace Layout
-#[component]
-fn Workspace() -> Element {
-    rsx! {
-        div {
-            class: "workspace-selector-layout",
-            div {
-                class: "workspace-selector-links",
-                for route in WorkspaceRoute::iter() {
-                    CustomLink {
-                        key: "{route}",
-                        label: route.get_message().unwrap_or_default(),
-                        href: route.clone(),
-                        css: "workspace-selector",
+        div { class: "workspace-selector-layout",
+            div { class: "workspace-selector-view",
+                // TODO: Workspace-Liste aus workspaces.ron laden und darstellen
+                // (Ordnername, Pfad darunter, Statusabzeichen). Bis dahin nur
+                // der leere Zustand.
+                div { class: "empty-state",
+                    span { class: "empty-state-title", "Noch kein Workspace" }
+                    span { "Der erste Workspace ist ein Ordner deiner Wahl." }
+                    // TODO: Nativen Ordner-Dialog anbinden, Marker anlegen und
+                    // den Workspace in den Context schreiben.
+                    button { class: "btn btn-primary", disabled: true,
+                        "Workspace hinzufügen…"
                     }
                 }
             }
-            div {
-                class: "workspace-selector-view",
-                Outlet::<WorkspaceRoute> { }
-            }
         }
     }
 }

src/workspace.rs

@@ -0,0 +1,34 @@
+use std::path::PathBuf;
+
+/// Ein geöffneter Workspace — der Ordner auf der Platte, in dem die Notizen liegen.
+///
+/// Heute genau ein Feld. Der Typ existiert trotzdem als eigener Name, weil
+/// `CONTEXT.md` „Workspace" als Domänenbegriff führt und die Einstellungen aus
+/// `.dionotes/workspace.ron` hier andocken werden.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Workspace {
+    pub root: PathBuf,
+}
+
+impl Workspace {
+    /// Anzeigename: der Ordnername. Bewusst abgeleitet statt gespeichert —
+    /// ein eigenes Namensfeld wäre nach dem ersten Umbenennen des Ordners falsch.
+    pub fn name(&self) -> String {
+        self.root
+            .file_name()
+            .map(|n| n.to_string_lossy().into_owned())
+            .unwrap_or_else(|| self.root.to_string_lossy().into_owned())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Workspace;
+    use std::path::PathBuf;
+
+    #[test]
+    fn name_is_the_folder_name() {
+        let ws = Workspace { root: PathBuf::from("C:/Users/marvin/Notizen") };
+        assert_eq!(ws.name(), "Notizen");
+    }
+}

src/workspace_list.rs

@@ -0,0 +1,130 @@
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::io;
+use std::path::PathBuf;
+
+/// Verzeichnisname der App. Überall kleingeschrieben — unter Linux ist das
+/// Konvention, unter Windows in `%LOCALAPPDATA%` unauffällig. Eine Crate nur
+/// für diese Normalisierung (`directories`) wäre der teurere Weg gewesen.
+const APP_DIR: &str = "dionotes";
+const FILE_NAME: &str = "workspaces.ron";
+
+/// Die anwendungsweite Liste bekannter Workspaces.
+///
+/// Sie enthält nur Pfade: Der Anzeigename ist der Ordnername und wäre als
+/// eigenes Feld nach dem ersten Umbenennen falsch. Auch keinen Zeitstempel —
+/// die **Reihenfolge ist die Sortierung**, zuletzt geöffnet steht vorn.
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceList {
+    workspaces: Vec<PathBuf>,
+}
+
+impl WorkspaceList {
+    pub fn entries(&self) -> &[PathBuf] {
+        &self.workspaces
+    }
+
+    /// Hebt einen Workspace an die Spitze — beim Öffnen wie beim Hinzufügen.
+    /// Weil vorher gefiltert wird, kann derselbe Pfad nicht doppelt vorkommen.
+    pub fn promote(&mut self, path: PathBuf) {
+        self.workspaces.retain(|known| known != &path);
+        self.workspaces.insert(0, path);
+    }
+
+    /// Wo die Liste liegt.
+    ///
+    /// Ein Ausdruck für alle Plattformen: `state_dir()` liefert nur unter Linux
+    /// `Some` — dort führt die XDG-Spec „recently used files" ausdrücklich als
+    /// State, gehört also nach `$XDG_STATE_HOME` und nicht nach `~/.config`.
+    /// Windows und macOS fallen auf das lokale Konfigurationsverzeichnis durch;
+    /// unter Windows bewusst `%LOCALAPPDATA%` statt Roaming, weil absolute
+    /// Workspace-Pfade maschinenspezifisch sind.
+    pub fn path() -> Option<PathBuf> {
+        let base = dirs::state_dir().or_else(dirs::config_local_dir)?;
+        Some(base.join(APP_DIR).join(FILE_NAME))
+    }
+
+    /// Lesen. Eine fehlende oder unlesbare Datei ergibt eine leere Liste statt
+    /// eines Fehlers: Sie enthält nichts Unwiederbringliches — der Nutzer wählt
+    /// seine Ordner einmal neu, seine Notizen sind nicht betroffen. Deshalb
+    /// braucht die Datei auch keine Schema-Version.
+    pub fn load() -> Self {
+        Self::path()
+            .and_then(|path| fs::read_to_string(path).ok())
+            .map(|text| Self::parse(&text))
+            .unwrap_or_default()
+    }
+
+    pub fn save(&self) -> io::Result<()> {
+        let path = Self::path().ok_or_else(|| {
+            io::Error::new(io::ErrorKind::NotFound, "kein Konfigurationsverzeichnis")
+        })?;
+        // Das Basisverzeichnis existiert garantiert, das der App nicht.
+        if let Some(dir) = path.parent() {
+            fs::create_dir_all(dir)?;
+        }
+        fs::write(path, self.to_ron()?)
+    }
+
+    fn parse(text: &str) -> Self {
+        ron::from_str(text).unwrap_or_default()
+    }
+
+    fn to_ron(&self) -> io::Result<String> {
+        ron::ser::to_string_pretty(self, ron::ser::PrettyConfig::default())
+            .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::WorkspaceList;
+    use std::path::PathBuf;
+
+    fn list_of(paths: &[&str]) -> WorkspaceList {
+        let mut list = WorkspaceList::default();
+        // rückwärts, damit die Reihenfolge am Ende der Eingabe entspricht
+        for p in paths.iter().rev() {
+            list.promote(PathBuf::from(p));
+        }
+        list
+    }
+
+    #[test]
+    fn promote_puts_new_entries_first() {
+        let mut list = list_of(&["a", "b"]);
+        list.promote(PathBuf::from("c"));
+        assert_eq!(list.entries(), [PathBuf::from("c"), PathBuf::from("a"), PathBuf::from("b")]);
+    }
+
+    #[test]
+    fn promote_moves_known_entries_without_duplicating() {
+        let mut list = list_of(&["a", "b", "c"]);
+        list.promote(PathBuf::from("c"));
+        assert_eq!(list.entries(), [PathBuf::from("c"), PathBuf::from("a"), PathBuf::from("b")]);
+    }
+
+    #[test]
+    fn survives_a_ron_roundtrip_with_windows_paths() {
+        let list = list_of(&[r"C:\Users\marvin\Notizen", r"D:\Projekte\Test"]);
+        let text = list.to_ron().expect("serialisierbar");
+        assert_eq!(WorkspaceList::parse(&text), list);
+    }
+
+    #[test]
+    fn path_lands_in_the_app_directory() {
+        let path = WorkspaceList::path().expect("Konfigurationsverzeichnis vorhanden");
+        assert!(
+            path.ends_with("dionotes/workspaces.ron"),
+            "unerwarteter Ablageort: {}",
+            path.display()
+        );
+        println!("Ablageort auf dieser Plattform: {}", path.display());
+    }
+
+    #[test]
+    fn unreadable_content_yields_an_empty_list() {
+        assert_eq!(WorkspaceList::parse("kein RON, nur Text"), WorkspaceList::default());
+        assert_eq!(WorkspaceList::parse(""), WorkspaceList::default());
+    }
+}