stfg 0.1.0

a tool that converts sqlite to/from git-friendly format
Documentation 
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

use ragit_cli::{
    ArgCount,
    ArgParser,
    ArgType,
    Span,
    get_closest_string,
};
use stfg::{Error, from_git, to_git};

fn main() {
    let args = std::env::args().collect::<Vec<_>>();

    if let Err(e) = run(&args) {
        match e {
            Error::CliError { message, span } => {
                eprintln!(
                    "cli error: {message}{}",
                    if let Some(span) = span {
                        format!("\n\n{}", ragit_cli::underline_span(&span))
                    } else {
                        String::new()
                    },
                );
            },
            _ => {
                eprintln!("{e:?}");
            },
        }

        std::process::exit(1);
    }
}

fn run(args: &[String]) -> Result<(), Error> {
    match args.get(1).map(|arg| arg.as_str()) {
        Some("to-git" | "from-sql") => {
            let parsed_args = ArgParser::new()
                .arg_flag("--output", ArgType::String)
                .short_flag(&["--output"])
                .args(ArgType::String, ArgCount::Exact(1))
                .parse(&args, 2)?;

            let input = parsed_args.get_args_exact(1)?[0].clone();
            let output = parsed_args.arg_flags.get("--output").unwrap().to_string();
            to_git(&input, &output)?;
        },
        Some("from-git" | "to-sql") => {
            let parsed_args = ArgParser::new()
                .arg_flag("--output", ArgType::String)
                .short_flag(&["--output"])
                .args(ArgType::String, ArgCount::Exact(1))
                .parse(&args, 2)?;

            let input = parsed_args.get_args_exact(1)?[0].clone();
            let output = parsed_args.arg_flags.get("--output").unwrap().to_string();
            from_git(&output, &input)?;
        },
        Some(invalid_command) => {
            let similar_command = get_closest_string(
                &[
                    "to-git",
                    "to-sql",
                    "from-git",
                    "from-sql",
                ].iter().map(|s| s.to_string()).collect::<Vec<_>>(),
                invalid_command,
            );

            return Err(Error::CliError {
                message: format!(
                    "`{invalid_command}` is an invalid command. {}",
                    if let Some(similar_command) = similar_command {
                        format!("There is a similar command: `{similar_command}`.")
                    } else {
                        String::new()
                    },
                ),
                span: Span::NthArg(0).render(&args, 1),
            });
        },
        _ => todo!(),
    }

    Ok(())
}