feature: Add Deref impl for ColoredStrings.

Author: shanecelis

src/lib.rs

@@ -39,26 +39,71 @@ mod color;
 pub mod control;
 mod style;
 
+// use std::str::pattern::Pattern;
 pub use self::customcolors::CustomColor;
 
 /// Custom colors support.
 pub mod customcolors;
 
 pub use color::*;
 
-use std::{borrow::Cow, fmt, ops::Deref};
+use std::{borrow::Cow, fmt, ops::Deref, ops::DerefMut};
 
 pub use style::{Style, Styles};
 
 /// A string that may have color and/or style applied to it.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ColoredString<'a> {
-    input: Cow<'a, str>,
+    pub input: Cow<'a, str>,
     fgcolor: Option<Color>,
     bgcolor: Option<Color>,
     style: style::Style,
 }
 
+/// A collection of colored strings.
+#[derive(Clone, Debug, PartialEq, Eq, Default)]
+pub struct ColoredStrings<'a>(pub Vec<ColoredString<'a>>);
+
+impl<'a> Deref for ColoredStrings<'a> {
+    type Target = Vec<ColoredString<'a>>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<'a> DerefMut for ColoredStrings<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<'a> ColoredStrings<'a> {
+    fn new() -> Self {
+        ColoredStrings::default()
+    }
+
+    pub fn split(self, pat: char) -> Vec<ColoredStrings<'a>> {
+        let mut accum: Vec<ColoredStrings> = Vec::new();
+        accum.push(ColoredStrings::default());
+        for colored_string in self.0 {
+            let mut i = colored_string.split(pat);
+            if let Some(mut first) = i.next() {
+                accum.last_mut().unwrap().push(first);
+            }
+            accum.extend(i.map(|s| {
+                ColoredStrings(vec![s])
+            }));
+        }
+        accum
+    }
+}
+
+impl<'a, T> From<T> for ColoredStrings<'a> where T: Into<Cow<'a, str>> {
+    fn from(item: T) -> Self {
+        Self(vec![item.into().into()])
+    }
+}
+
 /// The trait that enables something to be given color.
 ///
 /// You can use `colored` effectively simply by importing this trait
@@ -465,6 +510,25 @@ impl<'a> ColoredString<'a> {
 
         input_cow
     }
+
+    // We can use Pattern once it becomes stable.
+    // fn split<P: Pattern<'a>>(&'a self, pat: P) -> impl Iterator<Item = ColoredString<'a>>{
+    fn split(self, pat: char) -> impl Iterator<Item = ColoredString<'a>> {
+        let mut a = None;
+        let mut b = None;
+        if self.input.find(pat).is_none() {
+            a = Some(self);
+        } else {
+            b = Some(self.input.split(pat).map(move |s| ColoredString {
+                input: s.to_owned().into(),
+                fgcolor: self.fgcolor.clone(),
+                bgcolor: self.bgcolor.clone(),
+                style: self.style.clone()
+            }).collect::<Vec<_>>());
+        }
+        // Here's how you coalesce two iterators, only one of which has content.
+        a.into_iter().chain(b.into_iter().flatten())
+    }
 }
 
 impl Default for ColoredString<'static> {
@@ -623,6 +687,15 @@ impl<'a> fmt::Display for ColoredString<'a> {
     }
 }
 
+impl<'a> fmt::Display for ColoredStrings<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for s in &self.0 {
+            s.fmt(f)?
+        }
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;