refactor(treewide): Combine the separate crates in one workspace

1 files changed, 0 insertions, 178 deletions

diff --git a/src/comments/mod.rs b/src/comments/mod.rs
deleted file mode 100644
index 5fbc3fb..0000000
--- a/src/comments/mod.rs
+++ /dev/null
@@ -1,178 +0,0 @@
-// yt - A fully featured command line YouTube client
-//
-// Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-// This file is part of Yt.
-//
-// You should have received a copy of the License along with this program.
-// If not, see <https://www.gnu.org/licenses/gpl-3.0.txt>.
-
-use std::{
-    io::Write,
-    mem,
-    process::{Command, Stdio},
-};
-
-use anyhow::{bail, Context, Result};
-use comment::{CommentExt, Comments};
-use regex::Regex;
-use yt_dlp::wrapper::info_json::{Comment, InfoJson, Parent};
-
-use crate::{
-    app::App,
-    storage::video_database::{
-        getters::{get_currently_playing_video, get_video_info_json},
-        Video,
-    },
-};
-
-mod comment;
-mod display;
-
-pub async fn get_comments(app: &App) -> Result<Comments> {
-    let currently_playing_video: Video =
-        if let Some(video) = get_currently_playing_video(app).await? {
-            video
-        } else {
-            bail!("Could not find a currently playing video!");
-        };
-
-    let mut info_json: InfoJson = get_video_info_json(&currently_playing_video)
-        .await?
-        .expect("A currently *playing* must be cached. And thus the info.json should be available");
-
-    let base_comments = mem::take(&mut info_json.comments).expect("A video should have comments");
-    drop(info_json);
-
-    let mut comments = Comments::new();
-    base_comments.into_iter().for_each(|c| {
-        if let Parent::Id(id) = &c.parent {
-            comments.insert(&(id.clone()), CommentExt::from(c));
-        } else {
-            comments.push(CommentExt::from(c));
-        }
-    });
-
-    comments.vec.iter_mut().for_each(|comment| {
-       let replies = mem::take(&mut comment.replies);
-       let mut output_replies: Vec<CommentExt>  = vec![];
-
-       let re = Regex::new(r"\u{200b}?(@[^\t\s]+)\u{200b}?").unwrap();
-       for reply in replies {
-           if let Some(replyee_match) =  re.captures(&reply.value.text){
-               let full_match = replyee_match.get(0).expect("This always exists");
-               let text = reply.
-                   value.
-                   text[0..full_match.start()]
-                   .to_owned()
-                   +
-                   &reply
-                   .value
-                   .text[full_match.end()..];
-               let text: &str = text.trim().trim_matches('\u{200b}');
-
-               let replyee = replyee_match.get(1).expect("This should exist").as_str();
-
-
-               if let Some(parent) = output_replies
-                   .iter_mut()
-                   // .rev()
-                   .flat_map(|com| &mut com.replies)
-                   .flat_map(|com| &mut com.replies)
-                   .flat_map(|com| &mut com.replies)
-                   .filter(|com| com.value.author == replyee)
-                   .last()
-               {
-                   parent.replies.push(CommentExt::from(Comment {
-                       text: text.to_owned(),
-                       ..reply.value
-                   }))
-               } else if let Some(parent) = output_replies
-                   .iter_mut()
-                   // .rev()
-                   .flat_map(|com| &mut com.replies)
-                   .flat_map(|com| &mut com.replies)
-                   .filter(|com| com.value.author == replyee)
-                   .last()
-               {
-                   parent.replies.push(CommentExt::from(Comment {
-                       text: text.to_owned(),
-                       ..reply.value
-                   }))
-               } else if let Some(parent) = output_replies
-                   .iter_mut()
-                   // .rev()
-                   .flat_map(|com| &mut com.replies)
-                   .filter(|com| com.value.author == replyee)
-                   .last()
-               {
-                   parent.replies.push(CommentExt::from(Comment {
-                       text: text.to_owned(),
-                       ..reply.value
-                   }))
-               } else if let Some(parent) = output_replies.iter_mut()
-                   // .rev()
-                   .filter(|com| com.value.author == replyee)
-                   .last()
-               {
-                   parent.replies.push(CommentExt::from(Comment {
-                       text: text.to_owned(),
-                       ..reply.value
-                   }))
-               } else {
-                   eprintln!(
-                   "Failed to find a parent for ('{}') both directly and via replies! The reply text was:\n'{}'\n",
-                   replyee,
-                   reply.value.text
-               );
-                   output_replies.push(reply);
-               }
-           } else {
-               output_replies.push(reply);
-           }
-       }
-       comment.replies = output_replies;
-    });
-
-    Ok(comments)
-}
-
-pub async fn comments(app: &App) -> Result<()> {
-    let comments = get_comments(app).await?;
-
-    let mut less = Command::new("less")
-        .args(["--raw-control-chars"])
-        .stdin(Stdio::piped())
-        .stderr(Stdio::inherit())
-        .spawn()
-        .context("Failed to run less")?;
-
-    let mut child = Command::new("fmt")
-        .args(["--uniform-spacing", "--split-only", "--width=90"])
-        .stdin(Stdio::piped())
-        .stderr(Stdio::inherit())
-        .stdout(less.stdin.take().expect("Should be open"))
-        .spawn()
-        .context("Failed to run fmt")?;
-
-    let mut stdin = child.stdin.take().context("Failed to open stdin")?;
-    std::thread::spawn(move || {
-        stdin
-            .write_all(comments.render(true).as_bytes())
-            .expect("Should be able to write to stdin of fmt");
-    });
-
-    let _ = less.wait().context("Failed to await less")?;
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod test {
-    #[test]
-    fn test_string_replacement() {
-        let s = "A \n\nB\n\nC".to_owned();
-        assert_eq!("A \n  \n  B\n  \n  C", s.replace('\n', "\n  "))
-    }
-}