msy 0.4.6

Modern musl rsync alternative - Fast, parallel file synchronization
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

// Per-file progress display for large file transfers
//
// Shows real-time progress bars for files >= 1MB to provide better UX
// for long-running transfers without cluttering output for small files.
//
// TTY Detection:
// - indicatif automatically detects if stdout is a TTY
// - Progress bars are hidden when output is piped/redirected
// - Respects --quiet flag (handled in SyncEngine)
//
// Usage:
//   sy /source /dest --per-file-progress  # Show progress for large files
//   sy /source /dest --quiet               # Hide all progress

use indicatif::{ProgressBar, ProgressStyle};
use std::path::Path;
use std::sync::Arc;
use std::time::Duration;

/// Minimum file size (in bytes) to show progress bar
/// Files smaller than this are transferred too quickly for meaningful progress display
pub const MIN_SIZE_FOR_PROGRESS: u64 = 1024 * 1024; // 1MB

/// Create a progress bar for a file transfer
///
/// Returns Arc-wrapped progress bar that can be shared with the callback
pub fn create_file_progress_bar(file_path: &Path, total_bytes: u64) -> Arc<ProgressBar> {
	let pb = ProgressBar::new(total_bytes);

	// Format: filename [=====>] 45.2 MB/100 MB (45%) 12 MB/s ETA: 4s
	pb.set_style(
		ProgressStyle::with_template("{msg}\n[{bar:40.cyan/blue}] {bytes}/{total_bytes} ({percent}%) {bytes_per_sec} ETA: {eta}")
			.unwrap()
			.progress_chars("=>-"),
	);

	// Set message to filename (truncate if too long)
	let filename = file_path.file_name().and_then(|n| n.to_str()).unwrap_or("unknown");

	let msg = if filename.len() > 60 { format!("{}...", &filename[..57]) } else { filename.to_string() };

	pb.set_message(msg);

	// Update every 100ms for smooth progress
	pb.enable_steady_tick(Duration::from_millis(100));

	Arc::new(pb)
}

/// Create a progress callback for a file transfer
///
/// Returns a callback that can be passed to copy_file_streaming
pub fn create_progress_callback(file_path: &Path, total_bytes: u64) -> Arc<dyn Fn(u64, u64) + Send + Sync> {
	let pb = create_file_progress_bar(file_path, total_bytes);

	Arc::new(move |bytes_transferred: u64, _total: u64| {
		pb.set_position(bytes_transferred);
	})
}

/// Finish a progress bar
///
/// Call this after the transfer completes to finalize the display
#[cfg(test)]
pub fn finish_progress_bar(pb: Arc<ProgressBar>) {
	pb.finish_with_message("✓ Transfer complete");
}

#[cfg(test)]
mod tests {
	use super::*;
	use std::path::PathBuf;

	#[test]
	fn test_min_size_constant() {
		assert_eq!(MIN_SIZE_FOR_PROGRESS, 1024 * 1024);
	}

	#[test]
	fn test_create_progress_bar() {
		let path = PathBuf::from("/tmp/test.txt");
		let pb = create_file_progress_bar(&path, 1000);
		assert_eq!(pb.length(), Some(1000));
	}

	#[test]
	fn test_create_progress_bar_long_filename() {
		let long_name = "a".repeat(100);
		let path = PathBuf::from(format!("/tmp/{}", long_name));
		let pb = create_file_progress_bar(&path, 1000);

		// Message should be truncated
		let msg = pb.message();
		assert!(msg.len() <= 63); // 60 + "..."
	}

	#[test]
	fn test_create_progress_callback() {
		let path = PathBuf::from("/tmp/test.txt");
		let callback = create_progress_callback(&path, 1000);

		// Call callback to ensure it doesn't panic
		callback(500, 1000);
		callback(1000, 1000);
	}

	#[test]
	fn test_finish_progress_bar() {
		let path = PathBuf::from("/tmp/test.txt");
		let pb = create_file_progress_bar(&path, 1000);
		pb.set_position(1000);
		finish_progress_bar(pb);
		// Should not panic
	}
}