Crate xio 

XIO - Extended I/O Operations Library

xio is a library that provides extended I/O operations and utilities for file system manipulation, with a focus on asynchronous operations using Tokio. The library offers functionality for:

• Directory traversal with customizable filters
• File reading and writing operations
• Specialized Rust file processing
• File system utilities for common operations

Features

• Asynchronous file operations using Tokio
• Directory walking with customizable filters (hidden files, git directories, etc.)
• Specialized handling for Rust source files
• Batch file processing capabilities
• Integration with external tools (e.g., Neovim)
• Configurable logging with different verbosity levels

Logging Configuration

The library uses the log crate for logging. To configure logging in your application:

use env_logger::{Builder, Env};
use log::info;
 
// Set RUST_LOG environment variable to configure logging level
// Examples:
// export RUST_LOG=xio=debug    # Show all debug messages from xio
// export RUST_LOG=xio=info     # Show only info and above from xio
// export RUST_LOG=xio=warn     # Show only warnings and errors from xio
 
// Initialize logging in your application
Builder::from_env(Env::default())
    .filter_module("xio", log::LevelFilter::Info)  // Default level
    .init();

Example

use std::path::Path;
use xio::{walk_directory, anyhow};
use log::info;
 
async fn process_txt_files() -> anyhow::Result<()> {
    walk_directory("./", "txt", |path| {
        let path = path.to_path_buf();
        async move {
            info!("Processing: {}", path.display());
            Ok(())
        }
    }).await
}

Re-exports

pub use split::DirectorySplitter;

pub use split::FileMatcher;

pub use split::RegexFileMatcher;

pub use split::SplitConfig;

pub use anyhow;

pub use log;

pub use walkdir;

Modules

fs

File system utility functions for working with files and directories.

io

Traits, helpers, and type definitions for core I/O functionality.

split

Structs

Arc

A thread-safe reference-counting pointer. ‘Arc’ stands for ‘Atomically Reference Counted’.

Path

A slice of a path (akin to str).

PathBuf

An owned, mutable path (akin to String).

Functions

check_file_for_multiple_lines

Processes a file and adds it to a list if it contains multiple lines.

delete_files_with_extension

Deletes files with a specific extension in a directory and its subdirectories.

is_git_dir

Determines if a directory entry is a git repository directory.

is_hidden

Determines if a directory entry is hidden.

is_target_dir

Determines if a directory entry is a target directory.

open_files_in_neovim

Opens a list of files in Neovim or a specified editor.

process_file

Process a file with the given function.

process_rust_file

Process a Rust file and check for pedantic warnings.

read_file_content

Reads the entire content of a file into a string.

read_lines

Reads all lines from a file at the given path.

walk_directory

Walks through a directory and asynchronously processes files with a specific extension.

walk_rust_files

Walks through Rust files in a directory and applies a callback function to each file.

write_to_file

Writes content to a file at the specified path.

Type Aliases

IoResult

A specialized Result type for I/O operations.