refactor: organize ui components

Author: ymgyt

syndapi/src/persistence/memory.rs

@@ -13,7 +13,7 @@ pub struct MemoryDatastore {
 
 const TEST_DATA: &[&str] = &[
     "https://seanmonstar.com/rss",
-    "https://thesquareplanet.com/blog/feed.xml",
+    "https://thesquareplanet.com/feed.xml",
     "https://thiscute.world/en/index.xml",
     "https://blog.m-ou.se/index.xml",
     "https://keens.github.io/index.xml",

syndterm/src/application/mod.rs

@@ -2,65 +2,34 @@ use std::{pin::Pin, time::Duration};
 
 use crossterm::event::{Event as CrosstermEvent, KeyCode, KeyEvent, KeyEventKind};
 use futures_util::{FutureExt, Stream, StreamExt};
+use ratatui::widgets::Widget;
 use tokio::time::{Instant, Sleep};
 
 use crate::{
     auth::{
         self,
         device_flow::{DeviceAccessTokenResponse, DeviceAuthorizationResponse},
-        Authentication,
+        Credential,
     },
     client::Client,
     command::Command,
     job::Jobs,
     terminal::Terminal,
     ui::{
         self,
-        entries::Entries,
-        login::LoginMethods,
-        prompt::Prompt,
-        subscription::Subscription,
-        tabs::{Tab, Tabs},
+        components::{authentication::Authentication, root::Root, tabs::Tab, Components},
         theme::Theme,
     },
 };
 
 mod direction;
 pub use direction::{Direction, IndexOutOfRange};
 
-/// Cureent ui screen
-pub enum Screen {
-    Login,
-    Browse,
-}
-
-/// Handle user authentication
-#[derive(PartialEq, Eq)]
-pub enum AuthenticateState {
-    NotAuthenticated,
-    DeviceFlow(DeviceAuthorizationResponse),
-    Authenticated,
-}
-
-pub struct LoginState {
-    pub login_methods: LoginMethods,
-    pub auth_state: AuthenticateState,
-}
-
-pub struct State {
-    pub screen: Screen,
-    pub login: LoginState,
-    pub tabs: Tabs,
-    pub prompt: Prompt,
-    pub subscription: Subscription,
-    pub entries: Entries,
-}
-
 pub struct Application {
     terminal: Terminal,
     client: Client,
     jobs: Jobs,
-    state: State,
+    components: Components,
     theme: Theme,
     idle_timer: Pin<Box<Sleep>>,
 
@@ -75,34 +44,21 @@ pub enum EventLoopControlFlow {
 
 impl Application {
     pub fn new(terminal: Terminal, client: Client) -> Self {
-        let state = State {
-            screen: Screen::Login,
-            login: LoginState {
-                login_methods: LoginMethods::new(),
-                auth_state: AuthenticateState::NotAuthenticated,
-            },
-            tabs: Tabs::new(),
-            subscription: Subscription::new(),
-            entries: Entries::new(),
-            prompt: Prompt::new(),
-        };
-
         Self {
             terminal,
             client,
+            components: Components::new(),
             jobs: Jobs::new(),
-            state,
             theme: Theme::new(),
             idle_timer: Box::pin(tokio::time::sleep(Duration::from_millis(250))),
             should_quit: false,
             should_render: false,
         }
     }
 
-    pub fn set_auth(&mut self, auth: Authentication) {
-        self.client.set_credential(auth);
-        self.state.login.auth_state = AuthenticateState::Authenticated;
-        self.state.screen = Screen::Browse;
+    pub fn set_credential(&mut self, cred: Credential) {
+        self.client.set_credential(cred);
+        self.components.auth.authenticated();
         self.initial_fetch();
         self.should_render = true;
     }
@@ -170,7 +126,7 @@ impl Application {
             if self.should_render {
                 self.render();
                 self.should_render = false;
-                self.state.prompt.clear_error_message();
+                self.components.prompt.clear_error_message();
             }
 
             if self.should_quit {
@@ -204,8 +160,8 @@ impl Application {
                     self.complete_device_authroize_flow(device_access_token)
                 }
                 Command::MoveTabSelection(direction) => {
-                    match self.state.tabs.move_selection(direction) {
-                        Tab::Subscription if !self.state.subscription.has_subscription() => {
+                    match self.components.tabs.move_selection(direction) {
+                        Tab::Subscription if !self.components.subscription.has_subscription() => {
                             next = Some(Command::FetchSubscription {
                                 after: None,
                                 first: 50,
@@ -216,7 +172,7 @@ impl Application {
                     self.should_render = true;
                 }
                 Command::MoveSubscribedFeed(direction) => {
-                    self.state.subscription.move_selection(direction);
+                    self.components.subscription.move_selection(direction);
                     self.should_render = true;
                 }
                 Command::PromptFeedSubscription => {
@@ -239,15 +195,15 @@ impl Application {
                     self.fetch_subscription(after, first)
                 }
                 Command::UpdateSubscription(sub) => {
-                    self.state.subscription.update_subscription(sub);
+                    self.components.subscription.update_subscription(sub);
                     self.should_render = true;
                 }
                 Command::CompleteSubscribeFeed { feed } => {
-                    self.state.subscription.add_subscribed_feed(feed);
+                    self.components.subscription.add_subscribed_feed(feed);
                     self.should_render = true;
                 }
                 Command::CompleteUnsubscribeFeed { url } => {
-                    self.state.subscription.remove_unsubscribed_feed(url);
+                    self.components.subscription.remove_unsubscribed_feed(url);
                     self.should_render = true;
                 }
                 Command::OpenFeed => {
@@ -257,31 +213,30 @@ impl Application {
                     self.fetch_entries(after, first);
                 }
                 Command::UpdateEntries(payload) => {
-                    self.state.entries.update_entries(payload);
+                    self.components.entries.update_entries(payload);
                     self.should_render = true;
                 }
                 Command::MoveEntry(direction) => {
-                    self.state.entries.move_selection(direction);
+                    self.components.entries.move_selection(direction);
                     self.should_render = true;
                 }
                 Command::OpenEntry => {
                     self.open_entry();
                 }
                 Command::HandleError { message } => {
-                    self.state.prompt.set_error_message(message);
+                    self.components.prompt.set_error_message(message);
                     self.should_render = true;
                 }
             }
         }
     }
 
     fn render(&mut self) {
-        let cx = ui::Context {
-            state: &mut self.state,
-            theme: &self.theme,
-        };
+        let cx = ui::Context { theme: &self.theme };
+        let root = Root::new(&self.components, cx);
 
-        self.terminal.render(|frame| ui::render(frame, cx)).unwrap();
+        self.terminal
+            .render(|frame| Widget::render(root, frame.size(), frame.buffer_mut()));
     }
 
     #[allow(clippy::single_match)]
@@ -312,7 +267,7 @@ impl Application {
                         KeyCode::BackTab => {
                             return Some(Command::MoveTabSelection(Direction::Left))
                         }
-                        _ => match self.state.tabs.current() {
+                        _ => match self.state.components.tabs.current() {
                             Tab::Feeds => match key.code {
                                 KeyCode::Char('j') => {
                                     return Some(Command::MoveEntry(Direction::Down))
@@ -379,6 +334,7 @@ impl Application {
         // TODO: prompt deletion confirm
         let Some(url) = self
             .state
+            .components
             .subscription
             .selected_feed_url()
             .map(ToOwned::to_owned)
@@ -414,14 +370,20 @@ impl Application {
 
 impl Application {
     fn open_feed(&mut self) {
-        let Some(feed_website_url) = self.state.subscription.selected_feed_website_url() else {
+        let Some(feed_website_url) = self
+            .state
+            .components
+            .subscription
+            .selected_feed_website_url()
+        else {
             return;
         };
         open::that(feed_website_url).ok();
     }
 
     fn open_entry(&mut self) {
-        let Some(entry_website_url) = self.state.entries.selected_entry_website_url() else {
+        let Some(entry_website_url) = self.state.components.entries.selected_entry_website_url()
+        else {
             return;
         };
         open::that(entry_website_url).ok();
@@ -444,11 +406,6 @@ impl Application {
     }
 }
 
-#[derive(Debug)]
-pub enum AuthenticateMethod {
-    Github,
-}
-
 impl Application {
     fn authenticate(&mut self, method: AuthenticateMethod) {
         match method {
@@ -498,9 +455,9 @@ impl Application {
         };
 
         // TODO: handle error
-        auth::persist_authentication(auth.clone()).ok();
+        auth::persist_credential(auth.clone()).ok();
 
-        self.set_auth(auth);
+        self.set_credential(auth);
     }
 }
 

syndterm/src/auth/mod.rs

@@ -8,31 +8,36 @@ use crate::config;
 pub mod device_flow;
 pub mod github;
 
+#[derive(Debug, Clone, Copy)]
+pub enum AuthenticationProvider {
+    Github,
+}
+
 #[derive(Serialize, Deserialize, Clone)]
-pub enum Authentication {
+pub enum Credential {
     Github { access_token: String },
 }
 
-pub fn persist_authentication(auth: Authentication) -> anyhow::Result<()> {
-    let auth_path = auth_file();
-    if let Some(parent) = auth_path.parent() {
+pub fn persist_credential(cred: Credential) -> anyhow::Result<()> {
+    let cred_path = cred_file();
+    if let Some(parent) = cred_path.parent() {
         std::fs::create_dir_all(parent)?;
     }
-    let mut auth_file = std::fs::File::create(&auth_path)?;
+    let mut cred_file = std::fs::File::create(&cred_path)?;
 
-    debug!(path = ?auth_path.display(), "Create auth cache file");
+    debug!(path = ?cred_path.display(), "Create credential cache file");
 
-    serde_json::to_writer(&mut auth_file, &auth)?;
+    serde_json::to_writer(&mut cred_file, &cred)?;
 
     Ok(())
 }
 
-fn auth_file() -> PathBuf {
-    config::cache_dir().join("auth.json")
+fn cred_file() -> PathBuf {
+    config::cache_dir().join("credential.json")
 }
 
-pub fn authenticate_from_cache() -> Option<Authentication> {
-    std::fs::File::open(auth_file())
+pub fn credential_from_cache() -> Option<Credential> {
+    std::fs::File::open(cred_file())
         .ok()
         .and_then(|f| serde_json::from_reader(f).ok())
 }

syndterm/src/client/mod.rs

@@ -7,7 +7,7 @@ use serde::{de::DeserializeOwned, Serialize};
 use tracing::error;
 use url::Url;
 
-use crate::{auth::Authentication, config, types};
+use crate::{auth::Credential, config, types};
 
 use self::query::subscription::SubscriptionOutput;
 
@@ -39,9 +39,9 @@ impl Client {
         })
     }
 
-    pub fn set_credential(&mut self, auth: Authentication) {
+    pub fn set_credential(&mut self, auth: Credential) {
         let mut token = HeaderValue::try_from(match auth {
-            Authentication::Github { access_token } => format!("github {access_token}"),
+            Credential::Github { access_token } => format!("github {access_token}"),
         })
         .unwrap();
         token.set_sensitive(true);

syndterm/src/main.rs

@@ -69,9 +69,9 @@ async fn main() {
         Application::new(terminal, client)
     };
 
-    if let Some(auth) = auth::authenticate_from_cache() {
+    if let Some(auth) = auth::credential_from_cache() {
         info!("Use authentication cache");
-        app.set_auth(auth);
+        app.set_credential(auth);
     }
 
     info!("Running...");