jannie

mod.rs (6190B)

---

 use std::{
     cell::{BorrowError, BorrowMutError, RefCell},
     collections::BTreeMap,
     path::{Path, PathBuf},
     rc::Rc,
 };
 
 use indexmap::IndexMap;
 use uuid::Uuid;
 
 use crate::filetree::node::Node;
 
 pub mod node;
 
 pub type NodeRef<M> = Rc<RefCell<Node<M>>>;
 
 pub struct Filetree<M> {
     nodes: IndexMap<Uuid, NodeRef<M>>,
     paths: BTreeMap<PathBuf, Uuid>,
     root: Uuid,
 }
 
 impl<M> Filetree<M> {
     pub fn new(root: Node<M>) -> Self {
         // todo: check root better
         assert!(root.is_leaf());
         let mut filetree = Filetree {
             nodes: IndexMap::new(),
             paths: BTreeMap::new(),
             root: root.id(),
         };
         filetree.insert_node(root, None).unwrap();
         filetree
     }
 
     pub fn root(&self) -> NodeRef<M> {
         Rc::clone(
             self.nodes
                 .get(&self.root)
                 .expect("Filetree should have root"),
         )
     }
 
     pub fn nodes(&self) -> impl Iterator<Item = NodeRef<M>> {
         self.nodes.values().map(Rc::clone)
     }
 
     pub fn node(&self, node_id: Uuid) -> Option<NodeRef<M>> {
         self.nodes.get(&node_id).map(Rc::clone)
     }
 
     pub fn node_by_path(&self, path: &Path) -> Option<NodeRef<M>> {
         self.paths
             .get(path)
             .map(|node_id| self.nodes.get(node_id).expect("Filetree should have node"))
             .map(Rc::clone)
     }
 
     /// Checks if a node with this path exists
     pub fn check_path(&self, path: &Path) -> bool {
         self.paths.get(path).is_some()
     }
 }
 
 impl<M> Filetree<M> {
     pub fn insert(&mut self, node: Node<M>) -> Result<(), Error> {
         let mut path = node.path().to_owned();
         tracing::debug!("Trying to add node with path {path:?}");
         if path.ends_with("..") {
             return Err(Error::ParentDir);
         }
         if path.ends_with(".") {
             return Err(Error::CurrentDir);
         }
         if self.paths.get(&path).is_some() {
             return Err(Error::NodeExists);
         }
         path.pop();
         tracing::trace!("Searching for node with path {path:?}");
         if let Some(parent) = self.paths.get(&path).copied() {
             self.insert_node(node, Some(parent))?;
             Ok(())
         } else {
             Err(Error::MissingPath)
         }
     }
 
     fn insert_node(&mut self, mut node: Node<M>, parent: Option<Uuid>) -> Result<(), Error> {
         let node_id = node.id();
         if let Some(parent) = parent {
             self.nodes
                 .get(&parent)
                 .expect("Should have parent node")
                 .try_borrow_mut()?
                 .add_child(node_id);
             node.set_parent(parent);
         } else {
             node.unset_parent();
         }
         self.paths.insert(node.path().to_owned(), node_id);
         self.nodes.insert(node_id, Rc::new(RefCell::new(node)));
         Ok(())
     }
 }
 
 impl<M> Filetree<M> {
     pub fn print(&self) -> Result<(), Error> {
         let mut print_buffer = Vec::new();
         print_buffer.push((0, self.root));
         while let Some((offset, node_id)) = print_buffer.pop() {
             let node = self
                 .nodes
                 .get(&node_id)
                 .expect("Shold have the node")
                 .try_borrow()?;
             println!(
                 "{}| {}",
                 "  ".repeat(offset),
                 node.path()
                     .file_name()
                     .map(|name| name.to_str())
                     .flatten()
                     .unwrap_or("UNKNOWN")
             );
             print_buffer.extend(node.children().map(|child_id| (offset + 1, child_id)));
         }
         Ok(())
     }
 }
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
     #[error("Error borrowing mutably: {0}")]
     BorrowMutError(#[from] BorrowMutError),
     #[error("Error borrowing: {0}")]
     BorrowError(#[from] BorrowError),
     #[error("Node already exists in the tree")]
     NodeExists,
     #[error("Node extends the path too much, directory does not exist")]
     MissingPath,
     #[error("Use of current dir is disallowed")]
     CurrentDir,
     #[error("Use of parent dir is disallowed")]
     ParentDir,
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test_log::test(test)]
     fn cannot_insert_root() {
         let root = Node::new("/".into(), ());
         let mut tree = Filetree::new(root);
         assert!(dbg!(tree.insert(Node::new("/".into(), ()))).is_err());
     }
 
     #[test_log::test(test)]
     fn cannot_insert_relative() {
         let root = Node::new("/".into(), ());
         let mut tree = Filetree::new(root);
         assert!(dbg!(tree.insert(Node::new("dir".into(), ()))).is_err());
     }
 
     #[test_log::test(test)]
     fn cannot_insert_dots() {
         let root = Node::new("/".into(), ());
         let mut tree = Filetree::new(root);
         assert!(dbg!(tree.insert(Node::new("/.".into(), ()))).is_err());
         assert!(dbg!(tree.insert(Node::new("/..".into(), ()))).is_err());
     }
 
     #[test_log::test(test)]
     fn insert_one() {
         let root = Node::new("/".into(), ());
         let mut tree = Filetree::new(root);
         assert!(dbg!(tree.insert(Node::new("/dir".into(), ()))).is_ok());
     }
 
     #[test_log::test(test)]
     fn insert_exists() {
         let root = Node::new("/".into(), ());
         let mut tree = Filetree::new(root);
         assert!(dbg!(tree.insert(Node::new("/dir".into(), ()))).is_ok());
         assert!(dbg!(tree.insert(Node::new("/dir".into(), ()))).is_err());
     }
 
     #[test_log::test(test)]
     fn insert_many() {
         let root = Node::new("/".into(), ());
         let mut tree = Filetree::new(root);
         assert!(dbg!(tree.insert(Node::new("/dir".into(), ()))).is_ok());
         assert!(dbg!(tree.insert(Node::new("/dir/dir/dir".into(), ()))).is_err());
         assert!(dbg!(tree.insert(Node::new("/dir/dir".into(), ()))).is_ok());
         assert!(dbg!(tree.insert(Node::new("/dir/dir".into(), ()))).is_err());
         assert!(dbg!(tree.insert(Node::new("/dir/dir/dir".into(), ()))).is_ok());
         assert!(dbg!(tree.insert(Node::new("/dir2".into(), ()))).is_ok());
         assert!(dbg!(tree.insert(Node::new("/dir3".into(), ()))).is_ok());
     }
 }