gittype 0.8.0

A typing practice tool using your own code repositories
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
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
136
137
138
139
140
141
142
143
144
145
146
147

// Add the source modules to make RankingTitle available
#[path = "src/scoring/ranking_title.rs"]
mod ranking_title;

use ranking_title::RankingTitle;
use std::collections::HashMap;
use std::io::Write;
use std::process::Command;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Get all rank titles from the actual RankingTitle implementation
    let all_titles = RankingTitle::all_titles();
    println!(
        "Found {} rank titles from RankingTitle::all_titles()",
        all_titles.len()
    );

    let rank_titles: Vec<(&str, &str)> = all_titles
        .iter()
        .map(|title| (title.name(), title.color_palette()))
        .collect();

    println!(
        "Generating ASCII art for {} rank titles...",
        rank_titles.len()
    );

    let mut generated_patterns = HashMap::new();

    // Generate ASCII art for each title
    for (title, palette) in &rank_titles {
        print!("Generating '{}' with palette '{}'... ", title, palette);
        std::io::stdout().flush()?;

        // Run npx oh-my-logo
        let output = Command::new("npx")
            .args(["oh-my-logo", title, palette])
            .env("FORCE_COLOR", "1")
            .output()?;

        if output.status.success() {
            let ascii_output = String::from_utf8_lossy(&output.stdout);
            let lines: Vec<String> = ascii_output
                .lines()
                .map(|line| line.to_string())
                .filter(|line| !line.trim().is_empty()) // Remove empty lines
                .collect();

            if !lines.is_empty() {
                generated_patterns.insert(title.to_string(), lines);
                println!("✓ ({} lines)", generated_patterns[*title].len());
            } else {
                println!("❌ (empty output)");
            }
        } else {
            println!("❌ (command failed)");
            let stderr = String::from_utf8_lossy(&output.stderr);
            if !stderr.trim().is_empty() {
                eprintln!("Error: {}", stderr);
            }
        }
    }

    println!(
        "\nGenerated ASCII art for {} titles",
        generated_patterns.len()
    );

    // Generate the Rust file
    println!("Writing ascii_rank_titles_generated.rs...");

    let mut file = std::fs::File::create("src/game/ascii_rank_titles_generated.rs")?;

    writeln!(
        file,
        "/// ASCII art rank title patterns using oh-my-logo style with colored ANSI codes"
    )?;
    writeln!(
        file,
        "/// Auto-generated from oh-my-logo with different palettes for different rank categories"
    )?;
    writeln!(file)?;
    writeln!(file, "use std::collections::HashMap;")?;
    writeln!(file)?;
    writeln!(
        file,
        "pub fn get_all_rank_patterns() -> HashMap<String, Vec<String>> {{"
    )?;
    writeln!(file, "    let mut patterns = HashMap::new();")?;
    writeln!(file)?;

    // Sort titles for consistent output
    let mut sorted_titles: Vec<_> = generated_patterns.keys().collect();
    sorted_titles.sort();

    for title in sorted_titles {
        let lines = &generated_patterns[title];
        writeln!(file, "    // {}", title)?;
        writeln!(file, "    patterns.insert(\"{}\".to_string(), vec![", title)?;

        for line in lines {
            // Escape the line for Rust string literal
            let escaped_line = line
                .replace("\\", "\\\\")
                .replace("\"", "\\\"")
                .replace("\x1b", "\\x1b");
            writeln!(file, "        \"{}\".to_string(),", escaped_line)?;
        }

        writeln!(file, "    ]);")?;
        writeln!(file)?;
    }

    writeln!(file, "    patterns")?;
    writeln!(file, "}}")?;
    writeln!(file)?;
    writeln!(
        file,
        "pub fn get_rank_title_display(rank_title: &str) -> Vec<String> {{"
    )?;
    writeln!(file, "    let patterns = get_all_rank_patterns();")?;
    writeln!(file, "    patterns.get(rank_title)")?;
    writeln!(file, "        .cloned()")?;
    writeln!(
        file,
        "        .unwrap_or_else(|| vec![rank_title.to_string()])"
    )?;
    writeln!(file, "}}")?;

    println!("✓ Generated src/game/ascii_rank_titles_generated.rs");
    println!("Total titles with ASCII art: {}", generated_patterns.len());

    // Show summary by tier
    let mut tier_counts = HashMap::new();
    for (title, palette) in &rank_titles {
        if generated_patterns.contains_key(*title) {
            *tier_counts.entry(*palette).or_insert(0) += 1;
        }
    }

    println!("\nGenerated ASCII art by tier:");
    for (palette, count) in &tier_counts {
        println!("  {}: {} titles", palette, count);
    }

    Ok(())
}