vendor/array_tool/src/string.rs - toolchain/rustc - Git at Google

 // Copyright 2015-2017 Daniel P. Clark & array_tool Developers
 //
 // Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
 // http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
 // http://opensource.org/licenses/MIT>, at your option. This file may not be
 // copied, modified, or distributed except according to those terms.

 /// A grapheme iterator that produces the bytes for each grapheme.
 #[derive(Debug)]
 pub struct GraphemeBytesIter<'a> {
   source: &'a str,
   offset: usize,
   grapheme_count: usize,
 }
 impl<'a> GraphemeBytesIter<'a> {
   /// Creates a new grapheme iterator from a string source.
   pub fn new(source: &'a str) -> GraphemeBytesIter<'a> {
     GraphemeBytesIter {
       source: source,
       offset: 0,
       grapheme_count: 0,
     }
   }
 }
 impl<'a> Iterator for GraphemeBytesIter<'a> {
   type Item = &'a [u8];

   fn next(&mut self) -> Option<&'a [u8]> {
     let mut result: Option<&[u8]> = None;
     let mut idx = self.offset;
     for _ in self.offset..self.source.len() {
       idx += 1;
       if self.offset < self.source.len() {
         if self.source.is_char_boundary(idx) {
           let slice: &[u8] = self.source[self.offset..idx].as_bytes();

           self.grapheme_count += 1;
           self.offset = idx;

           result = Some(slice);
           break
         }
       }
     }
     result
   }
 }
 impl<'a> ExactSizeIterator for GraphemeBytesIter<'a> {
   fn len(&self) -> usize {
     self.source.chars().count()
   }
 }
 /// ToGraphemeBytesIter - create an iterator to return bytes for each grapheme in a string.
 pub trait ToGraphemeBytesIter<'a> {
   /// Returns a GraphemeBytesIter which you may iterate over.
   ///
   /// # Example
   /// ```
   /// use array_tool::string::ToGraphemeBytesIter;
   ///
   /// let string = "a s—d féZ";
   /// let mut graphemes = string.grapheme_bytes_iter();
   /// graphemes.skip(3).next();
   /// ```
   ///
   /// # Output
   /// ```text
   /// [226, 128, 148]
   /// ```
   fn grapheme_bytes_iter(&'a self) -> GraphemeBytesIter<'a>;
 }
 impl<'a> ToGraphemeBytesIter<'a> for str {
   fn grapheme_bytes_iter(&'a self) -> GraphemeBytesIter<'a> {
     GraphemeBytesIter::new(&self)
   }
 }

 /// Squeeze - squeezes duplicate characters down to one each
 pub trait Squeeze {
   /// # Example
   /// ```
   /// use array_tool::string::Squeeze;
   ///
   /// "yellow moon".squeeze("");
   /// ```
   ///
   /// # Output
   /// ```text
   /// "yelow mon"
   /// ```
   fn squeeze(&self, targets: &'static str) -> String;
 }
 impl Squeeze for str {
   fn squeeze(&self, targets: &'static str) -> String {
     let mut output = Vec::<u8>::with_capacity(self.len());
     let everything: bool = targets.is_empty();
     let chars = targets.grapheme_bytes_iter().collect::<Vec<&[u8]>>();
     let mut last: &[u8] = &[0];
     for character in self.grapheme_bytes_iter() {
       if last != character {
         output.extend_from_slice(character);
       } else if !(everything || chars.contains(&character)) {
         output.extend_from_slice(character);
       }
       last = character;
     }
     String::from_utf8(output).expect("squeeze failed to render String!")
   }
 }

 /// Justify - expand line to given width.
 pub trait Justify {
   /// # Example
   /// ```
   /// use array_tool::string::Justify;
   ///
   /// "asd asdf asd".justify_line(14);
   /// ```
   ///
   /// # Output
   /// ```text
   /// "asd  asdf  asd"
   /// ```
   fn justify_line(&self, width: usize) -> String;
 }

 impl Justify for str {
   fn justify_line(&self, width: usize) -> String {
     if self.is_empty() { return format!("{}", self) };
     let trimmed = self.trim() ;
     let len = trimmed.chars().count();
     if len >= width { return self.to_string(); };
     let difference = width - len;
     let iter = trimmed.split_whitespace();
     let spaces = iter.count() - 1;
     let mut iter = trimmed.split_whitespace().peekable();
     if spaces == 0 { return self.to_string(); }
     let mut obj = String::with_capacity(trimmed.len() + spaces);

     let div = difference / spaces;
     let mut remainder = difference % spaces;

     while let Some(x) = iter.next() {
       obj.push_str( x );
       let val = if remainder > 0 {
         remainder = remainder - 1;
         div + 1
       } else { div };
       for _ in 0..val+1 {
         if let Some(_) = iter.peek() { // Don't add spaces if last word
           obj.push_str( " " );
         }
       }
     }
     obj
   }
 }

 /// Substitute string character for each index given.
 pub trait SubstMarks {
   /// # Example
   /// ```
   /// use array_tool::string::SubstMarks;
   ///
   /// "asdf asdf asdf".subst_marks(vec![0,5,8], "Z");
   /// ```
   ///
   /// # Output
   /// ```text
   /// "Zsdf ZsdZ asdf"
   /// ```
   fn subst_marks(&self, marks: Vec<usize>, chr: &'static str) -> String;
 }
 impl SubstMarks for str {
   fn subst_marks(&self, marks: Vec<usize>, chr: &'static str) -> String {
     let mut output = Vec::<u8>::with_capacity(self.len());
     let mut count = 0;
     let mut last = 0;
     for i in 0..self.len() {
       let idx = i + 1;
       if self.is_char_boundary(idx) {
         if marks.contains(&count) {
           count += 1;
           last = idx;
           output.extend_from_slice(chr.as_bytes());
           continue
         }

         let slice: &[u8] = self[last..idx].as_bytes();
         output.extend_from_slice(slice);

         count += 1;
         last = idx
       }
     }
     String::from_utf8(output).expect("subst_marks failed to render String!")
   }
 }

 /// After whitespace
 pub trait AfterWhitespace {
   /// Given offset method will seek from there to end of string to find the first
   /// non white space.  Resulting value is counted from offset.
   ///
   /// # Example
   /// ```
   /// use array_tool::string::AfterWhitespace;
   ///
   /// assert_eq!(
   ///   "asdf           asdf asdf".seek_end_of_whitespace(6),
   ///   Some(9)
   /// );
   /// ```
   fn seek_end_of_whitespace(&self, offset: usize) -> Option<usize>;
 }
 impl AfterWhitespace for str {
   fn seek_end_of_whitespace(&self, offset: usize) -> Option<usize> {
     if self.len() < offset { return None; };
     let mut seeker = self[offset..self.len()].chars();
     let mut val = None;
     let mut indx = 0;
     while let Some(x) = seeker.next() {
       if x.ne(&" ".chars().next().unwrap()) {
         val = Some(indx);
         break;
       }
       indx += 1;
     }
     val
   }
 }

 /// Word wrapping
 pub trait WordWrap {
   ///  White space is treated as valid content and new lines will only be swapped in for
   ///  the last white space character at the end of the given width.  White space may reach beyond
   ///  the width you've provided.  You will need to trim end of lines in your own output (e.g.
   ///  splitting string at each new line and printing the line with trim_right).  Or just trust
   ///  that lines that are beyond the width are just white space and only print the width -
   ///  ignoring tailing white space.
   ///
   /// # Example
   /// ```
   /// use array_tool::string::WordWrap;
   ///
   /// "asd asdf asd".word_wrap(8);
   /// ```
   ///
   /// # Output
   /// ```text
   /// "asd asdf\nasd"
   /// ```
   fn word_wrap(&self, width: usize) -> String;
 }
 // No need to worry about character encoding since we're only checking for the
 // space and new line characters.
 impl WordWrap for &'static str {
   fn word_wrap(&self, width: usize) -> String {
     let mut markers = vec![];
     fn wordwrap(t: &'static str, chunk: usize, offset: usize, mrkrs: &mut Vec<usize>) -> String {
       match t[offset..*vec![offset+chunk,t.len()].iter().min().unwrap()].rfind("\n") {
         None => {
           match t[offset..*vec![offset+chunk,t.len()].iter().min().unwrap()].rfind(" ") {
             Some(x) => {
               let mut eows = x; // end of white space
               if offset+chunk < t.len() { // check if white space continues
                 match t.seek_end_of_whitespace(offset+x) {
                   Some(a) => {
                     if a.ne(&0) {
                       eows = x+a-1;
                     }
                   },
                   None => {},
                 }
               }
               if offset+chunk < t.len() { // safe to seek ahead by 1 or not end of string
                 if !["\n".chars().next().unwrap(), " ".chars().next().unwrap()].contains(
                   &t[offset+eows+1..offset+eows+2].chars().next().unwrap()
                   ) {
                   mrkrs.push(offset+eows)
                 }
               };
               wordwrap(t, chunk, offset+eows+1, mrkrs)
             },
             None => {
               if offset+chunk < t.len() { // String may continue
                 wordwrap(t, chunk, offset+1, mrkrs) // Recurse + 1 until next space
               } else {
                 use string::SubstMarks;

                 return t.subst_marks(mrkrs.to_vec(), "\n")
               }
             },
           }
         },
         Some(x) => {
           wordwrap(t, chunk, offset+x+1, mrkrs)
         },
       }
     };
     wordwrap(self, width+1, 0, &mut markers)
   }
 }
	// Copyright 2015-2017 Daniel P. Clark & array_tool Developers
	//
	// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
	// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
	// http://opensource.org/licenses/MIT>, at your option. This file may not be
	// copied, modified, or distributed except according to those terms.

	/// A grapheme iterator that produces the bytes for each grapheme.
	#[derive(Debug)]
	pub struct GraphemeBytesIter<'a> {
	source: &'a str,
	offset: usize,
	grapheme_count: usize,
	}
	impl<'a> GraphemeBytesIter<'a> {
	/// Creates a new grapheme iterator from a string source.
	pub fn new(source: &'a str) -> GraphemeBytesIter<'a> {
	GraphemeBytesIter {
	source: source,
	offset: 0,
	grapheme_count: 0,
	}
	}
	}
	impl<'a> Iterator for GraphemeBytesIter<'a> {
	type Item = &'a [u8];

	fn next(&mut self) -> Option<&'a [u8]> {
	let mut result: Option<&[u8]> = None;
	let mut idx = self.offset;
	for _ in self.offset..self.source.len() {
	idx += 1;
	if self.offset < self.source.len() {
	if self.source.is_char_boundary(idx) {
	let slice: &[u8] = self.source[self.offset..idx].as_bytes();

	self.grapheme_count += 1;
	self.offset = idx;

	result = Some(slice);
	break
	}
	}
	}
	result
	}
	}
	impl<'a> ExactSizeIterator for GraphemeBytesIter<'a> {
	fn len(&self) -> usize {
	self.source.chars().count()
	}
	}
	/// ToGraphemeBytesIter - create an iterator to return bytes for each grapheme in a string.
	pub trait ToGraphemeBytesIter<'a> {
	/// Returns a GraphemeBytesIter which you may iterate over.
	///
	/// # Example
	/// ```
	/// use array_tool::string::ToGraphemeBytesIter;
	///
	/// let string = "a s—d féZ";
	/// let mut graphemes = string.grapheme_bytes_iter();
	/// graphemes.skip(3).next();
	/// ```
	///
	/// # Output
	/// ```text
	/// [226, 128, 148]
	/// ```
	fn grapheme_bytes_iter(&'a self) -> GraphemeBytesIter<'a>;
	}
	impl<'a> ToGraphemeBytesIter<'a> for str {
	fn grapheme_bytes_iter(&'a self) -> GraphemeBytesIter<'a> {
	GraphemeBytesIter::new(&self)
	}
	}

	/// Squeeze - squeezes duplicate characters down to one each
	pub trait Squeeze {
	/// # Example
	/// ```
	/// use array_tool::string::Squeeze;
	///
	/// "yellow moon".squeeze("");
	/// ```
	///
	/// # Output
	/// ```text
	/// "yelow mon"
	/// ```
	fn squeeze(&self, targets: &'static str) -> String;
	}
	impl Squeeze for str {
	fn squeeze(&self, targets: &'static str) -> String {
	let mut output = Vec::<u8>::with_capacity(self.len());
	let everything: bool = targets.is_empty();
	let chars = targets.grapheme_bytes_iter().collect::<Vec<&[u8]>>();
	let mut last: &[u8] = &[0];
	for character in self.grapheme_bytes_iter() {
	if last != character {
	output.extend_from_slice(character);
	} else if !(everything \|\| chars.contains(&character)) {
	output.extend_from_slice(character);
	}
	last = character;
	}
	String::from_utf8(output).expect("squeeze failed to render String!")
	}
	}

	/// Justify - expand line to given width.
	pub trait Justify {
	/// # Example
	/// ```
	/// use array_tool::string::Justify;
	///
	/// "asd asdf asd".justify_line(14);
	/// ```
	///
	/// # Output
	/// ```text
	/// "asd asdf asd"
	/// ```
	fn justify_line(&self, width: usize) -> String;
	}

	impl Justify for str {
	fn justify_line(&self, width: usize) -> String {
	if self.is_empty() { return format!("{}", self) };
	let trimmed = self.trim() ;
	let len = trimmed.chars().count();
	if len >= width { return self.to_string(); };
	let difference = width - len;
	let iter = trimmed.split_whitespace();
	let spaces = iter.count() - 1;
	let mut iter = trimmed.split_whitespace().peekable();
	if spaces == 0 { return self.to_string(); }
	let mut obj = String::with_capacity(trimmed.len() + spaces);

	let div = difference / spaces;
	let mut remainder = difference % spaces;

	while let Some(x) = iter.next() {
	obj.push_str( x );
	let val = if remainder > 0 {
	remainder = remainder - 1;
	div + 1
	} else { div };
	for _ in 0..val+1 {
	if let Some(_) = iter.peek() { // Don't add spaces if last word
	obj.push_str( " " );
	}
	}
	}
	obj
	}
	}

	/// Substitute string character for each index given.
	pub trait SubstMarks {
	/// # Example
	/// ```
	/// use array_tool::string::SubstMarks;
	///
	/// "asdf asdf asdf".subst_marks(vec![0,5,8], "Z");
	/// ```
	///
	/// # Output
	/// ```text
	/// "Zsdf ZsdZ asdf"
	/// ```
	fn subst_marks(&self, marks: Vec<usize>, chr: &'static str) -> String;
	}
	impl SubstMarks for str {
	fn subst_marks(&self, marks: Vec<usize>, chr: &'static str) -> String {
	let mut output = Vec::<u8>::with_capacity(self.len());
	let mut count = 0;
	let mut last = 0;
	for i in 0..self.len() {
	let idx = i + 1;
	if self.is_char_boundary(idx) {
	if marks.contains(&count) {
	count += 1;
	last = idx;
	output.extend_from_slice(chr.as_bytes());
	continue
	}

	let slice: &[u8] = self[last..idx].as_bytes();
	output.extend_from_slice(slice);

	count += 1;
	last = idx
	}
	}
	String::from_utf8(output).expect("subst_marks failed to render String!")
	}
	}

	/// After whitespace
	pub trait AfterWhitespace {
	/// Given offset method will seek from there to end of string to find the first
	/// non white space. Resulting value is counted from offset.
	///
	/// # Example
	/// ```
	/// use array_tool::string::AfterWhitespace;
	///
	/// assert_eq!(
	/// "asdf asdf asdf".seek_end_of_whitespace(6),
	/// Some(9)
	/// );
	/// ```
	fn seek_end_of_whitespace(&self, offset: usize) -> Option<usize>;
	}
	impl AfterWhitespace for str {
	fn seek_end_of_whitespace(&self, offset: usize) -> Option<usize> {
	if self.len() < offset { return None; };
	let mut seeker = self[offset..self.len()].chars();
	let mut val = None;
	let mut indx = 0;
	while let Some(x) = seeker.next() {
	if x.ne(&" ".chars().next().unwrap()) {
	val = Some(indx);
	break;
	}
	indx += 1;
	}
	val
	}
	}

	/// Word wrapping
	pub trait WordWrap {
	/// White space is treated as valid content and new lines will only be swapped in for
	/// the last white space character at the end of the given width. White space may reach beyond
	/// the width you've provided. You will need to trim end of lines in your own output (e.g.
	/// splitting string at each new line and printing the line with trim_right). Or just trust
	/// that lines that are beyond the width are just white space and only print the width -
	/// ignoring tailing white space.
	///
	/// # Example
	/// ```
	/// use array_tool::string::WordWrap;
	///
	/// "asd asdf asd".word_wrap(8);
	/// ```
	///
	/// # Output
	/// ```text
	/// "asd asdf\nasd"
	/// ```
	fn word_wrap(&self, width: usize) -> String;
	}
	// No need to worry about character encoding since we're only checking for the
	// space and new line characters.
	impl WordWrap for &'static str {
	fn word_wrap(&self, width: usize) -> String {
	let mut markers = vec![];
	fn wordwrap(t: &'static str, chunk: usize, offset: usize, mrkrs: &mut Vec<usize>) -> String {
	match t[offset..*vec![offset+chunk,t.len()].iter().min().unwrap()].rfind("\n") {
	None => {
	match t[offset..*vec![offset+chunk,t.len()].iter().min().unwrap()].rfind(" ") {
	Some(x) => {
	let mut eows = x; // end of white space
	if offset+chunk < t.len() { // check if white space continues
	match t.seek_end_of_whitespace(offset+x) {
	Some(a) => {
	if a.ne(&0) {
	eows = x+a-1;
	}
	},
	None => {},
	}
	}
	if offset+chunk < t.len() { // safe to seek ahead by 1 or not end of string
	if !["\n".chars().next().unwrap(), " ".chars().next().unwrap()].contains(
	&t[offset+eows+1..offset+eows+2].chars().next().unwrap()
	) {
	mrkrs.push(offset+eows)
	}
	};
	wordwrap(t, chunk, offset+eows+1, mrkrs)
	},
	None => {
	if offset+chunk < t.len() { // String may continue
	wordwrap(t, chunk, offset+1, mrkrs) // Recurse + 1 until next space
	} else {
	use string::SubstMarks;

	return t.subst_marks(mrkrs.to_vec(), "\n")
	}
	},
	}
	},
	Some(x) => {
	wordwrap(t, chunk, offset+x+1, mrkrs)
	},
	}
	};
	wordwrap(self, width+1, 0, &mut markers)
	}
	}