Handle ANSI color codes about textwrap HOT 7 CLOSED

extern crate pulldown_cmark;
extern crate textwrap;

use pulldown_cmark::{Event, Parser, Tag};
use std::io::Write;

#[derive(Debug)]
enum Span<'a> {
    Text(String),
    Markup(&'a [u8]),
}

const RESET: &'static [u8] = b"\x1b[m";
const BOLD: &'static [u8] = b"\x1b[1m";
const ITALIC: &'static [u8] = b"\x1b[3m";
const UNDERLINE: &'static [u8] = b"\x1b[4m";

fn main() {
    let s = r#"**Markdown** is a [lightweight *markup* language](https://en.wikipedia.org/wiki/Lightweight_markup_language) with plain text formatting syntax."#;

    let mut text = String::new();
    let mut spans = vec![];
    let mut markup_stack = vec![];

    println!("//// events:");
    for event in Parser::new(s) {
        println!("{:?}", event);
        match event {
            Event::Text(t) => {
                text.push_str(&t);
                spans.push(Span::Text(t.into_owned()));
            }
            Event::Start(Tag::Strong) => {
                markup_stack.push(BOLD);
                spans.push(Span::Markup(BOLD));
            }
            Event::Start(Tag::Emphasis) => {
                markup_stack.push(ITALIC);
                spans.push(Span::Markup(ITALIC));
            }
            Event::Start(Tag::Link(_, _)) => {
                markup_stack.push(UNDERLINE);
                spans.push(Span::Markup(UNDERLINE));
            }
            Event::End(Tag::Strong) | Event::End(Tag::Emphasis) | Event::End(Tag::Link(_, _)) => {
                markup_stack.pop();
                spans.push(Span::Markup(RESET));
                spans.extend(markup_stack.iter().map(|m| Span::Markup(m)));
            }
            _ => {}
        }
    }
    println!();

    println!("//// without markup:");
    let wrapper = textwrap::Wrapper::with_splitter(30, textwrap::NoHyphenation);
    let filled = wrapper.fill(&text);
    assert_eq!(filled.len(), text.len(), "fill should not change length");
    println!("{}", filled);
    println!();

    println!("//// with markup:");
    let mut offset = 0;
    let mut out = std::io::stdout();
    for span in &spans {
        match span {
            Span::Markup(m) => {
                out.write_all(m).expect("write failed!");
            }
            Span::Text(t) => {
                // This uses the fact that `filled` has the same
                // length as `text`, except that some ' ' have been
                // replaced with newlines '\n'. We can thus share
                // offsets between the two strings.
                print!("{}", &filled[offset..offset + t.len()]);
                offset += t.len();
            }
        }
    }
    println!();
}

    let mut styled = StyledString::plain("Isn't ");
    styled.append(StyledString::styled("that ", Color::Dark(BaseColor::Red)));
    styled.append(StyledString::styled(
        "cool?",
        Style::from(Color::Light(BaseColor::Blue)).combine(Effect::Bold),
    ));