init

Author: DraugS

Cargo.lock

@@ -0,0 +1,13 @@
+[package]
+name = "file-manager"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.95"
+crossterm = { version = "0.28.1", features = ["event-stream"] }
+futures = "0.3.31"
+open = "5.3.2"
+ratatui = "0.29.0"
+tokio = { version = "1.40.0", features = ["full"] }
+trash = "5.2.1"

Cargo.toml

@@ -1,2 +1 @@
-# file-manager-rust
-File Manager Rust
+# File Manager Rust

README.md

@@ -0,0 +1,14 @@
+------------------------------
+            General
+------------------------------
+
+? - open/close this help
+Esc/q/Ctrl-c - exit
+
+------------------------------
+            Files
+------------------------------
+
+Ctrl-h - toggle hidden files and directories
+d - move file to trash
+Ctrl-d - delete file permanently

resources/help

@@ -0,0 +1,164 @@
+use std::{env, fs, path::PathBuf};
+
+use anyhow::Result;
+use ratatui::widgets::ListState;
+
+use crate::files;
+
+#[derive(Debug)]
+pub struct App {
+    // General
+    pub running: bool,
+
+    // Files
+    pub current_dir: PathBuf,
+    pub files: Vec<files::File>,
+    pub files_state: ListState,
+    pub show_hidden: bool,
+
+    // Help
+    pub show_help: bool,
+    pub help_offset: usize,
+}
+
+impl App {
+    pub fn new() -> Result<Self> {
+        let current_dir = env::current_dir()?;
+
+        Ok(App {
+            // General
+            running: true,
+
+            // Files
+            current_dir: current_dir.clone(),
+            files: files::list_dir(current_dir, false)?,
+            files_state: ListState::default().with_selected(Some(0)),
+            show_hidden: false,
+
+            // Help
+            show_help: false,
+            help_offset: 0,
+        })
+    }
+
+    pub fn quit(&mut self) {
+        self.running = false;
+    }
+
+    pub fn select_next(&mut self) {
+        if let Some(selected) = self.files_state.selected() {
+            if selected == self.files.len() - 1 {
+                self.files_state.select_first();
+                return;
+            }
+        }
+
+        self.files_state.select_next();
+    }
+
+    pub fn select_previous(&mut self) {
+        if let Some(selected) = self.files_state.selected() {
+            if selected == 0 {
+                self.files_state.select_last();
+                return;
+            }
+        }
+
+        self.files_state.select_previous();
+    }
+
+    pub fn toggle_hidden(&mut self) -> Result<()> {
+        self.show_hidden = !self.show_hidden;
+        self.refresh_files(None)?;
+
+        Ok(())
+    }
+
+    pub fn return_path(&mut self) -> Result<()> {
+        if let Some(parent_dir) = self.current_dir.parent() {
+            self.refresh_files(Some(PathBuf::from(parent_dir)))?;
+        }
+
+        Ok(())
+    }
+
+    pub fn open(&mut self) -> Result<()> {
+        if let Some(selected) = self.files_state.selected() {
+            let file = self.files.get(selected).unwrap();
+            if file.is_dir {
+                self.refresh_files(Some(self.current_dir.join(&file.name)))?;
+                return Ok(());
+            }
+
+            open::that(self.current_dir.join(&file.name))?;
+        }
+
+        Ok(())
+    }
+
+    pub fn move_to_trash(&mut self) -> Result<()> {
+        if let Some(selected) = self.files_state.selected() {
+            let file = self.files.get(selected).unwrap();
+            trash::delete(self.current_dir.join(&file.name))?;
+            self.refresh_files(None)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn remove_file(&mut self) -> Result<()> {
+        if let Some(selected) = self.files_state.selected() {
+            let file = self.files.get(selected).unwrap();
+            fs::remove_file(self.current_dir.join(&file.name))?;
+            self.refresh_files(None)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn toggle_help(&mut self) {
+        self.show_help = !self.show_help;
+    }
+
+    pub fn get_file_names(&self) -> Vec<String> {
+        self.files.iter().map(|f| f.formated_name.clone()).collect()
+    }
+
+    pub fn get_files_selected(&self) -> usize {
+        if let Some(selected) = self.files_state.selected() {
+            return selected;
+        }
+
+        0
+    }
+
+    pub fn get_preview(&self) -> String {
+        if let Some(selected) = self.files_state.selected() {
+            let file = self.files.get(selected).unwrap();
+            if file.is_dir {
+                return files::list_dir(self.current_dir.join(&file.name), self.show_hidden)
+                    .unwrap()
+                    .iter()
+                    .map(|f| f.formated_name.clone())
+                    .collect::<Vec<_>>()
+                    .join("\n");
+            }
+
+            return fs::read_to_string(self.current_dir.join(&file.name))
+                .unwrap_or("--Cannot read file--".to_string());
+        }
+
+        String::new()
+    }
+
+    fn refresh_files(&mut self, path: Option<PathBuf>) -> Result<()> {
+        if let Some(path_buf) = path {
+            self.current_dir = path_buf;
+        }
+
+        self.files = files::list_dir(self.current_dir.clone(), self.show_hidden)?;
+        self.files_state.select_first();
+
+        Ok(())
+    }
+}

src/app.rs

@@ -0,0 +1,98 @@
+use std::time::Duration;
+
+use anyhow::Result;
+use crossterm::event::{Event as CrosstermEvent, KeyEvent, MouseEvent};
+use futures::{FutureExt, StreamExt};
+use tokio::sync::mpsc;
+
+/// Terminal events.
+#[derive(Clone, Copy, Debug)]
+pub enum Event {
+    /// Terminal tick.
+    Tick,
+    /// Key press.
+    Key(KeyEvent),
+    /// Mouse click/scroll.
+    #[allow(dead_code)]
+    Mouse(MouseEvent),
+    /// Terminal resize.
+    #[allow(dead_code)]
+    Resize(u16, u16),
+}
+
+/// Terminal event handler.
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct EventHandler {
+    /// Event sender channel.
+    sender: mpsc::UnboundedSender<Event>,
+    /// Event receiver channel.
+    receiver: mpsc::UnboundedReceiver<Event>,
+    /// Event handler thread.
+    handler: tokio::task::JoinHandle<()>,
+}
+
+impl EventHandler {
+    /// Constructs a new instance of [`EventHandler`].
+    pub fn new(tick_rate: u64) -> Self {
+        let tick_rate = Duration::from_millis(tick_rate);
+        let (sender, receiver) = mpsc::unbounded_channel();
+        let _sender = sender.clone();
+        let handler = tokio::spawn(async move {
+            let mut reader = crossterm::event::EventStream::new();
+            let mut tick = tokio::time::interval(tick_rate);
+            loop {
+                let tick_delay = tick.tick();
+                let crossterm_event = reader.next().fuse();
+                tokio::select! {
+                  _ = _sender.closed() => {
+                    break;
+                  }
+                  _ = tick_delay => {
+                    _sender.send(Event::Tick).unwrap();
+                  }
+                  Some(Ok(evt)) = crossterm_event => {
+                    match evt {
+                      CrosstermEvent::Key(key) => {
+                        if key.kind == crossterm::event::KeyEventKind::Press {
+                          _sender.send(Event::Key(key)).unwrap();
+                        }
+                      },
+                      CrosstermEvent::Mouse(mouse) => {
+                        _sender.send(Event::Mouse(mouse)).unwrap();
+                      },
+                      CrosstermEvent::Resize(x, y) => {
+                        _sender.send(Event::Resize(x, y)).unwrap();
+                      },
+                      CrosstermEvent::FocusLost => {
+                      },
+                      CrosstermEvent::FocusGained => {
+                      },
+                      CrosstermEvent::Paste(_) => {
+                      },
+                    }
+                  }
+                };
+            }
+        });
+        Self {
+            sender,
+            receiver,
+            handler,
+        }
+    }
+
+    /// Receive the next event from the handler thread.
+    ///
+    /// This function will always block the current thread if
+    /// there is no data available and it's possible for more data to be sent.
+    pub async fn next(&mut self) -> Result<Event> {
+        self.receiver
+            .recv()
+            .await
+            .ok_or(anyhow::anyhow!(Box::new(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                "This is an IO error",
+            ))))
+    }
+}

src/event.rs

@@ -0,0 +1,58 @@
+use std::{
+    fs::{self, DirEntry},
+    path::PathBuf,
+};
+
+use anyhow::Result;
+
+#[derive(Debug)]
+pub struct File {
+    pub name: String,
+    pub formated_name: String,
+    pub is_dir: bool,
+}
+
+impl File {
+    pub fn new(name: String, is_dir: bool) -> Self {
+        let formated_name = if is_dir {
+            format!("🗀 {name}")
+        } else {
+            format!("🗎 {name}")
+        };
+
+        Self {
+            name,
+            formated_name,
+            is_dir,
+        }
+    }
+}
+
+pub fn list_dir(path: PathBuf, show_hidden: bool) -> Result<Vec<File>> {
+    let dir_entries: Vec<DirEntry> = fs::read_dir(path)?.filter_map(|entry| entry.ok()).collect();
+
+    let mut files: Vec<File> = Vec::new();
+    for entry in dir_entries {
+        let mut file_name = format!("{:?}", entry.file_name());
+
+        file_name = file_name
+            .strip_prefix("\"")
+            .unwrap_or(&file_name)
+            .to_string();
+
+        file_name = file_name
+            .strip_suffix("\"")
+            .unwrap_or(&file_name)
+            .to_string();
+
+        if file_name.starts_with(".") && !show_hidden {
+            continue;
+        }
+
+        files.push(File::new(file_name, entry.metadata()?.is_dir()));
+    }
+
+    files.sort_unstable_by_key(|file| (!file.is_dir, file.name.clone()));
+
+    Ok(files)
+}