Add counters to bulk rename function

Author: JustForFun88

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

@@ -1,7 +1,7 @@
 use std::{borrow::Cow, collections::HashMap, ffi::{OsStr, OsString}, io::{Read, Write}, path::PathBuf};
 
 use anyhow::{Result, anyhow};
-use crossterm::{execute, style::Print};
+use crossterm::{execute, style::Print, terminal};
 use scopeguard::defer;
 use tokio::{fs::{self, OpenOptions}, io::AsyncWriteExt};
 use yazi_config::YAZI;
@@ -12,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 {
@@ -46,12 +52,46 @@ impl Mgr {
 			defer!(AppProxy::resume());
 			AppProxy::stop().await;
 
-			let new: Vec<_> =
-				fs::read_to_string(&tmp).await?.lines().take(old.len()).map(PathBuf::from).collect();
+			let new_names = fs::read_to_string(&tmp).await?;
+			let new = Self::parse_new_names(&new_names, old.len()).await?;
 			Self::bulk_rename_do(root, old, new).await
 		});
 	}
 
+	/// Reads a number of lines from a string, attempting to parse them as either
+	/// fixed filenames or counter-based templates.
+	///
+	/// The number of expected lines must match `expected_count`.
+	/// If parsing fails, displays all errors to the user and waits for ENTER
+	/// before returning an error.
+	async fn parse_new_names(new_names: &str, expected_count: usize) -> Result<Vec<PathBuf>> {
+		match generate_names(&mut new_names.lines().take(expected_count)) {
+			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(())
+}

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

@@ -0,0 +1,218 @@
+//! This module provides functionality for creating and managing various formats
+//! of counters.
+//!
+//! Counters are used to generate sequences of values based on different
+//! alphabets and numeral systems, including ANSI, Cyrillic, and Roman letters,
+//! as well as digits.
+//!
+//! # Overview
+//!
+//! The module defines traits and structures for different formats of counters,
+//! including:
+//!
+//! - uppercase and lowercase ANSI letters;
+//! - uppercase and lowercase Cyrillic letters;
+//! - numeric counter;
+//! - uppercase and lowercase Roman numerals.
+//!
+//! The `CharacterCounter` structure provides a unified interface for handling
+//! these different formats of counters.
+
+use super::filename_template::CounterBuilder;
+use std::fmt;
+
+#[cfg(test)]
+mod test;
+
+#[macro_use]
+mod geneal;
+mod ansi;
+mod cyrillic;
+mod digit;
+mod roman;
+
+const UPPERCASE: bool = true;
+const LOWERCASE: bool = false;
+
+pub use ansi::{AnsiLower, AnsiUpper};
+pub use cyrillic::{CyrillicLower, CyrillicUpper};
+pub use digit::Digits;
+use geneal::write_number_as_letters_gen;
+pub use roman::{RomanLower, RomanUpper};
+
+/// Defines common behavior for counters that generate sequential values.
+pub trait Counter {
+	/// Writes the current value to the provided buffer.
+	fn write_value(&self, buf: &mut impl fmt::Write) -> fmt::Result;
+
+	/// Advances the counter to the next value in the sequence.
+	fn advance(&mut self);
+
+	/// Resets the counter to its initial value.
+	#[allow(dead_code)]
+	fn restart(&mut self);
+}
+
+pub trait CounterFormatter: Copy {
+	/// 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.
+	fn value_to_buffer(
+		self,
+		value: u32,
+		width: usize,
+		buf: &mut impl fmt::Write,
+	) -> Result<(), fmt::Error>;
+
+	/// Parses a zero-padded numeric string into a `u32` value.
+	fn string_to_value(self, value: &str) -> Option<u32>;
+}
+
+/// Enum representing different formats of character-based counters.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CounterFormat {
+	/// Numeric values (1, 2, ..., 999).
+	Digits(Digits),
+
+	/// Uppercase ANSI letters (A, B, C, ..., AA, AB, ...).
+	AnsiUpper(AnsiUpper),
+
+	/// Lowercase ANSI letters (a, b, c, ..., aa, ab, ...).
+	AnsiLower(AnsiLower),
+
+	/// Uppercase Roman numerals (I, II, III, IV, V, ...).
+	RomanUpper(RomanUpper),
+
+	/// Lowercase Roman numerals (i, ii, iii, iv, v, ...).
+	RomanLower(RomanLower),
+
+	/// Uppercase Cyrillic letters (А, Б, В, ..., АА, АБ, ...).
+	CyrillicUpper(CyrillicUpper),
+
+	/// Lowercase Cyrillic letters (а, б, в, ..., аа, аб, ...).
+	CyrillicLower(CyrillicLower),
+}
+
+impl Default for CounterFormat {
+	fn default() -> Self {
+		CounterFormat::Digits(Digits)
+	}
+}
+
+impl CounterFormatter for CounterFormat {
+	fn value_to_buffer(
+		self,
+		value: u32,
+		width: usize,
+		buf: &mut impl fmt::Write,
+	) -> Result<(), fmt::Error> {
+		match self {
+			CounterFormat::Digits(fmt) => fmt.value_to_buffer(value, width, buf),
+			CounterFormat::AnsiUpper(fmt) => fmt.value_to_buffer(value, width, buf),
+			CounterFormat::AnsiLower(fmt) => fmt.value_to_buffer(value, width, buf),
+			CounterFormat::RomanUpper(fmt) => fmt.value_to_buffer(value, width, buf),
+			CounterFormat::RomanLower(fmt) => fmt.value_to_buffer(value, width, buf),
+			CounterFormat::CyrillicUpper(fmt) => fmt.value_to_buffer(value, width, buf),
+			CounterFormat::CyrillicLower(fmt) => fmt.value_to_buffer(value, width, buf),
+		}
+	}
+
+	fn string_to_value(self, value: &str) -> Option<u32> {
+		match self {
+			CounterFormat::Digits(fmt) => fmt.string_to_value(value),
+			CounterFormat::AnsiUpper(fmt) => fmt.string_to_value(value),
+			CounterFormat::AnsiLower(fmt) => fmt.string_to_value(value),
+			CounterFormat::RomanUpper(fmt) => fmt.string_to_value(value),
+			CounterFormat::RomanLower(fmt) => fmt.string_to_value(value),
+			CounterFormat::CyrillicUpper(fmt) => fmt.string_to_value(value),
+			CounterFormat::CyrillicLower(fmt) => fmt.string_to_value(value),
+		}
+	}
+}
+
+impl fmt::Display for CounterFormat {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			CounterFormat::Digits(_) => write!(f, "Numeric Digits"),
+			CounterFormat::AnsiUpper(_) => write!(f, "ANSI Uppercase Letters"),
+			CounterFormat::AnsiLower(_) => write!(f, "ANSI Lowercase Letters"),
+			CounterFormat::RomanUpper(_) => write!(f, "Roman Uppercase Numerals"),
+			CounterFormat::RomanLower(_) => write!(f, "Roman Lowercase Numerals"),
+			CounterFormat::CyrillicUpper(_) => write!(f, "Cyrillic Uppercase Letters"),
+			CounterFormat::CyrillicLower(_) => write!(f, "Cyrillic Lowercase Letters"),
+		}
+	}
+}
+
+/// Represents a character-based counter. Provides a unified interface for
+/// handling different formats of counters.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CharacterCounter {
+	/// The format of counter (e.g., ANSI, Cyrillic, Roman, digits).
+	format: CounterFormat,
+
+	/// The initial numeric value of the counter, used to reset the counter.
+	start: u32,
+
+	/// The current numeric value of the counter.
+	state: u32,
+
+	/// The increment step size when advancing the counter.
+	step: u32,
+
+	/// The minimum width of the generated string, padded with leading zeros.
+	width: usize,
+}
+
+impl CharacterCounter {
+	/// Creates a new `CharacterCounter` instance.
+	///
+	/// # Arguments
+	///
+	/// * `format` - the format of counter (e.g., ANSI, Cyrillic, Roman, digits).
+	/// * `start` - the initial numeric value of the counter.
+	/// * `step` - the increment step size when advancing the counter.
+	/// * `width` - the minimum width of the generated string, padded with leading zeros.
+	pub fn new(format: CounterFormat, start: u32, step: u32, width: usize) -> Self {
+		Self { format, start, state: start, step, width }
+	}
+
+	/// Updates the `CharacterCounter` instance with the parameters set in
+	/// builder.
+	pub fn update_from(&mut self, builder: CounterBuilder) {
+		if self.format != builder.format() {
+			self.format = builder.format();
+		}
+
+		if let Some(start) = builder.start() {
+			self.start = start;
+			self.state = start;
+		}
+
+		if let Some(step) = builder.step() {
+			self.step = step;
+		}
+
+		if let Some(width) = builder.width() {
+			self.width = width;
+		}
+	}
+}
+
+impl Counter for CharacterCounter {
+	fn write_value(&self, buf: &mut impl fmt::Write) -> fmt::Result {
+		self.format.value_to_buffer(self.state, self.width, buf)
+	}
+
+	fn advance(&mut self) {
+		self.state += self.step;
+	}
+
+	fn restart(&mut self) {
+		self.state = self.start;
+	}
+}

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

@@ -0,0 +1,183 @@
+//! This module provides functionality for managing Roman numeral counters
+//! for both uppercase and lowercase Roman numerals.
+
+use super::{CounterFormatter, LOWERCASE, UPPERCASE};
+use std::fmt;
+
+/// A lookup table for uppercase Roman numerals and their values.
+const UPPERCASE_ROMAN_NUMERALS: [(&str, u32); 13] = [
+	("M", 1000),
+	("CM", 900),
+	("D", 500),
+	("CD", 400),
+	("C", 100),
+	("XC", 90),
+	("L", 50),
+	("XL", 40),
+	("X", 10),
+	("IX", 9),
+	("V", 5),
+	("IV", 4),
+	("I", 1),
+];
+
+/// A lookup table for lowercase Roman numerals and their values.
+const LOWERCASE_ROMAN_NUMERALS: [(&str, u32); 13] = [
+	("m", 1000),
+	("cm", 900),
+	("d", 500),
+	("cd", 400),
+	("c", 100),
+	("xc", 90),
+	("l", 50),
+	("xl", 40),
+	("x", 10),
+	("ix", 9),
+	("v", 5),
+	("iv", 4),
+	("i", 1),
+];
+
+/// A helper structure for generating uppercase Roman numerals (e.g., I, II, III, IV, V, ...).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct RomanUpper;
+
+/// A helper structure for generating lowercase Roman numerals (e.g., i, ii, iii, iv, v, ...).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct RomanLower;
+
+impl_counter_formatter! { RomanUpper, UPPERCASE }
+impl_counter_formatter! { RomanLower, LOWERCASE }
+
+/// Converts Roman numerals (e.g. I, II, III) to their corresponding numeric values.
+///
+/// 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>(start: &str) -> Option<u32> {
+	if invalid_string::<UPPERCASE>(start) {
+		return None;
+	};
+	let roman_numerals =
+		if UPPERCASE { &UPPERCASE_ROMAN_NUMERALS } else { &LOWERCASE_ROMAN_NUMERALS };
+
+	let mut num = 0;
+	let mut i = 0;
+
+	while i < start.len() {
+		if i + 1 < start.len() {
+			if let Some(&(_, value)) = roman_numerals.iter().find(|&&(s, _)| s == &start[i..=i + 1]) {
+				num += value;
+				i += 2;
+				continue;
+			}
+		}
+		if let Some(&(_, value)) = roman_numerals.iter().find(|&&(s, _)| s == &start[i..=i]) {
+			num += value;
+			i += 1;
+		} else {
+			return None;
+		}
+	}
+
+	Some(num)
+}
+
+/// Writes the numeric value as Roman numerals (e.g., 1 → "I", 4 → "IV") 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>(
+	mut num: u32,
+	width: usize,
+	buf: &mut impl fmt::Write,
+) -> fmt::Result {
+	if num == 0 {
+		return Ok(());
+	}
+
+	let roman_numerals =
+		if UPPERCASE { &UPPERCASE_ROMAN_NUMERALS } else { &LOWERCASE_ROMAN_NUMERALS };
+
+	let mut stack_buf = ['0'; 10];
+	let mut length = 0;
+
+	let mut iter = roman_numerals.iter().peekable();
+	'outer: while let Some(&&(roman, value)) = iter.peek() {
+		'inner: loop {
+			if num < value {
+				break 'inner;
+			}
+			let final_length = length + roman.len();
+			if final_length > stack_buf.len() {
+				break 'outer;
+			}
+			for (char_ref, char) in stack_buf[length..final_length].iter_mut().zip(roman.chars()) {
+				*char_ref = char
+			}
+			num -= value;
+			length += roman.len();
+		}
+		iter.next();
+	}
+
+	if num > 0 {
+		let mut vec_buf = Vec::with_capacity(20);
+		vec_buf.extend_from_slice(&stack_buf[..length]);
+
+		for &(roman, value) in iter {
+			while num >= value {
+				vec_buf.extend(roman.chars());
+				num -= value;
+				length += roman.len();
+			}
+		}
+
+		for _ in vec_buf.len()..width {
+			buf.write_char('0')?;
+		}
+		for &c in vec_buf.iter() {
+			buf.write_char(c)?;
+		}
+	} else {
+		for _ in length..width {
+			buf.write_char('0')?;
+		}
+		for &c in stack_buf[..length].iter() {
+			buf.write_char(c)?;
+		}
+	}
+
+	Ok(())
+}
+
+/// Checks if a string is non-empty and consists only of valid
+/// uppercase or lowercase Roman numerals.
+///
+/// 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;
+	}
+	let valid_chars = if UPPERCASE {
+		['M', 'D', 'C', 'L', 'X', 'V', 'I']
+	} else {
+		['m', 'd', 'c', 'l', 'x', 'v', 'i']
+	};
+
+	!str.chars().all(|c| valid_chars.contains(&c))
+}

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

@@ -0,0 +1,177 @@
+use super::*;
+
+const DIGITS_VALUES: [&str; 100] = [
+	"000", "001", "002", "003", "004", "005", "006", "007", "008", "009", "010", "011", "012", "013",
+	"014", "015", "016", "017", "018", "019", "020", "021", "022", "023", "024", "025", "026", "027",
+	"028", "029", "030", "031", "032", "033", "034", "035", "036", "037", "038", "039", "040", "041",
+	"042", "043", "044", "045", "046", "047", "048", "049", "050", "051", "052", "053", "054", "055",
+	"056", "057", "058", "059", "060", "061", "062", "063", "064", "065", "066", "067", "068", "069",
+	"070", "071", "072", "073", "074", "075", "076", "077", "078", "079", "080", "081", "082", "083",
+	"084", "085", "086", "087", "088", "089", "090", "091", "092", "093", "094", "095", "096", "097",
+	"098", "099",
+];
+
+#[test]
+fn test_digits_advance_100_iterations() {
+	let mut buf = String::new();
+	let counter = Digits;
+	for (idx, &expected_value) in DIGITS_VALUES.iter().enumerate() {
+		let _ = counter.value_to_buffer(idx as u32, 3, &mut buf);
+		assert_eq!(expected_value, &buf);
+		buf.clear();
+	}
+
+	for (idx, &expected_value) in DIGITS_VALUES.iter().enumerate() {
+		assert_eq!(counter.string_to_value(expected_value), Some(idx as u32));
+	}
+}
+
+const UPPERCASE_ANSI_VALUES: [&str; 100] = [
+	"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S",
+	"T", "U", "V", "W", "X", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI", "AJ",
+	"AK", "AL", "AM", "AN", "AO", "AP", "AQ", "AR", "AS", "AT", "AU", "AV", "AW", "AX", "AY", "AZ",
+	"BA", "BB", "BC", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BK", "BL", "BM", "BN", "BO", "BP",
+	"BQ", "BR", "BS", "BT", "BU", "BV", "BW", "BX", "BY", "BZ", "CA", "CB", "CC", "CD", "CE", "CF",
+	"CG", "CH", "CI", "CJ", "CK", "CL", "CM", "CN", "CO", "CP", "CQ", "CR", "CS", "CT", "CU", "CV",
+];
+
+const LOWERCASE_ANSI_VALUES: [&str; 100] = [
+	"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
+	"t", "u", "v", "w", "x", "y", "z", "aa", "ab", "ac", "ad", "ae", "af", "ag", "ah", "ai", "aj",
+	"ak", "al", "am", "an", "ao", "ap", "aq", "ar", "as", "at", "au", "av", "aw", "ax", "ay", "az",
+	"ba", "bb", "bc", "bd", "be", "bf", "bg", "bh", "bi", "bj", "bk", "bl", "bm", "bn", "bo", "bp",
+	"bq", "br", "bs", "bt", "bu", "bv", "bw", "bx", "by", "bz", "ca", "cb", "cc", "cd", "ce", "cf",
+	"cg", "ch", "ci", "cj", "ck", "cl", "cm", "cn", "co", "cp", "cq", "cr", "cs", "ct", "cu", "cv",
+];
+
+#[test]
+fn test_ansi_upper_advance_100_iterations() {
+	let mut buf = String::new();
+	let counter = AnsiUpper;
+	for (idx, &expected_value) in UPPERCASE_ANSI_VALUES.iter().enumerate() {
+		let _ = counter.value_to_buffer(idx as u32 + 1, 1, &mut buf);
+		assert_eq!(expected_value, &buf);
+		buf.clear();
+	}
+
+	for (idx, &expected_value) in UPPERCASE_ANSI_VALUES.iter().enumerate() {
+		assert_eq!(counter.string_to_value(expected_value), Some(idx as u32 + 1));
+	}
+}
+
+#[test]
+fn test_ansi_lower_advance_100_iterations() {
+	let mut buf = String::new();
+	let counter = AnsiLower;
+	for (idx, &expected_value) in LOWERCASE_ANSI_VALUES.iter().enumerate() {
+		let _ = counter.value_to_buffer(idx as u32 + 1, 1, &mut buf);
+		assert_eq!(expected_value, &buf);
+		buf.clear();
+	}
+
+	for (idx, &expected_value) in LOWERCASE_ANSI_VALUES.iter().enumerate() {
+		assert_eq!(counter.string_to_value(expected_value), Some(idx as u32 + 1));
+	}
+}
+
+const UPPERCASE_ROMAN_VALUES: [&str; 100] = [
+	"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XI", "XII", "XIII", "XIV", "XV",
+	"XVI", "XVII", "XVIII", "XIX", "XX", "XXI", "XXII", "XXIII", "XXIV", "XXV", "XXVI", "XXVII",
+	"XXVIII", "XXIX", "XXX", "XXXI", "XXXII", "XXXIII", "XXXIV", "XXXV", "XXXVI", "XXXVII",
+	"XXXVIII", "XXXIX", "XL", "XLI", "XLII", "XLIII", "XLIV", "XLV", "XLVI", "XLVII", "XLVIII",
+	"XLIX", "L", "LI", "LII", "LIII", "LIV", "LV", "LVI", "LVII", "LVIII", "LIX", "LX", "LXI",
+	"LXII", "LXIII", "LXIV", "LXV", "LXVI", "LXVII", "LXVIII", "LXIX", "LXX", "LXXI", "LXXII",
+	"LXXIII", "LXXIV", "LXXV", "LXXVI", "LXXVII", "LXXVIII", "LXXIX", "LXXX", "LXXXI", "LXXXII",
+	"LXXXIII", "LXXXIV", "LXXXV", "LXXXVI", "LXXXVII", "LXXXVIII", "LXXXIX", "XC", "XCI", "XCII",
+	"XCIII", "XCIV", "XCV", "XCVI", "XCVII", "XCVIII", "XCIX", "C",
+];
+
+const LOWERCASE_ROMAN_VALUES: [&str; 100] = [
+	"i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix", "x", "xi", "xii", "xiii", "xiv", "xv",
+	"xvi", "xvii", "xviii", "xix", "xx", "xxi", "xxii", "xxiii", "xxiv", "xxv", "xxvi", "xxvii",
+	"xxviii", "xxix", "xxx", "xxxi", "xxxii", "xxxiii", "xxxiv", "xxxv", "xxxvi", "xxxvii",
+	"xxxviii", "xxxix", "xl", "xli", "xlii", "xliii", "xliv", "xlv", "xlvi", "xlvii", "xlviii",
+	"xlix", "l", "li", "lii", "liii", "liv", "lv", "lvi", "lvii", "lviii", "lix", "lx", "lxi",
+	"lxii", "lxiii", "lxiv", "lxv", "lxvi", "lxvii", "lxviii", "lxix", "lxx", "lxxi", "lxxii",
+	"lxxiii", "lxxiv", "lxxv", "lxxvi", "lxxvii", "lxxviii", "lxxix", "lxxx", "lxxxi", "lxxxii",
+	"lxxxiii", "lxxxiv", "lxxxv", "lxxxvi", "lxxxvii", "lxxxviii", "lxxxix", "xc", "xci", "xcii",
+	"xciii", "xciv", "xcv", "xcvi", "xcvii", "xcviii", "xcix", "c",
+];
+
+#[test]
+fn test_roman_upper_advance_100_iterations() {
+	let mut buf = String::new();
+	let counter = RomanUpper;
+	for (idx, &expected_value) in UPPERCASE_ROMAN_VALUES.iter().enumerate() {
+		let _ = counter.value_to_buffer(idx as u32 + 1, 1, &mut buf);
+		assert_eq!(expected_value, &buf);
+		buf.clear();
+	}
+
+	for (idx, &expected_value) in UPPERCASE_ROMAN_VALUES.iter().enumerate() {
+		assert_eq!(counter.string_to_value(expected_value), Some(idx as u32 + 1));
+	}
+}
+
+#[test]
+fn test_roman_lower_advance_100_iterations() {
+	let mut buf = String::new();
+	let counter = RomanLower;
+	for (idx, &expected_value) in LOWERCASE_ROMAN_VALUES.iter().enumerate() {
+		let _ = counter.value_to_buffer(idx as u32 + 1, 1, &mut buf);
+		assert_eq!(expected_value, &buf);
+		buf.clear();
+	}
+
+	for (idx, &expected_value) in LOWERCASE_ROMAN_VALUES.iter().enumerate() {
+		assert_eq!(counter.string_to_value(expected_value), Some(idx as u32 + 1));
+	}
+}
+
+const UPPERCASE_CYRILLIC_VALUES: [&str; 100] = [
+	"А", "Б", "В", "Г", "Д", "Е", "Ж", "З", "И", "К", "Л", "М", "Н", "О", "П", "Р", "С", "Т", "У",
+	"Ф", "Х", "Ц", "Ч", "Ш", "Щ", "Э", "Ю", "Я", "АА", "АБ", "АВ", "АГ", "АД", "АЕ", "АЖ", "АЗ",
+	"АИ", "АК", "АЛ", "АМ", "АН", "АО", "АП", "АР", "АС", "АТ", "АУ", "АФ", "АХ", "АЦ", "АЧ", "АШ",
+	"АЩ", "АЭ", "АЮ", "АЯ", "БА", "ББ", "БВ", "БГ", "БД", "БЕ", "БЖ", "БЗ", "БИ", "БК", "БЛ", "БМ",
+	"БН", "БО", "БП", "БР", "БС", "БТ", "БУ", "БФ", "БХ", "БЦ", "БЧ", "БШ", "БЩ", "БЭ", "БЮ", "БЯ",
+	"ВА", "ВБ", "ВВ", "ВГ", "ВД", "ВЕ", "ВЖ", "ВЗ", "ВИ", "ВК", "ВЛ", "ВМ", "ВН", "ВО", "ВП", "ВР",
+];
+
+const LOWERCASE_CYRILLIC_VALUES: [&str; 100] = [
+	"а", "б", "в", "г", "д", "е", "ж", "з", "и", "к", "л", "м", "н", "о", "п", "р", "с", "т", "у",
+	"ф", "х", "ц", "ч", "ш", "щ", "э", "ю", "я", "аа", "аб", "ав", "аг", "ад", "ае", "аж", "аз",
+	"аи", "ак", "ал", "ам", "ан", "ао", "ап", "ар", "ас", "ат", "ау", "аф", "ах", "ац", "ач", "аш",
+	"ащ", "аэ", "аю", "ая", "ба", "бб", "бв", "бг", "бд", "бе", "бж", "бз", "би", "бк", "бл", "бм",
+	"бн", "бо", "бп", "бр", "бс", "бт", "бу", "бф", "бх", "бц", "бч", "бш", "бщ", "бэ", "бю", "бя",
+	"ва", "вб", "вв", "вг", "вд", "ве", "вж", "вз", "ви", "вк", "вл", "вм", "вн", "во", "вп", "вр",
+];
+
+#[test]
+fn test_cyrillic_upper_advance_100_iterations() {
+	let mut buf = String::new();
+	let counter = CyrillicUpper;
+	for (idx, &expected_value) in UPPERCASE_CYRILLIC_VALUES.iter().enumerate() {
+		let _ = counter.value_to_buffer(idx as u32 + 1, 1, &mut buf);
+		assert_eq!(expected_value, &buf);
+		buf.clear();
+	}
+
+	for (idx, &expected_value) in UPPERCASE_CYRILLIC_VALUES.iter().enumerate() {
+		assert_eq!(counter.string_to_value(expected_value), Some(idx as u32 + 1));
+	}
+}
+
+#[test]
+fn test_cyrillic_lower_advance_100_iterations() {
+	let mut buf = String::new();
+	let counter = CyrillicLower;
+	for (idx, &expected_value) in LOWERCASE_CYRILLIC_VALUES.iter().enumerate() {
+		let _ = counter.value_to_buffer(idx as u32 + 1, 1, &mut buf);
+		assert_eq!(expected_value, &buf);
+		buf.clear();
+	}
+
+	for (idx, &expected_value) in LOWERCASE_CYRILLIC_VALUES.iter().enumerate() {
+		assert_eq!(counter.string_to_value(expected_value), Some(idx as u32 + 1));
+	}
+}

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

@@ -0,0 +1,312 @@
+use super::*;
+
+#[test]
+fn test_new_creates_default_builder() {
+	let builder = CounterBuilder::new();
+	assert_eq!(builder.format(), CounterFormat::Digits(Digits));
+	assert_eq!(builder.start(), None);
+	assert_eq!(builder.step(), None);
+	assert_eq!(builder.width(), None);
+}
+
+#[test]
+fn test_try_set_format() {
+	let builder = CounterBuilder::new();
+
+	// Test all supported formats
+	let formats = [
+		("D", "  D  ", CounterFormat::Digits(Digits)),
+		("d", "  d  ", CounterFormat::Digits(Digits)),
+		("N", "  N  ", CounterFormat::Digits(Digits)),
+		("n", "  n  ", CounterFormat::Digits(Digits)),
+		("A", "  A  ", CounterFormat::AnsiUpper(AnsiUpper)),
+		("a", "  a  ", CounterFormat::AnsiLower(AnsiLower)),
+		("R", "  R  ", CounterFormat::RomanUpper(RomanUpper)),
+		("r", "  r  ", CounterFormat::RomanLower(RomanLower)),
+		("C", "  C  ", CounterFormat::CyrillicUpper(CyrillicUpper)),
+		("c", "  c  ", CounterFormat::CyrillicLower(CyrillicLower)),
+	];
+
+	for (without_space, with_space, expected) in formats.iter() {
+		let result = builder.try_set_format(without_space, 0..1, without_space);
+		assert_eq!(result.unwrap().format(), *expected,);
+		let result = builder.try_set_format(with_space, 0..5, with_space);
+		assert_eq!(result.unwrap().format(), *expected,);
+	}
+
+	let result = builder.try_set_format("", 0..0, "");
+	let error = result.unwrap_err();
+	assert_eq!(error.reason, "Empty counter kind");
+	assert_eq!(error.span, 0..0);
+	assert_eq!(error.expected, Some("one of D, d, N, n, A, a, R, r, C, c"));
+	assert_eq!(error.found, None);
+
+	let result =
+		CounterBuilder::new().try_set_format("  Ü-Wagen as examplé  ", 2..27, "  Ü-Wagen as examplé  ");
+	let error = result.unwrap_err();
+	assert_eq!(error.reason, "Unexpected counter kind");
+	assert_eq!(error.span, 4..25);
+	assert_eq!(error.expected, Some("one of D, d, N, n, A, a, R, r, C, c"));
+	assert_eq!(error.found, Some("Ü-Wagen as examplé"));
+}
+
+#[test]
+fn test_try_set_start() {
+	let builder = CounterBuilder::new();
+	let result = builder.try_set_start("n,5", Some((2..3, "5"))).unwrap();
+	assert_eq!(result.start(), Some(5));
+
+	let formats = [
+		("D", "25", 25),
+		("d", "25", 25),
+		("N", "25", 25),
+		("n", "25", 25),
+		("A", "AB", 28),
+		("a", "ab", 28),
+		("R", "IV", 4),
+		("r", "iv", 4),
+		("C", "АБ", 30),
+		("c", "аб", 30),
+	];
+
+	for (format, start, expected) in formats.iter() {
+		let builder = builder.try_set_format(format, 0..1, format).unwrap();
+		let result = builder.try_set_start(format, Some((2..4, start))).unwrap();
+		assert_eq!(result.start(), Some(*expected));
+	}
+
+	let result = builder.try_set_start("_", Some((2..3, "_"))).unwrap();
+	assert_eq!(result.start(), None);
+
+	let result = builder.try_set_start("  5  ", Some((0..5, "  5  "))).unwrap();
+	assert_eq!(result.start(), Some(5));
+
+	let result =
+		builder.try_set_start("  Ü-Wagen as examplé  ", Some((2..27, "  Ü-Wagen as examplé  ")));
+	let error = result.unwrap_err();
+	assert_eq!(error.span, 4..25);
+	assert_eq!(error.expected, Some("digit"));
+	assert_eq!(error.found, Some("Ü-Wagen as examplé"));
+}
+
+#[test]
+fn test_try_set_step() {
+	let builder = CounterBuilder::new();
+	let result = builder.try_set_step("5", Some((2..3, "5"))).unwrap();
+	assert_eq!(result.step(), Some(5));
+
+	let result = builder.try_set_step("_", Some((2..3, "_"))).unwrap();
+	assert_eq!(result.step(), None);
+
+	let result = builder.try_set_step("  5  ", Some((0..5, "  5  "))).unwrap();
+	assert_eq!(result.step(), Some(5));
+
+	let result =
+		builder.try_set_step("  Ü-Wagen as examplé  ", Some((2..27, "  Ü-Wagen as examplé  ")));
+	let error = result.unwrap_err();
+	assert_eq!(error.span, 4..25);
+	assert_eq!(error.expected, Some("digit"));
+	assert_eq!(error.found, Some("Ü-Wagen as examplé"));
+}
+
+#[test]
+fn test_try_set_width() {
+	let builder = CounterBuilder::new();
+	let result = builder.try_set_width("5", Some((2..3, "5"))).unwrap();
+	assert_eq!(result.width(), Some(5));
+
+	let result = builder.try_set_width("_", Some((2..3, "_"))).unwrap();
+	assert_eq!(result.width(), None);
+
+	let result = builder.try_set_width("  5  ", Some((0..5, "  5  "))).unwrap();
+	assert_eq!(result.width(), Some(5));
+
+	let result =
+		builder.try_set_width("  Ü-Wagen as examplé  ", Some((2..27, "  Ü-Wagen as examplé  ")));
+	let error = result.unwrap_err();
+	assert_eq!(error.span, 4..25);
+	assert_eq!(error.expected, Some("digit"));
+	assert_eq!(error.found, Some("Ü-Wagen as examplé"));
+}
+
+#[test]
+fn test_build_with_all_parameters() {
+	let builder = CounterBuilder::new()
+		.try_set_format("N,10,2,3", 0..1, "N")
+		.unwrap()
+		.try_set_start("N,10,2,3", Some((2..4, "10")))
+		.unwrap()
+		.try_set_step("N,10,2,3", Some((5..6, "2")))
+		.unwrap()
+		.try_set_width("N,10,2,3", Some((7..8, "3")))
+		.unwrap();
+	let counter = builder.build();
+	let mut buf = String::new();
+	counter.write_value(&mut buf).unwrap();
+	assert_eq!(buf, "010"); // Digits format, width 3
+}
+
+#[test]
+fn test_template_parse_no_counters() {
+	match Template::parse("plain text without counters") {
+		Err(TemplateError::NotCounter) => {}
+		_ => panic!("Expected NotCounter error"),
+	}
+}
+
+#[test]
+fn test_template_parse_counters() {
+	use super::{CounterFormat as CF, TemplatePart as TP};
+
+	// test includes escaped counters %%{R,3,4,5}
+	let inputs: [(&str, CF, CF, CF, CF, CF, Option<u32>, Option<u32>, Option<usize>); 8] = [
+		(
+			"Ü-%%{R,3,4,5}_%{D}_examplé_%{d}_你好_%{N}_слово_%{n}_word_%{A}.txt",
+			CF::Digits(Digits),
+			CF::Digits(Digits),
+			CF::Digits(Digits),
+			CF::Digits(Digits),
+			CF::AnsiUpper(AnsiUpper),
+			None,
+			None,
+			None,
+		),
+		(
+			"Ü-%%{R,3,4,5}_%{a}_examplé_%{R}_你好_%{r}_слово_%{C}_word_%{c}.txt",
+			CF::AnsiLower(AnsiLower),
+			CF::RomanUpper(RomanUpper),
+			CF::RomanLower(RomanLower),
+			CF::CyrillicUpper(CyrillicUpper),
+			CF::CyrillicLower(CyrillicLower),
+			None,
+			None,
+			None,
+		),
+		(
+			"Ü-%%{R,3,4,5}_%{D,3}_examplé_%{d,3}_你好_%{N,3}_слово_%{n,3}_word_%{A,3}.txt",
+			CF::Digits(Digits),
+			CF::Digits(Digits),
+			CF::Digits(Digits),
+			CF::Digits(Digits),
+			CF::AnsiUpper(AnsiUpper),
+			Some(3),
+			None,
+			None,
+		),
+		(
+			"Ü-%%{R,3,4,5}_%{a,c}_examplé_%{R,3}_你好_%{r,iii}_слово_%{C,3}_word_%{c,в}.txt",
+			CF::AnsiLower(AnsiLower),
+			CF::RomanUpper(RomanUpper),
+			CF::RomanLower(RomanLower),
+			CF::CyrillicUpper(CyrillicUpper),
+			CF::CyrillicLower(CyrillicLower),
+			Some(3),
+			None,
+			None,
+		),
+		(
+			"Ü-%%{R,3,4,5}_%{D,3,4}_examplé_%{d,3,4}_你好_%{N,3,4}_слово_%{n,3,4}_word_%{A,3,4}.txt",
+			CF::Digits(Digits),
+			CF::Digits(Digits),
+			CF::Digits(Digits),
+			CF::Digits(Digits),
+			CF::AnsiUpper(AnsiUpper),
+			Some(3),
+			Some(4),
+			None,
+		),
+		(
+			"Ü-%%{R,3,4,5}_%{a,c,14}_examplé_%{R,3,14}_你好_%{r,iii,14}_слово_%{C,3,14}_word_%{c,в,14}.txt",
+			CF::AnsiLower(AnsiLower),
+			CF::RomanUpper(RomanUpper),
+			CF::RomanLower(RomanLower),
+			CF::CyrillicUpper(CyrillicUpper),
+			CF::CyrillicLower(CyrillicLower),
+			Some(3),
+			Some(14),
+			None,
+		),
+		(
+			"Ü-%%{R,3,4,5}_%{D,3,4,55}_examplé_%{d,3,4,55}_你好_%{N,3,4,55}_слово_%{n,3,4,55}_word_%{A,3,4,55}.txt",
+			CF::Digits(Digits),
+			CF::Digits(Digits),
+			CF::Digits(Digits),
+			CF::Digits(Digits),
+			CF::AnsiUpper(AnsiUpper),
+			Some(3),
+			Some(4),
+			Some(55),
+		),
+		(
+			"Ü-%%{R,3,4,5}_%{a,c,14,6}_examplé_%{R,3,14,6}_你好_%{r,iii,14,6}_слово_%{C,3,14,6}_word_%{c,в,14,6}.txt",
+			CF::AnsiLower(AnsiLower),
+			CF::RomanUpper(RomanUpper),
+			CF::RomanLower(RomanLower),
+			CF::CyrillicUpper(CyrillicUpper),
+			CF::CyrillicLower(CyrillicLower),
+			Some(3),
+			Some(14),
+			Some(6),
+		),
+	];
+
+	for (idx, &(input, c1, c2, c3, c4, c5, start, step, width)) in inputs.iter().enumerate() {
+		let parsed = Template::parse(input).expect("Should parse a single counter");
+		assert_eq!(parsed.counter_count(), 5);
+
+		assert_eq!(
+			parsed.parts(),
+			&[
+				TP::Text("Ü-"),
+				TP::Text("%{"),
+				TP::Text("R,3,4,5}_"),
+				TP::CounterBuilder(CounterBuilder { format: c1, start, step, width }),
+				TP::Text("_example\u{301}_"),
+				TP::CounterBuilder(CounterBuilder { format: c2, start, step, width }),
+				TP::Text("_你好_"),
+				TP::CounterBuilder(CounterBuilder { format: c3, start, step, width }),
+				TP::Text("_слово_"),
+				TP::CounterBuilder(CounterBuilder { format: c4, start, step, width }),
+				TP::Text("_word_"),
+				TP::CounterBuilder(CounterBuilder { format: c5, start, step, width }),
+				TP::Text(".txt")
+			],
+			"Failed to pass {} index",
+			idx
+		);
+	}
+}
+
+#[test]
+fn test_template_parse_unclosed_delimiter() {
+	let input = "file_%{N.txt";
+	match Template::parse(input) {
+		Err(TemplateError::Parse(parse_err)) => {
+			assert_eq!(parse_err.reason, "Unclosed delimiter");
+			assert_eq!(parse_err.expected, Some("}"));
+		}
+		_ => panic!("Expected 'unclosed delimiter'."),
+	}
+}
+
+#[test]
+fn test_template_parse_extra_commas() {
+	let input = "some %{N,2,2,2,} text";
+	let result = Template::parse(input);
+	match result {
+		Err(TemplateError::Parse(parse_err)) => {
+			assert_eq!(
+				parse_err,
+				ParseError {
+					input: "some %{N,2,2,2,} text",
+					span: 14..15,
+					reason: "Extra arguments",
+					expected: Some("no additional arguments"),
+					found: None,
+				}
+			);
+		}
+		Ok(_) => panic!("Expected TemplateError::Parse"),
+		Err(_) => panic!("Expected TemplateError::Parse"),
+	}
+}

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

@@ -0,0 +1,310 @@
+//! This module provides functionality to generate file paths from input strings
+//! containing counters and template variables. It parses lines of text and
+//! produces either fixed filenames or filenames based on templates with
+//! dynamically updated counters.
+
+use std::{error::Error, fmt, fmt::Write, ops::Range, path::PathBuf};
+
+use unicode_width::UnicodeWidthStr;
+
+use super::{
+	counters::Counter,
+	filename_template::{ParseError, ParsedLine, TemplatePart},
+};
+
+#[cfg(test)]
+mod tests;
+
+/// Generates a sequence of file paths from an input lines of text.
+///
+/// Each line is parsed into either a fixed filename or a template containing
+/// counters. If the line contains a template, counters are created and
+/// dynamically updated across lines, ensuring consistent numbering and
+/// formatting.
+///
+/// For details on counter syntax and template parsing, see
+/// [`super::filename_template::Template::parse`].
+///
+/// If any line contains counters, the number of counters must remain consistent
+/// across all lines. If there's a mismatch in the expected and actual number of
+/// counters in any line, the function records a
+/// [`PathGenError::MismatchCounters`].
+///
+/// # Error Handling
+///
+/// Instead of stopping execution at the first encountered error, the function
+/// collects all errors in a [`Vec<PathGenError>`], allowing the caller to see
+/// every problematic line at once.
+///
+/// # Flexibility
+///   
+/// While the number of counters per line must be consistent, individual counter
+/// parameters (such as format, start, step, and width) may vary line by line.
+/// Counters update their values accordingly based on each line’s
+/// specifications.
+///
+/// # Arguments
+///
+/// * `lines` - An Iterator with elements representing either a fixed filename
+///   or a counter-based template.
+pub fn generate_names<'a, T>(lines: &mut T) -> Result<Vec<PathBuf>, Vec<PathGenError<'a>>>
+where
+	T: Iterator<Item = &'a str>,
+{
+	let mut results = Vec::new();
+	let mut errors = Vec::new();
+
+	let mut counters = Vec::new();
+
+	for (idx, line) in lines.enumerate() {
+		match ParsedLine::try_from(line) {
+			Ok(ParsedLine::Fixed(literal)) => {
+				results.push(PathBuf::from(literal));
+			}
+			Ok(ParsedLine::Countable(template)) => {
+				if counters.is_empty() {
+					counters.extend(template.parts().iter().filter_map(|part| match part {
+						TemplatePart::Text(_) => None,
+						TemplatePart::CounterBuilder(builder) => Some(builder.build()),
+					}))
+				}
+
+				if counters.len() != template.counter_count() {
+					errors.push(PathGenError::MismatchCounters {
+						expected: counters.len(),
+						got: template.counter_count(),
+						line_number: idx + 1,
+						content: line,
+					});
+					continue;
+				}
+
+				let mut out = String::new();
+				let mut counter_idx = 0;
+
+				for part in template.parts() {
+					match part {
+						TemplatePart::Text(text) => {
+							out.push_str(text);
+						}
+						TemplatePart::CounterBuilder(builder) => {
+							let counter = &mut counters[counter_idx];
+							counter.update_from(*builder);
+
+							let _ = counter.write_value(&mut out);
+							counter.advance();
+
+							counter_idx += 1;
+						}
+					}
+				}
+
+				results.push(PathBuf::from(out));
+			}
+			Err(parse_err) => {
+				errors.push(PathGenError::ParseError { line_number: idx + 1, error: parse_err });
+			}
+		}
+	}
+
+	if errors.is_empty() { Ok(results) } else { Err(errors) }
+}
+
+/// Represents errors that can occur during filename generation.
+#[derive(Debug, PartialEq, Eq)]
+pub enum PathGenError<'a> {
+	/// Error parsing a line into a valid counter template.
+	ParseError { line_number: usize, error: ParseError<'a> },
+
+	/// Error indicating mismatch between the expected and actual
+	/// number of counters at some line
+	MismatchCounters { expected: usize, got: usize, line_number: usize, content: &'a str },
+}
+
+impl fmt::Display for PathGenError<'_> {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		self.write_to(f, u16::MAX)
+	}
+}
+
+impl Error for PathGenError<'_> {}
+
+impl PathGenError<'_> {
+	/// Writes a formatted error message to a provided formatter or buffer, taking
+	/// into account terminal width for enhanced readability.
+	///
+	/// This method formats error messages differently depending on the available
+	/// width of the terminal, trimming and adjusting content to prevent line
+	/// overflow and maintain clarity.
+	///
+	/// # Arguments
+	///
+	/// * `out` - A mutable reference to an object implementing the `Write` trait
+	///   where the formatted error message will be written.
+	/// * `term_width` - The maximum width of the terminal, which determines how
+	///   the error message should be formatted.
+	pub fn write_to(&self, out: &mut impl Write, term_width: u16) -> fmt::Result {
+		// Calculates the number of digits in a given line number (for formatting
+		// alignment).
+		fn print_width(mut n: usize) -> usize {
+			let mut width = 1;
+			while n >= 10 {
+				n /= 10;
+				width += 1;
+			}
+			width
+		}
+
+		match self {
+			PathGenError::ParseError { line_number, error } => {
+				let Range { start, end } = error.span;
+
+				// Calculate the width needed for the line number.
+				let line_num_width = print_width(*line_number);
+
+				// Calculate the width needed to print the line number and
+				// separator (e.g., "182| ").
+				let available = term_width.saturating_sub(line_num_width as u16 + 2) as usize;
+
+				// Prepare the input string for display and calculate its full width.
+				let mut print_input = error.input;
+				let input_len_full = UnicodeWidthStr::width(print_input);
+				// Calculate the width of the string before the error start.
+				let mut input_len_left = UnicodeWidthStr::width(&print_input[..start]);
+				// Calculate the width of the error span, ensuring at least 1 character.
+				let input_len_span = UnicodeWidthStr::width(&print_input[start..end]).max(1);
+
+				// Constructs a hint string indicating expected and found values, if applicable.
+				let mut hint = String::new();
+				let mut hint_len = 0;
+
+				if let Some(exp) = &error.expected {
+					let _ = write!(hint, " Expected: '{}'", exp);
+					hint_len = UnicodeWidthStr::width(hint.as_str());
+				}
+				if let Some(fnd) = &error.found {
+					let _ = write!(hint, ", found: '{}'", fnd);
+					hint_len = UnicodeWidthStr::width(hint.as_str());
+				}
+
+				// Determines formatting style based on available width.
+				let mut could_use_pretty_print = false;
+				let mut prepend_dots = false;
+				let mut append_dots = false;
+
+				// Check if there's enough space to display the full input string and the error
+				// details
+				if available >= input_len_full && available >= input_len_left + input_len_span + hint_len {
+					could_use_pretty_print = true;
+				} else if available >= input_len_left + input_len_span + UnicodeWidthStr::width("…")
+					&& available >= input_len_left + input_len_span + hint_len
+				{
+					// The full input doesn't fit, but there's space for the left part, error span,
+					// ellipsis ("…") and the error details.
+
+					// Truncate the input string to the end of the error position
+					print_input = &print_input[..end];
+					// Indicate that an ellipsis should be appended to show truncation at the end
+					append_dots = true;
+					could_use_pretty_print = true;
+				} else if available
+					>= UnicodeWidthStr::width("…") + UnicodeWidthStr::width(&print_input[start..])
+					&& available >= UnicodeWidthStr::width("…") + input_len_span + hint_len
+				{
+					// There's space for an ellipsis, the error span from start, and hint
+					// Truncate the input string to start at the error position
+					print_input = &print_input[start..];
+					// Indicate that an ellipsis should be prepended to show truncation at the start
+					prepend_dots = true;
+
+					// Reset the left length since we're starting from the error position
+					input_len_left = 0;
+					could_use_pretty_print = true;
+				}
+
+				// Print the error header
+				write!(out, "Error: {}", error.reason)?;
+
+				if could_use_pretty_print {
+					// Write a blank line with alignment for the line number.
+					writeln!(out, "\n{:>offset$}|", "", offset = line_num_width)?;
+
+					// Write the line number and input, with optional ellipses.
+					write!(out, "{}| ", line_number)?;
+					if prepend_dots {
+						write!(out, "…")?;
+						// Adjust the input_len_left since we printed '…'
+						input_len_left = UnicodeWidthStr::width("…");
+					}
+					write!(out, "{}", print_input)?;
+					if append_dots {
+						write!(out, "…")?;
+					}
+					// Write the caret line indicating the error span and the hint.
+					writeln!(
+						out,
+						"\n{:>num_offset$}| {:>offset$}{:^>length$}{}\n",
+						"",
+						"",
+						"",
+						hint,
+						num_offset = line_num_width,
+						offset = input_len_left,
+						length = input_len_span
+					)
+				} else {
+					// Fallback: write the hint and the full input line.
+					writeln!(out, ".{}", hint)?;
+					writeln!(out, "{}| {}\n", line_number, error.input)
+				}
+			}
+
+			PathGenError::MismatchCounters { expected, got, line_number, content } => {
+				// Calculate the width needed for the line number.
+				let line_num_width = print_width(*line_number);
+
+				// Calculate the width needed to print the line number and
+				// separator (e.g., "182| ").
+				let available = term_width.saturating_sub(line_num_width as u16 + 2) as usize;
+
+				// Calculate the width of the content.
+				let input_len_span = UnicodeWidthStr::width(*content).max(1);
+
+				let hint = format!(" Expected {} counters, but got {}", expected, got);
+				let hint_len = UnicodeWidthStr::width(hint.as_str());
+
+				let mut could_use_pretty_print = false;
+
+				if available >= input_len_span + hint_len {
+					could_use_pretty_print = true;
+				}
+
+				// Print the error header
+				write!(out, "Error: Mismatch counter numbers")?;
+
+				if could_use_pretty_print {
+					// Write a blank line with alignment.
+					writeln!(out, "\n{:>offset$}|", "", offset = line_num_width)?;
+
+					// Write the line number and content.
+					writeln!(out, "{}| {}", line_number, content)?;
+
+					// Write the caret line spanning the entire content and the hint.
+					writeln!(
+						out,
+						"{:>num_offset$}| {:^>length$}{}\n",
+						"",
+						"",
+						hint,
+						num_offset = line_num_width,
+						length = input_len_span
+					)
+				} else {
+					// Fallback: write the hint and the content.
+					writeln!(out, ".{}", hint)?;
+					writeln!(out, "{}| {}\n", line_number, content)
+				}
+			}
+		}
+	}
+}

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

@@ -0,0 +1,144 @@
+use std::path::PathBuf;
+
+use super::*;
+
+// Helper to quickly compare Ok(Vec<PathBuf>)
+fn assert_ok_paths(result: Result<Vec<PathBuf>, Vec<PathGenError>>, expected: &[&str]) {
+	match result {
+		Ok(paths) => {
+			let actual: Vec<_> = paths.iter().map(|p| p.to_string_lossy()).collect();
+			let expected: Vec<_> = expected.iter().copied().map(String::from).collect();
+			assert_eq!(actual, expected, "Expected {:?}, got {:?}", expected, actual);
+		}
+		Err(errs) => panic!("Expected Ok(...), got Err({:?})", errs),
+	}
+}
+
+#[test]
+fn test_generate_names_no_counters() {
+	// All lines are just plain filenames (no counters)
+	let mut input = "file1.txt\nfile2.txt\nanother_file\n".lines();
+	let result = generate_names(&mut input);
+	// Should succeed, returning the same lines as PathBuf
+	assert_ok_paths(result, &["file1.txt", "file2.txt", "another_file"]);
+}
+
+#[test]
+fn test_generate_names() {
+	let input = [
+		// Start = 1, Step = 1, Width = 1
+		"file_%{D}_%{d}_%{N}_%{n}_%{A}_%{a}_%{R}_%{r}_%{C}_%{c}.txt", // print 1
+		"file_%{D}_%{d}_%{N}_%{n}_%{A}_%{a}_%{R}_%{r}_%{C}_%{c}.txt", // print 1
+		// Start = 5, Step = 1, Width = 1
+		"file_%{D,5}_%{d,5}_%{N,5}_%{n,5}_%{A,5}_%{a,5}_%{R,5}_%{r,5}_%{C,5}_%{c,5}.txt", // print 5
+		"file_%{D  }_%{d  }_%{N  }_%{n  }_%{A  }_%{a  }_%{R  }_%{r  }_%{C  }_%{c  }.txt", // print 6
+		// Start = 5 (two times), Step = 1, Width = 1
+		"file_%{D,5}_%{d,5}_%{N,5}_%{n,5}_%{A,5}_%{a,5}_%{R,5}_%{r,5}_%{C,5}_%{c,5}.txt", // print 5
+		"file_%{D,5}_%{d,5}_%{N,5}_%{n,5}_%{A,5}_%{a,5}_%{R,5}_%{r,5}_%{C,5}_%{c,5}.txt", // print 5 (again)
+		// Start = 5, Step = 3, Width = 1
+		"file_%{D,_,3}_%{d,_,3}_%{N,_,3}_%{n,_,3}_%{A,_,3}_%{a,_,3}_%{R,_,3}_%{r,_,3}_%{C,_,3}_%{c,_,3}.txt", // print 6
+		"file_%{D}_%{d}_%{N}_%{n}_%{A}_%{a}_%{R}_%{r}_%{C}_%{c}.txt", // print 9
+		// Start = 5, Step = 3, Width = 3
+		"file_%{D,_,_,3}_%{d,_,_,3}_%{N,_,_,3}_%{n,_,_,3}_%{A,_,_,3}_%{a,_,_,3}_%{R,_,_,3}_%{r,_,_,3}_%{C,_,_,3}_%{c,_,_,3}.txt", // print 012
+		"file_%{D}_%{d}_%{N}_%{n}_%{A}_%{a}_%{R}_%{r}_%{C}_%{c}.txt", // print 015
+		// Change counter formats, Start = 5, Step = 3, Width = 3
+		"file_%{A}_%{R}_%{C}_%{N}_%{a}_%{r}_%{c}_%{n}_%{D}_%{d}.txt", // print 018
+	]
+	.join("\n");
+
+	let result = generate_names(&mut input.lines());
+	assert_ok_paths(
+		result,
+		&[
+			"file_1_1_1_1_A_a_I_i_А_а.txt",
+			"file_2_2_2_2_B_b_II_ii_Б_б.txt",
+			"file_5_5_5_5_E_e_V_v_Д_д.txt",
+			"file_6_6_6_6_F_f_VI_vi_Е_е.txt",
+			"file_5_5_5_5_E_e_V_v_Д_д.txt",
+			"file_5_5_5_5_E_e_V_v_Д_д.txt",
+			"file_6_6_6_6_F_f_VI_vi_Е_е.txt",
+			"file_9_9_9_9_I_i_IX_ix_И_и.txt",
+			"file_012_012_012_012_00L_00l_XII_xii_00М_00м.txt",
+			"file_015_015_015_015_00O_00o_0XV_0xv_00П_00п.txt",
+			"file_00R_XVIII_00Т_018_00r_xviii_00т_018_018_018.txt",
+		],
+	);
+}
+
+#[test]
+fn test_generate_names_mismatch_counters() {
+	// First line has 2 counters, second line has 1
+	let input = "\
+        file_%{n}_%{a}.txt\n\
+        file_%{n}.txt\
+    ";
+	let result = generate_names(&mut input.lines()).unwrap_err();
+	// Should produce PathGenError::MismatchCounters
+	assert_eq!(
+		result,
+		&[PathGenError::MismatchCounters {
+			expected: 2,
+			got: 1,
+			line_number: 2,
+			content: "file_%{n}.txt",
+		}]
+	);
+}
+
+#[test]
+fn test_generate_names_parse_errors() {
+	let input = "\
+        Ü-Wagen examplé_слово_%{???}.txt\n\
+        Ü-Wagen examplé_слово_%{n,???}.txt\n\
+        Ü-Wagen examplé_слово_%{n,1,???}.txt\n\
+        Ü-Wagen examplé_слово_%{n,1,1,???}.txt\n\
+        Ü-Wagen examplé_слово_%{n,1,1,1,???}.txt\n\
+        Ü-Wagen examplé_слово_%{n,1,1,1,}.txt\n\
+        Ü-Wagen examplé_слово_%{n}.txt\n\
+        Ü-Wagen examplé_слово_%{n}_%{n}.txt
+    ";
+	let mut output = String::new();
+	generate_names(&mut input.lines()).unwrap_err().iter().for_each(|err| {
+		let _ = write!(output, "{err}");
+	});
+
+	let expected = "\
+Error: Unexpected counter kind
+ |
+1| Ü-Wagen examplé_слово_%{???}.txt
+ |                         ^^^ Expected: 'one of D, d, N, n, A, a, R, r, C, c', found: '???'
+
+Error: Invalid digit found in string
+ |
+2| Ü-Wagen examplé_слово_%{n,???}.txt
+ |                           ^^^ Expected: 'digit', found: '???'
+
+Error: Invalid digit found in string
+ |
+3| Ü-Wagen examplé_слово_%{n,1,???}.txt
+ |                             ^^^ Expected: 'digit', found: '???'
+
+Error: Invalid digit found in string
+ |
+4| Ü-Wagen examplé_слово_%{n,1,1,???}.txt
+ |                               ^^^ Expected: 'digit', found: '???'
+
+Error: Extra arguments
+ |
+5| Ü-Wagen examplé_слово_%{n,1,1,1,???}.txt
+ |                                ^^^^ Expected: 'no additional arguments'
+
+Error: Extra arguments
+ |
+6| Ü-Wagen examplé_слово_%{n,1,1,1,}.txt
+ |                                ^ Expected: 'no additional arguments'
+
+Error: Mismatch counter numbers
+ |
+8| Ü-Wagen examplé_слово_%{n}_%{n}.txt
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Expected 1 counters, but got 2
+
+";
+
+	assert_eq!(output, expected);
+}