so fucking messy please ignore everything

Cargo.toml

@@ -14,4 +14,20 @@ tokio = { version = "1", features = ["full"] }
 warp = { version = "0.4", features = ["server"] }
 termimad = "0.34.1"
 text-template = "0.1.0"
-iocraft = "0.7.17"
+#iocraft = "0.7.17"
+#ratatui = "0.30.0"
+#beautify = "0.2.0"
+borderrs = "0.1.1"
+boxen = "0.3.1"
+#blo_cli = "0.2.1"
+ansi-align = "0.2.2"
+#tabular = { version = "0.2.0", features = ["ansi-cell"] }
+#rich-rs = "1.1.0"
+lipgloss = "0.1.1"
+#textwrap = "0.16.2"
+mdriver = "0.14.0"
+#tree-sitter-md = { version = "0.5.2", features = ["parser"] }
+#mdfrier = "0.2.0"
+markless = "0.9.10"
+mq-view = "0.1.9"
+mq-markdown = { version = "0.5.14", features = ["color"] }

src/main.rs

@@ -1,10 +1,18 @@
+#![warn(unused_extern_crates)]
 use std::{
     fs::ReadDir,
+    io::{BufWriter, Write, stdout},
+    ops::Deref,
     path::{self, Path, PathBuf},
     str::FromStr,
 };
 
-use iocraft::{ElementExt, prelude::*};
+use ansi_align::{AlignOptions, ansi_align, ansi_align_with_options};
+use borderrs::BorderFormatter;
+use boxen::boxen;
+use lipgloss::{Border, Position};
+use mq_markdown::{ColorTheme, ListStyle, Markdown, Node, RenderOptions, UrlSurroundStyle};
+use mq_view::{RenderConfig, render_markdown, render_markdown_with_config};
 use serde::de::value;
 use warp::{Filter, filters::path::FullPath};
 
@@ -42,24 +50,260 @@ fn renderer(path: FullPath, user_agent: String) -> Box<dyn warp::Reply> {
 
         if user_agent.starts_with("curl/") {
             println!("displaying curl formatting");
+            /*let box_opts = boxen::builder()
+            .border_style(boxen::BorderStyle::Round)
+            .width(60)
+            .padding(3)
+            .text_alignment(boxen::TextAlignment::Center);*/
             let page_markdowns: Vec<String> = page_contents
                 .iter()
                 .map(|x| {
-                    let marked_down =
+                    /*let md_two = Markdown::new(std::fs::read_to_string(x).unwrap_or_default());
-                        termimad::text(std::fs::read_to_string(x).unwrap_or_default().as_str())
+                    let console = rich_rs::Console::new();
-                            .to_string();
+                    let options = ConsoleOptions::default();
-                    element! {
+                    let seg = md_two.render(&console, &options);
-                        View (
+                    for s in seg {
-                            border_style: BorderStyle::Round,
+                        println!("{}", s.text);
-                            border_color: Color::Blue,
+                    }*/
-                            ) {
+                    //                    println!("{}", seg);
-                            Text(content: marked_down)
+                    //
-                        }
+
+                    /*let mut frier = mdfrier::MdFrier::new().unwrap();
+                    let lines = frier.parse(
+                        60,
+                        std::fs::read_to_string(x).unwrap().as_str(),
+                        &mdfrier::DefaultMapper,
+                    );
+                    let text: String = lines
+                        .iter()
+                        .flat_map(|l| l.spans.iter().map(|s| s.content.as_str()))
+                        .collect();*/
+
+                    //println!("{}", text);
+
+                    //let dm = tree_sitter_md::MarkdownParser::default();
+                    //tree_sitter_md::MarkdownCursor::type_id
+                    //dm.parse(std::fs::read(x).unwrap(), old_tree);
+                    /*
+                    /*let mut md_parser = mdriver::StreamingParser::with_width(
+                        "Solarized (dark)",
+                        mdriver::ImageProtocol::None,
+                        60,
+                    );*/*/
+                    /*let mut md_parser = mdriver::StreamingParser::new();
+                    let mdd = mdriver::StreamingParser::new()
+                        .feed(std::fs::read_to_string(x).unwrap_or_default().as_str());
+                    //let mdd = md_parser
+                    //    .format_inline(std::fs::read_to_string(x).unwrap_or_default().as_str());
+
+                    let mddd = md_parser.feed(mdd.as_str());
+                    let mdddd = md_parser.wrap_text(mddd.as_str(), "    ", "");
+
+                    println!("{}", mdddd);*/
+
+                    let source = std::fs::read_to_string(x).unwrap();
+                    /*let theme = mq_markdown::ColorTheme {
+                        heading:"",
+                        code:"",
+                        code_inline:"",
+                        emphasis:"",
+                        strong:"",
+                        link:"",
+                        link_url:"",
+                        image:"",
+                        blockquote_marker:"",
+                        delete:"",
+                        horizontal_rule:"",
+                        html:"",
+                        frontmatter:"",
+                        list_marker:"",
+                        table_separator:"",
+                        math:"",
+                    };*/
+                    /*let theme = ColorTheme {
+                        heading: ("\u{1b}[1m\u{1b}[36m", "\u{1b}[0m"),
+                        code: ("\u{1b}[32m", "\u{1b}[0m"),
+                        code_inline: ("\u{1b}[32m", "\u{1b}[0m"),
+                        emphasis: ("\u{1b}[3m\u{1b}[33m", "\u{1b}[0m"),
+                        strong: ("\u{1b}[1m", "\u{1b}[0m"),
+                        link: ("\u{1b}[4m\u{1b}[34m", "\u{1b}[0m"),
+                        link_url: ("\u{1b}[34m", "\u{1b}[0m"),
+                        image: ("\u{1b}[35m", "\u{1b}[0m"),
+                        blockquote_marker: ("\u{1b}[2m", "\u{1b}[0m"),
+                        delete: ("\u{1b}[31m\u{1b}[2m", "\u{1b}[0m"),
+                        horizontal_rule: ("\u{1b}[2m", "\u{1b}[0m"),
+                        html: ("\u{1b}[2m", "\u{1b}[0m"),
+                        frontmatter: ("\u{1b}[2m", "\u{1b}[0m"),
+                        list_marker: ("\u{1b}[33m", "\u{1b}[0m"),
+                        table_separator: ("\u{1b}[2m", "\u{1b}[0m"),
+                        math: ("\u{1b}[32m", "\u{1b}[0m"),
+                    };*/
+                    //println!("{:?}", ColorTheme::COLORED);
+                    //mq_markdown::ColorTheme::from(value)
+
+                    //Markdown::to_colored_string_with_theme(&self, theme)
+                    let mut mq: mq_markdown::Markdown = source.parse().unwrap();
+                    let render_opts = RenderOptions {
+                        list_style: ListStyle::Dash,
+                        link_url_style: UrlSurroundStyle::None,
+                        link_title_style: mq_markdown::TitleSurroundStyle::Single,
+                    };
+                    mq.set_options(render_opts);
+                    let theme = ColorTheme::parse_colors("heading=34:code=31");
+                    //mq.to_html();
+                    mq.to_colored_string_with_theme(&theme);
+                    /*for n in &mut mq.nodes {
+                        if n.is_heading(Some(1)) {
+                            //println!("{:#?}", n.node_values());
+                            n.set_attr("value", "test_value");
+                            //n.
+                        };
+                    }*/
+                    /*let new_mq: Vec<Node> = mq
+                        .nodes
+                        .clone()
+                        .iter_mut()
+                        .map(|n| {
+                            if n.ite .is_heading(Some(1)) {
+                                n.set_attr("value", "test_value");
+                            };
+                            n.to_owned()
+                        })
+                        .collect();
+                    let new_q = Markdown::new(new_mq);
+                    mq.nodes.remove(1);*/
+                    let render_conf = RenderConfig {
+                        header_full_width_highlight: false,
+                    };
+
+                    //mq_view::SyntaxHighlighter::new().highlight("code", Markdown);
+                    let styled_mq = mq_view::render_markdown_to_string(&mq).unwrap();
+
+                    let mut writer: Vec<u8> = Vec::new();
+
+                    render_markdown_with_config(&mq, &mut writer, &render_conf).unwrap();
+
+                    let render_string = String::from_utf8(writer).unwrap();
+
+                    println!("{}", render_string);
+
+                    //MARKLESS IS GREAT
+                    /*
+                    let test = markless::document::Document::parse(
+                        std::fs::read_to_string(x).unwrap().as_str(),
+                    )
+                    .unwrap();
+                    for l in test.visible_lines(0, test.line_count()) {
+                        println!("{}", l.as_str());
                     }
-                    .to_string()
+                    */
+                    //
+
+                    //println!("{:#?}", test.line_at(1));
+
+                    let md = mdriver::StreamingParser::new().feed(
+                        termimad::text(std::fs::read_to_string(x).unwrap_or_default().as_str())
+                            .to_string()
+                            .as_str(),
+                    );
+                    let border_style = lipgloss::Style::new()
+                        .border(Border::new(
+                            "─", "─", "│", "│", "╭", "╮", "╰", "╯", "", "", "", "", "",
+                        ))
+                        .width(80)
+                        .padding(0, 2, 0, 2)
+                        .align_horizontal(lipgloss::position::CENTER);
+                    border_style.render(render_string.as_str())
+                    //let mut table = Table::new("{:<}");
+                    /*let md_two = rich_rs::Text::from_markup(
+                        std::fs::read_to_string(x).unwrap_or_default().as_str(),
+                        false,
+                    )
+                    .unwrap_or_default();
+                    format!("{}", md_two.to_markup())*/
+                    //blo_cli::styles::border(&md, BorderStyle::Rounded, None)
+                    /*ansi_align_with_options(
+                        md.as_str(),
+                        &AlignOptions::new(ansi_align::Alignment::Center).with_pad("-"),
+                    )
+                    .to_string()*/
+                    //println!()
+                    /*boxen::options::DimensionConstraints {}
+                    let boxen_opts = boxen::builder()
+                        .border_style(boxen::BorderStyle::Round)
+                        .title(x.file_stem().unwrap().to_str().unwrap_or_default())
+                        .width(60)
+                        //.height(0)
+                        .padding(1)
+                        .fullscreen(boxen::FullscreenMode::Custom(|_, _| (70, 1000)))
+                        .text_alignment(boxen::TextAlignment::Center)
+                        .build();
+                    /*boxen::options::DimensionConstraints {
+                        max_width: Some(40),
+                        max_height: None,
+                    }*/
+                    boxen("test", Some(boxen_opts)).unwrap()*/
+                    //builder("test")
+                    /*    (
+                        termimad::text(std::fs::read_to_string(x).unwrap_or_default().as_str())
+                            .to_string(),
+                    )
+                    .unwrap()*/
+                    //.split("\n")
+                    //.map(|y| format!("{}", y))
+                    //.collect::<Vec<String>>() //::<Vec<MixedTextContent>>()
+                    /*for line in
+                        termimad::text(std::fs::read_to_string(x).unwrap_or_default().as_str())
+                            .to_string()
+                            .split("\n")
+                    {
+                        MixedTextContent::new(line)
+                    }*/
+                    /*                    MixedTextContent::new(
+                        termimad::text(std::fs::read_to_string(x).unwrap_or_default().as_str())
+                            .to_string(),
+                    )*/
                 })
                 .collect();
-            let page_md_collected = page_markdowns.join("\n");
+
+            for c in &page_markdowns {
+                println!("{}\n", c);
+            }
+            //beautify::Colors::border()
+            //let line = ratatui::text::Line::from("text test!");
+            //           let writer = Vec::new().clone();
+            //            let be = ratatui::backend::CrosstermBackend::new(writer.clone());
+            //            let mut term = ratatui::Terminal::new(be).unwrap();
+            //term.draw(|f: &mut Frame| f.render_widget(line, f.area()));
+            //let bytes = writer;
+            /*ratatui::run(|t| {
+                //                loop {
+                t.draw(|f| f.render_widget("line", f.area()));
+                //                }
+            });*/
+
+            //   .draw(|f| f.render_widget(line, f.area()))
+            //   .unwrap();
+            //            ratatui::run(|term| term.draw(|f| f.render_widget(line, f.area())).unwrap());
+            //            let string = String::from_utf8(writer.clone()).unwrap();
+            //            println!("maybe: {}", string);
+            //todo!();
+            //ratatui::widgets::Block::new()
+            //println!("{:#?}", page_markdowns);
+            /*let test_text = tui::text::Text::from();
+            let test_block = tui::widgets::Paragraph::new("test");*/
+            /*let md_element = element! {
+                View (
+                    border_style: BorderStyle::Round,
+                    border_color: Color::Blue,
+                    //width: 30,
+                    display: Display::Flex,
+                    ) {
+                    MixedText(contents: page_markdowns)
+                }
+            }
+            .to_string();*/
+            let page_md_collected = format!("{}\n", page_markdowns.join("\n"));
 
             /*            let test = iocraft::prelude::element! {
                 View(