ailloli_ui_fs/
operations.rs

1//! Serializable descriptions of filesystem work and its coarse operation kind.
2
3use crate::FileUri;
4
5/// Coarse operation category used for progress, policy, and diagnostics.
6///
7/// # Examples
8///
9/// ```
10/// use ailloli_ui_fs::FileOperationKind;
11/// assert_ne!(FileOperationKind::Copy, FileOperationKind::Move);
12/// ```
13#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
14pub enum FileOperationKind {
15    /// List a directory.
16    ReadDir,
17    /// Read complete file bytes.
18    ReadFile,
19    /// Write complete file bytes.
20    WriteFile,
21    /// Retrieve entry metadata.
22    Metadata,
23    /// Create a directory.
24    CreateDir,
25    /// Rename an entry, normally within one provider/filesystem.
26    Rename,
27    /// Copy an entry while retaining the source.
28    Copy,
29    /// Move an entry so the source no longer exists.
30    Move,
31    /// Remove one non-directory or empty directory entry.
32    Remove,
33    /// Remove an entry and all descendants.
34    RemoveRecursive,
35}
36
37/// Serializable description of one filesystem operation.
38///
39/// This value carries intent only and does not execute I/O. URI relationships,
40/// byte counts, and provider capabilities are not validated by construction.
41///
42/// # Examples
43///
44/// ```
45/// use ailloli_ui_fs::{FileOperation, FileOperationKind, FileUri};
46/// let operation = FileOperation::ReadFile { uri: FileUri::parse("file:///tmp/a.txt")? };
47/// assert_eq!(operation.kind(), FileOperationKind::ReadFile);
48/// # Ok::<(), ailloli_ui_fs::FileError>(())
49/// ```
50#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
51pub enum FileOperation {
52    /// Directory listing request.
53    ReadDir {
54        /// Directory to list.
55        uri: FileUri,
56    },
57    /// Complete file read request.
58    ReadFile {
59        /// File to read.
60        uri: FileUri,
61    },
62    /// Complete file write request.
63    WriteFile {
64        /// Destination file.
65        uri: FileUri,
66        /// Declared input length in bytes; not validated against an external buffer.
67        bytes_len: u64,
68    },
69    /// Metadata lookup request.
70    Metadata {
71        /// Entry to inspect.
72        uri: FileUri,
73    },
74    /// Directory creation request.
75    CreateDir {
76        /// Directory URI to create.
77        uri: FileUri,
78    },
79    /// Same-provider rename request.
80    Rename {
81        /// Current URI.
82        from: FileUri,
83        /// Desired URI.
84        to: FileUri,
85    },
86    /// Copy request that retains the source.
87    Copy {
88        /// Source entry.
89        from: FileUri,
90        /// Destination entry.
91        to: FileUri,
92    },
93    /// Move request that removes the source.
94    Move {
95        /// Source entry.
96        from: FileUri,
97        /// Destination entry.
98        to: FileUri,
99    },
100    /// Non-recursive removal request.
101    Remove {
102        /// Entry to remove.
103        uri: FileUri,
104    },
105    /// Recursive subtree removal request.
106    RemoveRecursive {
107        /// Subtree root to remove.
108        uri: FileUri,
109    },
110}
111
112impl FileOperation {
113    /// Returns the payload-free category corresponding to this operation.
114    ///
115    /// # Examples
116    ///
117    /// ```
118    /// use ailloli_ui_fs::{FileOperation, FileOperationKind, FileUri};
119    /// let operation = FileOperation::WriteFile { uri: FileUri::parse("file:///tmp/a")?, bytes_len: 12 };
120    /// assert_eq!(operation.kind(), FileOperationKind::WriteFile);
121    /// # Ok::<(), ailloli_ui_fs::FileError>(())
122    /// ```
123    pub fn kind(&self) -> FileOperationKind {
124        match self {
125            Self::ReadDir { .. } => FileOperationKind::ReadDir,
126            Self::ReadFile { .. } => FileOperationKind::ReadFile,
127            Self::WriteFile { .. } => FileOperationKind::WriteFile,
128            Self::Metadata { .. } => FileOperationKind::Metadata,
129            Self::CreateDir { .. } => FileOperationKind::CreateDir,
130            Self::Rename { .. } => FileOperationKind::Rename,
131            Self::Copy { .. } => FileOperationKind::Copy,
132            Self::Move { .. } => FileOperationKind::Move,
133            Self::Remove { .. } => FileOperationKind::Remove,
134            Self::RemoveRecursive { .. } => FileOperationKind::RemoveRecursive,
135        }
136    }
137}
138
139#[cfg(test)]
140mod tests {
141    //! Covers the category mapping for transfer and recursive operations.
142
143    use super::*;
144
145    #[test]
146    fn file_transfer_operations_report_new_kinds() {
147        let from = FileUri::parse("file:///tmp/from").expect("from");
148        let to = FileUri::parse("file:///tmp/to").expect("to");
149
150        assert_eq!(
151            FileOperation::Copy {
152                from: from.clone(),
153                to: to.clone(),
154            }
155            .kind(),
156            FileOperationKind::Copy
157        );
158        assert_eq!(
159            FileOperation::Move {
160                from: from.clone(),
161                to,
162            }
163            .kind(),
164            FileOperationKind::Move
165        );
166        assert_eq!(
167            FileOperation::RemoveRecursive { uri: from }.kind(),
168            FileOperationKind::RemoveRecursive
169        );
170    }
171}