style: Apply cargo fmt formatting

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: alanbld

crates/utf8dok-ooxml/src/archive.rs

@@ -474,7 +474,10 @@ mod tests {
 
         // Both methods should return the same result
         assert_eq!(archive.contains("test.xml"), archive.has_file("test.xml"));
-        assert_eq!(archive.contains("missing.xml"), archive.has_file("missing.xml"));
+        assert_eq!(
+            archive.contains("missing.xml"),
+            archive.has_file("missing.xml")
+        );
     }
 
     #[test]
@@ -559,8 +562,7 @@ mod tests {
         let mut manifest = Manifest::new();
         manifest.add_element(
             "source",
-            crate::manifest::ElementMeta::new("source.adoc")
-                .with_hash("abc123"),
+            crate::manifest::ElementMeta::new("source.adoc").with_hash("abc123"),
         );
 
         // Set manifest
@@ -639,14 +641,8 @@ mod tests {
         archive.write_utf8dok_string("utf8dok.toml", "[template]\npath = \"t.dotx\"");
 
         let mut manifest = Manifest::new();
-        manifest.add_element(
-            "source",
-            crate::manifest::ElementMeta::new("source.adoc"),
-        );
-        manifest.add_element(
-            "config",
-            crate::manifest::ElementMeta::new("utf8dok.toml"),
-        );
+        manifest.add_element("source", crate::manifest::ElementMeta::new("source.adoc"));
+        manifest.add_element("config", crate::manifest::ElementMeta::new("utf8dok.toml"));
         archive.set_manifest(&manifest).unwrap();
 
         // Verify all parts exist

crates/utf8dok-ooxml/src/conversion.rs

@@ -635,10 +635,7 @@ mod tests {
 
     #[test]
     fn test_generate_anchor_special_chars() {
-        assert_eq!(
-            generate_anchor("What's New?"),
-            Some("whats-new".into())
-        );
+        assert_eq!(generate_anchor("What's New?"), Some("whats-new".into()));
         assert_eq!(
             generate_anchor("C++ Programming"),
             Some("c-programming".into())
@@ -668,10 +665,7 @@ mod tests {
     fn test_extract_plain_text_formatted() {
         let inlines = vec![
             Inline::Text("Plain ".to_string()),
-            Inline::Format(
-                FormatType::Bold,
-                Box::new(Inline::Text("bold".to_string())),
-            ),
+            Inline::Format(FormatType::Bold, Box::new(Inline::Text("bold".to_string()))),
             Inline::Text(" text".to_string()),
         ];
         assert_eq!(extract_plain_text(&inlines), "Plain bold text");
@@ -802,7 +796,10 @@ mod tests {
         // Verify both styles and relationships are accessible
         assert!(ctx.styles.is_some());
         assert!(ctx.relationships.is_some());
-        assert_eq!(ctx.relationships.unwrap().get("rId1"), Some("https://example.com"));
+        assert_eq!(
+            ctx.relationships.unwrap().get("rId1"),
+            Some("https://example.com")
+        );
     }
 
     #[test]
@@ -1099,7 +1096,9 @@ mod tests {
         // Unicode-only text may return None if all chars are filtered
         if let Some(a) = anchor {
             // If it returns Some, should be ASCII-safe
-            assert!(a.chars().all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_'));
+            assert!(a
+                .chars()
+                .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_'));
         }
         // Not panicking is the main test
     }

crates/utf8dok-ooxml/src/extract.rs

@@ -1986,7 +1986,10 @@ mod tests {
         assert_eq!(metadata.title, Some("Full Document".to_string()));
         assert_eq!(metadata.author, Some("Test Author".to_string()));
         assert_eq!(metadata.subject, Some("Test Subject".to_string()));
-        assert_eq!(metadata.keywords, Some("test, document, metadata".to_string()));
+        assert_eq!(
+            metadata.keywords,
+            Some("test, document, metadata".to_string())
+        );
         assert_eq!(metadata.revision, Some("5".to_string()));
         assert_eq!(metadata.created, Some("2025-01-01T00:00:00Z".to_string()));
         assert_eq!(metadata.modified, Some("2025-06-15T12:00:00Z".to_string()));
@@ -2009,8 +2012,7 @@ mod tests {
 
     #[test]
     fn test_extractor_with_force_parse_builder() {
-        let extractor = AsciiDocExtractor::new()
-            .with_force_parse(true);
+        let extractor = AsciiDocExtractor::new().with_force_parse(true);
 
         assert!(extractor.force_parse);
     }

crates/utf8dok-ooxml/src/image.rs

@@ -338,7 +338,7 @@ mod tests {
         assert_eq!(emu_to_pixels(4762), 0); // Just under 0.5
         assert_eq!(emu_to_pixels(4763), 1); // Just over 0.5, rounds to 1
         assert_eq!(emu_to_pixels(9525), 1); // Exactly 1 pixel
-        // 9525 * 1.5 = 14287.5, so 14288 is just over 1.5
+                                            // 9525 * 1.5 = 14287.5, so 14288 is just over 1.5
         assert_eq!(emu_to_pixels(14288), 2); // Just over 1.5 pixels rounds to 2
         assert_eq!(emu_to_pixels(14287), 1); // Just under 1.5 pixels rounds to 1
     }
@@ -383,9 +383,15 @@ mod tests {
 
     #[test]
     fn test_content_type_unknown_extension() {
-        assert_eq!(content_type_for_extension("xyz"), "application/octet-stream");
+        assert_eq!(
+            content_type_for_extension("xyz"),
+            "application/octet-stream"
+        );
         assert_eq!(content_type_for_extension(""), "application/octet-stream");
-        assert_eq!(content_type_for_extension("unknown"), "application/octet-stream");
+        assert_eq!(
+            content_type_for_extension("unknown"),
+            "application/octet-stream"
+        );
     }
 
     #[test]
@@ -435,7 +441,12 @@ mod tests {
         assert!(img.is_anchor());
         assert!(!img.is_inline());
 
-        if let ImagePosition::Anchor { horizontal, vertical, wrap } = img.position {
+        if let ImagePosition::Anchor {
+            horizontal,
+            vertical,
+            wrap,
+        } = img.position
+        {
             assert_eq!(horizontal, 100000);
             assert_eq!(vertical, 200000);
             assert_eq!(wrap, WrapType::Tight);

crates/utf8dok-ooxml/src/manifest.rs

@@ -407,7 +407,10 @@ mod tests {
         assert_eq!(retrieved.type_, "diagram");
         assert_eq!(retrieved.source, Some("diagrams/flow.mmd".to_string()));
         assert_eq!(retrieved.hash, Some("sha256:abc123def456".to_string()));
-        assert_eq!(retrieved.description, Some("System architecture overview".to_string()));
+        assert_eq!(
+            retrieved.description,
+            Some("System architecture overview".to_string())
+        );
     }
 
     #[test]
@@ -452,7 +455,12 @@ mod tests {
         // Empty manifest should have version and empty elements
         let parsed: serde_json::Value = serde_json::from_str(&json_str).unwrap();
         assert_eq!(parsed.get("version").unwrap(), "1.0");
-        assert!(parsed.get("elements").unwrap().as_object().unwrap().is_empty());
+        assert!(parsed
+            .get("elements")
+            .unwrap()
+            .as_object()
+            .unwrap()
+            .is_empty());
     }
 
     #[test]
@@ -461,8 +469,8 @@ mod tests {
             .with_source("doc.adoc")
             .with_hash("hash1")
             .with_description("desc1")
-            .with_source("updated.adoc")  // Can update
-            .with_hash("hash2");          // Can update again
+            .with_source("updated.adoc") // Can update
+            .with_hash("hash2"); // Can update again
 
         assert_eq!(meta.type_, "source");
         assert_eq!(meta.source, Some("updated.adoc".to_string()));
@@ -492,8 +500,7 @@ mod tests {
     fn test_manifest_unicode_values() {
         let mut manifest = Manifest::new();
 
-        let meta = ElementMeta::new("document")
-            .with_description("文档说明 - Document with 日本語");
+        let meta = ElementMeta::new("document").with_description("文档说明 - Document with 日本語");
 
         manifest.add_element("doc", meta);
 

crates/utf8dok-ooxml/src/relationships.rs

@@ -701,10 +701,7 @@ mod tests {
         let mut rels = Relationships::new();
 
         // Add relationships with special characters in target
-        rels.add(
-            "path/with spaces/file.xml".to_string(),
-            "type".to_string(),
-        );
+        rels.add("path/with spaces/file.xml".to_string(), "type".to_string());
         rels.add(
             "unicode/日本語/ファイル.xml".to_string(),
             "type".to_string(),
@@ -737,7 +734,10 @@ mod tests {
 
         // Verify all are retrievable
         assert_eq!(rels.get(&http_id), Some("https://example.com/page"));
-        assert_eq!(rels.get(&ftp_id), Some("ftp://files.example.com/download.zip"));
+        assert_eq!(
+            rels.get(&ftp_id),
+            Some("ftp://files.example.com/download.zip")
+        );
         assert_eq!(rels.get(&mail_id), Some("mailto:user@example.com"));
     }
 
@@ -800,7 +800,11 @@ mod tests {
             Relationships::TYPE_HYPERLINK,
         ];
         let unique: std::collections::HashSet<_> = types.iter().collect();
-        assert_eq!(unique.len(), types.len(), "All type constants should be unique");
+        assert_eq!(
+            unique.len(),
+            types.len(),
+            "All type constants should be unique"
+        );
     }
 
     #[test]
@@ -810,13 +814,18 @@ mod tests {
         rels.add_image("media/img1.png");
         rels.add_image("media/img2.jpg");
         rels.add_hyperlink("https://example.com");
-        rels.add("styles.xml".to_string(), Relationships::TYPE_STYLES.to_string());
+        rels.add(
+            "styles.xml".to_string(),
+            Relationships::TYPE_STYLES.to_string(),
+        );
 
         // Count by type
-        let image_count = rels.iter()
+        let image_count = rels
+            .iter()
             .filter(|(_, rel)| rel.rel_type == Relationships::TYPE_IMAGE)
             .count();
-        let link_count = rels.iter()
+        let link_count = rels
+            .iter()
             .filter(|(_, rel)| rel.rel_type == Relationships::TYPE_HYPERLINK)
             .count();
 

crates/utf8dok-ooxml/src/style_contract_validator.rs

@@ -963,7 +963,9 @@ mod tests {
 
         let result = StyleContractValidator::validate_invariants(&contract);
         assert!(result.has_errors());
-        assert!(result.errors()[0].message.contains("not a valid XML NCName"));
+        assert!(result.errors()[0]
+            .message
+            .contains("not a valid XML NCName"));
     }
 
     #[test]
@@ -1289,11 +1291,7 @@ mod tests {
             );
 
             let result = StyleContractValidator::validate_schema(&contract);
-            assert!(
-                result.is_valid(),
-                "Heading level {} should be valid",
-                level
-            );
+            assert!(result.is_valid(), "Heading level {} should be valid", level);
         }
     }
 
@@ -1408,7 +1406,8 @@ mod tests {
         let mut referenced = HashSet::new();
         referenced.insert("section-1".to_string());
 
-        let result = StyleContractValidator::validate_completeness_rendering(&contract, &referenced);
+        let result =
+            StyleContractValidator::validate_completeness_rendering(&contract, &referenced);
         assert!(result.is_valid());
     }
 
@@ -1534,33 +1533,43 @@ mod tests {
     fn test_is_valid_semantic_id_valid_ids() {
         assert!(StyleContractValidator::is_valid_semantic_id("simple"));
         assert!(StyleContractValidator::is_valid_semantic_id("with-dashes"));
-        assert!(StyleContractValidator::is_valid_semantic_id("section-1-intro"));
+        assert!(StyleContractValidator::is_valid_semantic_id(
+            "section-1-intro"
+        ));
         assert!(StyleContractValidator::is_valid_semantic_id("a"));
         assert!(StyleContractValidator::is_valid_semantic_id("abc123"));
         // Digits allowed as first character
-        assert!(StyleContractValidator::is_valid_semantic_id("123-numeric-start"));
+        assert!(StyleContractValidator::is_valid_semantic_id(
+            "123-numeric-start"
+        ));
     }
 
     #[test]
     fn test_is_valid_semantic_id_invalid_ids() {
         assert!(!StyleContractValidator::is_valid_semantic_id(""));
         assert!(!StyleContractValidator::is_valid_semantic_id("has spaces"));
         // Underscores not allowed
-        assert!(!StyleContractValidator::is_valid_semantic_id("with_underscore"));
+        assert!(!StyleContractValidator::is_valid_semantic_id(
+            "with_underscore"
+        ));
         assert!(!StyleContractValidator::is_valid_semantic_id(
             "-starts-with-dash"
         ));
         assert!(!StyleContractValidator::is_valid_semantic_id("has.dot"));
         // Uppercase not allowed
-        assert!(!StyleContractValidator::is_valid_semantic_id("HasUppercase"));
+        assert!(!StyleContractValidator::is_valid_semantic_id(
+            "HasUppercase"
+        ));
     }
 
     #[test]
     fn test_is_valid_xml_ncname_valid_names() {
         assert!(StyleContractValidator::is_valid_xml_ncname("_Toc123"));
         assert!(StyleContractValidator::is_valid_xml_ncname("_Ref456"));
         assert!(StyleContractValidator::is_valid_xml_ncname("_Hlk789"));
-        assert!(StyleContractValidator::is_valid_xml_ncname("SimpleBookmark"));
+        assert!(StyleContractValidator::is_valid_xml_ncname(
+            "SimpleBookmark"
+        ));
         assert!(StyleContractValidator::is_valid_xml_ncname("_underscore"));
         assert!(StyleContractValidator::is_valid_xml_ncname("a"));
     }
@@ -1571,7 +1580,9 @@ mod tests {
         assert!(!StyleContractValidator::is_valid_xml_ncname(
             "123StartWithNumber"
         ));
-        assert!(!StyleContractValidator::is_valid_xml_ncname("-StartWithDash"));
+        assert!(!StyleContractValidator::is_valid_xml_ncname(
+            "-StartWithDash"
+        ));
         assert!(!StyleContractValidator::is_valid_xml_ncname("has space"));
         assert!(!StyleContractValidator::is_valid_xml_ncname("has:colon"));
     }