see-cat 0.8.1

A cute cat(1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use crate::config::initialize_app;
use crate::viewers::{determine_viewer, ViewerManager};
use std::io::{self, IsTerminal};
use std::path::Path;

mod app;
mod config;
mod constants;
mod directory_tree;
mod render;
mod utils;
mod viewers;

use base64::{engine::general_purpose, Engine as _};
use std::fs;

fn main() -> std::io::Result<()> {
    let (config, file_paths) = initialize_app()?;
    if config.debug_mode {
        eprintln!("Debug mode enabled");
        eprintln!("Configuration: {:?}", config);
    }

    let viewer_manager = ViewerManager::new();

    match &file_paths {
        Some(paths) if !paths.is_empty() => {
            for path in paths {
                let path = Path::new(path);
                if path.is_dir() {
                    directory_tree::handle_directory(path)?;
                } else {
                    let viewer = determine_viewer(path);
                    if viewer.contains(&"image".to_string()) {
                        let img_data = fs::read(path)?;
                        let b64 = general_purpose::STANDARD.encode(&img_data);
                        let extension = path.extension().unwrap().to_str().unwrap();
                        let content = format!("data:image/{};base64,{}", extension, b64);

                        if !io::stdout().is_terminal() {
                            let file_name = path.file_name().unwrap().to_str().unwrap();
                            println!("![{}]({})", file_name, content);
                        } else {
                            viewer_manager.visualize(&viewer, &content, None)?;
                        }
                    } else {
                        let content = app::read_content(Some(path.to_string_lossy().into_owned()))?;
                        if !io::stdout().is_terminal() {
                            print!("{}", content);
                        } else {
                            viewer_manager.visualize(
                                &viewer,
                                &content,
                                Some(path.to_str().unwrap()),
                            )?;
                        }
                    }
                }
            }
        }
        _ => {
            let content = app::read_content(None)?;
            if !io::stdout().is_terminal() {
                print!("{}", content);
            } else {
                viewer_manager.visualize(&["markdown".to_string()], &content, None)?;
            }
        }
    }

    Ok(())
}