gitv 0.1.0

A git repos analyzing and visualizing tool built in Rust.
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

mod config;
mod executor;
mod fetcher;
mod gitimp;
mod record;
mod render;
mod shell;

use anyhow::Result;
use clap::{IntoApp, Parser};
use config::*;
use executor::*;
use fetcher::*;
use gitimp::*;
use record::*;
use std::{fs::File, io::Write, process::exit};

#[derive(Debug, Parser)]
#[clap(about = "\nA git repos analyzing and visualizing tool built in Rust.")]
#[clap(version)]
struct Cli {
    /// Retrieve repos and create new databases
    #[clap(short, long)]
    create: bool,

    /// Fetch repos metadata from remote source (github)
    #[clap(short, long)]
    fetch: bool,

    /// Render query result as the given mode (htlm, table)
    #[clap(short, long)]
    render: bool,

    /// Load data and enter into a new spawn shell
    #[clap(short, long)]
    shell: bool,

    /// Generate the example config file (default: gitv.example.yaml)
    #[clap(short, long)]
    gernerate: bool,

    /// config file path (default: gitv.yaml)
    path: Option<String>,
}

static DEFAULT_CONFIG: &str = include_str!("../static/gitv.example.yaml");

#[tokio::main]
async fn main() -> Result<()> {
    let cli: Cli = Cli::parse();
    if !cli.create && !cli.fetch && !cli.render && !cli.shell && !cli.gernerate {
        Cli::command().print_help().unwrap();
        exit(0)
    }

    if cli.gernerate {
        let p = &cli.path.unwrap_or_else(|| "gitv.example.yaml".to_string());
        let mut f = match File::create(p) {
            Err(e) => {
                println!("Create config file error: {}", e);
                exit(1)
            }
            Ok(f) => f,
        };

        if let Err(e) = f.write_all(DEFAULT_CONFIG.as_bytes()) {
            println!("Write config file error: {}", e);
            exit(1)
        }
        exit(0)
    }

    let c: Config = match config::load_config(&cli.path.unwrap_or_else(|| "gitv.yaml".to_string()))
    {
        Err(e) => {
            println!("Load config error: {}", e);
            exit(1);
        }
        Ok(c) => c,
    };

    if cli.create && c.create.is_some() {
        if let Err(e) = CsvSerializer::serialize(c.create.unwrap()).await {
            println!("Create database error: {}", e);
            exit(1);
        };
        exit(0)
    }

    if cli.fetch && c.fetch.is_some() {
        let repo_fetcher = RepoFetcher::new(c.fetch.unwrap());
        if let Err(e) = repo_fetcher.fetch().await {
            println!("Fetch repos error: {}", e);
            exit(1);
        };
        exit(0)
    }

    if cli.shell && c.shell.is_some() {
        let ctx = Executor::create_context(c.shell.unwrap().executions).await;
        let ctx = match ctx {
            Err(e) => {
                println!("Create executor context error: {}", e);
                exit(1)
            }
            Ok(ctx) => ctx,
        };

        if let Err(e) = shell::console_loop(ctx).await {
            println!("Shell console loop error: {}", e);
            exit(1);
        };
        exit(0)
    }

    if cli.render && c.render.is_some() {
        let render_config = c.render.unwrap();
        let executions = render_config.executions.clone();
        let ctx = match Executor::create_context(executions).await {
            Err(e) => {
                println!("Create executor context error: {}", e);
                exit(1)
            }
            Ok(ctx) => ctx,
        };

        if let Err(e) = render::create_render(ctx, render_config).render().await {
            println!("Render output error: {}", e);
            exit(1);
        }
        exit(0)
    }

    Ok(())
}