vendor/nu-ansi-term/src/display.rs - toolchain/rustc - Git at Google

 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;

 /// 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,
 {
     pub(crate) style: Style,
     pub(crate) string: Cow<'a, S>,
 }

 /// Cloning an `AnsiGenericString` will clone its underlying string.
 ///
 /// # Examples
 ///
 /// ```
 /// use nu_ansi_term::AnsiString;
 ///
 /// 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 {
             style: self.style,
             string: self.string.clone(),
         }
     }
 }

 // You might think that the hand-written Clone impl above is the same as the
 // one that gets generated with #[derive]. But it’s not *quite* the same!
 //
 // `str` is not Clone, and the derived Clone implementation puts a Clone
 // constraint on the S type parameter (generated using --pretty=expanded):
 //
 //                  ↓_________________↓
 //     impl <'a, S: ::std::clone::Clone + 'a + ToOwned + ?Sized> ::std::clone::Clone
 //     for ANSIGenericString<'a, S> where
 //     <S as ToOwned>::Owned: fmt::Debug { ... }
 //
 // This resulted in compile errors when you tried to derive Clone on a type
 // that used it:
 //
 //     #[derive(PartialEq, Debug, Clone, Default)]
 //     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.
 ///
 /// Although not technically a string itself, it can be turned into
 /// one with the `to_string` method.
 ///
 /// # Examples
 ///
 /// ```
 /// use nu_ansi_term::AnsiString;
 /// use nu_ansi_term::Color::Red;
 ///
 /// let red_string = Red.paint("a red string");
 /// println!("{}", red_string);
 /// ```
 ///
 /// ```
 /// use nu_ansi_term::AnsiString;
 ///
 /// 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 {
             string: input.into(),
             style: Style::default(),
         }
     }
 }

 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
     }

     /// Directly access the style mutably
     pub fn style_ref_mut(&mut self) -> &mut Style {
         &mut self.style
     }
 }

 /// 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;

 /// 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>;

 /// A function to construct an `AnsiStrings` instance.
 #[allow(non_snake_case)]
 pub fn AnsiStrings<'a>(arg: &'a [AnsiString<'a>]) -> AnsiStrings<'a> {
     AnsiGenericStrings(arg)
 }

 /// 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]>;

 /// A function to construct an `AnsiByteStrings` instance.
 #[allow(non_snake_case)]
 pub fn AnsiByteStrings<'a>(arg: &'a [AnsiByteString<'a>]) -> AnsiByteStrings<'a> {
     AnsiGenericStrings(arg)
 }

 // ---- paint functions ----

 impl Style {
     /// 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 {
             string: input.into(),
             style: self,
         }
     }
 }

 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 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 {
             string: input.into(),
             style: self.normal(),
         }
     }
 }

 // ---- writers for individual ANSI strings ----

 impl<'a> fmt::Display for AnsiString<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         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
     /// sequences for the associated `Style` around the bytes.
     pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
         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> {
         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> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         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
     /// 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 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> {
         use self::Difference::*;

         let first = match self.0.first() {
             None => return Ok(()),
             Some(f) => f,
         };

         write!(w, "{}", first.style.prefix())?;
         w.write_str(first.string.as_ref())?;

         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())?,
                 Empty => { /* Do nothing! */ }
             }

             w.write_str(&window[1].string)?;
         }

         // 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() {
             if !last.style.is_plain() {
                 write!(w, "{}", RESET)?;
             }
         }

         Ok(())
     }
 }

 // ---- tests ----

 #[cfg(test)]
 mod tests {
     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 = AnsiStrings(&[one, two]).to_string();
         assert_eq!(output, "onetwo");
     }
 }
	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;

	/// 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,
	{
	pub(crate) style: Style,
	pub(crate) string: Cow<'a, S>,
	}

	/// Cloning an `AnsiGenericString` will clone its underlying string.
	///
	/// # Examples
	///
	/// ```
	/// use nu_ansi_term::AnsiString;
	///
	/// 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 {
	style: self.style,
	string: self.string.clone(),
	}
	}
	}

	// You might think that the hand-written Clone impl above is the same as the
	// one that gets generated with #[derive]. But it’s not quite the same!
	//
	// `str` is not Clone, and the derived Clone implementation puts a Clone
	// constraint on the S type parameter (generated using --pretty=expanded):
	//
	// ↓_________________↓
	// impl <'a, S: ::std::clone::Clone + 'a + ToOwned + ?Sized> ::std::clone::Clone
	// for ANSIGenericString<'a, S> where
	// <S as ToOwned>::Owned: fmt::Debug { ... }
	//
	// This resulted in compile errors when you tried to derive Clone on a type
	// that used it:
	//
	// #[derive(PartialEq, Debug, Clone, Default)]
	// 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.
	///
	/// Although not technically a string itself, it can be turned into
	/// one with the `to_string` method.
	///
	/// # Examples
	///
	/// ```
	/// use nu_ansi_term::AnsiString;
	/// use nu_ansi_term::Color::Red;
	///
	/// let red_string = Red.paint("a red string");
	/// println!("{}", red_string);
	/// ```
	///
	/// ```
	/// use nu_ansi_term::AnsiString;
	///
	/// 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 {
	string: input.into(),
	style: Style::default(),
	}
	}
	}

	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
	}

	/// Directly access the style mutably
	pub fn style_ref_mut(&mut self) -> &mut Style {
	&mut self.style
	}
	}

	/// 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;

	/// 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>;

	/// A function to construct an `AnsiStrings` instance.
	#[allow(non_snake_case)]
	pub fn AnsiStrings<'a>(arg: &'a [AnsiString<'a>]) -> AnsiStrings<'a> {
	AnsiGenericStrings(arg)
	}

	/// 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]>;

	/// A function to construct an `AnsiByteStrings` instance.
	#[allow(non_snake_case)]
	pub fn AnsiByteStrings<'a>(arg: &'a [AnsiByteString<'a>]) -> AnsiByteStrings<'a> {
	AnsiGenericStrings(arg)
	}

	// ---- paint functions ----

	impl Style {
	/// 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 {
	string: input.into(),
	style: self,
	}
	}
	}

	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 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 {
	string: input.into(),
	style: self.normal(),
	}
	}
	}

	// ---- writers for individual ANSI strings ----

	impl<'a> fmt::Display for AnsiString<'a> {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	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
	/// sequences for the associated `Style` around the bytes.
	pub fn write_to<W: io::Write>(&self, w: &mut W) -> io::Result<()> {
	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> {
	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> {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	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
	/// 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 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> {
	use self::Difference::*;

	let first = match self.0.first() {
	None => return Ok(()),
	Some(f) => f,
	};

	write!(w, "{}", first.style.prefix())?;
	w.write_str(first.string.as_ref())?;

	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())?,
	Empty => { /* Do nothing! */ }
	}

	w.write_str(&window[1].string)?;
	}

	// 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() {
	if !last.style.is_plain() {
	write!(w, "{}", RESET)?;
	}
	}

	Ok(())
	}
	}

	// ---- tests ----

	#[cfg(test)]
	mod tests {
	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 = AnsiStrings(&[one, two]).to_string();
	assert_eq!(output, "onetwo");
	}
	}