gengo 0.14.3

Get the language distribution stats of your repository
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

//! Provides sources to get files and their attributes.

use crate::Language;

#[cfg(feature = "directory")]
pub use directory::Directory;

#[cfg(feature = "git")]
pub use git::Git;
use std::marker::{Send, Sync};
use std::path::Path;

#[cfg(feature = "directory")]
mod directory;

#[cfg(feature = "git")]
mod git;

/// Provides files and overrides.
pub trait FileSource<'files>: Sync {
    type Filepath: AsRef<Path>;
    type Contents: AsRef<[u8]>;
    type Entry: Send;
    /// Sometimes it's necessary to share a state between iterations to reduce
    /// expensive commands.
    type State: Send + Clone;
    type Iter: Iterator<Item = Self::Entry> + Send;

    /// Returns an iterator over the entries use to get filenames and contents.
    fn entries(&'files self) -> crate::Result<Self::Iter>;

    /// Gets a filename from an entry.
    fn filepath(
        &'files self,
        entry: &Self::Entry,
        state: &mut Self::State,
    ) -> crate::Result<Self::Filepath>;

    /// Gets file contents from an entry.
    fn contents(
        &'files self,
        entry: &Self::Entry,
        state: &mut Self::State,
    ) -> crate::Result<Self::Contents>;

    /// Gets a state that can be shared between iterations.
    fn state(&'files self) -> crate::Result<Self::State>;

    /// Provides combined overrides for the file.
    fn overrides(&self, path: impl AsRef<Path>, state: &mut Self::State) -> Overrides {
        Overrides {
            language: self.language_override(&path, state),
            is_documentation: self.is_documentation_override(&path, state),
            is_generated: self.is_generated_override(&path, state),
            is_vendored: self.is_vendored_override(&path, state),
            is_detectable: self.is_detectable_override(&path, state),
        }
    }

    /// Provides an optional override for the detected language.
    fn language_override(
        &self,
        _path: impl AsRef<Path>,
        _state: &mut Self::State,
    ) -> Option<Language> {
        None
    }

    /// Provides an optional override for documentation file detection.
    fn is_documentation_override(
        &self,
        _path: impl AsRef<Path>,
        _state: &mut Self::State,
    ) -> Option<bool> {
        None
    }

    /// Provides an optional override for generated file detection.
    fn is_generated_override(
        &self,
        _path: impl AsRef<Path>,
        _state: &mut Self::State,
    ) -> Option<bool> {
        None
    }

    /// Provides an optional override for vendored file detection.
    fn is_vendored_override(
        &self,
        _path: impl AsRef<Path>,
        _state: &mut Self::State,
    ) -> Option<bool> {
        None
    }

    /// Provides an optional override for if the file is detectable.
    fn is_detectable_override(
        &self,
        _path: impl AsRef<Path>,
        _state: &mut Self::State,
    ) -> Option<bool> {
        None
    }
}

#[non_exhaustive]
#[derive(Default)]
pub struct Overrides {
    pub language: Option<Language>,
    pub is_documentation: Option<bool>,
    pub is_generated: Option<bool>,
    pub is_vendored: Option<bool>,
    pub is_detectable: Option<bool>,
}