pdf_oxide 0.3.22

The fastest Rust PDF library with text extraction: 0.8ms mean, 100% pass rate on 3,830 PDFs. 5× faster than pdf_extract, 17× faster than oxidize_pdf. Extract, create, and edit PDFs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

//! TDD Tests for Whitespace Normalization
//!
//! Tests verify that consecutive spaces and newlines are properly normalized
//! while preserving intentional formatting (code blocks, tables, paragraph breaks).

#[test]
fn test_normalize_single_space() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    assert_eq!(normalizer.normalize("hello world"), "hello world");
}

#[test]
fn test_normalize_multiple_spaces() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    assert_eq!(normalizer.normalize("hello   world"), "hello world");
    assert_eq!(normalizer.normalize("hello     world"), "hello world");
}

#[test]
fn test_normalize_tabs_to_spaces() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    assert_eq!(normalizer.normalize("hello\t\tworld"), "hello world");
}

#[test]
fn test_normalize_mixed_whitespace() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    assert_eq!(normalizer.normalize("hello  \t  world"), "hello world");
}

#[test]
fn test_preserve_single_newline() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    let result = normalizer.normalize("line1\nline2");
    assert!(result.contains('\n'));
    assert!(!result.contains("  ")); // No double spaces
}

#[test]
fn test_collapse_multiple_newlines_to_paragraph_break() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    let result = normalizer.normalize("para1\n\n\npara2");
    // Multiple newlines collapse to double newline (paragraph break)
    assert!(result.contains("para1") && result.contains("para2"));
}

#[test]
fn test_trim_leading_spaces() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    assert_eq!(normalizer.normalize("   hello"), "hello");
}

#[test]
fn test_trim_trailing_spaces() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    assert_eq!(normalizer.normalize("hello   "), "hello");
}

#[test]
fn test_preserve_layout_mode_no_normalization() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(true);
    let text = "hello   world";
    // In layout mode, spacing is preserved
    assert_eq!(normalizer.normalize(text), text);
}

#[test]
fn test_preserve_intentional_double_space() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    // Single intentional double-space (old-style sentence spacing)
    let text = "Sentence one.  Sentence two.";
    let result = normalizer.normalize(text);
    // Should normalize to single space
    assert!(!result.contains("  "));
}

#[test]
fn test_normalize_at_line_breaks() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    let result = normalizer.normalize("line1   \nline2");
    // Trailing spaces before newline should be trimmed
    assert!(!result.contains("   \n"));
}

#[test]
fn test_normalize_after_line_breaks() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    let result = normalizer.normalize("line1\n   line2");
    // Leading spaces after newline should be trimmed
    assert!(!result.contains("\n   "));
}

#[test]
fn test_handle_empty_string() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    assert_eq!(normalizer.normalize(""), "");
}

#[test]
fn test_handle_only_whitespace() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    assert!(normalizer.normalize("   \t  \n  ").trim().is_empty());
}

#[test]
fn test_normalize_multiple_paragraphs() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    let text = "Para 1  with  spaces\n\n\nPara 2   with   spaces";
    let result = normalizer.normalize(text);

    // Both paragraphs should have single spaces
    assert!(!result.contains("  with  "));
    assert!(!result.contains("   with   "));
}

#[test]
fn test_normalize_code_block_marker_preserved() {
    use pdf_oxide::pipeline::text_processing::WhitespaceNormalizer;

    let normalizer = WhitespaceNormalizer::new(false);
    // Markdown code fence should be preserved
    let text = "```\ncode with spaces\n```";
    let result = normalizer.normalize(text);
    assert!(result.contains("```"));
}