storkit: merge 416_refactor_split_io_fs_rs_into_submodules

2026-03-27 16:05:42 +00:00
parent 8bc0bd592e
commit 26f5b25f22
6 changed files with 903 additions and 830 deletions
@@ -0,0 +1,263 @@
+use crate::state::SessionState;
+use serde::Serialize;
+use std::fs;
+use std::path::PathBuf;
+
+use super::paths::{resolve_path, resolve_path_impl};
+
+async fn read_file_impl(full_path: PathBuf) -> Result<String, String> {
+    tokio::task::spawn_blocking(move || {
+        fs::read_to_string(&full_path).map_err(|e| format!("Failed to read file: {}", e))
+    })
+    .await
+    .map_err(|e| format!("Task failed: {}", e))?
+}
+
+pub async fn read_file(path: String, state: &SessionState) -> Result<String, String> {
+    let full_path = resolve_path(state, &path)?;
+    read_file_impl(full_path).await
+}
+
+async fn write_file_impl(full_path: PathBuf, content: String) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        if let Some(parent) = full_path.parent() {
+            fs::create_dir_all(parent)
+                .map_err(|e| format!("Failed to create directories: {}", e))?;
+        }
+
+        fs::write(&full_path, content).map_err(|e| format!("Failed to write file: {}", e))
+    })
+    .await
+    .map_err(|e| format!("Task failed: {}", e))?
+}
+
+pub async fn write_file(path: String, content: String, state: &SessionState) -> Result<(), String> {
+    let root = state.get_project_root()?;
+    let full_path = resolve_path_impl(root, &path)?;
+    write_file_impl(full_path, content).await
+}
+
+#[derive(Serialize, Debug, poem_openapi::Object)]
+pub struct FileEntry {
+    pub name: String,
+    pub kind: String,
+}
+
+async fn list_directory_impl(full_path: PathBuf) -> Result<Vec<FileEntry>, String> {
+    tokio::task::spawn_blocking(move || {
+        let entries = fs::read_dir(&full_path).map_err(|e| format!("Failed to read dir: {}", e))?;
+
+        let mut result = Vec::new();
+        for entry in entries {
+            let entry = entry.map_err(|e| e.to_string())?;
+            let ft = entry.file_type().map_err(|e| e.to_string())?;
+            let name = entry.file_name().to_string_lossy().to_string();
+
+            result.push(FileEntry {
+                name,
+                kind: if ft.is_dir() {
+                    "dir".to_string()
+                } else {
+                    "file".to_string()
+                },
+            });
+        }
+
+        result.sort_by(|a, b| match (a.kind.as_str(), b.kind.as_str()) {
+            ("dir", "file") => std::cmp::Ordering::Less,
+            ("file", "dir") => std::cmp::Ordering::Greater,
+            _ => a.name.cmp(&b.name),
+        });
+
+        Ok(result)
+    })
+    .await
+    .map_err(|e| format!("Task failed: {}", e))?
+}
+
+pub async fn list_directory(path: String, state: &SessionState) -> Result<Vec<FileEntry>, String> {
+    let full_path = resolve_path(state, &path)?;
+    list_directory_impl(full_path).await
+}
+
+pub async fn list_directory_absolute(path: String) -> Result<Vec<FileEntry>, String> {
+    let full_path = PathBuf::from(path);
+    list_directory_impl(full_path).await
+}
+
+pub async fn create_directory_absolute(path: String) -> Result<bool, String> {
+    let full_path = PathBuf::from(path);
+    tokio::task::spawn_blocking(move || {
+        fs::create_dir_all(&full_path).map_err(|e| format!("Failed to create directory: {}", e))?;
+        Ok(true)
+    })
+    .await
+    .map_err(|e| format!("Task failed: {}", e))?
+}
+
+/// List all files in the project recursively, respecting .gitignore.
+/// Returns relative paths from the project root (files only, not directories).
+pub async fn list_project_files(state: &SessionState) -> Result<Vec<String>, String> {
+    let root = state.get_project_root()?;
+    list_project_files_impl(root).await
+}
+
+pub async fn list_project_files_impl(root: PathBuf) -> Result<Vec<String>, String> {
+    use ignore::WalkBuilder;
+
+    let root_clone = root.clone();
+    let files = tokio::task::spawn_blocking(move || {
+        let mut result = Vec::new();
+        let walker = WalkBuilder::new(&root_clone).git_ignore(true).build();
+
+        for entry in walker.flatten() {
+            if entry.file_type().map(|ft| ft.is_file()).unwrap_or(false) {
+                let relative = entry
+                    .path()
+                    .strip_prefix(&root_clone)
+                    .unwrap_or(entry.path())
+                    .to_string_lossy()
+                    .to_string();
+                result.push(relative);
+            }
+        }
+
+        result.sort();
+        result
+    })
+    .await
+    .map_err(|e| format!("Task failed: {e}"))?;
+
+    Ok(files)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::state::SessionState;
+    use std::path::PathBuf;
+    use tempfile::tempdir;
+
+    fn make_state_with_root(path: PathBuf) -> SessionState {
+        let state = SessionState::default();
+        {
+            let mut root = state.project_root.lock().unwrap();
+            *root = Some(path);
+        }
+        state
+    }
+
+    // --- file operations ---
+
+    #[tokio::test]
+    async fn read_file_impl_reads_content() {
+        let dir = tempdir().unwrap();
+        let file = dir.path().join("test.txt");
+        fs::write(&file, "hello world").unwrap();
+
+        let content = read_file_impl(file).await.unwrap();
+        assert_eq!(content, "hello world");
+    }
+
+    #[tokio::test]
+    async fn read_file_impl_errors_on_missing() {
+        let dir = tempdir().unwrap();
+        let result = read_file_impl(dir.path().join("missing.txt")).await;
+        assert!(result.is_err());
+    }
+
+    #[tokio::test]
+    async fn write_file_impl_creates_and_writes() {
+        let dir = tempdir().unwrap();
+        let file = dir.path().join("sub").join("output.txt");
+
+        write_file_impl(file.clone(), "content".to_string())
+            .await
+            .unwrap();
+
+        assert_eq!(fs::read_to_string(&file).unwrap(), "content");
+    }
+
+    // --- list directory ---
+
+    #[tokio::test]
+    async fn list_directory_impl_returns_sorted_entries() {
+        let dir = tempdir().unwrap();
+        fs::create_dir(dir.path().join("zdir")).unwrap();
+        fs::create_dir(dir.path().join("adir")).unwrap();
+        fs::write(dir.path().join("file.txt"), "").unwrap();
+
+        let entries = list_directory_impl(dir.path().to_path_buf()).await.unwrap();
+
+        assert_eq!(entries[0].name, "adir");
+        assert_eq!(entries[0].kind, "dir");
+        assert_eq!(entries[1].name, "zdir");
+        assert_eq!(entries[1].kind, "dir");
+        assert_eq!(entries[2].name, "file.txt");
+        assert_eq!(entries[2].kind, "file");
+    }
+
+    // --- list_project_files_impl ---
+
+    #[tokio::test]
+    async fn list_project_files_returns_all_files() {
+        let dir = tempdir().unwrap();
+        fs::create_dir(dir.path().join("src")).unwrap();
+        fs::write(dir.path().join("src/main.rs"), "fn main() {}").unwrap();
+        fs::write(dir.path().join("README.md"), "# readme").unwrap();
+
+        let files = list_project_files_impl(dir.path().to_path_buf())
+            .await
+            .unwrap();
+
+        assert!(files.contains(&"README.md".to_string()));
+        assert!(files.contains(&"src/main.rs".to_string()));
+    }
+
+    #[tokio::test]
+    async fn list_project_files_excludes_dirs_from_output() {
+        let dir = tempdir().unwrap();
+        fs::create_dir(dir.path().join("subdir")).unwrap();
+        fs::write(dir.path().join("file.txt"), "").unwrap();
+
+        let files = list_project_files_impl(dir.path().to_path_buf())
+            .await
+            .unwrap();
+
+        assert!(files.contains(&"file.txt".to_string()));
+        assert!(!files.iter().any(|f| f == "subdir"));
+    }
+
+    #[tokio::test]
+    async fn list_project_files_returns_sorted() {
+        let dir = tempdir().unwrap();
+        fs::write(dir.path().join("z.txt"), "").unwrap();
+        fs::write(dir.path().join("a.txt"), "").unwrap();
+
+        let files = list_project_files_impl(dir.path().to_path_buf())
+            .await
+            .unwrap();
+
+        let a_idx = files.iter().position(|f| f == "a.txt").unwrap();
+        let z_idx = files.iter().position(|f| f == "z.txt").unwrap();
+        assert!(a_idx < z_idx);
+    }
+
+    #[tokio::test]
+    async fn list_project_files_with_state() {
+        let dir = tempdir().unwrap();
+        fs::write(dir.path().join("hello.rs"), "").unwrap();
+        let state = make_state_with_root(dir.path().to_path_buf());
+
+        let files = list_project_files(&state).await.unwrap();
+
+        assert!(files.contains(&"hello.rs".to_string()));
+    }
+
+    #[tokio::test]
+    async fn list_project_files_errors_without_project() {
+        let state = SessionState::default();
+        let result = list_project_files(&state).await;
+        assert!(result.is_err());
+    }
+}