fix title/progression based on expansion_type and name rules

Author: feored

Cargo.toml

@@ -15,3 +15,5 @@ bit = "0.1.1"
 log = "0.4"
 serde = { version = "1", features = ["derive"] }
 serde_with = "3"
+unicode-script = "0.5.8"
+unicode-segmentation = "1"

src/character/mod.rs

@@ -1,7 +1,8 @@
 //! Character section model and format-specific codecs.
 //!
 //! [`title_for_progression_d2r`] and [`Character::title_d2r`] implement the default D2R
-//! title rules. Modded title systems are out of scope.
+//! title rules. `Save::title_d2r()` is the canonical entry point. Modded title systems
+//! are out of scope.
 
 use std::fmt;
 
@@ -252,12 +253,13 @@ impl Character {
 
     /// Return the default D2R title for this character state.
     ///
+    /// Pass the canonical [`crate::ExpansionType`] from [`crate::Save::expansion_type`].
     /// Mods may use different title rules.
-    pub fn title_d2r(&self) -> Option<&'static str> {
+    pub fn title_d2r(&self, expansion_type: crate::ExpansionType) -> Option<&'static str> {
         title_for_progression_d2r(
             self.progression,
             self.class,
-            self.status.expansion,
+            !matches!(expansion_type, crate::ExpansionType::Classic),
             self.status.hardcore,
         )
     }

src/character/tests.rs

@@ -1,7 +1,8 @@
 #[cfg(test)]
 mod tests {
-    use crate::character::v105::{MODE_ROTW, OFFSET_MODE_MARKER};
+    use crate::ExpansionType;
     use crate::character::*;
+    use crate::character::v105::{MODE_ROTW, OFFSET_MODE_MARKER};
     use crate::format::FormatId;
 
     #[test]
@@ -182,34 +183,34 @@ mod tests {
         character.set_legacy_expansion_flag(false);
         character.set_hardcore(false);
         character.progression = 4;
-        assert_eq!(character.title_d2r(), Some("Dame"));
+        assert_eq!(character.title_d2r(ExpansionType::Classic), Some("Dame"));
 
         character.set_legacy_expansion_flag(false);
         character.set_hardcore(true);
         character.progression = 12;
-        assert_eq!(character.title_d2r(), Some("Queen"));
+        assert_eq!(character.title_d2r(ExpansionType::Classic), Some("Queen"));
 
         character.set_legacy_expansion_flag(true);
         character.set_hardcore(false);
         character.progression = 10;
-        assert_eq!(character.title_d2r(), Some("Champion"));
+        assert_eq!(character.title_d2r(ExpansionType::Expansion), Some("Champion"));
 
         character.set_legacy_expansion_flag(true);
         character.set_hardcore(true);
         character.progression = 15;
-        assert_eq!(character.title_d2r(), Some("Guardian"));
+        assert_eq!(character.title_d2r(ExpansionType::Expansion), Some("Guardian"));
 
         // Warlock uses male title variants.
         character.class = Class::Warlock;
         character.set_legacy_expansion_flag(false);
         character.set_hardcore(false);
         character.progression = 12;
-        assert_eq!(character.title_d2r(), Some("Baron"));
+        assert_eq!(character.title_d2r(ExpansionType::Classic), Some("Baron"));
 
         // Expansion normally skips these values.
         character.set_legacy_expansion_flag(true);
         character.set_hardcore(false);
         character.progression = 9;
-        assert_eq!(character.title_d2r(), None);
+        assert_eq!(character.title_d2r(ExpansionType::Expansion), None);
     }
 }

src/format/compatibility.rs

@@ -16,7 +16,7 @@ fn class_compatibility_issues(
                     code: CompatibilityCode::UnknownClassRequiresKnownTarget,
                     blocking: true,
                     message: format!(
-                        "Unknown class id {class_id} cannot be safely converted to known format {target:?}."
+                        "Unknown class id {class_id} cannot be converted to {target:?}."
                     ),
                 });
             }
@@ -26,15 +26,15 @@ fn class_compatibility_issues(
                 issues.push(CompatibilityIssue {
                     code: CompatibilityCode::WarlockRequiresRotW,
                     blocking: true,
-                    message: "Warlock class is only supported in RotW editions.".to_string(),
+                    message: "Warlock can only be encoded as RotW.".to_string(),
                 });
             }
 
             if expansion_type != ExpansionType::RotW {
                 issues.push(CompatibilityIssue {
                     code: CompatibilityCode::WarlockRequiresRotWExpansion,
                     blocking: true,
-                    message: "Warlock class requires RotW expansion type.".to_string(),
+                    message: "Warlock requires RotW expansion mode.".to_string(),
                 });
             }
         }
@@ -43,8 +43,7 @@ fn class_compatibility_issues(
                 issues.push(CompatibilityIssue {
                     code: CompatibilityCode::ExpansionClassRequiresExpansionMode,
                     blocking: true,
-                    message: "Druid and Assassin classes are not valid in Classic mode."
-                        .to_string(),
+                    message: "Druid and Assassin cannot be encoded in Classic mode.".to_string(),
                 });
             }
         }
@@ -64,8 +63,7 @@ pub(crate) fn compatibility_issues(save: &Save, target: FormatId) -> Vec<Compati
         issues.push(CompatibilityIssue {
             code: CompatibilityCode::RotWExpansionRequiresRotWEdition,
             blocking: true,
-            message: "Cannot encode RotW expansion type as v99 or other non-RotW editions."
-                .to_string(),
+            message: "RotW expansion mode cannot be encoded to non-RotW formats.".to_string(),
         });
     }
 

src/format/summary.rs

@@ -1,7 +1,5 @@
 use crate::character::decode_for_format as decode_character_for_format;
-use crate::{
-    ExpansionType, IssueKind, IssueSeverity, ParseHardError, ParseIssue, SaveSummary, Strictness,
-};
+use crate::{IssueKind, IssueSeverity, ParseHardError, ParseIssue, SaveSummary, Strictness};
 
 use super::layout::{
     expansion_type_from_decoded_character, layout_for_decode, push_issue, range_readable,
@@ -87,18 +85,10 @@ pub(crate) fn summarize(
         Ok(character) => {
             let expansion_type =
                 expansion_type_from_decoded_character(selected_layout.format_id(), &character);
+            let title = character.title_d2r(expansion_type).map(str::to_string);
             let class = character.class;
-            let progression = character.progression;
-            let is_hardcore = character.is_hardcore();
             let level = character.level();
             let name = character.name;
-            let title = crate::character::title_for_progression_d2r(
-                progression,
-                class,
-                !matches!(expansion_type, ExpansionType::Classic),
-                is_hardcore,
-            )
-            .map(str::to_string);
             summary.expansion_type = Some(expansion_type);
             summary.name = Some(name);
             summary.class = Some(class);

src/format/tests.rs

@@ -153,7 +153,9 @@ fn encode_v99_rejects_rotw_expansion_type() {
     let error = encode(&save, FormatId::V99, CompatibilityChecks::Enforce)
         .expect_err("v99 should reject RotW expansion type");
     assert!(
-        error.to_string().contains("Cannot encode RotW expansion type as v99"),
+        error
+            .to_string()
+            .contains("RotW expansion mode cannot be encoded to non-RotW formats"),
         "unexpected error message: {error}"
     );
 }
@@ -205,7 +207,7 @@ fn summarize_extracts_core_fields_v99() {
     assert_eq!(summary.name.as_deref(), Some(parsed.save.character.name.as_str()));
     assert_eq!(summary.class, Some(parsed.save.character.class));
     assert_eq!(summary.level, Some(parsed.save.character.level()));
-    assert_eq!(summary.title, parsed.save.character.title_d2r().map(str::to_string));
+    assert_eq!(summary.title, parsed.save.title_d2r().map(str::to_string));
     assert!(summary.issues.is_empty());
 }
 

src/lib.rs

@@ -438,6 +438,11 @@ impl Save {
         format::compatibility_issues(self, target)
     }
 
+    /// Return the default D2R title for this save using the canonical expansion mode.
+    pub fn title_d2r(&self) -> Option<&'static str> {
+        self.character.title_d2r(self.expansion_type())
+    }
+
     /// Validate the current save using backend-owned canonical rules.
     pub fn validate(&self) -> validation::ValidationReport {
         validation::build_validation_report(self)
@@ -671,6 +676,16 @@ mod tests {
         assert_eq!(save.game_edition(), None);
     }
 
+    #[test]
+    fn save_title_uses_canonical_expansion_type() {
+        let mut save = Save::new(FormatId::V105, Class::Amazon);
+        save.set_expansion_type(ExpansionType::Classic);
+        save.character.set_legacy_expansion_flag(true);
+        save.character.progression = 4;
+
+        assert_eq!(save.title_d2r(), Some("Dame"));
+    }
+
     #[test]
     fn set_expansion_type_updates_v105_mode_marker_without_touching_status_bit() {
         let mut save = Save::new(FormatId::V105, Class::Amazon);