git-ref-format-core 0.6.0

Core types for the git-ref-format crate
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

use std::fmt::{self, Display};

use super::PatternStr;
use crate::{lit, RefStr};

pub type Iter<'a> = std::str::Split<'a, char>;

pub enum Component<'a> {
    Glob(Option<&'a PatternStr>),
    Normal(&'a RefStr),
}

impl Component<'_> {
    #[inline]
    pub fn as_str(&self) -> &str {
        self.as_ref()
    }
}

impl AsRef<str> for Component<'_> {
    #[inline]
    fn as_ref(&self) -> &str {
        match self {
            Self::Glob(None) => "*",
            Self::Glob(Some(x)) => x.as_str(),
            Self::Normal(x) => x.as_str(),
        }
    }
}

impl Display for Component<'_> {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(self.as_str())
    }
}

impl<T: lit::Lit> From<T> for Component<'static> {
    #[inline]
    fn from(_: T) -> Self {
        Self::Normal(T::NAME)
    }
}

#[must_use = "iterators are lazy and do nothing unless consumed"]
#[derive(Clone)]
pub struct Components<'a> {
    inner: Iter<'a>,
}

impl<'a> Iterator for Components<'a> {
    type Item = Component<'a>;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next().map(|next| match next {
            "*" => Component::Glob(None),
            x if x.contains('*') => Component::Glob(Some(PatternStr::from_str(x))),
            x => Component::Normal(RefStr::from_str(x)),
        })
    }
}

impl DoubleEndedIterator for Components<'_> {
    #[inline]
    fn next_back(&mut self) -> Option<Self::Item> {
        self.inner.next_back().map(|next| match next {
            "*" => Component::Glob(None),
            x if x.contains('*') => Component::Glob(Some(PatternStr::from_str(x))),
            x => Component::Normal(RefStr::from_str(x)),
        })
    }
}

impl<'a> From<&'a PatternStr> for Components<'a> {
    #[inline]
    fn from(p: &'a PatternStr) -> Self {
        Self {
            inner: p.as_str().split('/'),
        }
    }
}

pub mod component {
    use super::Component;
    use crate::name;

    pub const STAR: Component = Component::Glob(None);
    pub const HEADS: Component = Component::Normal(name::HEADS);
    pub const MAIN: Component = Component::Normal(name::MAIN);
    pub const MASTER: Component = Component::Normal(name::MASTER);
    pub const NAMESPACES: Component = Component::Normal(name::NAMESPACES);
    pub const NOTES: Component = Component::Normal(name::NOTES);
    pub const ORIGIN: Component = Component::Normal(name::ORIGIN);
    pub const REFS: Component = Component::Normal(name::REFS);
    pub const REMOTES: Component = Component::Normal(name::REMOTES);
    pub const TAGS: Component = Component::Normal(name::TAGS);
}