diff options
Diffstat (limited to '')
| -rw-r--r-- | vendor/nu-ansi-term/src/display.rs (renamed from vendor/ansi_term/src/display.rs) | 220 |
1 files changed, 107 insertions, 113 deletions
diff --git a/vendor/ansi_term/src/display.rs b/vendor/nu-ansi-term/src/display.rs index 17c54f008..bed934cb3 100644 --- a/vendor/ansi_term/src/display.rs +++ b/vendor/nu-ansi-term/src/display.rs @@ -1,40 +1,40 @@ +use crate::ansi::RESET; +use crate::difference::Difference; +use crate::style::{Color, Style}; +use crate::write::AnyWrite; use std::borrow::Cow; use std::fmt; use std::io; -use std::ops::Deref; -use ansi::RESET; -use difference::Difference; -use style::{Style, Colour}; -use write::AnyWrite; - - -/// An `ANSIGenericString` includes a generic string type and a `Style` to -/// display that string. `ANSIString` and `ANSIByteString` are aliases for +/// An `AnsiGenericString` includes a generic string type and a `Style` to +/// display that string. `AnsiString` and `AnsiByteString` are aliases for /// this type on `str` and `\[u8]`, respectively. #[derive(PartialEq, Debug)] -pub struct ANSIGenericString<'a, S: 'a + ToOwned + ?Sized> -where <S as ToOwned>::Owned: fmt::Debug { - style: Style, - string: Cow<'a, S>, +pub struct AnsiGenericString<'a, S: 'a + ToOwned + ?Sized> +where + <S as ToOwned>::Owned: fmt::Debug, +{ + pub(crate) style: Style, + pub(crate) string: Cow<'a, S>, } - -/// Cloning an `ANSIGenericString` will clone its underlying string. +/// Cloning an `AnsiGenericString` will clone its underlying string. /// /// # Examples /// /// ``` -/// use ansi_term::ANSIString; +/// use nu_ansi_term::AnsiString; /// -/// let plain_string = ANSIString::from("a plain string"); +/// let plain_string = AnsiString::from("a plain string"); /// let clone_string = plain_string.clone(); /// assert_eq!(clone_string, plain_string); /// ``` -impl<'a, S: 'a + ToOwned + ?Sized> Clone for ANSIGenericString<'a, S> -where <S as ToOwned>::Owned: fmt::Debug { - fn clone(&self) -> ANSIGenericString<'a, S> { - ANSIGenericString { +impl<'a, S: 'a + ToOwned + ?Sized> Clone for AnsiGenericString<'a, S> +where + <S as ToOwned>::Owned: fmt::Debug, +{ + fn clone(&self) -> AnsiGenericString<'a, S> { + AnsiGenericString { style: self.style, string: self.string.clone(), } @@ -56,14 +56,12 @@ where <S as ToOwned>::Owned: fmt::Debug { // that used it: // // #[derive(PartialEq, Debug, Clone, Default)] -// pub struct TextCellContents(Vec<ANSIString<'static>>); +// pub struct TextCellContents(Vec<AnsiString<'static>>); // ^^^^^^^^^^^^^^^^^^^^^^^^^ // error[E0277]: the trait `std::clone::Clone` is not implemented for `str` // // The hand-written impl above can ignore that constraint and still compile. - - /// An ANSI String is a string coupled with the `Style` to display it /// in a terminal. /// @@ -73,39 +71,41 @@ where <S as ToOwned>::Owned: fmt::Debug { /// # Examples /// /// ``` -/// use ansi_term::ANSIString; -/// use ansi_term::Colour::Red; +/// use nu_ansi_term::AnsiString; +/// use nu_ansi_term::Color::Red; /// /// let red_string = Red.paint("a red string"); /// println!("{}", red_string); /// ``` /// /// ``` -/// use ansi_term::ANSIString; +/// use nu_ansi_term::AnsiString; /// -/// let plain_string = ANSIString::from("a plain string"); -/// assert_eq!(&*plain_string, "a plain string"); +/// let plain_string = AnsiString::from("a plain string"); /// ``` -pub type ANSIString<'a> = ANSIGenericString<'a, str>; - -/// An `ANSIByteString` represents a formatted series of bytes. Use -/// `ANSIByteString` when styling text with an unknown encoding. -pub type ANSIByteString<'a> = ANSIGenericString<'a, [u8]>; - -impl<'a, I, S: 'a + ToOwned + ?Sized> From<I> for ANSIGenericString<'a, S> -where I: Into<Cow<'a, S>>, - <S as ToOwned>::Owned: fmt::Debug { - fn from(input: I) -> ANSIGenericString<'a, S> { - ANSIGenericString { +pub type AnsiString<'a> = AnsiGenericString<'a, str>; + +/// An `AnsiByteString` represents a formatted series of bytes. Use +/// `AnsiByteString` when styling text with an unknown encoding. +pub type AnsiByteString<'a> = AnsiGenericString<'a, [u8]>; + +impl<'a, I, S: 'a + ToOwned + ?Sized> From<I> for AnsiGenericString<'a, S> +where + I: Into<Cow<'a, S>>, + <S as ToOwned>::Owned: fmt::Debug, +{ + fn from(input: I) -> AnsiGenericString<'a, S> { + AnsiGenericString { string: input.into(), - style: Style::default(), + style: Style::default(), } } } -impl<'a, S: 'a + ToOwned + ?Sized> ANSIGenericString<'a, S> - where <S as ToOwned>::Owned: fmt::Debug { - +impl<'a, S: 'a + ToOwned + ?Sized> AnsiGenericString<'a, S> +where + <S as ToOwned>::Owned: fmt::Debug, +{ /// Directly access the style pub fn style_ref(&self) -> &Style { &self.style @@ -117,133 +117,128 @@ impl<'a, S: 'a + ToOwned + ?Sized> ANSIGenericString<'a, S> } } -impl<'a, S: 'a + ToOwned + ?Sized> Deref for ANSIGenericString<'a, S> -where <S as ToOwned>::Owned: fmt::Debug { - type Target = S; - - fn deref(&self) -> &S { - self.string.deref() - } -} - - -/// A set of `ANSIGenericString`s collected together, in order to be +/// A set of `AnsiGenericStrings`s collected together, in order to be /// written with a minimum of control characters. #[derive(Debug, PartialEq)] -pub struct ANSIGenericStrings<'a, S: 'a + ToOwned + ?Sized> - (pub &'a [ANSIGenericString<'a, S>]) - where <S as ToOwned>::Owned: fmt::Debug, S: PartialEq; +pub struct AnsiGenericStrings<'a, S: 'a + ToOwned + ?Sized>(pub &'a [AnsiGenericString<'a, S>]) +where + <S as ToOwned>::Owned: fmt::Debug, + S: PartialEq; -/// A set of `ANSIString`s collected together, in order to be written with a +/// A set of `AnsiString`s collected together, in order to be written with a /// minimum of control characters. -pub type ANSIStrings<'a> = ANSIGenericStrings<'a, str>; +pub type AnsiStrings<'a> = AnsiGenericStrings<'a, str>; -/// A function to construct an `ANSIStrings` instance. +/// A function to construct an `AnsiStrings` instance. #[allow(non_snake_case)] -pub fn ANSIStrings<'a>(arg: &'a [ANSIString<'a>]) -> ANSIStrings<'a> { - ANSIGenericStrings(arg) +pub fn AnsiStrings<'a>(arg: &'a [AnsiString<'a>]) -> AnsiStrings<'a> { + AnsiGenericStrings(arg) } -/// A set of `ANSIByteString`s collected together, in order to be +/// A set of `AnsiByteString`s collected together, in order to be /// written with a minimum of control characters. -pub type ANSIByteStrings<'a> = ANSIGenericStrings<'a, [u8]>; +pub type AnsiByteStrings<'a> = AnsiGenericStrings<'a, [u8]>; -/// A function to construct an `ANSIByteStrings` instance. +/// A function to construct an `AnsiByteStrings` instance. #[allow(non_snake_case)] -pub fn ANSIByteStrings<'a>(arg: &'a [ANSIByteString<'a>]) -> ANSIByteStrings<'a> { - ANSIGenericStrings(arg) +pub fn AnsiByteStrings<'a>(arg: &'a [AnsiByteString<'a>]) -> AnsiByteStrings<'a> { + AnsiGenericStrings(arg) } - // ---- paint functions ---- impl Style { - - /// Paints the given text with this colour, returning an ANSI string. + /// Paints the given text with this color, returning an ANSI string. #[must_use] - pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> ANSIGenericString<'a, S> - where I: Into<Cow<'a, S>>, - <S as ToOwned>::Owned: fmt::Debug { - ANSIGenericString { + pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> AnsiGenericString<'a, S> + where + I: Into<Cow<'a, S>>, + <S as ToOwned>::Owned: fmt::Debug, + { + AnsiGenericString { string: input.into(), - style: self, + style: self, } } } - -impl Colour { - - /// Paints the given text with this colour, returning an ANSI string. +impl Color { + /// Paints the given text with this color, returning an ANSI string. /// This is a short-cut so you don’t have to use `Blue.normal()` just /// to get blue text. /// /// ``` - /// use ansi_term::Colour::Blue; + /// use nu_ansi_term::Color::Blue; /// println!("{}", Blue.paint("da ba dee")); /// ``` #[must_use] - pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> ANSIGenericString<'a, S> - where I: Into<Cow<'a, S>>, - <S as ToOwned>::Owned: fmt::Debug { - ANSIGenericString { + pub fn paint<'a, I, S: 'a + ToOwned + ?Sized>(self, input: I) -> AnsiGenericString<'a, S> + where + I: Into<Cow<'a, S>>, + <S as ToOwned>::Owned: fmt::Debug, + { + AnsiGenericString { string: input.into(), - style: self.normal(), + style: self.normal(), } } } - // ---- writers for individual ANSI strings ---- -impl<'a> fmt::Display for ANSIString<'a> { +impl<'a> fmt::Display for AnsiString<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let w: &mut fmt::Write = f; + let w: &mut dyn fmt::Write = f; self.write_to_any(w) } } -impl<'a> ANSIByteString<'a> { - /// Write an `ANSIByteString` to an `io::Write`. This writes the escape +impl<'a> AnsiByteString<'a> { + /// Write an `AnsiByteString` to an `io::Write`. This writes the escape /// sequences for the associated `Style` around the bytes. pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> { - let w: &mut io::Write = w; + let w: &mut dyn io::Write = w; self.write_to_any(w) } } -impl<'a, S: 'a + ToOwned + ?Sized> ANSIGenericString<'a, S> -where <S as ToOwned>::Owned: fmt::Debug, &'a S: AsRef<[u8]> { - fn write_to_any<W: AnyWrite<wstr=S> + ?Sized>(&self, w: &mut W) -> Result<(), W::Error> { +impl<'a, S: 'a + ToOwned + ?Sized> AnsiGenericString<'a, S> +where + <S as ToOwned>::Owned: fmt::Debug, + &'a S: AsRef<[u8]>, +{ + fn write_to_any<W: AnyWrite<Wstr = S> + ?Sized>(&self, w: &mut W) -> Result<(), W::Error> { write!(w, "{}", self.style.prefix())?; w.write_str(self.string.as_ref())?; write!(w, "{}", self.style.suffix()) } } - // ---- writers for combined ANSI strings ---- -impl<'a> fmt::Display for ANSIStrings<'a> { +impl<'a> fmt::Display for AnsiStrings<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let f: &mut fmt::Write = f; + let f: &mut dyn fmt::Write = f; self.write_to_any(f) } } -impl<'a> ANSIByteStrings<'a> { - /// Write `ANSIByteStrings` to an `io::Write`. This writes the minimal +impl<'a> AnsiByteStrings<'a> { + /// Write `AnsiByteStrings` to an `io::Write`. This writes the minimal /// escape sequences for the associated `Style`s around each set of /// bytes. pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> { - let w: &mut io::Write = w; + let w: &mut dyn io::Write = w; self.write_to_any(w) } } -impl<'a, S: 'a + ToOwned + ?Sized + PartialEq> ANSIGenericStrings<'a, S> -where <S as ToOwned>::Owned: fmt::Debug, &'a S: AsRef<[u8]> { - fn write_to_any<W: AnyWrite<wstr=S> + ?Sized>(&self, w: &mut W) -> Result<(), W::Error> { +impl<'a, S: 'a + ToOwned + ?Sized + PartialEq> AnsiGenericStrings<'a, S> +where + <S as ToOwned>::Owned: fmt::Debug, + &'a S: AsRef<[u8]>, +{ + fn write_to_any<W: AnyWrite<Wstr = S> + ?Sized>(&self, w: &mut W) -> Result<(), W::Error> { use self::Difference::*; let first = match self.0.first() { @@ -257,14 +252,14 @@ where <S as ToOwned>::Owned: fmt::Debug, &'a S: AsRef<[u8]> { for window in self.0.windows(2) { match Difference::between(&window[0].style, &window[1].style) { ExtraStyles(style) => write!(w, "{}", style.prefix())?, - Reset => write!(w, "{}{}", RESET, window[1].style.prefix())?, - NoDifference => {/* Do nothing! */}, + Reset => write!(w, "{}{}", RESET, window[1].style.prefix())?, + Empty => { /* Do nothing! */ } } w.write_str(&window[1].string)?; } - // Write the final reset string after all of the ANSIStrings have been + // Write the final reset string after all of the AnsiStrings have been // written, *except* if the last one has no styles, because it would // have already been written by this point. if let Some(last) = self.0.last() { @@ -277,20 +272,19 @@ where <S as ToOwned>::Owned: fmt::Debug, &'a S: AsRef<[u8]> { } } - // ---- tests ---- #[cfg(test)] mod tests { - pub use super::super::ANSIStrings; - pub use style::Style; - pub use style::Colour::*; + pub use super::super::AnsiStrings; + pub use crate::style::Color::*; + pub use crate::style::Style; #[test] fn no_control_codes_for_plain() { let one = Style::default().paint("one"); let two = Style::default().paint("two"); - let output = format!("{}", ANSIStrings( &[ one, two ] )); - assert_eq!(&*output, "onetwo"); + let output = AnsiStrings(&[one, two]).to_string(); + assert_eq!(output, "onetwo"); } } |