pdf_oxide_cli 0.3.19

CLI for pdf-oxide — the fastest PDF toolkit. 22 commands: text extraction, PDF to markdown, search, merge, split, images, compress, encrypt, watermark, forms, and more.
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

use pdf_oxide::geometry::Rect;
use pdf_oxide::layout::RectFilterMode;
use std::path::Path;

pub fn run(
    file: &Path,
    format: &str,
    area: Option<&str>,
    pages: Option<&str>,
    output: Option<&Path>,
    password: Option<&str>,
    json: bool,
) -> pdf_oxide::Result<()> {
    let mut doc = super::open_doc(file, password)?;
    let page_count = doc.page_count()?;
    let page_indices = super::resolve_pages(pages, page_count)?;

    let region = if let Some(area_str) = area {
        Some(parse_area(area_str)?)
    } else {
        None
    };

    if json {
        let mut all_pages = Vec::new();
        for &page_idx in &page_indices {
            let page_data = match format {
                "words" => {
                    let words = if let Some(r) = region {
                        doc.extract_words_in_rect(page_idx, r, RectFilterMode::Intersects)?
                    } else {
                        doc.extract_words(page_idx)?
                    };
                    serde_json::to_value(words).unwrap()
                },
                "lines" => {
                    let lines = if let Some(r) = region {
                        doc.extract_text_lines_in_rect(page_idx, r, RectFilterMode::Intersects)?
                    } else {
                        doc.extract_text_lines(page_idx)?
                    };
                    serde_json::to_value(lines).unwrap()
                },
                _ => {
                    let text = if let Some(r) = region {
                        doc.extract_text_in_rect(page_idx, r, RectFilterMode::Intersects)?
                    } else {
                        doc.extract_text(page_idx)?
                    };
                    serde_json::json!(text)
                },
            };
            all_pages.push(serde_json::json!({
                "page": page_idx + 1,
                "content": page_data,
            }));
        }

        let json_out = serde_json::json!({
            "file": file.display().to_string(),
            "format": format,
            "area": area,
            "pages": all_pages,
        });
        super::write_output(&serde_json::to_string_pretty(&json_out).unwrap(), output)?;
    } else {
        let mut results: Vec<String> = Vec::new();
        for &page_idx in &page_indices {
            let text = match format {
                "words" => {
                    let words = if let Some(r) = region {
                        doc.extract_words_in_rect(page_idx, r, RectFilterMode::Intersects)?
                    } else {
                        doc.extract_words(page_idx)?
                    };
                    words
                        .iter()
                        .map(|w| w.text.as_str())
                        .collect::<Vec<_>>()
                        .join(" ")
                },
                "lines" => {
                    let lines = if let Some(r) = region {
                        doc.extract_text_lines_in_rect(page_idx, r, RectFilterMode::Intersects)?
                    } else {
                        doc.extract_text_lines(page_idx)?
                    };
                    lines
                        .iter()
                        .map(|l| l.text.as_str())
                        .collect::<Vec<_>>()
                        .join("\n")
                },
                _ => {
                    if let Some(r) = region {
                        doc.extract_text_in_rect(page_idx, r, RectFilterMode::Intersects)?
                    } else {
                        doc.extract_text(page_idx)?
                    }
                },
            };
            results.push(text);
        }
        let combined = results.join("\n\n---\n\n");
        super::write_output(&combined, output)?;
    }

    Ok(())
}

fn parse_area(s: &str) -> pdf_oxide::Result<Rect> {
    let parts: Vec<&str> = s.split(',').map(|p| p.trim()).collect();
    if parts.len() != 4 {
        return Err(pdf_oxide::Error::InvalidOperation(
            "Area must be provided as x,y,width,height".to_string(),
        ));
    }

    let x = parts[0].parse::<f32>().map_err(|_| {
        pdf_oxide::Error::InvalidOperation(format!("Invalid x coordinate: {}", parts[0]))
    })?;
    let y = parts[1].parse::<f32>().map_err(|_| {
        pdf_oxide::Error::InvalidOperation(format!("Invalid y coordinate: {}", parts[1]))
    })?;
    let w = parts[2]
        .parse::<f32>()
        .map_err(|_| pdf_oxide::Error::InvalidOperation(format!("Invalid width: {}", parts[2])))?;
    let h = parts[3]
        .parse::<f32>()
        .map_err(|_| pdf_oxide::Error::InvalidOperation(format!("Invalid height: {}", parts[3])))?;

    Ok(Rect::new(x, y, w, h))
}