retro 2026.2.210

Retro game catalog management.
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

use clap::{Parser, Subcommand};
use clap_verbosity_flag::Verbosity;

use env_logger;

use super::compress;
use super::link;
use super::playlist;
use super::rename;

#[derive(Debug, Parser)]
#[command(name = "retro")]
#[command(about = "synchronize retro games")]
#[command(version)]
struct Cli {
    #[command(subcommand)]
    command: Commands,

    #[command(flatten)]
    verbose: Verbosity,
}

// Macro that defines the Commands enum and automatically generates the dispatch method.
// When you add a new variant to the enum, the dispatch method is automatically updated.
macro_rules! define_commands {
    (
        // Capture enum-level attributes (e.g., #[derive(...)])
        $(#[$enum_meta:meta])*
        // Capture the enum name
        enum $enum_name:ident {
            // Capture zero or more variants (the * means repetition)
            $(
                // Capture variant-level attributes (e.g., #[clap(...)])
                $(#[$variant_meta:meta])*
                // Capture variant name and its type
                $variant:ident($variant_type:ty),
            )*
        }
    ) => {
        // Re-emit the enum definition with all attributes preserved
        $(#[$enum_meta])*
        enum $enum_name {
            $(
                $(#[$variant_meta])*
                $variant($variant_type),
            )*
        }

        // Automatically generate the dispatch implementation
        impl $enum_name {
            fn dispatch(self) -> Result<(), String> {
                match self {
                    // Generate a match arm for each variant
                    // Each arm extracts the args and calls its dispatch method
                    $(
                        $enum_name::$variant(args) => args.dispatch(),
                    )*
                }
            }
        }
    };
}

define_commands! {
    #[derive(Debug, Subcommand)]
    enum Commands {
        #[clap(visible_alias = "chd")]
        Compress(compress::Args),
        Link(link::Args),
        #[clap(visible_alias = "m3u")]
        Playlist(playlist::Args),
        Rename(rename::Args),
    }
}

pub fn dispatch() -> Result<(), String> {
    let args = Cli::parse();

    env_logger::Builder::new()
        .filter_level(args.verbose.log_level_filter())
        .format_level(false)
        .format_target(false)
        .format_timestamp(None)
        .init();

    args.command.dispatch()
}