Implement ANSI formatting stuff

Author: matthew-a-thomas

.gitignore

@@ -0,0 +1,2 @@
+/target
+**/*.rs.bk

Cargo.lock

@@ -0,0 +1,9 @@
+[package]
+name = "colored"
+version = "0.1.0"
+authors = ["Matt Thomas <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

Cargo.toml

@@ -0,0 +1,34 @@
+use crate::colors::*;
+use core::fmt;
+
+pub trait Background: Sized {
+    fn background(self, rgb: Rgb) -> WithBackground<Self>;
+}
+
+pub struct WithBackground<T> {
+    t: T,
+    rgb: Rgb
+}
+
+impl<T> Background for &T {
+    fn background(self, rgb: Rgb) -> WithBackground<Self> {
+        WithBackground {
+            t: self,
+            rgb
+        }
+    }
+}
+
+impl<T> fmt::Display for WithBackground<T>
+where T: fmt::Display {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "\x1B[48;2;{};{};{}m{}\x1B[0m", self.rgb.r, self.rgb.g, self.rgb.b, self.t)
+    }
+}
+
+impl<T> fmt::Debug for WithBackground<T>
+where T: fmt::Debug {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "\x1B[48;2;{};{};{}m{:?}\x1B[0m", self.rgb.r, self.rgb.g, self.rgb.b, self.t)
+    }
+}

src/background.rs

@@ -0,0 +1,31 @@
+use core::fmt;
+
+pub trait Blink: Sized {
+    fn blink(self) -> WithBlink<Self>;
+}
+
+pub struct WithBlink<T> {
+    t: T
+}
+
+impl<T> Blink for &T {
+    fn blink(self) -> WithBlink<Self> {
+        WithBlink {
+            t: self
+        }
+    }
+}
+
+impl<T> fmt::Display for WithBlink<T>
+where T: fmt::Display {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "\x1B[5m{}\x1B[0m", self.t)
+    }
+}
+
+impl<T> fmt::Debug for WithBlink<T>
+where T: fmt::Debug {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "\x1B[5m{:?}\x1B[0m", self.t)
+    }
+}

src/blink.rs

@@ -0,0 +1,31 @@
+use core::fmt;
+
+pub trait Bold<T>: Sized {
+    fn bold(self) -> WithBold<Self>;
+}
+
+pub struct WithBold<T> {
+    t: T
+}
+
+impl<T> Bold<T> for &T {
+    fn bold(self) -> WithBold<Self> {
+        WithBold {
+            t: self
+        }
+    }
+}
+
+impl<T> fmt::Display for WithBold<T>
+where T: fmt::Display {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "\x1B[1m{}\x1B[0m", self.t)
+    }
+}
+
+impl<T> fmt::Debug for WithBold<T>
+where T: fmt::Debug {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "\x1B[1m{:?}\x1B[0m", self.t)
+    }
+}

src/bold.rs

@@ -0,0 +1,54 @@
+#[derive(Clone)]
+#[derive(Copy)]
+#[derive(Debug)]
+pub struct Rgb {
+    pub r: u8,
+    pub g: u8,
+    pub b: u8
+}
+
+impl Rgb {
+    pub const fn new(r: u8, g: u8, b: u8) -> Self {
+        Self {
+            r,
+            g,
+            b
+        }
+    }
+}
+
+pub struct Colors();
+
+impl Colors {
+    pub fn red() -> Rgb {
+        Rgb::new(255, 0, 0)
+    }
+
+    pub fn orange() -> Rgb {
+        Rgb::new(255, 127, 0)
+    }
+
+    pub fn yellow() -> Rgb {
+        Rgb::new(255, 255, 0)
+    }
+
+    pub fn green() -> Rgb {
+        Rgb::new(0, 255, 0)
+    }
+
+    pub fn cyan() -> Rgb {
+        Rgb::new(0, 255, 255)
+    }
+
+    pub fn blue() -> Rgb {
+        Rgb::new(0, 0, 255)
+    }
+
+    pub fn purple() -> Rgb {
+        Rgb::new(127, 0, 127)
+    }
+
+    pub fn violet() -> Rgb {
+        Rgb::new(127, 0, 255)
+    }
+}

src/colors.rs

@@ -0,0 +1,34 @@
+use crate::colors::*;
+use core::fmt;
+
+pub trait Foreground: Sized {
+    fn foreground(self, rgb: Rgb) -> WithForeground<Self>;
+}
+
+pub struct WithForeground<T> {
+    t: T,
+    rgb: Rgb
+}
+
+impl<T> Foreground for &T {
+    fn foreground(self, rgb: Rgb) -> WithForeground<Self> {
+        WithForeground {
+            t: self,
+            rgb
+        }
+    }
+}
+
+impl<T> fmt::Display for WithForeground<T>
+where T: fmt::Display {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "\x1B[38;2;{};{};{}m{}\x1B[0m", self.rgb.r, self.rgb.g, self.rgb.b, self.t)
+    }
+}
+
+impl<T> fmt::Debug for WithForeground<T>
+where T: fmt::Debug {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "\x1B[38;2;{};{};{}m{:?}\x1B[0m", self.rgb.r, self.rgb.g, self.rgb.b, self.t)
+    }
+}

src/foreground.rs

@@ -0,0 +1,31 @@
+use core::fmt;
+
+pub trait Italic: Sized {
+    fn italic(self) -> WithItalic<Self>;
+}
+
+pub struct WithItalic<T> {
+    t: T
+}
+
+impl<T> Italic for &T {
+    fn italic(self) -> WithItalic<Self> {
+        WithItalic {
+            t: self
+        }
+    }
+}
+
+impl<T> fmt::Display for WithItalic<T>
+where T: fmt::Display {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "\x1B[3m{}\x1B[0m", self.t)
+    }
+}
+
+impl<T> fmt::Debug for WithItalic<T>
+where T: fmt::Debug {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "\x1B[3m{:?}\x1B[0m", self.t)
+    }
+}

src/italic.rs

@@ -0,0 +1,17 @@
+#![no_std]
+
+mod background;
+mod blink;
+mod bold;
+mod colors;
+mod foreground;
+mod italic;
+mod underline;
+
+pub use background::*;
+pub use blink::*;
+pub use bold::*;
+pub use colors::*;
+pub use foreground::*;
+pub use italic::*;
+pub use underline::*;