refactor: flatten module files from subdirectories into single files

src/app.rs

@@ -0,0 +1,138 @@
+mod home_ops;
+mod profile_ext;
+mod types;
+
+pub mod cred;
+pub mod form;
+pub mod settings;
+
+pub use cred::{CredFormField, CredFormState};
+pub use form::{FormField, FormState};
+pub use profile_ext::{display_name, split_args};
+pub use settings::{SettingsField, SettingsState};
+pub use types::*;
+
+use crate::config::{ConnectionProfile, ConnectionType, SshellConfig};
+use anyhow::Result;
+use std::cmp::Reverse;
+
+pub struct App {
+    pub config: SshellConfig,
+    pub session: Session,
+}
+
+impl App {
+    pub fn load() -> Result<Self> {
+        let config = SshellConfig::load()?;
+        let app = Self {
+            config,
+            session: Session::new(),
+        };
+        Ok(app)
+    }
+
+    pub fn entries(&self) -> Vec<(&String, &ConnectionProfile)> {
+        let mut ssh_entries: Vec<_> = self
+            .config
+            .connections
+            .iter()
+            .filter(|(name, profile)| {
+                profile_ext::matches_search(name, profile, &self.session.home.search)
+            })
+            .filter(|(_, profile)| matches!(profile.kind, ConnectionType::Ssh { .. }))
+            .collect();
+        let shell_entries: Vec<_> = self
+            .config
+            .connections
+            .iter()
+            .filter(|(name, profile)| {
+                profile_ext::matches_search(name, profile, &self.session.home.search)
+            })
+            .filter(|(_, profile)| matches!(profile.kind, ConnectionType::Shell { .. }))
+            .collect();
+        ssh_entries.extend(shell_entries);
+        ssh_entries
+    }
+
+    pub fn quick_entries(&self) -> Vec<(&String, &ConnectionProfile)> {
+        let mut entries = self.entries();
+        match self.session.home.quick_sort {
+            QuickSortMode::Usage => entries.sort_by(|a, b| {
+                b.1.usage_count
+                    .cmp(&a.1.usage_count)
+                    .then_with(|| a.1.added_order.cmp(&b.1.added_order))
+            }),
+            QuickSortMode::Added => entries.sort_by_key(|entry| Reverse(entry.1.added_order)),
+            QuickSortMode::Name => entries.sort_by(|a, b| {
+                a.0.to_lowercase()
+                    .cmp(&b.0.to_lowercase())
+                    .then_with(|| a.1.added_order.cmp(&b.1.added_order))
+            }),
+            QuickSortMode::Smart => entries.sort_by(|a, b| {
+                profile_ext::smart_score(b.1)
+                    .cmp(&profile_ext::smart_score(a.1))
+                    .then_with(|| b.1.usage_count.cmp(&a.1.usage_count))
+                    .then_with(|| a.1.added_order.cmp(&b.1.added_order))
+            }),
+        }
+        entries
+    }
+
+    pub fn selected_name(&self) -> Option<String> {
+        self.entries()
+            .get(self.session.home.selected)
+            .map(|(name, _)| (*name).clone())
+    }
+
+    pub fn move_selection(&mut self, delta: isize) {
+        let len = match self.session.mode {
+            Mode::ImportSelector => {
+                self.session.import.shell_candidates.len() + self.session.import.candidates.len()
+            }
+            Mode::Credentials => self.config.credentials.entries.len(),
+            _ => self.entries().len(),
+        };
+        let selected = match self.session.mode {
+            Mode::ImportSelector => &mut self.session.import.cursor,
+            Mode::Credentials => &mut self.session.credentials.selected,
+            _ => &mut self.session.home.selected,
+        };
+        if len == 0 {
+            *selected = 0;
+            return;
+        }
+        *selected = (*selected as isize + delta).rem_euclid(len as isize) as usize;
+    }
+
+    pub fn jump_group(&mut self) {
+        let entries = self.entries();
+        let Some((_, current)) = entries.get(self.session.home.selected) else {
+            return;
+        };
+        let target_is_shell = matches!(current.kind, ConnectionType::Ssh { .. });
+        if let Some(idx) = entries.iter().position(|(_, profile)| {
+            matches!(
+                (&profile.kind, target_is_shell),
+                (ConnectionType::Shell { .. }, true) | (ConnectionType::Ssh { .. }, false)
+            )
+        }) {
+            self.session.home.selected = idx;
+        }
+    }
+
+    pub fn record_use(&mut self, name: &str) -> Result<()> {
+        if let Some(profile) = self.config.connections.get_mut(name) {
+            profile.usage_count = profile.usage_count.saturating_add(1);
+            self.config.save()?;
+        }
+        Ok(())
+    }
+
+    pub fn toast(&mut self, message: impl Into<String>, success: bool) {
+        self.session.toast = Some(Toast {
+            message: message.into(),
+            success,
+            born: std::time::Instant::now(),
+        });
+    }
+}