gosyn 0.2.10

Golang syntax parser in Rust
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

use std::ffi::OsStr;
use std::fs;
use std::io;
use std::path::{Path, PathBuf};

pub struct Walkdir {
    dirs: Vec<fs::ReadDir>,
}

impl Walkdir {
    pub fn new<P: AsRef<Path>>(root: P) -> io::Result<Walkdir> {
        let root = root.as_ref();
        let dirs = vec![root.read_dir()?];

        Ok(Walkdir { dirs })
    }

    pub fn with_ext<S: AsRef<OsStr>, const N1: usize, const N2: usize>(
        self,
        include: [S; N1],
        exclude: [S; N2],
    ) -> io::Result<Walkext<S, N1, N2>> {
        let dir = self;
        Ok(Walkext { dir, include, exclude })
    }

    pub fn next_file(&mut self) -> io::Result<Option<PathBuf>> {
        match self.dirs.pop() {
            None => Ok(None),
            Some(mut dir) => match dir.next() {
                None => self.next_file(),
                Some(entry) => {
                    self.dirs.push(dir);
                    match entry {
                        Err(err) => Err(err),
                        Ok(file) => match file.path() {
                            path if path.ends_with("testdata") => self.next_file(),
                            path if path.is_file() => Ok(Some(path)),
                            path if path.is_dir() => {
                                let dir2 = path.read_dir()?;
                                self.dirs.push(dir2);
                                self.next_file()
                            }
                            _ => self.next_file(),
                        },
                    }
                }
            },
        }
    }
}

pub struct Walkext<S: AsRef<OsStr>, const N1: usize, const N2: usize> {
    dir: Walkdir,

    include: [S; N1],
    exclude: [S; N2],
}

impl<S: AsRef<OsStr>, const N1: usize, const N2: usize> Walkext<S, N1, N2> {
    pub fn next_file(&mut self) -> io::Result<Option<PathBuf>> {
        while let Some(file) = self.dir.next_file()? {
            if !self.include.iter().any(|ext| {
                // TODO: find better way to compare path extension
                let ext = ext.as_ref().to_str().unwrap();
                let filename = file.to_str().unwrap();
                filename.ends_with(ext)
            }) {
                continue;
            }

            if self.exclude.iter().any(|ext| {
                let ext = ext.as_ref().to_str().unwrap();
                let filename = file.to_str().unwrap();
                filename.ends_with(ext)
            }) {
                continue;
            }

            return Ok(Some(file));
        }

        Ok(None)
    }
}

#[cfg(test)]
mod tests {
    use super::Walkdir;
    use std::env;
    use std::fs;
    use std::io;

    #[test]
    fn list_files() -> io::Result<()> {
        let temp = env::temp_dir();
        let dir = temp.join("walkdir_test");
        fs::create_dir_all(&dir)?;

        println!("list all files...");
        let mut walk = Walkdir::new(&dir)?;
        while let Ok(Some(path)) = walk.next_file() {
            println!("{:?}", path);
        }

        println!("list go files...");
        let mut walk = Walkdir::new(&dir)?.with_ext(["go"], [])?;
        while let Ok(Some(path)) = walk.next_file() {
            println!("{:?}", path);
        }

        Ok(())
    }
}