feat: centralize permissions into a single struct

src/codec/filesystem/mod.rs

@@ -1,9 +1,7 @@
 mod block_kind;
-mod directory_permissions;
-mod file_permissions;
 mod node_kind;
+mod permissions;
 
 pub use block_kind::BlockKind;
-pub use directory_permissions::DirectoryPermissions;
-pub use file_permissions::FilePermissions;
 pub use node_kind::NodeKind;
+pub use permissions::Permissions;

src/codec/filesystem/file_permissions.rs → src/codec/filesystem/permissions.rs

@@ -3,24 +3,24 @@ use winnow::{binary::le_u8, Parser};
 
 use crate::codec::{ParserResult, Stream};
 
-const FILE_PERMISSIONS_RESERVED_MASK: u8 = 0b1111_1000;
+const PERMISSIONS_RESERVED_MASK: u8 = 0b1111_1000;
 
-const FILE_PERMISSIONS_EXECUTABLE: u8 = 0b0000_0100;
+const PERMISSIONS_EXECUTABLE: u8 = 0b0000_0100;
 
-const FILE_PERMISSIONS_IMMUTABLE: u8 = 0b0000_0010;
+const PERMISSIONS_IMMUTABLE: u8 = 0b0000_0010;
 
-const FILE_PERMISSIONS_OWNER_WRITE_ONLY: u8 = 0b0000_0001;
+const PERMISSIONS_OWNER_WRITE_ONLY: u8 = 0b0000_0001;
 
 // todo(sstelfox): We only need one type of permission, they can be shared to simplify the
 // protocol.
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
-pub struct FilePermissions {
+pub struct Permissions {
     executable: bool,
     immutable: bool,
     owner_write_only: bool,
 }
 
-impl FilePermissions {
+impl Permissions {
     pub fn owner_write_only(&self) -> bool {
         self.owner_write_only
     }
@@ -32,15 +32,15 @@ impl FilePermissions {
         let mut options: u8 = 0x00;
 
         if self.owner_write_only {
-            options |= FILE_PERMISSIONS_OWNER_WRITE_ONLY;
+            options |= PERMISSIONS_OWNER_WRITE_ONLY;
         }
 
         if self.executable {
-            options |= FILE_PERMISSIONS_EXECUTABLE;
+            options |= PERMISSIONS_EXECUTABLE;
         }
 
         if self.immutable {
-            options |= FILE_PERMISSIONS_IMMUTABLE;
+            options |= PERMISSIONS_IMMUTABLE;
         }
 
         writer.write_all(&[options]).await?;
@@ -59,17 +59,17 @@ impl FilePermissions {
     pub fn parse(input: Stream) -> ParserResult<Self> {
         let (input, byte) = le_u8.parse_peek(input)?;
 
-        if cfg!(feature = "strict") && byte & FILE_PERMISSIONS_RESERVED_MASK != 0 {
+        if cfg!(feature = "strict") && byte & PERMISSIONS_RESERVED_MASK != 0 {
             let err = winnow::error::ParserError::from_error_kind(
                 &input,
                 winnow::error::ErrorKind::Verify,
             );
             return Err(winnow::error::ErrMode::Cut(err));
         }
 
-        let owner_write_only = byte & FILE_PERMISSIONS_OWNER_WRITE_ONLY != 0;
-        let executable = byte & FILE_PERMISSIONS_EXECUTABLE != 0;
-        let immutable = byte & FILE_PERMISSIONS_IMMUTABLE != 0;
+        let owner_write_only = byte & PERMISSIONS_OWNER_WRITE_ONLY != 0;
+        let executable = byte & PERMISSIONS_EXECUTABLE != 0;
+        let immutable = byte & PERMISSIONS_IMMUTABLE != 0;
 
         let permissions = Self {
             owner_write_only,

src/filesystem/drive/directory_handle.rs

@@ -19,7 +19,7 @@ use crate::filesystem::nodes::{Node, NodeData, NodeId, NodeName};
 use crate::filesystem::{ContentLocation, ContentReference, FileContent, NodeBuilder};
 use crate::stores::DataStore;
 
-use self::filesystem::FilePermissions;
+use self::filesystem::Permissions;
 
 const MAX_PATH_DEPTH: usize = 32;
 
@@ -66,13 +66,8 @@ impl DirectoryHandle {
         Ok(directory)
     }
 
-    /// Changes the permission on the target node. Currently not implemented and changes are
-    /// expected to combine the [`FilePermissions`] with the [`crate::codec::filesystem::DirectoryPermissions`] all at once.
-    pub async fn chmod(
-        &self,
-        _path: &[&str],
-        _owner: FilePermissions,
-    ) -> Result<(), OperationError> {
+    /// Changes the permission on the target node. Currently not implemented.
+    pub async fn chmod(&self, _path: &[&str], _owner: Permissions) -> Result<(), OperationError> {
         unimplemented!()
     }
 

src/filesystem/nodes/node_data/mod.rs

@@ -5,7 +5,7 @@ use futures::{AsyncWrite, AsyncWriteExt};
 use winnow::binary::le_u16;
 use winnow::Parser;
 
-use crate::codec::filesystem::{DirectoryPermissions, FilePermissions};
+use crate::codec::filesystem::Permissions;
 use crate::codec::{Cid, ParserResult, PermanentId, Stream};
 use crate::filesystem::nodes::{NodeKind, NodeName};
 use crate::filesystem::FileContent;
@@ -17,14 +17,14 @@ use self::child_map::ChildMapEntry;
 
 pub enum NodeData {
     File {
-        permissions: FilePermissions,
+        permissions: Permissions,
         associated_data: ChildMap,
         content: FileContent,
     },
     #[allow(dead_code)]
     AssociatedData { content: FileContent },
     Directory {
-        permissions: DirectoryPermissions,
+        permissions: Permissions,
         children: ChildMap,
     },
 }
@@ -112,7 +112,7 @@ impl NodeData {
 
     pub(crate) fn new_directory() -> Self {
         Self::Directory {
-            permissions: DirectoryPermissions::default(),
+            permissions: Permissions::default(),
             children: HashMap::new(),
         }
     }
@@ -161,7 +161,7 @@ impl NodeData {
 
         match kind {
             NodeKind::File => {
-                let (data_buf, permissions) = FilePermissions::parse(input)?;
+                let (data_buf, permissions) = Permissions::parse(input)?;
                 let (data_buf, associated_data) = parse_children(data_buf)?;
                 let (data_buf, content) = FileContent::parse(data_buf)?;
 
@@ -175,7 +175,7 @@ impl NodeData {
             }
             //NodeKind::AssociatedData => {}
             NodeKind::Directory => {
-                let (data_buf, permissions) = DirectoryPermissions::parse(input)?;
+                let (data_buf, permissions) = Permissions::parse(input)?;
                 let (data_buf, children) = parse_children(data_buf)?;
 
                 let data = NodeData::Directory {
@@ -217,11 +217,11 @@ impl NodeData {
         match self {
             NodeData::AssociatedData { content } => content.size(),
             NodeData::Directory { .. } => {
-                let base_size = DirectoryPermissions::size() + 8;
+                let base_size = Permissions::size() + 8;
                 base_size as u64 + self.children_size()
             }
             NodeData::File { content, .. } => {
-                let base_size = FilePermissions::size();
+                let base_size = Permissions::size();
 
                 base_size as u64 + content.size() + self.children_size()
             }
@@ -240,23 +240,23 @@ impl NodeData {
 
     pub(crate) fn empty_file() -> Self {
         Self::File {
-            permissions: FilePermissions::default(),
+            permissions: Permissions::default(),
             associated_data: HashMap::new(),
             content: FileContent::EmptyFile,
         }
     }
 
     pub(crate) fn full_file(content: FileContent) -> Self {
         Self::File {
-            permissions: FilePermissions::default(),
+            permissions: Permissions::default(),
             associated_data: HashMap::new(),
             content,
         }
     }
 
     pub(crate) fn stub_file(data_size: u64) -> Self {
         Self::File {
-            permissions: FilePermissions::default(),
+            permissions: Permissions::default(),
             associated_data: HashMap::new(),
             content: FileContent::Stub { data_size },
         }