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
|
use std::convert::TryFrom;
use bstr::ByteSlice;
use winnow::{
combinator::{opt, preceded, terminated},
prelude::*,
token::{tag, take_till},
};
/// The information usually found in remote progress messages as sent by a git server during
/// fetch, clone and push operations.
#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RemoteProgress<'a> {
#[cfg_attr(feature = "serde", serde(borrow))]
/// The name of the action, like "clone".
pub action: &'a bstr::BStr,
/// The percentage to indicate progress, between 0 and 100.
pub percent: Option<u32>,
/// The amount of items already processed.
pub step: Option<usize>,
/// The maximum expected amount of items. `step` / `max` * 100 = `percent`.
pub max: Option<usize>,
}
impl<'a> RemoteProgress<'a> {
/// Parse the progress from a typical git progress `line` as sent by the remote.
pub fn from_bytes(mut line: &[u8]) -> Option<RemoteProgress<'_>> {
parse_progress(&mut line).ok().and_then(|r| {
if r.percent.is_none() && r.step.is_none() && r.max.is_none() {
None
} else {
Some(r)
}
})
}
/// Parse `text`, which is interpreted as error if `is_error` is true, as [`RemoteProgress`] and call the respective
/// methods on the given `progress` instance.
pub fn translate_to_progress(is_error: bool, text: &[u8], progress: &mut impl gix_features::progress::Progress) {
fn progress_name(current: Option<String>, action: &[u8]) -> String {
match current {
Some(current) => format!(
"{}: {}",
current.split_once(':').map_or(&*current, |x| x.0),
action.as_bstr()
),
None => action.as_bstr().to_string(),
}
}
if is_error {
// ignore keep-alive packages sent with 'sideband-all'
if !text.is_empty() {
progress.fail(progress_name(None, text));
}
} else {
match RemoteProgress::from_bytes(text) {
Some(RemoteProgress {
action,
percent: _,
step,
max,
}) => {
progress.set_name(progress_name(progress.name(), action));
progress.init(max, gix_features::progress::count("objects"));
if let Some(step) = step {
progress.set(step);
}
}
None => progress.set_name(progress_name(progress.name(), text)),
};
}
}
}
fn parse_number(i: &mut &[u8]) -> PResult<usize, ()> {
take_till(0.., |c: u8| !c.is_ascii_digit())
.try_map(btoi::btoi)
.parse_next(i)
}
fn next_optional_percentage(i: &mut &[u8]) -> PResult<Option<u32>, ()> {
opt(terminated(
preceded(
take_till(0.., |c: u8| c.is_ascii_digit()),
parse_number.try_map(u32::try_from),
),
tag(b"%"),
))
.parse_next(i)
}
fn next_optional_number(i: &mut &[u8]) -> PResult<Option<usize>, ()> {
opt(preceded(take_till(0.., |c: u8| c.is_ascii_digit()), parse_number)).parse_next(i)
}
fn parse_progress<'i>(line: &mut &'i [u8]) -> PResult<RemoteProgress<'i>, ()> {
let action = take_till(1.., |c| c == b':').parse_next(line)?;
let percent = next_optional_percentage.parse_next(line)?;
let step = next_optional_number.parse_next(line)?;
let max = next_optional_number.parse_next(line)?;
Ok(RemoteProgress {
action: action.into(),
percent,
step,
max,
})
}
|
