dev_tool/

file_util.rs

//! 文件工具
use chrono::{DateTime, Local};
use std::fs::{self, File};
use std::io::{self, Read, Write};
use std::path::Path;

/// 文件常规操作，如读写、目录创建、删除等
pub struct FileUtil;

impl FileUtil {
    /// 罗列指定路径下的子目录及文件。
    ///
    /// 参数 `path` 是要罗列内容的目标路径。
    /// 参数 `recurse` 决定是否以递归方式罗列子文件夹内的内容。
    ///
    /// 返回值是一个包含所有子目录及文件路径的 `Vec<String>`。
    /// 如果在读取目录时发生错误，将返回一个空的 `Vec`。
    pub fn list(path: &Path, recurse: bool) -> Vec<String> {
        let mut result = Vec::new();
        let entries = match fs::read_dir(path) {
            Ok(entries) => entries,
            Err(_) => return result,
        };

        for entry in entries {
            let entry = match entry {
                Ok(entry) => entry,
                Err(_) => continue,
            };
            let path = entry.path();
            if path.is_dir() {
                if recurse {
                    result.extend(Self::list(&path, true));
                }
                result.push(path.to_string_lossy().to_string());
            } else {
                result.push(path.to_string_lossy().to_string());
            }
        }
        result
    }

    /// 获取指定文件的元数据信息
    ///
    /// 该函数封装了标准库中的 fs::metadata 方法，用于获取文件的基本信息，
    /// 包括文件大小、创建时间、修改时间、文件类型等元数据。
    ///
    /// # 参数
    /// * `file_path` - 要获取元数据的文件路径字符串引用
    ///
    /// # 返回值
    /// 返回一个 io::Result<std::fs::Metadata> 类型：
    /// * 成功时返回包含文件元数据的 Metadata 对象
    /// * 失败时返回对应的 IO 错误信息
    ///
    /// # 错误处理
    /// 当文件不存在或没有访问权限时，会返回相应的 IO 错误
    pub fn metadata(file_path: &str) -> io::Result<std::fs::Metadata> {
        fs::metadata(file_path)
    }

    /// 获取指定文件的最后修改时间
    ///
    /// # 参数
    /// * `file_path` - 要查询的文件路径字符串引用
    ///
    /// # 返回值
    /// 返回 Result<String, io::Error> 类型：
    /// * 成功时返回格式化的时间字符串，格式为 "YYYY-MM-DD HH:MM:SS"
    /// * 失败时返回对应的 IO 错误
    ///
    /// # 错误处理
    /// 当文件不存在或无法访问时，会返回相应的 IO 错误
    pub fn last_midified(file_path: &str) -> io::Result<String> {
        // 获取文件元数据
        let metadata = fs::metadata(file_path)?;
        // 提取文件最后修改时间
        let last_modified = metadata.modified().unwrap();
        // 将系统时间转换为本地时间格式
        let last_modified: DateTime<Local> = last_modified.into();
        // 格式化时间为指定字符串格式并返回
        Ok(last_modified.format("%Y-%m-%d %H:%M:%S").to_string())
    }

    /// 读取本地文件内容并以UTF - 8字符串形式返回。
    ///
    /// 参数 `path` 是要读取的文件路径。
    ///
    /// 如果文件成功打开并读取，将返回包含文件内容的 `String`。
    /// 如果在打开或读取文件时发生I/O错误，将返回对应的 `io::Error`。
    pub fn read_string(path: &Path) -> Result<String, io::Error> {
        let mut file = File::open(path)?;
        let mut contents = String::new();
        file.read_to_string(&mut contents)?;
        Ok(contents)
    }

    /// 读取本地文件内容并以字节数组形式返回。
    ///
    /// 参数 `path` 是要读取的文件路径。
    ///
    /// 如果文件成功打开并读取，将返回包含文件内容的 `Vec<u8>`。
    /// 如果在打开或读取文件时发生I/O错误，将返回对应的 `io::Error`。
    pub fn read_bytes(path: &Path) -> Result<Vec<u8>, io::Error> {
        let mut file = File::open(path)?;
        let mut contents = Vec::new();
        file.read_to_end(&mut contents)?;
        Ok(contents)
    }

    /// 将给定的字符串内容以覆盖方式写入到指定路径的文本文件。
    ///
    /// 参数 `path` 是要写入的文件路径。
    /// 参数 `content` 是要写入文件的字符串内容。
    ///
    /// 如果文件成功创建并写入内容，将返回 `Ok(())`。
    /// 如果在创建或写入文件时发生I/O错误，将返回对应的 `io::Error`。
    pub fn write_string(path: &Path, content: String) -> io::Result<()> {
        let mut file = File::create(path)?;
        file.write_all(content.as_bytes())?;
        Ok(())
    }

    /// 将给定的字符串内容以追加方式写入到指定路径的文件。
    ///
    /// 参数 `path` 是要写入的文件路径。
    /// 参数 `content` 是要追加到文件的字符串内容。
    ///
    /// 如果文件成功打开并追加内容，将返回 `Ok(())`。
    /// 如果在打开或写入文件时发生I/O错误，将返回对应的 `io::Error`。
    pub fn append_string(path: &Path, content: String) -> io::Result<()> {
        let mut file = File::options().append(true).open(path)?;
        file.write_all(content.as_bytes())?;
        Ok(())
    }

    /// 将给定的字节数组内容写入到指定路径的文件。
    ///
    /// 参数 `path` 是要写入的文件路径。
    /// 参数 `bytes` 是要写入文件的字节数组内容。
    ///
    /// 如果文件成功创建并写入内容，将返回 `Ok(())`。
    /// 如果在创建或写入文件时发生I/O错误，将返回对应的 `io::Error`。
    pub fn write_bytes(path: &Path, bytes: &[u8]) -> io::Result<()> {
        let mut file = File::create(path)?;
        file.write_all(bytes)?;
        Ok(())
    }

    /// 创建目录及其所有必要的父目录
    pub fn create_dir_with_parents(dir_path: &str) -> io::Result<()> {
        fs::create_dir_all(dir_path)
    }

    /// 删除单个文件
    pub fn delete_file(file_path: &str) -> io::Result<()> {
        fs::remove_file(file_path)
    }

    /// 删除含有子文件的目录
    pub fn delete_directory(dir_path: &str) -> io::Result<()> {
        fs::remove_dir_all(dir_path)
    }

    /// 使用glob模式匹配文件路径
    ///
    /// 该函数接收一个glob模式字符串，搜索匹配的文件路径，并返回路径字符串的向量。
    ///
    /// # 参数
    /// * `pattern` - glob模式字符串，用于匹配文件路径
    ///
    /// # 返回值
    /// 返回一个Result类型，成功时包含匹配到的文件路径字符串向量，失败时包含IO错误
    ///
    /// # 示例
    /// ```
    /// let files = FileUtil::glob("D:/*/sub_dir").unwrap();
    /// ```
    pub fn glob(pattern: &str) -> io::Result<Vec<String>> {
        let mut results = Vec::new();
        let r = glob::glob(pattern);
        if r.is_err() {
            return Err(io::Error::new(io::ErrorKind::Other, r.err().unwrap().to_string()));
        }
        // 遍历glob模式匹配到的所有路径
        for entry in r.unwrap() {
            match entry {
                Ok(path) => {
                    let tmp = path.into_os_string().into_string().unwrap();
                    let tmp = tmp.replace("\\", "/");
                    results.push(tmp);
                },
                Err(e) => println!("{:?}", e),
            }
        }
        Ok(results)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    static ROOT_DIR: &str = "d:/tmp/";

    #[test]
    fn test_glob() {
        let xx = FileUtil::glob("D:/*/sub_dir").unwrap();
        println!("{:?}", xx);
    }

    #[test]
    fn test_list() {
        let temp_dir = Path::new(ROOT_DIR);
        let sub_dir = temp_dir.join("sub_dir");
        std::fs::create_dir(&sub_dir).expect("Failed to create sub dir");
        let file_path = sub_dir.join("test_file.txt");
        std::fs::File::create(&file_path).expect("Failed to create file");

        let result = FileUtil::list(temp_dir, true);
        assert!(result.contains(&file_path.to_string_lossy().to_string()));
    }

    #[test]
    fn test_read_string() -> io::Result<()> {
        let temp_path = Path::new(ROOT_DIR).join("temp_file.txt");
        println!("{:?}", temp_path);
        let mut temp_file = File::options()
            .write(true)
            .create(true)
            .open(temp_path.as_path())?;
        let content = "test content".to_string();
        temp_file
            .write_all(content.as_bytes())
            .expect("Failed to write to temp file");

        let result = FileUtil::read_string(temp_path.as_path());
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), content);
        Ok(())
    }

    #[test]
    fn test_read_bytes() {
        let temp_path = Path::new(ROOT_DIR).join("temp_file.txt");
        let mut temp_file = File::options()
            .write(true)
            .open(temp_path.as_path())
            .unwrap();
        let content = [1, 2, 3];
        temp_file
            .write_all(&content)
            .expect("Failed to write to temp file");

        let result = FileUtil::read_bytes(temp_path.as_path());
        assert!(result.is_ok());
    }

    #[test]
    fn test_write_string() {
        let temp_path = Path::new(ROOT_DIR).join("temp_file.txt");
        let _temp_file = File::options().write(true).open(&temp_path).unwrap();
        let content = "test write content".to_string();

        let result = FileUtil::write_string(&temp_path, content.clone());
        assert!(result.is_ok());

        let read_result = FileUtil::read_string(&temp_path);
        assert!(read_result.is_ok());
        assert_eq!(read_result.unwrap(), content);
    }

    #[test]
    fn test_append_string() {
        let temp_path = Path::new(ROOT_DIR).join("temp_file.txt");
        let _temp_file = File::open(&temp_path).unwrap();
        let initial_content = "initial content".to_string();
        let append_content = " appended content".to_string();
        FileUtil::write_string(&temp_path, initial_content.clone())
            .expect("Failed to write initial content");

        let append_result = FileUtil::append_string(&temp_path, append_content.clone());
        assert!(append_result.is_ok());

        let read_result = FileUtil::read_string(&temp_path);
        assert!(read_result.is_ok());
        assert_eq!(read_result.unwrap(), initial_content + &append_content);
    }

    #[test]
    fn test_write_bytes() {
        let temp_path = Path::new(ROOT_DIR).join("temp_file.txt");
        let _temp_file = File::open(&temp_path).unwrap();
        let content = [4, 5, 6];

        let result = FileUtil::write_bytes(&temp_path, &content);
        assert!(result.is_ok());

        let read_result = FileUtil::read_bytes(&temp_path);
        assert!(read_result.is_ok());
        assert_eq!(read_result.unwrap(), content);
    }
}