Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 561 insertions, 0 deletions

diff --git a/vendor/indicatif/src/draw_target.rs b/vendor/indicatif/src/draw_target.rs
new file mode 100644
index 0000000..a2c055f
--- /dev/null
+++ b/vendor/indicatif/src/draw_target.rs
@@ -0,0 +1,561 @@
+use std::io;
+use std::sync::{Arc, RwLock, RwLockWriteGuard};
+use std::thread::panicking;
+use std::time::Duration;
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::Instant;
+
+use console::Term;
+#[cfg(target_arch = "wasm32")]
+use instant::Instant;
+
+use crate::multi::{MultiProgressAlignment, MultiState};
+use crate::TermLike;
+
+/// Target for draw operations
+///
+/// This tells a progress bar or a multi progress object where to paint to.
+/// The draw target is a stateful wrapper over a drawing destination and
+/// internally optimizes how often the state is painted to the output
+/// device.
+#[derive(Debug)]
+pub struct ProgressDrawTarget {
+    kind: TargetKind,
+}
+
+impl ProgressDrawTarget {
+    /// Draw to a buffered stdout terminal at a max of 20 times a second.
+    ///
+    /// For more information see [`ProgressDrawTarget::term`].
+    pub fn stdout() -> Self {
+        Self::term(Term::buffered_stdout(), 20)
+    }
+
+    /// Draw to a buffered stderr terminal at a max of 20 times a second.
+    ///
+    /// This is the default draw target for progress bars.  For more
+    /// information see [`ProgressDrawTarget::term`].
+    pub fn stderr() -> Self {
+        Self::term(Term::buffered_stderr(), 20)
+    }
+
+    /// Draw to a buffered stdout terminal at a max of `refresh_rate` times a second.
+    ///
+    /// For more information see [`ProgressDrawTarget::term`].
+    pub fn stdout_with_hz(refresh_rate: u8) -> Self {
+        Self::term(Term::buffered_stdout(), refresh_rate)
+    }
+
+    /// Draw to a buffered stderr terminal at a max of `refresh_rate` times a second.
+    ///
+    /// For more information see [`ProgressDrawTarget::term`].
+    pub fn stderr_with_hz(refresh_rate: u8) -> Self {
+        Self::term(Term::buffered_stderr(), refresh_rate)
+    }
+
+    pub(crate) fn new_remote(state: Arc<RwLock<MultiState>>, idx: usize) -> Self {
+        Self {
+            kind: TargetKind::Multi { state, idx },
+        }
+    }
+
+    /// Draw to a terminal, with a specific refresh rate.
+    ///
+    /// Progress bars are by default drawn to terminals however if the
+    /// terminal is not user attended the entire progress bar will be
+    /// hidden.  This is done so that piping to a file will not produce
+    /// useless escape codes in that file.
+    ///
+    /// Will panic if refresh_rate is `0`.
+    pub fn term(term: Term, refresh_rate: u8) -> Self {
+        Self {
+            kind: TargetKind::Term {
+                term,
+                last_line_count: 0,
+                rate_limiter: RateLimiter::new(refresh_rate),
+                draw_state: DrawState::default(),
+            },
+        }
+    }
+
+    /// Draw to a boxed object that implements the [`TermLike`] trait.
+    pub fn term_like(term_like: Box<dyn TermLike>) -> Self {
+        Self {
+            kind: TargetKind::TermLike {
+                inner: term_like,
+                last_line_count: 0,
+                rate_limiter: None,
+                draw_state: DrawState::default(),
+            },
+        }
+    }
+
+    /// Draw to a boxed object that implements the [`TermLike`] trait,
+    /// with a specific refresh rate.
+    pub fn term_like_with_hz(term_like: Box<dyn TermLike>, refresh_rate: u8) -> Self {
+        Self {
+            kind: TargetKind::TermLike {
+                inner: term_like,
+                last_line_count: 0,
+                rate_limiter: Option::from(RateLimiter::new(refresh_rate)),
+                draw_state: DrawState::default(),
+            },
+        }
+    }
+
+    /// A hidden draw target.
+    ///
+    /// This forces a progress bar to be not rendered at all.
+    pub fn hidden() -> Self {
+        Self {
+            kind: TargetKind::Hidden,
+        }
+    }
+
+    /// Returns true if the draw target is hidden.
+    ///
+    /// This is internally used in progress bars to figure out if overhead
+    /// from drawing can be prevented.
+    pub fn is_hidden(&self) -> bool {
+        match self.kind {
+            TargetKind::Hidden => true,
+            TargetKind::Term { ref term, .. } => !term.is_term(),
+            TargetKind::Multi { ref state, .. } => state.read().unwrap().is_hidden(),
+            _ => false,
+        }
+    }
+
+    /// Returns the current width of the draw target.
+    pub(crate) fn width(&self) -> u16 {
+        match self.kind {
+            TargetKind::Term { ref term, .. } => term.size().1,
+            TargetKind::Multi { ref state, .. } => state.read().unwrap().width(),
+            TargetKind::Hidden => 0,
+            TargetKind::TermLike { ref inner, .. } => inner.width(),
+        }
+    }
+
+    /// Notifies the backing `MultiProgress` (if applicable) that the associated progress bar should
+    /// be marked a zombie.
+    pub(crate) fn mark_zombie(&self) {
+        if let TargetKind::Multi { idx, state } = &self.kind {
+            state.write().unwrap().mark_zombie(*idx);
+        }
+    }
+
+    /// Apply the given draw state (draws it).
+    pub(crate) fn drawable(&mut self, force_draw: bool, now: Instant) -> Option<Drawable<'_>> {
+        match &mut self.kind {
+            TargetKind::Term {
+                term,
+                last_line_count,
+                rate_limiter,
+                draw_state,
+            } => {
+                if !term.is_term() {
+                    return None;
+                }
+
+                match force_draw || rate_limiter.allow(now) {
+                    true => Some(Drawable::Term {
+                        term,
+                        last_line_count,
+                        draw_state,
+                    }),
+                    false => None, // rate limited
+                }
+            }
+            TargetKind::Multi { idx, state, .. } => {
+                let state = state.write().unwrap();
+                Some(Drawable::Multi {
+                    idx: *idx,
+                    state,
+                    force_draw,
+                    now,
+                })
+            }
+            TargetKind::TermLike {
+                inner,
+                last_line_count,
+                rate_limiter,
+                draw_state,
+            } => match force_draw || rate_limiter.as_mut().map_or(true, |r| r.allow(now)) {
+                true => Some(Drawable::TermLike {
+                    term_like: &**inner,
+                    last_line_count,
+                    draw_state,
+                }),
+                false => None, // rate limited
+            },
+            // Hidden, finished, or no need to refresh yet
+            _ => None,
+        }
+    }
+
+    /// Properly disconnects from the draw target
+    pub(crate) fn disconnect(&self, now: Instant) {
+        match self.kind {
+            TargetKind::Term { .. } => {}
+            TargetKind::Multi { idx, ref state, .. } => {
+                let state = state.write().unwrap();
+                let _ = Drawable::Multi {
+                    state,
+                    idx,
+                    force_draw: true,
+                    now,
+                }
+                .clear();
+            }
+            TargetKind::Hidden => {}
+            TargetKind::TermLike { .. } => {}
+        };
+    }
+
+    pub(crate) fn remote(&self) -> Option<(&Arc<RwLock<MultiState>>, usize)> {
+        match &self.kind {
+            TargetKind::Multi { state, idx } => Some((state, *idx)),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn adjust_last_line_count(&mut self, adjust: LineAdjust) {
+        self.kind.adjust_last_line_count(adjust);
+    }
+}
+
+#[derive(Debug)]
+enum TargetKind {
+    Term {
+        term: Term,
+        last_line_count: usize,
+        rate_limiter: RateLimiter,
+        draw_state: DrawState,
+    },
+    Multi {
+        state: Arc<RwLock<MultiState>>,
+        idx: usize,
+    },
+    Hidden,
+    TermLike {
+        inner: Box<dyn TermLike>,
+        last_line_count: usize,
+        rate_limiter: Option<RateLimiter>,
+        draw_state: DrawState,
+    },
+}
+
+impl TargetKind {
+    /// Adjust `last_line_count` such that the next draw operation keeps/clears additional lines
+    fn adjust_last_line_count(&mut self, adjust: LineAdjust) {
+        let last_line_count: &mut usize = match self {
+            Self::Term {
+                last_line_count, ..
+            } => last_line_count,
+            Self::TermLike {
+                last_line_count, ..
+            } => last_line_count,
+            _ => return,
+        };
+
+        match adjust {
+            LineAdjust::Clear(count) => *last_line_count = last_line_count.saturating_add(count),
+            LineAdjust::Keep(count) => *last_line_count = last_line_count.saturating_sub(count),
+        }
+    }
+}
+
+pub(crate) enum Drawable<'a> {
+    Term {
+        term: &'a Term,
+        last_line_count: &'a mut usize,
+        draw_state: &'a mut DrawState,
+    },
+    Multi {
+        state: RwLockWriteGuard<'a, MultiState>,
+        idx: usize,
+        force_draw: bool,
+        now: Instant,
+    },
+    TermLike {
+        term_like: &'a dyn TermLike,
+        last_line_count: &'a mut usize,
+        draw_state: &'a mut DrawState,
+    },
+}
+
+impl<'a> Drawable<'a> {
+    /// Adjust `last_line_count` such that the next draw operation keeps/clears additional lines
+    pub(crate) fn adjust_last_line_count(&mut self, adjust: LineAdjust) {
+        let last_line_count: &mut usize = match self {
+            Drawable::Term {
+                last_line_count, ..
+            } => last_line_count,
+            Drawable::TermLike {
+                last_line_count, ..
+            } => last_line_count,
+            _ => return,
+        };
+
+        match adjust {
+            LineAdjust::Clear(count) => *last_line_count = last_line_count.saturating_add(count),
+            LineAdjust::Keep(count) => *last_line_count = last_line_count.saturating_sub(count),
+        }
+    }
+
+    pub(crate) fn state(&mut self) -> DrawStateWrapper<'_> {
+        let mut state = match self {
+            Drawable::Term { draw_state, .. } => DrawStateWrapper::for_term(draw_state),
+            Drawable::Multi { state, idx, .. } => state.draw_state(*idx),
+            Drawable::TermLike { draw_state, .. } => DrawStateWrapper::for_term(draw_state),
+        };
+
+        state.reset();
+        state
+    }
+
+    pub(crate) fn clear(mut self) -> io::Result<()> {
+        let state = self.state();
+        drop(state);
+        self.draw()
+    }
+
+    pub(crate) fn draw(self) -> io::Result<()> {
+        match self {
+            Drawable::Term {
+                term,
+                last_line_count,
+                draw_state,
+            } => draw_state.draw_to_term(term, last_line_count),
+            Drawable::Multi {
+                mut state,
+                force_draw,
+                now,
+                ..
+            } => state.draw(force_draw, None, now),
+            Drawable::TermLike {
+                term_like,
+                last_line_count,
+                draw_state,
+            } => draw_state.draw_to_term(term_like, last_line_count),
+        }
+    }
+}
+
+pub(crate) enum LineAdjust {
+    /// Adds to `last_line_count` so that the next draw also clears those lines
+    Clear(usize),
+    /// Subtracts from `last_line_count` so that the next draw retains those lines
+    Keep(usize),
+}
+
+pub(crate) struct DrawStateWrapper<'a> {
+    state: &'a mut DrawState,
+    orphan_lines: Option<&'a mut Vec<String>>,
+}
+
+impl<'a> DrawStateWrapper<'a> {
+    pub(crate) fn for_term(state: &'a mut DrawState) -> Self {
+        Self {
+            state,
+            orphan_lines: None,
+        }
+    }
+
+    pub(crate) fn for_multi(state: &'a mut DrawState, orphan_lines: &'a mut Vec<String>) -> Self {
+        Self {
+            state,
+            orphan_lines: Some(orphan_lines),
+        }
+    }
+}
+
+impl std::ops::Deref for DrawStateWrapper<'_> {
+    type Target = DrawState;
+
+    fn deref(&self) -> &Self::Target {
+        self.state
+    }
+}
+
+impl std::ops::DerefMut for DrawStateWrapper<'_> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.state
+    }
+}
+
+impl Drop for DrawStateWrapper<'_> {
+    fn drop(&mut self) {
+        if let Some(orphaned) = &mut self.orphan_lines {
+            orphaned.extend(self.state.lines.drain(..self.state.orphan_lines_count));
+            self.state.orphan_lines_count = 0;
+        }
+    }
+}
+
+#[derive(Debug)]
+struct RateLimiter {
+    interval: u16, // in milliseconds
+    capacity: u8,
+    prev: Instant,
+}
+
+/// Rate limit but allow occasional bursts above desired rate
+impl RateLimiter {
+    fn new(rate: u8) -> Self {
+        Self {
+            interval: 1000 / (rate as u16), // between 3 and 1000 milliseconds
+            capacity: MAX_BURST,
+            prev: Instant::now(),
+        }
+    }
+
+    fn allow(&mut self, now: Instant) -> bool {
+        if now < self.prev {
+            return false;
+        }
+
+        let elapsed = now - self.prev;
+        // If `capacity` is 0 and not enough time (`self.interval` ms) has passed since
+        // `self.prev` to add new capacity, return `false`. The goal of this method is to
+        // make this decision as efficient as possible.
+        if self.capacity == 0 && elapsed < Duration::from_millis(self.interval as u64) {
+            return false;
+        }
+
+        // We now calculate `new`, the number of ms, since we last returned `true`,
+        // and `remainder`, which represents a number of ns less than 1ms which we cannot
+        // convert into capacity now, so we're saving it for later.
+        let (new, remainder) = (
+            elapsed.as_millis() / self.interval as u128,
+            elapsed.as_nanos() % (self.interval as u128 * 1_000_000),
+        );
+
+        // We add `new` to `capacity`, subtract one for returning `true` from here,
+        // then make sure it does not exceed a maximum of `MAX_BURST`, then store it.
+        self.capacity = Ord::min(MAX_BURST as u128, (self.capacity as u128) + new - 1) as u8;
+        // Store `prev` for the next iteration after subtracting the `remainder`.
+        // Just use `unwrap` here because it shouldn't be possible for this to underflow.
+        self.prev = now
+            .checked_sub(Duration::from_nanos(remainder as u64))
+            .unwrap();
+        true
+    }
+}
+
+const MAX_BURST: u8 = 20;
+
+/// The drawn state of an element.
+#[derive(Clone, Debug, Default)]
+pub(crate) struct DrawState {
+    /// The lines to print (can contain ANSI codes)
+    pub(crate) lines: Vec<String>,
+    /// The number of lines that shouldn't be reaped by the next tick.
+    pub(crate) orphan_lines_count: usize,
+    /// True if we should move the cursor up when possible instead of clearing lines.
+    pub(crate) move_cursor: bool,
+    /// Controls how the multi progress is aligned if some of its progress bars get removed, default is `Top`
+    pub(crate) alignment: MultiProgressAlignment,
+}
+
+impl DrawState {
+    fn draw_to_term(
+        &mut self,
+        term: &(impl TermLike + ?Sized),
+        last_line_count: &mut usize,
+    ) -> io::Result<()> {
+        if panicking() {
+            return Ok(());
+        }
+
+        if !self.lines.is_empty() && self.move_cursor {
+            term.move_cursor_up(*last_line_count)?;
+        } else {
+            // Fork of console::clear_last_lines that assumes that the last line doesn't contain a '\n'
+            let n = *last_line_count;
+            term.move_cursor_up(n.saturating_sub(1))?;
+            for i in 0..n {
+                term.clear_line()?;
+                if i + 1 != n {
+                    term.move_cursor_down(1)?;
+                }
+            }
+            term.move_cursor_up(n.saturating_sub(1))?;
+        }
+
+        let shift = match self.alignment {
+            MultiProgressAlignment::Bottom if self.lines.len() < *last_line_count => {
+                let shift = *last_line_count - self.lines.len();
+                for _ in 0..shift {
+                    term.write_line("")?;
+                }
+                shift
+            }
+            _ => 0,
+        };
+
+        let term_height = term.height() as usize;
+        let term_width = term.width() as usize;
+        let len = self.lines.len();
+        let mut real_len = 0;
+        let mut last_line_filler = 0;
+        debug_assert!(self.orphan_lines_count <= self.lines.len());
+        for (idx, line) in self.lines.iter().enumerate() {
+            let line_width = console::measure_text_width(line);
+            let diff = if line.is_empty() {
+                // Empty line are new line
+                1
+            } else {
+                // Calculate real length based on terminal width
+                // This take in account linewrap from terminal
+                let terminal_len = (line_width as f64 / term_width as f64).ceil() as usize;
+
+                // If the line is effectively empty (for example when it consists
+                // solely of ANSI color code sequences, count it the same as a
+                // new line. If the line is measured to be len = 0, we will
+                // subtract with overflow later.
+                usize::max(terminal_len, 1)
+            };
+            // Don't consider orphan lines when comparing to terminal height.
+            debug_assert!(idx <= real_len);
+            if self.orphan_lines_count <= idx
+                && real_len - self.orphan_lines_count + diff > term_height
+            {
+                break;
+            }
+            real_len += diff;
+            if idx != 0 {
+                term.write_line("")?;
+            }
+            term.write_str(line)?;
+            if idx + 1 == len {
+                // Keep the cursor on the right terminal side
+                // So that next user writes/prints will happen on the next line
+                last_line_filler = term_width.saturating_sub(line_width);
+            }
+        }
+        term.write_str(&" ".repeat(last_line_filler))?;
+
+        term.flush()?;
+        *last_line_count = real_len - self.orphan_lines_count + shift;
+        Ok(())
+    }
+
+    fn reset(&mut self) {
+        self.lines.clear();
+        self.orphan_lines_count = 0;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{MultiProgress, ProgressBar, ProgressDrawTarget};
+
+    #[test]
+    fn multi_is_hidden() {
+        let mp = MultiProgress::with_draw_target(ProgressDrawTarget::hidden());
+
+        let pb = mp.add(ProgressBar::new(100));
+        assert!(mp.is_hidden());
+        assert!(pb.is_hidden());
+    }
+}