processors-rs 0.7.1

Embed anything at lightning speed
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

use parse_line_util::FromLine;

use super::*;
use core::fmt;

#[derive(Debug, PartialEq)]
pub struct ConfigParameterOutput {
    pub output: String,
    pub config_parameters: Vec<ConfigParameter>,
}

impl fmt::Display for ConfigParameterOutput {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.output)
    }
}

#[derive(Debug, PartialEq)]
pub struct ConfigParameter {
    pub name: String,
    pub default_value: String,
    pub description: String,
}

impl fmt::Display for ConfigParameter {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{} {} {}",
            self.name, self.default_value, self.description,
        )
    }
}

impl FromLine for ConfigParameter {
    fn from_line(line: &str) -> Option<Self> {
        let (name, x) = line.split_once("\t")?;
        let (default_value, description) = x.split_once("\t")?;

        Some(ConfigParameter {
            name: name.into(),
            default_value: default_value.into(),
            description: description.into(),
        })
    }
}

pub fn get_tesseract_config_parameters() -> error::TessResult<ConfigParameterOutput> {
    let mut command = command::get_tesseract_command(None);
    command.arg("--print-parameters");

    let output = command::run_tesseract_command(&mut command)?;

    let config_parameters = string_to_config_parameter_output(&output)?;

    Ok(ConfigParameterOutput {
        output,
        config_parameters,
    })
}

fn string_to_config_parameter_output(
    output: &str,
) -> crate::pdf::tesseract::error::TessResult<Vec<ConfigParameter>> {
    output
        .lines()
        .skip(1)
        .map(ConfigParameter::parse)
        .collect::<_>()
}

#[cfg(test)]
mod tests {
    use crate::pdf::tesseract::output_config_parameters::{
        string_to_config_parameter_output, ConfigParameter,
    };

    #[test]
    fn test_string_to_config_parameter_output() {
        let result = string_to_config_parameter_output(
            "Tesseract parameters:\n\
        log_level\t2147483647\tLogging level\n\
        textord_dotmatrix_gap\t3\t pixel gap for broken pixed pitch\n\
        textord_debug_block\t0\tBlock to do debug on\n\
        textord_pitch_range\t2\tMax range test on pitch",
        )
        .unwrap();

        let expected = ConfigParameter {
            name: "log_level".into(),
            default_value: "2147483647".into(),
            description: "Logging level".into(),
        };

        assert_eq!(result.first().unwrap(), &expected);
    }

    #[test]
    fn test_get_tesseract_config_parameters() {
        let result =
            crate::pdf::tesseract::output_config_parameters::get_tesseract_config_parameters()
                .unwrap();
        let x = result
            .config_parameters
            .iter()
            .find(|&x| x.name == "tessedit_char_whitelist")
            .unwrap();

        let expected = ConfigParameter {
            name: "tessedit_char_whitelist".into(),
            default_value: "".into(),
            description: "Whitelist of chars to recognize".into(),
        };

        assert_eq!(*x, expected);
    }

    #[test]
    fn test_string_to_config_parameter_output_parse_error() {
        let result = string_to_config_parameter_output(
            "Tesseract parameters:\n\
        log_level\t2147483647\tLogging level\n\
        Test\n\
        textord_debug_block\t0\tBlock to do debug on\n\
        textord_pitch_range\t2\tMax range test on pitch",
        );
        assert_eq!(
            result,
            Err(crate::pdf::tesseract::error::TessError::ParseError(
                "invalid line 'Test'".into()
            ))
        )
    }
}