Add counters to bulk rename function

Author: JustForFun88

yazi-core/src/mgr/commands/bulk_rename.rs

@@ -1,6 +1,7 @@
 use std::{borrow::Cow, collections::HashMap, ffi::{OsStr, OsString}, io::{Read, Write}, path::PathBuf};
 
 use anyhow::{Result, anyhow};
+use crossterm::terminal;
 use scopeguard::defer;
 use tokio::{fs::{self, OpenOptions}, io::AsyncWriteExt};
 use yazi_config::YAZI;
@@ -11,6 +12,12 @@ use yazi_shared::{terminal_clear, tty::TTY, url::Url};
 
 use crate::mgr::Mgr;
 
+mod counters;
+mod filename_template;
+mod name_generator;
+
+use name_generator::generate_names;
+
 impl Mgr {
 	pub(super) fn bulk_rename(&self) {
 		let Some(opener) = YAZI.opener.block(YAZI.open.all("bulk-rename.txt", "text/plain")) else {
@@ -45,11 +52,45 @@ impl Mgr {
 			defer!(AppProxy::resume());
 			AppProxy::stop().await;
 
-			let new: Vec<_> = fs::read_to_string(&tmp).await?.lines().map(PathBuf::from).collect();
+			let new_names = fs::read_to_string(&tmp).await?;
+			let new = Self::parse_new_names(&new_names).await?;
 			Self::bulk_rename_do(root, old, new).await
 		});
 	}
 
+	/// Reads lines from a string, tries to parse them as either fixed filenames or
+	/// counter-based templates (via `generate_names`).
+	///
+	/// If parsing fails, this function will display the errors to the user and wait
+	/// for an ENTER key press before returning an error.
+	async fn parse_new_names(new_names: &str) -> Result<Vec<PathBuf>> {
+		match generate_names(new_names) {
+			Ok(paths) => Ok(paths),
+			Err(errors) => {
+				let (width, _) = terminal::size().unwrap_or((80, 120));
+				let mut buffer = String::new();
+				errors.iter().for_each(|error| {
+					let _ = error.write_to(&mut buffer, width);
+				});
+
+				// Show all parse errors in TTY, then return an error
+				terminal_clear(TTY.writer())?;
+				{
+					let mut w = TTY.lockout();
+					writeln!(w, "Errors encountered while parsing rename lines:")?;
+					writeln!(w, "{buffer}")?;
+					writeln!(w, "\nPress ENTER to exit")?;
+					w.flush()?;
+				}
+				// Wait for user input
+				TTY.reader().read_exact(&mut [0])?;
+
+				// Return an error to skip further rename
+				Err(anyhow::anyhow!("Parsing errors in rename lines"))
+			}
+		}
+	}
+
 	async fn bulk_rename_do(root: PathBuf, old: Vec<PathBuf>, new: Vec<PathBuf>) -> Result<()> {
 		terminal_clear(TTY.writer())?;
 		if old.len() != new.len() {

yazi-core/src/mgr/commands/bulk_rename/counters/ansi.rs

@@ -0,0 +1,64 @@
+//! This module provides functionality for managing ANSI letter counters for both
+//! uppercase and lowercase letters, following Excel's alphabetic counter style.
+
+use super::{CounterFormatter, LOWERCASE, UPPERCASE, write_number_as_letters_gen};
+use std::fmt;
+
+/// A helper structure for generating uppercase ANSI letters (e.g., A, B, ..., AA, AB).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AnsiUpper;
+
+/// A helper structure for generating lowercase ANSI letters (e.g., a, b, ..., aa, ab).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AnsiLower;
+
+impl_counter_formatter! { AnsiUpper, UPPERCASE }
+impl_counter_formatter! { AnsiLower, LOWERCASE }
+
+/// Converts ANSI letters (e.g., "A", "Z", "AA") to their corresponding numeric values.
+/// The conversion follows Excel's alphabetic counter rules: 'A' = 1, 'B' = 2, ...,
+/// 'Z' = 26, 'AA' = 27, etc.
+///
+/// The `UPPERCASE` constant determines whether the string should be validated
+/// as uppercase or lowercase.
+///
+/// # Returns
+///
+/// Returns `Some(u32)` if conversion is successful; otherwise, returns `None`.
+#[inline]
+fn convert_letters_to_number<const UPPERCASE: bool>(value: &str) -> Option<u32> {
+	if value.is_empty() {
+		return None;
+	}
+
+	if UPPERCASE {
+		if !value.chars().all(|c| c.is_ascii_uppercase()) {
+			return None;
+		}
+	} else if !value.chars().all(|c| c.is_ascii_lowercase()) {
+		return None;
+	}
+
+	let result = value.chars().rev().enumerate().fold(0_u32, |acc, (i, c)| {
+		acc + ((c as u32) - (if UPPERCASE { 'A' } else { 'a' } as u32) + 1) * 26_u32.pow(i as u32)
+	});
+
+	Some(result)
+}
+
+/// Writes the numeric value as ANSI letters (e.g., 1 → "A", 27 → "AA") into the provided buffer.
+///
+/// # Arguments
+///
+/// * `num` - The numeric value to convert.
+/// * `width` - The minimum width of the generated string, padded with zeros if necessary.
+/// * `buf` - The buffer to write the resulting string into.
+#[inline]
+fn write_number_as_letters<const UPPERCASE: bool>(
+	num: u32,
+	width: usize,
+	buf: &mut impl fmt::Write,
+) -> fmt::Result {
+	let base = if UPPERCASE { b'A' } else { b'a' };
+	write_number_as_letters_gen(num, width, 26, |r| (base + r as u8) as char, buf)
+}

yazi-core/src/mgr/commands/bulk_rename/counters/cyrillic.rs

@@ -0,0 +1,104 @@
+//! This module provides functionality for managing Cyrillic letter counters for both
+//! uppercase and lowercase letters, following Excel's alphabetic counter style.
+
+use super::{CounterFormatter, LOWERCASE, UPPERCASE, write_number_as_letters_gen};
+use std::fmt;
+
+/// An array of uppercase Cyrillic letters used for indexing and mapping.
+/// This array includes all uppercase Cyrillic letters excluding 'Ё', 'Й', 'Ъ', 'Ы', 'Ь'.
+const UPPERCASE_CYRILLIC: [char; 28] = [
+	'А', 'Б', 'В', 'Г', 'Д', 'Е', 'Ж', 'З', 'И', 'К', 'Л', 'М', 'Н', 'О', 'П', 'Р', 'С', 'Т', 'У',
+	'Ф', 'Х', 'Ц', 'Ч', 'Ш', 'Щ', 'Э', 'Ю', 'Я',
+];
+
+/// An array of lowercase Cyrillic letters used for indexing and mapping.
+/// This array includes all lowercase Cyrillic letters excluding 'ё', 'й', 'ъ', 'ы', 'ь'.
+const LOWERCASE_CYRILLIC: [char; 28] = [
+	'а', 'б', 'в', 'г', 'д', 'е', 'ж', 'з', 'и', 'к', 'л', 'м', 'н', 'о', 'п', 'р', 'с', 'т', 'у',
+	'ф', 'х', 'ц', 'ч', 'ш', 'щ', 'э', 'ю', 'я',
+];
+
+/// A helper structure for generating uppercase Cyrillic letters (e.g., А, Б, В, ..., АА, АБ),
+/// while excluding 'Ё', 'Й', 'Ъ', 'Ы' and 'Ь'.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CyrillicUpper;
+
+/// A helper structure for generating lowercase Cyrillic letters (e.g., а, б, в, ..., аа, аб),
+/// while excluding 'ё', 'й', 'ъ', 'ы' and 'ь'.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CyrillicLower;
+
+impl_counter_formatter! { CyrillicUpper, UPPERCASE }
+impl_counter_formatter! { CyrillicLower, LOWERCASE }
+
+/// Converts Cyrillic letters (e.g., "Б", "В", "БА") to their corresponding numeric values.
+/// The conversion follows Excel's alphabetic counter rules: 'А' = 1, 'Б' = 2, ...,
+/// 'Я' = 28, 'АА' = 29, etc.
+///
+/// The `UPPERCASE` constant determines whether the string should be validated
+/// as uppercase or lowercase.
+///
+/// # Returns
+///
+/// Returns `Some(u32)` if conversion is successful; otherwise, returns `None`.
+#[inline]
+fn convert_letters_to_number<const UPPERCASE: bool>(value: &str) -> Option<u32> {
+	if invalid_string::<UPPERCASE>(value) {
+		return None;
+	}
+	let lookup = if UPPERCASE { &UPPERCASE_CYRILLIC } else { &LOWERCASE_CYRILLIC };
+
+	let result = value.chars().rev().enumerate().fold(0_u32, |acc, (i, c)| {
+		if let Some(index) = lookup.iter().position(|&x| x == c) {
+			acc + (index as u32 + 1) * 28_u32.pow(i as u32)
+		} else {
+			acc
+		}
+	});
+	Some(result)
+}
+
+/// Writes the numeric value as Cyrillic letters (e.g., 1 → "А", 28 → "Я") into the provided buffer.
+///
+/// # Arguments
+///
+/// * `num` - The numeric value to convert.
+/// * `width` - The minimum width of the generated string, padded with zeros if necessary.
+/// * `buf` - The buffer to write the resulting string into.
+#[inline]
+fn write_number_as_letters<const UPPERCASE: bool>(
+	num: u32,
+	width: usize,
+	buf: &mut impl fmt::Write,
+) -> fmt::Result {
+	let lookup = if UPPERCASE { &UPPERCASE_CYRILLIC } else { &LOWERCASE_CYRILLIC };
+
+	write_number_as_letters_gen(num, width, 28, |remainder| lookup[remainder as usize], buf)
+}
+
+/// Checks if a string is non-empty and consists only of valid uppercase or
+/// lowercase Cyrillic letters, excluding 'Ё', 'Й', 'Ъ', 'Ы', and 'Ь'
+/// ('ё', 'й', 'ъ', 'ы' and 'ь').
+///
+/// The `UPPERCASE` constant determines whether to check uppercase or lowercase letters.
+///
+/// # Returns
+///
+/// Returns `true` if the string is invalid; otherwise, returns `false`.
+#[inline]
+fn invalid_string<const UPPERCASE: bool>(str: &str) -> bool {
+	if str.is_empty() {
+		return true;
+	}
+	if UPPERCASE {
+		!str.chars().all(|c| {
+			// ('А'..='Я') == ('\u{0410}'..='\u{042F}')
+			('\u{0410}'..='\u{042F}').contains(&c) && !matches!(c, 'Ё' | 'Й' | 'Ъ' | 'Ы' | 'Ь')
+		})
+	} else {
+		!str.chars().all(|c| {
+			// ('а'..='я') == ('\u{0430}'..='\u{044F}')
+			('\u{0430}'..='\u{044F}').contains(&c) && !matches!(c, 'ё' | 'й' | 'ъ' | 'ы' | 'ь')
+		})
+	}
+}

yazi-core/src/mgr/commands/bulk_rename/counters/digit.rs

@@ -0,0 +1,33 @@
+//! This module provides functionality for managing Arabic numeral counters.
+
+use super::CounterFormatter;
+use std::fmt;
+
+/// A helper structure for generating numeric values (e.g., 1, 2, ..., 999 or 001, 002).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Digits;
+
+impl CounterFormatter for Digits {
+	/// Formats a value as a zero-padded string and writes it to a buffer.
+	///
+	/// # Arguments
+	///
+	/// * `value` - The numeric value to format.
+	/// * `width` - The minimum width of the output string.
+	/// * `buf` - A mutable reference to a buffer.
+	#[inline]
+	fn value_to_buffer(
+		self,
+		value: u32,
+		width: usize,
+		buf: &mut impl fmt::Write,
+	) -> Result<(), fmt::Error> {
+		write!(buf, "{value:0>width$}")
+	}
+
+	/// Parses a zero-padded numeric string into a `u32` value.
+	#[inline]
+	fn string_to_value(self, value: &str) -> Option<u32> {
+		value.parse().ok()
+	}
+}

yazi-core/src/mgr/commands/bulk_rename/counters/geneal.rs

@@ -0,0 +1,99 @@
+use std::fmt;
+
+/// This macro generates an implementation of CounterFormatter for a given
+/// counter helper type.
+///
+/// # Arguments
+///
+/// * `$type` - The target helper struct (e.g., `AnsiUpper`).
+/// * `$case` - A boolean constant determining whether the counter uppercase or lowercase.
+macro_rules! impl_counter_formatter {
+	($type:ty, $case:expr) => {
+		impl CounterFormatter for $type {
+			#[inline]
+			fn value_to_buffer(self, value: u32, width: usize, buf: &mut impl fmt::Write) -> fmt::Result {
+				write_number_as_letters::<{ $case }>(value, width, buf)
+			}
+
+			#[inline]
+			fn string_to_value(self, value: &str) -> Option<u32> {
+				convert_letters_to_number::<{ $case }>(value)
+			}
+		}
+	};
+}
+
+/// Converts a given numeric value into an alphabetic representation following a base-N numbering system,
+/// similar to Excel-style column labels (e.g., 1 → A, 2 → B, ..., 26 → Z, 27 → AA, etc.).
+///
+/// This function generalizes the process for different alphabets by allowing a customizable base (`alphabet_len`)
+/// and a transformation function (`convert_fn`) that maps remainder values to characters.
+///
+/// # Arguments
+///
+/// * `num` - The numeric value to be converted. Since alphabetic numbering systems start from 1
+///   (e.g., A = 1, B = 2), it should be non-zero value.
+///
+/// * `width` - The minimum width of the output string. If necessary, the result will be left-padded with '0'.
+///
+/// * `alphabet_len` - The base of the numbering system (e.g., 26 for Latin, 28 for Cyrillic, etc.).
+///
+/// * `convert_fn` - A closure that converts a remainder (`u32`) into a corresponding character.
+///   - The `remainder` represents the remainder of division by `alphabet_len` (i.e., `num % alphabet_len`).
+///   - The closure should map this remainder to a specific character in the corresponding alphabet
+///     (e.g., `b'A' + remainder as u8`).
+///
+/// * `buf` - A mutable reference to a `fmt::Write` buffer where the result is written.
+#[inline]
+pub(super) fn write_number_as_letters_gen(
+	mut num: u32,
+	width: usize,
+	alphabet_len: u32,
+	mut convert_fn: impl FnMut(u32) -> char,
+	buf: &mut impl fmt::Write,
+) -> fmt::Result {
+	if num == 0 {
+		return Ok(());
+	}
+
+	let mut stack_buf = ['0'; 10];
+	let mut written_len = 0;
+
+	for char in &mut stack_buf {
+		if num == 0 {
+			break;
+		}
+		let remainder = (num - 1) % alphabet_len;
+		*char = convert_fn(remainder);
+		num = (num - remainder - 1) / alphabet_len;
+		written_len += 1;
+	}
+
+	if num > 0 {
+		let mut vec_buf = Vec::with_capacity(20);
+		vec_buf.extend_from_slice(&stack_buf);
+
+		while num > 0 {
+			let remainder = (num - 1) % alphabet_len;
+			vec_buf.push(convert_fn(remainder));
+			num = (num - remainder - 1) / alphabet_len;
+			written_len += 1;
+		}
+
+		for _ in vec_buf.len()..width {
+			buf.write_char('0')?;
+		}
+		for &c in vec_buf.iter().rev() {
+			buf.write_char(c)?;
+		}
+	} else {
+		for _ in written_len..width {
+			buf.write_char('0')?;
+		}
+		for &c in stack_buf[..written_len].iter().rev() {
+			buf.write_char(c)?;
+		}
+	}
+
+	Ok(())
+}