office 0.8.1

Excel reader
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

extern crate office;
extern crate glob;

use std::env;
use glob::{glob, GlobError};
use office::{Excel, DataType, Error};

type MissingReference = Option<usize>;

#[derive(Debug)]
enum FileStatus {
    ExcelError(Error),
    VbaError(Error),
    RangeError(Error),
    Valid(MissingReference, usize),
    Glob(GlobError),
}

fn main() {
    
    // Search recursively for all excel files matching argument pattern
    // Output statistics: nb broken references, nb broken cells etc...
    let pattern = format!("{}/**/*.xl*", env::args().skip(1).next().unwrap_or(".".to_string()));
    let mut filecount = 0;

    for f in glob(&pattern).expect("Failed to read excel glob, the first \
                                    argument must correspond to a directory") {
        filecount += 1;
        let mut status = Vec::new();
        let f = match f {
            Ok(f) => f,
            Err(e) => {
                status.push(FileStatus::Glob(e));
                continue;
            }
        };
        println!("Analysing {:?}", f.display());

        match Excel::open(&f) {
            Ok(mut xl) => {
                let mut missing = None;
                let mut cell_errors = 0;
                if xl.has_vba() {
                    match xl.vba_project() {
                        Ok(ref mut vba) => {
                            let refs = vba.get_references();
                            missing = Some(refs.into_iter()
                                .filter(|r| r.is_missing()).count());
                        },
                        Err(e) => status.push(FileStatus::VbaError(e)),
                    }
                }

                match xl.sheet_names() {
                    Ok(sheets) => {
                        for s in sheets {
                            match xl.worksheet_range(&s) {
                                Ok(range) => {
                                    cell_errors += range.rows()
                                        .map(|r| r.iter()
                                             .map(|c| if let &DataType::Error(_) = c { 1usize } else { 0 })
                                             .sum::<usize>())
                                        .sum::<usize>();
                                },
                                Err(e) => status.push(FileStatus::RangeError(e)),
                            }
                        }
                    },
                    Err(e) => status.push(FileStatus::ExcelError(e)),
                }

                status.push(FileStatus::Valid(missing, cell_errors));
            },
            Err(e) => status.push(FileStatus::ExcelError(e)),
        }
        println!("{:#?}\r\n", status);
    }

    println!("Found {} excel files", filecount);
}