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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
use std::{borrow::Cow, ops::Range};
use bstr::{BStr, BString, ByteSlice, ByteVec};
use gix_hash::ObjectId;
use crate::{match_group::Item, RefSpecRef};
/// A type keeping enough information about a ref-spec to be able to efficiently match it against multiple matcher items.
pub struct Matcher<'a> {
pub(crate) lhs: Option<Needle<'a>>,
pub(crate) rhs: Option<Needle<'a>>,
}
impl<'a> Matcher<'a> {
/// Match `item` against this spec and return `(true, Some<rhs>)` to gain the other side of the match as configured, or `(true, None)`
/// if there was no `rhs`.
///
/// This may involve resolving a glob with an allocation, as the destination is built using the matching portion of a glob.
pub fn matches_lhs(&self, item: Item<'_>) -> (bool, Option<Cow<'a, BStr>>) {
match (self.lhs, self.rhs) {
(Some(lhs), None) => (lhs.matches(item).is_match(), None),
(Some(lhs), Some(rhs)) => lhs.matches(item).into_match_outcome(rhs, item),
(None, _) => {
unreachable!("For all we know, the lefthand side is never empty. Push specs might change that.")
}
}
}
}
#[derive(Debug, Copy, Clone)]
pub(crate) enum Needle<'a> {
FullName(&'a BStr),
PartialName(&'a BStr),
Glob { name: &'a BStr, asterisk_pos: usize },
Object(ObjectId),
}
enum Match {
/// There was no match.
None,
/// No additional data is provided as part of the match.
Normal,
/// The range of text to copy from the originating item name
GlobRange(Range<usize>),
}
impl Match {
fn is_match(&self) -> bool {
!matches!(self, Match::None)
}
fn into_match_outcome<'a>(self, destination: Needle<'a>, item: Item<'_>) -> (bool, Option<Cow<'a, BStr>>) {
let arg = match self {
Match::None => return (false, None),
Match::Normal => None,
Match::GlobRange(range) => Some((range, item)),
};
(true, destination.to_bstr_replace(arg).into())
}
}
impl<'a> Needle<'a> {
#[inline]
fn matches(&self, item: Item<'_>) -> Match {
match self {
Needle::FullName(name) => {
if *name == item.full_ref_name {
Match::Normal
} else {
Match::None
}
}
Needle::PartialName(name) => crate::spec::expand_partial_name(name, |expanded| {
(expanded == item.full_ref_name).then_some(Match::Normal)
})
.unwrap_or(Match::None),
Needle::Glob { name, asterisk_pos } => {
match item.full_ref_name.get(..*asterisk_pos) {
Some(full_name_portion) if full_name_portion != name[..*asterisk_pos] => {
return Match::None;
}
None => return Match::None,
_ => {}
};
let tail = &name[*asterisk_pos + 1..];
if !item.full_ref_name.ends_with(tail) {
return Match::None;
}
let end = item.full_ref_name.len() - tail.len();
Match::GlobRange(*asterisk_pos..end)
}
Needle::Object(id) => {
if *id == item.target {
return Match::Normal;
}
match item.object {
Some(object) if object == *id => Match::Normal,
_ => Match::None,
}
}
}
}
fn to_bstr_replace(self, range: Option<(Range<usize>, Item<'_>)>) -> Cow<'a, BStr> {
match (self, range) {
(Needle::FullName(name), None) => Cow::Borrowed(name),
(Needle::PartialName(name), None) => Cow::Owned({
let mut base: BString = "refs/".into();
if !(name.starts_with(b"tags/") || name.starts_with(b"remotes/")) {
base.push_str("heads/");
}
base.push_str(name);
base
}),
(Needle::Glob { name, asterisk_pos }, Some((range, item))) => {
let mut buf = Vec::with_capacity(name.len() + range.len() - 1);
buf.push_str(&name[..asterisk_pos]);
buf.push_str(&item.full_ref_name[range]);
buf.push_str(&name[asterisk_pos + 1..]);
Cow::Owned(buf.into())
}
(Needle::Object(id), None) => {
let mut name = id.to_string();
name.insert_str(0, "refs/heads/");
Cow::Owned(name.into())
}
(Needle::Glob { .. }, None) => unreachable!("BUG: no range provided for glob pattern"),
(_, Some(_)) => {
unreachable!("BUG: range provided even though needle wasn't a glob. Globs are symmetric.")
}
}
}
pub fn to_bstr(self) -> Cow<'a, BStr> {
self.to_bstr_replace(None)
}
}
impl<'a> From<&'a BStr> for Needle<'a> {
fn from(v: &'a BStr) -> Self {
if let Some(pos) = v.find_byte(b'*') {
Needle::Glob {
name: v,
asterisk_pos: pos,
}
} else if v.starts_with(b"refs/") {
Needle::FullName(v)
} else if let Ok(id) = gix_hash::ObjectId::from_hex(v) {
Needle::Object(id)
} else {
Needle::PartialName(v)
}
}
}
impl<'a> From<RefSpecRef<'a>> for Matcher<'a> {
fn from(v: RefSpecRef<'a>) -> Self {
Matcher {
lhs: v.src.map(Into::into),
rhs: v.dst.map(Into::into),
}
}
}
|
