From 938d05a6d534ba7547cdb93fb45108ef28e701c9 Mon Sep 17 00:00:00 2001 From: Sylvestre Ledru Date: Tue, 17 Jun 2025 22:47:11 +0200 Subject: [PATCH] l10n: port split for translation + add french --- src/uu/split/locales/en-US.ftl | 45 +++++++++ src/uu/split/locales/fr-FR.ftl | 61 ++++++++++++ src/uu/split/src/filenames.rs | 10 +- src/uu/split/src/number.rs | 3 +- src/uu/split/src/platform/unix.rs | 24 ++++- src/uu/split/src/platform/windows.rs | 16 +++- src/uu/split/src/split.rs | 136 +++++++++++++++------------ src/uu/split/src/strategy.rs | 12 ++- 8 files changed, 233 insertions(+), 74 deletions(-) create mode 100644 src/uu/split/locales/fr-FR.ftl diff --git a/src/uu/split/locales/en-US.ftl b/src/uu/split/locales/en-US.ftl index 0b870d633..4247eb5b9 100644 --- a/src/uu/split/locales/en-US.ftl +++ b/src/uu/split/locales/en-US.ftl @@ -14,3 +14,48 @@ split-after-help = Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; - l/K/N output Kth of N to stdout without splitting lines/records - r/N like 'l' but use round robin distribution - r/K/N likewise but only output Kth of N to stdout + +# Error messages +split-error-suffix-not-parsable = invalid suffix length: { $value } +split-error-suffix-contains-separator = invalid suffix { $value }, contains directory separator +split-error-suffix-too-small = the suffix length needs to be at least { $length } +split-error-multi-character-separator = multi-character separator { $separator } +split-error-multiple-separator-characters = multiple separator characters specified +split-error-filter-with-kth-chunk = --filter does not process a chunk extracted to stdout +split-error-invalid-io-block-size = invalid IO block size: { $size } +split-error-not-supported = --filter is currently not supported in this platform +split-error-invalid-number-of-chunks = invalid number of chunks: { $chunks } +split-error-invalid-chunk-number = invalid chunk number: { $chunk } +split-error-invalid-number-of-lines = invalid number of lines: { $error } +split-error-invalid-number-of-bytes = invalid number of bytes: { $error } +split-error-cannot-split-more-than-one-way = cannot split in more than one way +split-error-overflow = Overflow +split-error-output-file-suffixes-exhausted = output file suffixes exhausted +split-error-numerical-suffix-start-too-large = numerical suffix start value is too large for the suffix length +split-error-cannot-open-for-reading = cannot open { $file } for reading +split-error-would-overwrite-input = { $file } would overwrite input; aborting +split-error-cannot-determine-input-size = { $input }: cannot determine input size +split-error-cannot-determine-file-size = { $input }: cannot determine file size +split-error-cannot-read-from-input = { $input }: cannot read from input : { $error } +split-error-input-output-error = input/output error +split-error-unable-to-open-file = unable to open { $file }; aborting +split-error-unable-to-reopen-file = unable to re-open { $file }; aborting +split-error-file-descriptor-limit = at file descriptor limit, but no file descriptor left to close. Closed { $count } writers before. +split-error-shell-process-returned = Shell process returned { $code } +split-error-shell-process-terminated = Shell process terminated by signal + +# Help messages for command-line options +split-help-bytes = put SIZE bytes per output file +split-help-line-bytes = put at most SIZE bytes of lines per output file +split-help-lines = put NUMBER lines/records per output file +split-help-number = generate CHUNKS output files; see explanation below +split-help-additional-suffix = additional SUFFIX to append to output file names +split-help-filter = write to shell COMMAND; file name is $FILE (Currently not implemented for Windows) +split-help-elide-empty-files = do not generate empty output files with '-n' +split-help-numeric-suffixes-short = use numeric suffixes starting at 0, not alphabetic +split-help-numeric-suffixes = same as -d, but allow setting the start value +split-help-hex-suffixes-short = use hex suffixes starting at 0, not alphabetic +split-help-hex-suffixes = same as -x, but allow setting the start value +split-help-suffix-length = generate suffixes of length N (default 2) +split-help-verbose = print a diagnostic just before each output file is opened +split-help-separator = use SEP instead of newline as the record separator; '\\0' (zero) specifies the NUL character diff --git a/src/uu/split/locales/fr-FR.ftl b/src/uu/split/locales/fr-FR.ftl new file mode 100644 index 000000000..e8e70c280 --- /dev/null +++ b/src/uu/split/locales/fr-FR.ftl @@ -0,0 +1,61 @@ +split-about = Créer des fichiers de sortie contenant des sections consécutives ou entrelacées de l'entrée +split-usage = split [OPTION]... [ENTRÉE [PRÉFIXE]] +split-after-help = Sortir des morceaux de taille fixe d'ENTRÉE vers PREFIXEaa, PREFIXEab, ...; la taille par défaut est 1000, et le PRÉFIXE par défaut est 'x'. Sans ENTRÉE, ou quand ENTRÉE est -, lire l'entrée standard. + + L'argument TAILLE est un entier et une unité optionnelle (exemple: 10K est 10*1024). + Les unités sont K,M,G,T,P,E,Z,Y,R,Q (puissances de 1024) ou KB,MB,... (puissances de 1000). + Les préfixes binaires peuvent être utilisés aussi: KiB=K, MiB=M, et ainsi de suite. + + CHUNKS peut être: + + - N diviser en N fichiers basé sur la taille de l'entrée + - K/N sortir le Kème de N vers stdout + - l/N diviser en N fichiers sans diviser les lignes/enregistrements + - l/K/N sortir le Kème de N vers stdout sans diviser les lignes/enregistrements + - r/N comme 'l' mais utiliser la distribution round robin + - r/K/N pareillement mais ne sortir que le Kème de N vers stdout + +# Messages d'erreur +split-error-suffix-not-parsable = longueur de suffixe invalide : { $value } +split-error-suffix-contains-separator = suffixe invalide { $value }, contient un séparateur de répertoire +split-error-suffix-too-small = la longueur du suffixe doit être au moins { $length } +split-error-multi-character-separator = séparateur multi-caractères { $separator } +split-error-multiple-separator-characters = plusieurs caractères de séparateur spécifiés +split-error-filter-with-kth-chunk = --filter ne traite pas un chunk extrait vers stdout +split-error-invalid-io-block-size = taille de bloc IO invalide : { $size } +split-error-not-supported = --filter n'est actuellement pas supporté sur cette plateforme +split-error-invalid-number-of-chunks = nombre de chunks invalide : { $chunks } +split-error-invalid-chunk-number = numéro de chunk invalide : { $chunk } +split-error-invalid-number-of-lines = nombre de lignes invalide : { $error } +split-error-invalid-number-of-bytes = nombre d'octets invalide : { $error } +split-error-cannot-split-more-than-one-way = impossible de diviser de plus d'une façon +split-error-overflow = Débordement +split-error-output-file-suffixes-exhausted = suffixes de fichiers de sortie épuisés +split-error-numerical-suffix-start-too-large = la valeur de départ du suffixe numérique est trop grande pour la longueur du suffixe +split-error-cannot-open-for-reading = impossible d'ouvrir { $file } en lecture +split-error-would-overwrite-input = { $file } écraserait l'entrée ; abandon +split-error-cannot-determine-input-size = { $input } : impossible de déterminer la taille de l'entrée +split-error-cannot-determine-file-size = { $input } : impossible de déterminer la taille du fichier +split-error-cannot-read-from-input = { $input } : impossible de lire depuis l'entrée : { $error } +split-error-input-output-error = erreur d'entrée/sortie +split-error-unable-to-open-file = impossible d'ouvrir { $file } ; abandon +split-error-unable-to-reopen-file = impossible de rouvrir { $file } ; abandon +split-error-file-descriptor-limit = limite de descripteurs de fichiers atteinte, mais aucun descripteur de fichier à fermer. { $count } écrivains fermés auparavant. +split-error-shell-process-returned = Le processus shell a retourné { $code } +split-error-shell-process-terminated = Le processus shell a été terminé par un signal + +# Messages d'aide pour les options de ligne de commande +split-help-bytes = mettre TAILLE octets par fichier de sortie +split-help-line-bytes = mettre au maximum TAILLE octets de lignes par fichier de sortie +split-help-lines = mettre NOMBRE lignes/enregistrements par fichier de sortie +split-help-number = générer CHUNKS fichiers de sortie ; voir l'explication ci-dessous +split-help-additional-suffix = SUFFIXE supplémentaire à ajouter aux noms de fichiers de sortie +split-help-filter = écrire vers la COMMANDE shell ; le nom de fichier est $FILE (Actuellement non implémenté pour Windows) +split-help-elide-empty-files = ne pas générer de fichiers de sortie vides avec '-n' +split-help-numeric-suffixes-short = utiliser des suffixes numériques commençant à 0, pas alphabétiques +split-help-numeric-suffixes = identique à -d, mais permet de définir la valeur de départ +split-help-hex-suffixes-short = utiliser des suffixes hexadécimaux commençant à 0, pas alphabétiques +split-help-hex-suffixes = identique à -x, mais permet de définir la valeur de départ +split-help-suffix-length = générer des suffixes de longueur N (par défaut 2) +split-help-verbose = afficher un diagnostic juste avant l'ouverture de chaque fichier de sortie +split-help-separator = utiliser SEP au lieu de nouvelle ligne comme séparateur d'enregistrement ; '\\0' (zéro) spécifie le caractère NUL diff --git a/src/uu/split/src/filenames.rs b/src/uu/split/src/filenames.rs index 52b284a16..ec959063c 100644 --- a/src/uu/split/src/filenames.rs +++ b/src/uu/split/src/filenames.rs @@ -39,10 +39,12 @@ use crate::{ OPT_NUMERIC_SUFFIXES_SHORT, OPT_SUFFIX_LENGTH, }; use clap::ArgMatches; +use std::collections::HashMap; use std::path::is_separator; use thiserror::Error; use uucore::display::Quotable; use uucore::error::{UResult, USimpleError}; +use uucore::locale::{get_message, get_message_with_args}; /// The format to use for suffixes in the filename for each output chunk. #[derive(Clone, Copy)] @@ -82,15 +84,15 @@ pub struct Suffix { #[derive(Debug, Error)] pub enum SuffixError { /// Invalid suffix length parameter. - #[error("invalid suffix length: {}", .0.quote())] + #[error("{}", get_message_with_args("split-error-suffix-not-parsable", HashMap::from([("value".to_string(), .0.quote().to_string())])))] NotParsable(String), /// Suffix contains a directory separator, which is not allowed. - #[error("invalid suffix {}, contains directory separator", .0.quote())] + #[error("{}", get_message_with_args("split-error-suffix-contains-separator", HashMap::from([("value".to_string(), .0.quote().to_string())])))] ContainsSeparator(String), /// Suffix is not large enough to split into specified chunks - #[error("the suffix length needs to be at least {0}")] + #[error("{}", get_message_with_args("split-error-suffix-too-small", HashMap::from([("length".to_string(), .0.to_string())])))] TooSmall(usize), } @@ -315,7 +317,7 @@ impl<'a> FilenameIterator<'a> { FixedWidthNumber::new(radix, suffix.length, suffix.start).map_err(|_| { USimpleError::new( 1, - "numerical suffix start value is too large for the suffix length", + get_message("split-error-numerical-suffix-start-too-large"), ) })?, ) diff --git a/src/uu/split/src/number.rs b/src/uu/split/src/number.rs index 6de90cfe7..58401af20 100644 --- a/src/uu/split/src/number.rs +++ b/src/uu/split/src/number.rs @@ -16,6 +16,7 @@ //! [positional notation]: https://en.wikipedia.org/wiki/Positional_notation use std::error::Error; use std::fmt::{self, Display, Formatter}; +use uucore::locale::get_message; /// An overflow due to incrementing a number beyond its representable limit. #[derive(Debug)] @@ -23,7 +24,7 @@ pub struct Overflow; impl Display for Overflow { fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f, "Overflow") + write!(f, "{}", get_message("split-error-overflow")) } } diff --git a/src/uu/split/src/platform/unix.rs b/src/uu/split/src/platform/unix.rs index 446d8d667..4b2468d92 100644 --- a/src/uu/split/src/platform/unix.rs +++ b/src/uu/split/src/platform/unix.rs @@ -2,6 +2,7 @@ // // For the full copyright and license information, please view the LICENSE // file that was distributed with this source code. +use std::collections::HashMap; use std::env; use std::io::Write; use std::io::{BufWriter, Error, Result}; @@ -10,6 +11,7 @@ use std::process::{Child, Command, Stdio}; use uucore::error::USimpleError; use uucore::fs; use uucore::fs::FileInformation; +use uucore::locale::get_message_with_args; use uucore::show; /// A writer that writes to a shell_process' stdin @@ -110,11 +112,17 @@ impl Drop for FilterWriter { if return_code != 0 { show!(USimpleError::new( 1, - format!("Shell process returned {return_code}") + get_message_with_args( + "split-error-shell-process-returned", + HashMap::from([("code".to_string(), return_code.to_string())]) + ) )); } } else { - show!(USimpleError::new(1, "Shell process terminated by signal")); + show!(USimpleError::new( + 1, + get_message_with_args("split-error-shell-process-terminated", HashMap::new()) + )); } } } @@ -134,14 +142,22 @@ pub fn instantiate_current_writer( .create(true) .truncate(true) .open(Path::new(&filename)) - .map_err(|_| Error::other(format!("unable to open '{filename}'; aborting")))? + .map_err(|_| { + Error::other(get_message_with_args( + "split-error-unable-to-open-file", + HashMap::from([("file".to_string(), filename.to_string())]), + )) + })? } else { // re-open file that we previously created to append to it std::fs::OpenOptions::new() .append(true) .open(Path::new(&filename)) .map_err(|_| { - Error::other(format!("unable to re-open '{filename}'; aborting")) + Error::other(get_message_with_args( + "split-error-unable-to-reopen-file", + HashMap::from([("file".to_string(), filename.to_string())]), + )) })? }; Ok(BufWriter::new(Box::new(file) as Box)) diff --git a/src/uu/split/src/platform/windows.rs b/src/uu/split/src/platform/windows.rs index 576fa43c4..a1bfc84f2 100644 --- a/src/uu/split/src/platform/windows.rs +++ b/src/uu/split/src/platform/windows.rs @@ -2,10 +2,12 @@ // // For the full copyright and license information, please view the LICENSE // file that was distributed with this source code. +use std::collections::HashMap; use std::io::Write; use std::io::{BufWriter, Error, Result}; use std::path::Path; use uucore::fs; +use uucore::locale::get_message_with_args; /// Get a file writer /// @@ -23,13 +25,23 @@ pub fn instantiate_current_writer( .create(true) .truncate(true) .open(Path::new(&filename)) - .map_err(|_| Error::other(format!("unable to open '{filename}'; aborting")))? + .map_err(|_| { + Error::other(get_message_with_args( + "split-error-unable-to-open-file", + HashMap::from([("file".to_string(), filename.to_string())]), + )) + })? } else { // re-open file that we previously created to append to it std::fs::OpenOptions::new() .append(true) .open(Path::new(&filename)) - .map_err(|_| Error::other(format!("unable to re-open '{filename}'; aborting")))? + .map_err(|_| { + Error::other(get_message_with_args( + "split-error-unable-to-reopen-file", + HashMap::from([("file".to_string(), filename.to_string())]), + )) + })? }; Ok(BufWriter::new(Box::new(file) as Box)) } diff --git a/src/uu/split/src/split.rs b/src/uu/split/src/split.rs index 8736927a1..1a8eb5f4a 100644 --- a/src/uu/split/src/split.rs +++ b/src/uu/split/src/split.rs @@ -13,6 +13,7 @@ mod strategy; use crate::filenames::{FilenameIterator, Suffix, SuffixError}; use crate::strategy::{NumberType, Strategy, StrategyError}; use clap::{Arg, ArgAction, ArgMatches, Command, ValueHint, parser::ValueSource}; +use std::collections::HashMap; use std::env; use std::ffi::OsString; use std::fs::{File, metadata}; @@ -22,10 +23,10 @@ use std::path::Path; use thiserror::Error; use uucore::display::Quotable; use uucore::error::{FromIo, UIoError, UResult, USimpleError, UUsageError}; +use uucore::locale::{get_message, get_message_with_args}; use uucore::parser::parse_size::parse_size_u64; use uucore::format_usage; -use uucore::locale::get_message; use uucore::uio_error; static OPT_BYTES: &str = "bytes"; @@ -237,7 +238,7 @@ pub fn uu_app() -> Command { .long(OPT_BYTES) .allow_hyphen_values(true) .value_name("SIZE") - .help("put SIZE bytes per output file"), + .help(get_message("split-help-bytes")), ) .arg( Arg::new(OPT_LINE_BYTES) @@ -245,7 +246,7 @@ pub fn uu_app() -> Command { .long(OPT_LINE_BYTES) .allow_hyphen_values(true) .value_name("SIZE") - .help("put at most SIZE bytes of lines per output file"), + .help(get_message("split-help-line-bytes")), ) .arg( Arg::new(OPT_LINES) @@ -254,7 +255,7 @@ pub fn uu_app() -> Command { .allow_hyphen_values(true) .value_name("NUMBER") .default_value("1000") - .help("put NUMBER lines/records per output file"), + .help(get_message("split-help-lines")), ) .arg( Arg::new(OPT_NUMBER) @@ -262,7 +263,7 @@ pub fn uu_app() -> Command { .long(OPT_NUMBER) .allow_hyphen_values(true) .value_name("CHUNKS") - .help("generate CHUNKS output files; see explanation below"), + .help(get_message("split-help-number")), ) // rest of the arguments .arg( @@ -271,7 +272,7 @@ pub fn uu_app() -> Command { .allow_hyphen_values(true) .value_name("SUFFIX") .default_value("") - .help("additional SUFFIX to append to output file names"), + .help(get_message("split-help-additional-suffix")), ) .arg( Arg::new(OPT_FILTER) @@ -279,15 +280,13 @@ pub fn uu_app() -> Command { .allow_hyphen_values(true) .value_name("COMMAND") .value_hint(ValueHint::CommandName) - .help( - "write to shell COMMAND; file name is $FILE (Currently not implemented for Windows)", - ), + .help(get_message("split-help-filter")), ) .arg( Arg::new(OPT_ELIDE_EMPTY_FILES) .long(OPT_ELIDE_EMPTY_FILES) .short('e') - .help("do not generate empty output files with '-n'") + .help(get_message("split-help-elide-empty-files")) .action(ArgAction::SetTrue), ) .arg( @@ -298,9 +297,9 @@ pub fn uu_app() -> Command { OPT_NUMERIC_SUFFIXES, OPT_NUMERIC_SUFFIXES_SHORT, OPT_HEX_SUFFIXES, - OPT_HEX_SUFFIXES_SHORT + OPT_HEX_SUFFIXES_SHORT, ]) - .help("use numeric suffixes starting at 0, not alphabetic"), + .help(get_message("split-help-numeric-suffixes-short")), ) .arg( Arg::new(OPT_NUMERIC_SUFFIXES) @@ -311,10 +310,10 @@ pub fn uu_app() -> Command { OPT_NUMERIC_SUFFIXES, OPT_NUMERIC_SUFFIXES_SHORT, OPT_HEX_SUFFIXES, - OPT_HEX_SUFFIXES_SHORT + OPT_HEX_SUFFIXES_SHORT, ]) .value_name("FROM") - .help("same as -d, but allow setting the start value"), + .help(get_message("split-help-numeric-suffixes")), ) .arg( Arg::new(OPT_HEX_SUFFIXES_SHORT) @@ -324,9 +323,9 @@ pub fn uu_app() -> Command { OPT_NUMERIC_SUFFIXES, OPT_NUMERIC_SUFFIXES_SHORT, OPT_HEX_SUFFIXES, - OPT_HEX_SUFFIXES_SHORT + OPT_HEX_SUFFIXES_SHORT, ]) - .help("use hex suffixes starting at 0, not alphabetic"), + .help(get_message("split-help-hex-suffixes-short")), ) .arg( Arg::new(OPT_HEX_SUFFIXES) @@ -337,10 +336,10 @@ pub fn uu_app() -> Command { OPT_NUMERIC_SUFFIXES, OPT_NUMERIC_SUFFIXES_SHORT, OPT_HEX_SUFFIXES, - OPT_HEX_SUFFIXES_SHORT + OPT_HEX_SUFFIXES_SHORT, ]) .value_name("FROM") - .help("same as -x, but allow setting the start value"), + .help(get_message("split-help-hex-suffixes")), ) .arg( Arg::new(OPT_SUFFIX_LENGTH) @@ -348,12 +347,12 @@ pub fn uu_app() -> Command { .long(OPT_SUFFIX_LENGTH) .allow_hyphen_values(true) .value_name("N") - .help("generate suffixes of length N (default 2)"), + .help(get_message("split-help-suffix-length")), ) .arg( Arg::new(OPT_VERBOSE) .long(OPT_VERBOSE) - .help("print a diagnostic just before each output file is opened") + .help(get_message("split-help-verbose")) .action(ArgAction::SetTrue), ) .arg( @@ -363,7 +362,7 @@ pub fn uu_app() -> Command { .allow_hyphen_values(true) .value_name("SEP") .action(ArgAction::Append) - .help("use SEP instead of newline as the record separator; '\\0' (zero) specifies the NUL character"), + .help(get_message("split-help-separator")), ) .arg( Arg::new(OPT_IO_BLKSIZE) @@ -376,10 +375,7 @@ pub fn uu_app() -> Command { .default_value("-") .value_hint(ValueHint::FilePath), ) - .arg( - Arg::new(ARG_PREFIX) - .default_value("x") - ) + .arg(Arg::new(ARG_PREFIX).default_value("x")) } /// Parameters that control how a file gets split. @@ -420,27 +416,27 @@ enum SettingsError { Suffix(SuffixError), /// Multi-character (Invalid) separator - #[error("multi-character separator {}", .0.quote())] + #[error("{}", get_message_with_args("split-error-multi-character-separator", HashMap::from([("separator".to_string(), .0.quote().to_string())])))] MultiCharacterSeparator(String), /// Multiple different separator characters - #[error("multiple separator characters specified")] + #[error("{}", get_message("split-error-multiple-separator-characters"))] MultipleSeparatorCharacters, /// Using `--filter` with `--number` option sub-strategies that print Kth chunk out of N chunks to stdout /// K/N /// l/K/N /// r/K/N - #[error("--filter does not process a chunk extracted to stdout")] + #[error("{}", get_message("split-error-filter-with-kth-chunk"))] FilterWithKthChunkNumber, /// Invalid IO block size - #[error("invalid IO block size: {}", .0.quote())] + #[error("{}", get_message_with_args("split-error-invalid-io-block-size", HashMap::from([("size".to_string(), .0.quote().to_string())])))] InvalidIOBlockSize(String), /// The `--filter` option is not supported on Windows. #[cfg(windows)] - #[error("{OPT_FILTER} is currently not supported in this platform")] + #[error("{}", get_message("split-error-not-supported"))] NotSupported, } @@ -532,8 +528,9 @@ impl Settings { is_new: bool, ) -> io::Result>> { if platform::paths_refer_to_same_file(&self.input, filename) { - return Err(io::Error::other(format!( - "'{filename}' would overwrite input; aborting" + return Err(io::Error::other(get_message_with_args( + "split-error-would-overwrite-input", + HashMap::from([("file".to_string(), filename.quote().to_string())]), ))); } @@ -634,8 +631,9 @@ where } else if input == "-" { // STDIN stream that did not fit all content into a buffer // Most likely continuous/infinite input stream - return Err(io::Error::other(format!( - "{input}: cannot determine input size" + return Err(io::Error::other(get_message_with_args( + "split-error-cannot-determine-input-size", + HashMap::from([("input".to_string(), input.to_string())]), ))); } else { // Could be that file size is larger than set read limit @@ -659,8 +657,9 @@ where // Give up and return an error // TODO It might be possible to do more here // to address all possible file types and edge cases - return Err(io::Error::other(format!( - "{input}: cannot determine file size" + return Err(io::Error::other(get_message_with_args( + "split-error-cannot-determine-file-size", + HashMap::from([("input".to_string(), input.to_string())]), ))); } } @@ -706,9 +705,9 @@ struct ByteChunkWriter<'a> { impl<'a> ByteChunkWriter<'a> { fn new(chunk_size: u64, settings: &'a Settings) -> UResult { let mut filename_iterator = FilenameIterator::new(&settings.prefix, &settings.suffix)?; - let filename = filename_iterator - .next() - .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?; + let filename = filename_iterator.next().ok_or_else(|| { + USimpleError::new(1, get_message("split-error-output-file-suffixes-exhausted")) + })?; if settings.verbose { println!("creating file {}", filename.quote()); } @@ -744,10 +743,9 @@ impl Write for ByteChunkWriter<'_> { self.num_bytes_remaining_in_current_chunk = self.chunk_size; // Allocate the new file, since at this point we know there are bytes to be written to it. - let filename = self - .filename_iterator - .next() - .ok_or_else(|| io::Error::other("output file suffixes exhausted"))?; + let filename = self.filename_iterator.next().ok_or_else(|| { + io::Error::other(get_message("split-error-output-file-suffixes-exhausted")) + })?; if self.settings.verbose { println!("creating file {}", filename.quote()); } @@ -846,9 +844,9 @@ impl<'a> LineChunkWriter<'a> { settings: &Settings, filename_iterator: &mut FilenameIterator, ) -> io::Result>> { - let filename = filename_iterator - .next() - .ok_or_else(|| io::Error::other("output file suffixes exhausted"))?; + let filename = filename_iterator.next().ok_or_else(|| { + io::Error::other(get_message("split-error-output-file-suffixes-exhausted")) + })?; if settings.verbose { println!("creating file {}", filename.quote()); } @@ -957,9 +955,9 @@ impl ManageOutFiles for OutFiles { .map_err(|e| io::Error::other(format!("{e}")))?; let mut out_files: Self = Self::new(); for _ in 0..num_files { - let filename = filename_iterator - .next() - .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?; + let filename = filename_iterator.next().ok_or_else(|| { + USimpleError::new(1, get_message("split-error-output-file-suffixes-exhausted")) + })?; let maybe_writer = if is_writer_optional { None } else { @@ -1030,7 +1028,11 @@ impl ManageOutFiles for OutFiles { // If this fails - give up and propagate the error uucore::show_error!( - "at file descriptor limit, but no file descriptor left to close. Closed {count} writers before." + "{}", + get_message_with_args( + "split-error-file-descriptor-limit", + HashMap::from([("count".to_string(), count.to_string())]) + ) ); return Err(maybe_writer.err().unwrap().into()); } @@ -1169,7 +1171,13 @@ where Err(error) => { return Err(USimpleError::new( 1, - format!("{}: cannot read from input : {error}", settings.input), + get_message_with_args( + "split-error-cannot-read-from-input", + HashMap::from([ + ("input".to_string(), settings.input.clone()), + ("error".to_string(), error.to_string()), + ]), + ), )); } } @@ -1476,9 +1484,9 @@ where let mut line = &line[..]; loop { if remaining == 0 { - let filename = filename_iterator - .next() - .ok_or_else(|| USimpleError::new(1, "output file suffixes exhausted"))?; + let filename = filename_iterator.next().ok_or_else(|| { + USimpleError::new(1, get_message("split-error-output-file-suffixes-exhausted")) + })?; if settings.verbose { println!("creating file {}", filename.quote()); } @@ -1530,8 +1538,12 @@ fn split(settings: &Settings) -> UResult<()> { let r_box = if settings.input == "-" { Box::new(stdin()) as Box } else { - let r = File::open(Path::new(&settings.input)) - .map_err_context(|| format!("cannot open {} for reading", settings.input.quote()))?; + let r = File::open(Path::new(&settings.input)).map_err_context(|| { + get_message_with_args( + "split-error-cannot-open-for-reading", + HashMap::from([("file".to_string(), settings.input.quote().to_string())]), + ) + })?; Box::new(r) as Box }; let mut reader = if let Some(c) = settings.io_blksize { @@ -1575,7 +1587,11 @@ fn split(settings: &Settings) -> UResult<()> { // indicate that. A special error message needs to be // printed in that case. ErrorKind::Other => Err(USimpleError::new(1, format!("{e}"))), - _ => Err(uio_error!(e, "input/output error")), + _ => Err(uio_error!( + e, + "{}", + get_message("split-error-input-output-error") + )), }, } } @@ -1593,7 +1609,11 @@ fn split(settings: &Settings) -> UResult<()> { // indicate that. A special error message needs to be // printed in that case. ErrorKind::Other => Err(USimpleError::new(1, format!("{e}"))), - _ => Err(uio_error!(e, "input/output error")), + _ => Err(uio_error!( + e, + "{}", + get_message("split-error-input-output-error") + )), }, } } diff --git a/src/uu/split/src/strategy.rs b/src/uu/split/src/strategy.rs index a8526ada2..06960b2c8 100644 --- a/src/uu/split/src/strategy.rs +++ b/src/uu/split/src/strategy.rs @@ -7,9 +7,11 @@ use crate::{OPT_BYTES, OPT_LINE_BYTES, OPT_LINES, OPT_NUMBER}; use clap::{ArgMatches, parser::ValueSource}; +use std::collections::HashMap; use thiserror::Error; use uucore::{ display::Quotable, + locale::{get_message, get_message_with_args}, parser::parse_size::{ParseSizeError, parse_size_u64, parse_size_u64_max}, }; @@ -69,7 +71,7 @@ pub enum NumberTypeError { /// -n r/N /// -n r/K/N /// ``` - #[error("invalid number of chunks: {}", .0.quote())] + #[error("{}", get_message_with_args("split-error-invalid-number-of-chunks", HashMap::from([("chunks".to_string(), .0.quote().to_string())])))] NumberOfChunks(String), /// The chunk number was invalid. @@ -84,7 +86,7 @@ pub enum NumberTypeError { /// -n l/K/N /// -n r/K/N /// ``` - #[error("invalid chunk number: {}", .0.quote())] + #[error("{}", get_message_with_args("split-error-invalid-chunk-number", HashMap::from([("chunk".to_string(), .0.quote().to_string())])))] ChunkNumber(String), } @@ -198,11 +200,11 @@ pub enum Strategy { #[derive(Debug, Error)] pub enum StrategyError { /// Invalid number of lines. - #[error("invalid number of lines: {0}")] + #[error("{}", get_message_with_args("split-error-invalid-number-of-lines", HashMap::from([("error".to_string(), .0.to_string())])))] Lines(ParseSizeError), /// Invalid number of bytes. - #[error("invalid number of bytes: {0}")] + #[error("{}", get_message_with_args("split-error-invalid-number-of-bytes", HashMap::from([("error".to_string(), .0.to_string())])))] Bytes(ParseSizeError), /// Invalid number type. @@ -210,7 +212,7 @@ pub enum StrategyError { NumberType(NumberTypeError), /// Multiple chunking strategies were specified (but only one should be). - #[error("cannot split in more than one way")] + #[error("{}", get_message("split-error-cannot-split-more-than-one-way"))] MultipleWays, }