feat: markdown viewer

Author: SilenLoc

Cargo.lock

@@ -25,3 +25,4 @@ maud = "0.27.0"
 markdown = "1.0.0"
 xshell = "0.2.7"
 dirs = "6.0.0"
+tui-markdown = "0.3.7"

Cargo.toml

@@ -1,10 +1,9 @@
 mod chat;
-mod docs;
+mod markdown;
 mod meetups;
 mod remote;
 
 use argh::FromArgs;
-use inquire::{InquireError, Select};
 
 #[derive(FromArgs, PartialEq, Debug)]
 /// The Rust-Basel cli.
@@ -18,52 +17,20 @@ struct Basel {
 enum Command {
     Job(JobCommand),
     Mtp(MeetupCommand),
-    Doc(DocCommand),
-    Init(InitCommand),
     Website(WebsiteCommand),
     Chat(ChatCommand),
 }
 
-impl From<String> for Command {
-    fn from(s: String) -> Self {
-        match s.as_str() {
-            "job" => Command::Job(JobCommand {}),
-            "meetup" => Command::Mtp(MeetupCommand {}),
-            "doc" => Command::Doc(DocCommand {}),
-            _ => panic!("Unknown command"),
-        }
-    }
-}
-
-fn command_as_vec() -> Vec<&'static str> {
-    vec!["job", "meetup", "doc"]
-}
-
 #[derive(FromArgs, PartialEq, Debug)]
 /// Find the featured jobs.
 #[argh(subcommand, name = "job")]
 struct JobCommand {}
 
-#[derive(FromArgs, PartialEq, Debug)]
-/// Go to the documentation for this application.
-#[argh(subcommand, name = "doc")]
-struct DocCommand {}
-
 #[derive(FromArgs, PartialEq, Debug)]
 /// Explore meetups
 #[argh(subcommand, name = "meetup")]
 struct MeetupCommand {}
 
-#[derive(FromArgs, PartialEq, Debug)]
-/// Inits the repository
-#[argh(subcommand, name = "init")]
-struct InitCommand {}
-
-#[derive(FromArgs, PartialEq, Debug)]
-/// Builds the website
-#[argh(subcommand, name = "website")]
-struct WebsiteCommand {}
-
 #[derive(FromArgs, PartialEq, Debug)]
 /// Runs the chat
 #[argh(subcommand, name = "chat")]
@@ -77,7 +44,7 @@ fn main() {
     let basel: Basel = argh::from_env();
     match basel.commands {
         Some(c) => match_command(c),
-        None => inquire(),
+        None => println!("Use basel --help for usage"),
     }
 }
 
@@ -87,22 +54,13 @@ fn match_command(c: Command) {
             println!("Help needed to implement a nice job ui and systemy");
         }
         Command::Mtp(_mtp) => meetups::meetup_ui(),
-
-        Command::Doc(_doc) => docs::docs_ui(),
-        Command::Init(_init_command) => meetups::init::init(),
         Command::Website(_website_command) => meetups::website::build(),
 
         Command::Chat(_chat_command) => chat::connect(_chat_command.code),
     }
 }
 
-fn inquire() {
-    let ans: Result<&str, InquireError> = Select::new("commands", command_as_vec()).prompt();
-
-    let Ok(ans) = ans else {
-        println!("No selection made");
-        return;
-    };
-
-    match_command(ans.to_owned().into());
-}
+#[derive(FromArgs, PartialEq, Debug)]
+/// Builds the website [internal]
+#[argh(subcommand, name = "website")]
+struct WebsiteCommand {}

src/docs.rs

@@ -0,0 +1,215 @@
+use std::io;
+use std::time::{Duration, Instant};
+
+use ratatui::{DefaultTerminal, text::Text};
+
+use crate::markdown::{
+    commands::Command,
+    events::{self, Action, CommandAction},
+    navigation::Navigation,
+    search::Search,
+    ui::{self, Mode},
+};
+
+/// Main application state and logic
+pub struct App {
+    text: Text<'static>,
+    original_text: Text<'static>,
+    navigation: Navigation,
+    search: Search,
+    mode: Mode,
+    command_input: String,
+    status_message: Option<String>,
+    highlight_time: Option<Instant>,
+    exit: bool,
+}
+
+impl App {
+    pub fn new(text: Text<'static>) -> Self {
+        Self {
+            original_text: text.clone(),
+            text,
+            navigation: Navigation::new(),
+            search: Search::new(),
+            mode: Mode::Normal,
+            command_input: String::new(),
+            status_message: None,
+            highlight_time: None,
+            exit: false,
+        }
+    }
+
+    pub fn run(&mut self, terminal: &mut DefaultTerminal) -> io::Result<()> {
+        while !self.exit {
+            terminal.draw(|frame| {
+                ui::draw(
+                    frame,
+                    &self.text,
+                    self.navigation.scroll,
+                    &self.mode,
+                    &self.command_input,
+                    &self.status_message,
+                )
+            })?;
+
+            // Check if highlight time has expired
+            if let Some(highlight_time) = self.highlight_time
+                && highlight_time.elapsed() >= Duration::from_secs(2)
+            {
+                self.clear_highlights();
+                self.highlight_time = None;
+            }
+
+            self.handle_events()?;
+        }
+        Ok(())
+    }
+
+    fn handle_events(&mut self) -> io::Result<()> {
+        // Use a timeout to check for highlight expiration
+        if let Some(key_event) = events::poll_events(Duration::from_millis(100))? {
+            match self.mode {
+                Mode::Normal => self.handle_normal_mode(key_event),
+                Mode::Command => self.handle_command_mode(key_event),
+            }
+        }
+        Ok(())
+    }
+
+    fn handle_normal_mode(&mut self, key_event: crossterm::event::KeyEvent) {
+        match events::handle_normal_mode(key_event) {
+            Action::Quit => self.exit = true,
+            Action::EnterCommandMode => {
+                self.mode = Mode::Command;
+                self.command_input.clear();
+                self.status_message = None;
+            }
+            Action::ScrollDown(amount) => self.navigation.scroll_down(amount, &self.text),
+            Action::ScrollUp(amount) => self.navigation.scroll_up(amount),
+            Action::NextMatch => self.next_search_result(),
+            Action::PrevMatch => self.prev_search_result(),
+            Action::None => {}
+        }
+    }
+
+    fn handle_command_mode(&mut self, key_event: crossterm::event::KeyEvent) {
+        match events::handle_command_mode(key_event) {
+            CommandAction::Exit => {
+                self.mode = Mode::Normal;
+                self.command_input.clear();
+            }
+            CommandAction::Execute => {
+                self.execute_command();
+                self.mode = Mode::Normal;
+            }
+            CommandAction::AppendChar(c) => {
+                self.command_input.push(c);
+            }
+            CommandAction::Backspace => {
+                self.command_input.pop();
+            }
+            CommandAction::None => {}
+        }
+    }
+
+    fn execute_command(&mut self) {
+        let command = Command::parse(&self.command_input);
+
+        match command {
+            Command::Quit => {
+                self.exit = true;
+            }
+            Command::Search(query) => {
+                self.perform_search(&query);
+            }
+            Command::Jump(line_num) => match self.navigation.jump_to_line(line_num, &self.text) {
+                Ok(()) => {
+                    self.status_message = Some(format!("Jumped to line {}", line_num));
+                }
+                Err(msg) => {
+                    self.status_message = Some(msg);
+                }
+            },
+            Command::Help => {
+                self.status_message = Some(Command::help_text());
+            }
+            Command::Unknown(msg) => {
+                self.status_message = Some(msg);
+            }
+        }
+
+        self.command_input.clear();
+    }
+
+    fn perform_search(&mut self, query: &str) {
+        if query.is_empty() {
+            self.status_message = Some("Empty search query".to_string());
+            return;
+        }
+
+        let count = self.search.perform_search(query, &self.original_text);
+
+        if count > 0 {
+            // Apply highlighting and start timer
+            self.text = self.search.highlight_matches(&self.original_text);
+            self.highlight_time = Some(Instant::now());
+
+            // Jump to first result
+            if let Some(line) = self.search.current_match() {
+                self.navigation.scroll_to_line(line as u16);
+            }
+
+            self.status_message = Some(format!("Found {} matches for '{}'", count, query));
+        } else {
+            self.status_message = Some(format!("No matches found for '{}'", query));
+        }
+    }
+
+    fn next_search_result(&mut self) {
+        if !self.search.has_results() {
+            self.status_message = Some("No search results. Use :s <query> to search".to_string());
+            return;
+        }
+
+        if let Some(line) = self.search.next_match() {
+            // Re-highlight to update the current match indicator and reset timer
+            self.text = self.search.highlight_matches(&self.original_text);
+            self.highlight_time = Some(Instant::now());
+
+            self.navigation.scroll_to_line(line as u16);
+
+            self.status_message = Some(format!(
+                "Match {}/{}",
+                self.search.current_index + 1,
+                self.search.results.len()
+            ));
+        }
+    }
+
+    fn prev_search_result(&mut self) {
+        if !self.search.has_results() {
+            self.status_message = Some("No search results. Use :s <query> to search".to_string());
+            return;
+        }
+
+        if let Some(line) = self.search.prev_match() {
+            // Re-highlight to update the current match indicator and reset timer
+            self.text = self.search.highlight_matches(&self.original_text);
+            self.highlight_time = Some(Instant::now());
+
+            self.navigation.scroll_to_line(line as u16);
+
+            self.status_message = Some(format!(
+                "Match {}/{}",
+                self.search.current_index + 1,
+                self.search.results.len()
+            ));
+        }
+    }
+
+    fn clear_highlights(&mut self) {
+        // Reset to original text without highlights
+        self.text = self.original_text.clone();
+        self.search.clear();
+    }
+}

src/main.rs

@@ -0,0 +1,50 @@
+/// Command execution and parsing for the markdown viewer
+pub enum Command {
+    Quit,
+    Search(String),
+    Jump(usize),
+    Help,
+    Unknown(String),
+}
+
+impl Command {
+    pub fn parse(input: &str) -> Self {
+        let parts: Vec<&str> = input.split_whitespace().collect();
+
+        if parts.is_empty() {
+            return Command::Unknown(String::new());
+        }
+
+        match parts[0] {
+            "q" | "quit" => Command::Quit,
+            "s" | "search" => {
+                if parts.len() > 1 {
+                    let query = parts[1..].join(" ");
+                    Command::Search(query)
+                } else {
+                    Command::Unknown("Usage: :s <query>".to_string())
+                }
+            }
+            "jump" => {
+                if parts.len() > 1 {
+                    if let Ok(line_num) = parts[1].parse::<usize>() {
+                        Command::Jump(line_num)
+                    } else {
+                        Command::Unknown("Usage: :jump <line_number>".to_string())
+                    }
+                } else {
+                    Command::Unknown("Usage: :jump <line_number>".to_string())
+                }
+            }
+            "help" => Command::Help,
+            _ => Command::Unknown(format!(
+                "Unknown command: {}. Type :help for help",
+                parts[0]
+            )),
+        }
+    }
+
+    pub fn help_text() -> String {
+        "Commands: :q (quit) | :s <query> (search) | :jump <line> | :help | j/k (scroll) | n/N (next/prev match)".to_string()
+    }
+}