Struct PackTranslation 

pub struct PackTranslation { /* private fields */ }

Translation data for an entire pack.

Contains all translatable strings from a pack along with their translations and metadata about translation status.

Persistence and Format Versioning

This struct is serialized to JSON files for storage. There are currently two on-disk formats, picked by the version field:

• 0 — legacy format. Per-entry key/value_original/value_translated/ needs_retranslation/removed; no aut, and no src_lang, authors, glossary or version at the root. The user can opt back into this format from the translator UI to share translations with older tooling.
• 1 — current format. Adds version, src_lang, authors, glossary and aut, and uses the shorter per-entry field names (src/dst/retr/rem/aut).

On load, files without a version field are treated as v0 — i.e. existing translation hubs and legacy local files keep their format unless the user explicitly upgrades them.

Parent Translations

When a pack has dependencies, translations from parent mods are also loaded and used for auto-translation, ensuring consistent terminology across dependent mods.

Implementations

impl PackTranslation

pub fn relative_path(&self, game_key: &str) -> String

Path of this translation’s file, relative to a translations folder or the hub’s root.

Arguments

• game_key - Key of the game the translation belongs to.

Returns

{game_key}/{pack_name}/{file_name}, with / separators so it’s also valid as a repository path.

pub fn stats(&self) -> TranslationStats

Line counts of this translation, ignoring lines removed from the pack.

pub fn hub_submission(&self, game_key: &str) -> HubSubmission

Build the submission of this translation to the Translation Hub.

Arguments

• game_key - Key of the game the translation belongs to.

Returns

The paths, branch and texts of the submission.

pub fn submit_to_hub( &self, client: &GitHubClient, hub_owner: &str, hub_name: &str, game_key: &str, content: &str, ) -> Result<SubmissionResult>

Submit this translation to the Translation Hub as a pull request, or update its open one.

The commit goes on top of the hub’s current default branch, in the hub itself if the user can push to it, or in the user’s fork otherwise (created if needed). Each submission replaces the previous one in the translation’s branch, so an open pull request always shows a single commit.

Arguments

• client - GitHub client, signed in as the submitting user.
• hub_owner - Owner of the Translation Hub repository.
• hub_name - Name of the Translation Hub repository.
• game_key - Key of the game the translation belongs to.
• content - Contents of the translation’s file, as saved on disk.

Returns

The pull request’s page, and whether it was newly opened.

Errors

Returns an error if the hub can’t be found, the fork isn’t ready in time, or any GitHub request fails.

impl PackTranslation

pub fn version(&self) -> &u32

On-disk format version. See the struct-level docs for the meaning of each value. New in-memory translations default to v1; legacy files without this field are treated as v0.

pub fn language(&self) -> &String

Target language code for translations (e.g., “ES”, “DE”, “FR”).

pub fn src_lang(&self) -> &String

Source language code these translations are based on (e.g., “EN”).

Missing from the old format; defaults to DEFAULT_SRC_LANG when loading legacy files.

pub fn pack_name(&self) -> &String

Name of the pack these translations belong to.

pub fn authors(&self) -> &Vec<String>

Names of the translators who contributed to this translation.

Missing from the old format; defaults to an empty list when loading legacy files.

pub fn glossary(&self) -> &BTreeMap<String, String>

Per-pack glossary of preferred translations for specific source terms.

Stored as a sorted map (source term → preferred translation) so the JSON output is deterministic. v1+ only; dropped when saving as v0.

pub fn translations(&self) -> &HashMap<String, Translation>

Map of Loc keys to their translation data.

Keys are the original Loc entry keys from the pack.

impl PackTranslation

pub fn version_mut(&mut self) -> &mut u32

On-disk format version. See the struct-level docs for the meaning of each value. New in-memory translations default to v1; legacy files without this field are treated as v0.

pub fn language_mut(&mut self) -> &mut String

Target language code for translations (e.g., “ES”, “DE”, “FR”).

pub fn src_lang_mut(&mut self) -> &mut String

Source language code these translations are based on (e.g., “EN”).

Missing from the old format; defaults to DEFAULT_SRC_LANG when loading legacy files.

pub fn pack_name_mut(&mut self) -> &mut String

Name of the pack these translations belong to.

pub fn authors_mut(&mut self) -> &mut Vec<String>

Names of the translators who contributed to this translation.

Missing from the old format; defaults to an empty list when loading legacy files.

pub fn glossary_mut(&mut self) -> &mut BTreeMap<String, String>

Per-pack glossary of preferred translations for specific source terms.

Stored as a sorted map (source term → preferred translation) so the JSON output is deterministic. v1+ only; dropped when saving as v0.

pub fn translations_mut(&mut self) -> &mut HashMap<String, Translation>

Map of Loc keys to their translation data.

Keys are the original Loc entry keys from the pack.

impl PackTranslation

pub fn set_version(&mut self, val: u32) -> &mut Self

On-disk format version. See the struct-level docs for the meaning of each value. New in-memory translations default to v1; legacy files without this field are treated as v0.

pub fn set_language(&mut self, val: String) -> &mut Self

Target language code for translations (e.g., “ES”, “DE”, “FR”).

pub fn set_src_lang(&mut self, val: String) -> &mut Self

Source language code these translations are based on (e.g., “EN”).

Missing from the old format; defaults to DEFAULT_SRC_LANG when loading legacy files.

pub fn set_pack_name(&mut self, val: String) -> &mut Self

Name of the pack these translations belong to.

pub fn set_authors(&mut self, val: Vec<String>) -> &mut Self

Names of the translators who contributed to this translation.

Missing from the old format; defaults to an empty list when loading legacy files.

pub fn set_glossary(&mut self, val: BTreeMap<String, String>) -> &mut Self

Per-pack glossary of preferred translations for specific source terms.

Stored as a sorted map (source term → preferred translation) so the JSON output is deterministic. v1+ only; dropped when saving as v0.

pub fn set_translations( &mut self, val: HashMap<String, Translation>, ) -> &mut Self

Map of Loc keys to their translation data.

Keys are the original Loc entry keys from the pack.

impl PackTranslation

pub fn new( paths: &[PathBuf], pack: &Pack, game_key: &str, src_lang: &str, language: &str, dependencies: &Dependencies, base_english: &HashMap<String, String>, base_local_fixes: &HashMap<String, String>, ) -> Result<Self>

pub fn sort_and_merge_locs_for_translation(locs: &mut [&RFile]) -> Result<Loc>

pub fn vanilla_loc_file_name(src_lang: &str) -> String

Name of the TSV with the vanilla texts of a source language.

Arguments

• src_lang - Source language code (e.g. “EN”, “SP”).

Returns

VANILLA_LOC_NAME_EN for English, vanilla_{src_lang}.tsv for any other language.

pub fn generate_vanilla_loc( game: &GameInfo, game_path: &Path, src_lang: &str, dest_folder: &Path, ) -> Result<bool>

Generates the vanilla texts TSV of a language from the game’s locale packs.

The file is kept so it can still be used after the game stops shipping that language, and it’s only regenerated when the locale packs are newer than it.

Arguments

• game - Game the locale packs belong to.
• game_path - Path of the game’s installation.
• src_lang - Language code of the locale packs to read (e.g. “SP”).
• dest_folder - Folder where the TSV is written.

Returns

true if the game has locale packs for the language (so the TSV is up to date), false otherwise.

Errors

Returns an error if the game’s data folder can’t be read, or if the packs can’t be read or the TSV written.

pub fn apply(&self, _pack: &mut Pack) -> Result<()>

This function applies a PackTranslation to a Pack.

pub fn load( paths: &[PathBuf], pack_name: &str, game_key: &str, src_lang: &str, language: &str, ) -> Result<Self>

This function loads a PackTranslation to memory from either a local json file, or a remote one.

Files written in the old format (with key, value_original, value_translated, needs_retranslation, removed and without src_lang/authors/glossary/aut) are accepted transparently via serde aliases and field defaults — no explicit version probing needed.

On-disk layout:

• v1+ → {game_key}/{pack_name}/{src_lang}-{language}.json.
• v0 → {game_key}/{pack_name}/{language}.json (no source language in the path, since v0 implicitly assumed English).

load_json will probe both paths in that order so users who upgrade RPFM keep finding their existing translations even if they were saved before this refactor.

pub fn file_name(&self) -> String

Name of the file this translation is saved as, which depends on its format version.

Returns

{src_lang}-{language}.json for v1+, or the legacy {language}.json for v0.

pub fn save(&mut self, path: &Path, game_key: &str) -> Result<()>

This function saves a PackTranslation from memory to a .json file with the provided path.

The on-disk format depends on Self::version: 0 writes the legacy shape, 1 (or higher) writes the current shape. Downgrading v1 → v0 drops fields that don’t exist in v0 (src_lang, authors, glossary and the per-entry aut flag).

The filename also depends on the version: v1+ uses {src_lang}-{language}.json so translations from different source languages live side-by-side; v0 keeps the legacy {language}.json because the old format had no concept of source language.

pub fn definition() -> Definition

pub fn from_table(&mut self, table: &TableInMemory) -> Result<()>

pub fn to_table(&self) -> Result<TableInMemory>

pub fn glossary_definition() -> Definition

Definition of the per-pack glossary table, used to drive the UI table view.

The glossary is a flat two-column table: a source term (used as the key) and the preferred translation for it.

pub fn glossary_to_table(&self) -> Result<TableInMemory>

Materialize the glossary as an editable TableInMemory for the UI.

pub fn glossary_from_table(&mut self, table: &TableInMemory) -> Result<()>

Replace the glossary with the contents of table. Empty source cells are dropped so a trailing blank row left over from the UI doesn’t end up in the saved JSON.

Trait Implementations

impl Clone for PackTranslation

fn clone(&self) -> PackTranslation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PackTranslation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PackTranslation

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PackTranslation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PackTranslation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.