From 8f410d1ead74b979481f1488a4dcddd33ea829c7 Mon Sep 17 00:00:00 2001 From: Ben Bridle Date: Thu, 25 Aug 2022 21:27:39 +1200 Subject: [PATCH] Initial commit --- .gitignore | 2 + Cargo.toml | 9 +++++ src/entry.rs | 86 +++++++++++++++++++++++++++++++++++++++++ src/error.rs | 48 +++++++++++++++++++++++ src/lib.rs | 10 +++++ src/operations.rs | 30 ++++++++++++++ src/operations/cp.rs | 62 +++++++++++++++++++++++++++++ src/operations/ls.rs | 51 ++++++++++++++++++++++++ src/operations/mkdir.rs | 20 ++++++++++ src/operations/rm.rs | 23 +++++++++++ 10 files changed, 341 insertions(+) create mode 100644 .gitignore create mode 100644 Cargo.toml create mode 100644 src/entry.rs create mode 100644 src/error.rs create mode 100644 src/lib.rs create mode 100644 src/operations.rs create mode 100644 src/operations/cp.rs create mode 100644 src/operations/ls.rs create mode 100644 src/operations/mkdir.rs create mode 100644 src/operations/rm.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..96ef6c0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +/target +Cargo.lock diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..0ff8d56 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "vagabond" +version = "1.0.0" +authors = ["Ben Bridle "] +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] diff --git a/src/entry.rs b/src/entry.rs new file mode 100644 index 0000000..2679e42 --- /dev/null +++ b/src/entry.rs @@ -0,0 +1,86 @@ +use crate::EntryReadError; +use std::path::{Path, PathBuf}; + +#[derive(PartialEq)] +pub enum EntryType { + File, + Directory, +} + +pub struct Entry { + pub entry_type: EntryType, + pub is_symlink: bool, + pub name: String, + pub extension: String, + pub path: PathBuf, + pub original_path: PathBuf, +} +impl Entry { + pub fn from_path>(path: P) -> Result { + let path = path.as_ref(); + let metadata = path.metadata()?; + let canonical_path = std::fs::canonicalize(path)?; + let canonical_metadata = canonical_path.metadata()?; + let entry_type = if canonical_metadata.is_file() { + EntryType::File + } else if canonical_metadata.is_dir() { + EntryType::Directory + } else { + return Err(EntryReadError::NotFound); + }; + + let name = match path.file_name() { + Some(osstr) => osstr.to_string_lossy().to_string(), + None => unreachable!(), + }; + let extension = match path.extension() { + Some(extension) => extension.to_string_lossy().into(), + None => String::default(), + }; + Ok(Entry { + entry_type, + name, + extension, + path: canonical_path, + original_path: path.to_path_buf(), + is_symlink: metadata.is_symlink(), + }) + } + + /// Splits the filename on the last period, ignoring any period at the + /// start of the filename. If no extension is found, the extension is empty. + pub fn split_name(&self) -> (String, String) { + match self.name.rsplit_once(".") { + Some(("", _)) | None => (self.name.to_string(), String::new()), + Some((prefix, extension)) => (prefix.to_string(), extension.to_string()), + } + } + + pub fn is_file(&self) -> bool { + match self.entry_type { + EntryType::File => true, + _ => false, + } + } + + pub fn is_directory(&self) -> bool { + match self.entry_type { + EntryType::Directory => true, + _ => false, + } + } + + pub fn read_as_bytes(&self) -> Result, EntryReadError> { + return Ok(std::fs::read(&self.path)?); + } + + pub fn read_as_utf8_string(&self) -> Result { + return Ok(String::from_utf8_lossy(&self.read_as_bytes()?).to_string()); + } +} + +impl AsRef for Entry { + fn as_ref(&self) -> &Path { + &self.path + } +} diff --git a/src/error.rs b/src/error.rs new file mode 100644 index 0000000..0e8d99f --- /dev/null +++ b/src/error.rs @@ -0,0 +1,48 @@ +use std::io::Error as IoError; +use std::io::ErrorKind; + +#[derive(Debug)] +pub enum EntryReadError { + NotFound, + PermissionDenied, +} +impl From for EntryReadError { + fn from(io_error: IoError) -> Self { + match io_error.kind() { + ErrorKind::NotFound => Self::NotFound, + // An intermediate path component was a plain file, not a directory + ErrorKind::NotADirectory => Self::NotFound, + // A cyclic symbolic link chain was included in the provided path + ErrorKind::FilesystemLoop => Self::NotFound, + ErrorKind::PermissionDenied => Self::PermissionDenied, + err => panic!("Unexpected IoError encountered: {:?}", err), + } + } +} + +#[derive(Debug)] +pub enum EntryWriteError { + NotFound, + PermissionDenied, +} +impl From for EntryWriteError { + fn from(error: EntryReadError) -> Self { + match error { + EntryReadError::NotFound => EntryWriteError::NotFound, + EntryReadError::PermissionDenied => EntryWriteError::PermissionDenied, + } + } +} +impl From for EntryWriteError { + fn from(io_error: IoError) -> Self { + match io_error.kind() { + ErrorKind::NotFound => Self::NotFound, + // An intermediate path component was a plain file, not a directory + ErrorKind::NotADirectory => Self::NotFound, + // A cyclic symbolic link chain was included in the provided path + ErrorKind::FilesystemLoop => Self::NotFound, + ErrorKind::PermissionDenied => Self::PermissionDenied, + err => panic!("Unexpected IoError encountered: {:?}", err), + } + } +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..deea25c --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,10 @@ +#![feature(io_error_more)] + +mod error; +pub use error::*; + +mod operations; +pub use operations::*; + +mod entry; +pub use entry::{Entry, EntryType}; diff --git a/src/operations.rs b/src/operations.rs new file mode 100644 index 0000000..54ce8c7 --- /dev/null +++ b/src/operations.rs @@ -0,0 +1,30 @@ +use crate::*; +use std::path::Path; + +mod ls; +pub use ls::*; + +mod cp; +pub use cp::*; + +mod rm; +pub use rm::*; + +mod mkdir; +pub use mkdir::*; + +pub fn append_to_file

(_path: P, _content: &str) -> Result<(), EntryWriteError> +where + P: AsRef, +{ + unimplemented!() +} + +pub fn write_to_file

(path: P, content: &str) -> Result<(), EntryWriteError> +where + P: AsRef, +{ + make_parent_directory(&path)?; + std::fs::write(&path, content)?; + Ok(()) +} diff --git a/src/operations/cp.rs b/src/operations/cp.rs new file mode 100644 index 0000000..be43826 --- /dev/null +++ b/src/operations/cp.rs @@ -0,0 +1,62 @@ +use crate::make_parent_directory; +use crate::{get_entry, get_optional_entry, list_directory}; +use crate::{EntryType, EntryWriteError}; +use std::path::Path; + +pub fn copy(source_path: P, target_path: Q) -> Result<(), EntryWriteError> +where + P: AsRef, + Q: AsRef, +{ + let source = get_entry(&source_path)?; + let target = get_optional_entry(&target_path)?; + let target_type = target.and_then(|e| Some(e.entry_type)); + + match (source.entry_type, target_type) { + (EntryType::File, Some(EntryType::File)) => { + copy_file(source_path, target_path)?; + } + (EntryType::File, Some(EntryType::Directory)) => { + let target_path = target_path.as_ref().join(source.name); + copy_file(source_path, target_path)?; + } + (EntryType::File, None) => { + make_parent_directory(&target_path)?; + copy_file(source_path, target_path)?; + } + (EntryType::Directory, Some(EntryType::File)) => { + std::fs::remove_file(&target_path)?; + copy_directory(&source_path, &target_path)?; + } + (EntryType::Directory, Some(EntryType::Directory)) => { + let target_path = target_path.as_ref().join(source.name); + copy_directory(source_path, target_path)?; + } + (EntryType::Directory, None) => { + make_parent_directory(&target_path)?; + copy_directory(source_path, target_path)?; + } + } + Ok(()) +} + +fn copy_file(source_path: P, target_path: Q) -> Result<(), EntryWriteError> +where + P: AsRef, + Q: AsRef, +{ + std::fs::copy(source_path, target_path)?; + Ok(()) +} + +fn copy_directory(source_path: P, target_path: Q) -> Result<(), EntryWriteError> +where + P: AsRef, + Q: AsRef, +{ + for entry in list_directory(&source_path)? { + let target_path = target_path.as_ref().join(entry.name); + copy(entry.path, &target_path)?; + } + Ok(()) +} diff --git a/src/operations/ls.rs b/src/operations/ls.rs new file mode 100644 index 0000000..2d2da5d --- /dev/null +++ b/src/operations/ls.rs @@ -0,0 +1,51 @@ +use crate::{Entry, EntryReadError, EntryType}; +use std::path::Path; + +pub fn get_entry

(path: P) -> Result +where + P: AsRef, +{ + Entry::from_path(path) +} + +pub fn get_optional_entry

(path: P) -> Result, EntryReadError> +where + P: AsRef, +{ + match get_entry(path) { + Ok(e) => Ok(Some(e)), + Err(EntryReadError::NotFound) => Ok(None), + Err(other) => Err(other), + } +} + +pub fn list_directory

(path: P) -> Result, EntryReadError> +where + P: AsRef, +{ + let mut entries = Vec::new(); + for dir_entry in std::fs::read_dir(path)? { + let entry = match Entry::from_path(&dir_entry?.path()) { + Ok(v) => v, + Err(_) => continue, + }; + entries.push(entry); + } + return Ok(entries); +} + +/// Recursively descend into a directory and all sub-directories, +/// returning an [`Entry`](struct.Entry.html) for each discovered file. +pub fn traverse_directory

(path: P) -> Result, EntryReadError> +where + P: AsRef, +{ + let mut file_entries = Vec::new(); + for entry in list_directory(path)? { + match entry.entry_type { + EntryType::File => file_entries.push(entry), + EntryType::Directory => file_entries.extend(traverse_directory(&entry.path)?), + } + } + return Ok(file_entries); +} diff --git a/src/operations/mkdir.rs b/src/operations/mkdir.rs new file mode 100644 index 0000000..011b8cf --- /dev/null +++ b/src/operations/mkdir.rs @@ -0,0 +1,20 @@ +use crate::EntryWriteError; +use std::path::Path; + +pub fn make_directory

(path: P) -> Result<(), EntryWriteError> +where + P: AsRef, +{ + std::fs::DirBuilder::new().recursive(true).create(path)?; + Ok(()) +} + +pub fn make_parent_directory

(path: P) -> Result<(), EntryWriteError> +where + P: AsRef, +{ + match path.as_ref().parent() { + Some(parent) => make_directory(parent), + None => Ok(()), + } +} diff --git a/src/operations/rm.rs b/src/operations/rm.rs new file mode 100644 index 0000000..846a094 --- /dev/null +++ b/src/operations/rm.rs @@ -0,0 +1,23 @@ +use crate::EntryWriteError; +use crate::{get_entry, EntryType}; +use std::path::Path; + +pub fn remove

(path: P) -> Result<(), EntryWriteError> +where + P: AsRef, +{ + let entry = get_entry(&path)?; + match entry.entry_type { + EntryType::File => std::fs::remove_file(&path)?, + EntryType::Directory => std::fs::remove_dir_all(&path)?, + } + Ok(()) +} + +pub fn remove_file

(path: P) -> Result<(), EntryWriteError> +where + P: AsRef, +{ + std::fs::remove_file(path)?; + Ok(()) +}