specker 0.3.5

Testing utility that simplifies file matching against bunch of templates.
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

// Copyright 2017 Nerijus Arlauskas
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.

use Result;
use spec::{Options, Spec};
use std::fs::File;
use std::io::Read;
use std::path::{Path, PathBuf};
use walkdir::{self, WalkDir};

/// Parsed specification at a path.
#[derive(Debug, Clone)]
pub struct SpecPath {
    pub spec: Spec,
    pub path: PathBuf,
}

/// Iterator over parsed specification files.
pub struct SpecWalkIter<'a> {
    extension: &'a str,
    walk_dir: walkdir::IntoIter,
    options: Options<'a>,
}

impl<'a> Iterator for SpecWalkIter<'a> {
    type Item = Result<SpecPath>;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            match self.walk_dir.next() {
                None => return None,
                Some(Err(e)) => return Some(Err(e.into())),
                Some(Ok(entry)) => {
                    return Some(
                        match (entry.file_type().is_file(), entry.path().extension()) {
                            (true, Some(v)) if v == self.extension => self.process_entry(&entry),
                            _ => continue,
                        },
                    )
                }
            }
        }
    }
}

impl<'a> SpecWalkIter<'a> {
    fn process_entry(&mut self, entry: &walkdir::DirEntry) -> Result<SpecPath> {
        let path: PathBuf = entry.path().into();
        let mut contents = String::new();
        File::open(&path)?.read_to_string(&mut contents)?;
        Spec::parse(self.options, contents.as_bytes())
            .map(|spec| SpecPath {
                spec: spec,
                path: (&path).clone(),
            })
            .map_err(move |e| (path, e).into())
    }
}

/// Walks spec directory and returns the iterator over all parsed `SpecPath` objects.
pub fn walk_spec_dir<'a>(
    path: &Path,
    extension: &'a str,
    options: Options<'a>,
) -> SpecWalkIter<'a> {
    SpecWalkIter {
        extension: extension,
        walk_dir: WalkDir::new(path).into_iter(),
        options: options,
    }
}