melody_cli 0.20.0

A CLI wrapping the Melody language compiler
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

use colored::Colorize;

pub fn print_output(output: &str) {
    println!("{}", output.bright_blue());
}

pub fn print_repl_output(output: &str) {
    println!("{}\n", output.bright_blue());
}

pub fn print_source_line(line_number: usize, line: &str) {
    println!("{} {}", line_number.to_string().dimmed(), line.bright_blue());
}

pub fn report_unrecognized_command(source: &str) {
    eprintln!(
        "{} {} {}\n",
        "Error:".bright_red(),
        "unrecognized command".bright_red(),
        format!("\"{source}\"").bright_blue(),
    );
}

pub fn print_repl_welcome() {
    println!(
        "{}\n\n{}\n\n{}\n{}\n{}\n{}\n{}\n",
        format!("Melody REPL v{}", env!("CARGO_PKG_VERSION")).bright_green(),
        "Commands:".bright_green(),
        format_args!(
            "- {} - {}",
            ":u, :undo".bright_blue(),
            "undo the latest line".bright_green()
        ),
        format_args!(
            "- {} - {}",
            ":r, :redo".bright_blue(),
            "redo the latest undo".bright_green()
        ),
        format_args!(
            "- {} - {}",
            ":c, :clear".bright_blue(),
            "clear all REPL history and previous input".bright_green()
        ),
        format_args!(
            "- {} - {}",
            ":s, :source".bright_blue(),
            "print all previously entered lines".bright_green()
        ),
        format_args!("- {} - {}", ":e, :exit".bright_blue(), "exit the REPL".bright_green()),
    );
}

pub fn report_nothing_to_undo() {
    eprintln!("{}", "nothing to undo\n".bright_red());
}

pub fn report_no_lines_to_print() {
    eprintln!("{}", "no lines to print\n".bright_red());
}

pub fn prompt() {
    print!("{}", "~ ".bright_blue());
}

pub fn report_undo(newline: bool) {
    println!("{}{}", "undo".bright_green(), if newline { "\n" } else { "" });
}

pub fn report_exit() {
    println!("{}", "exit".bright_green());
}

pub fn report_nothing_to_redo() {
    eprintln!("{}", "nothing to redo\n".bright_red());
}

pub fn report_redo() {
    println!("{}", "redo".bright_green());
}

pub fn report_clear() {
    println!("{}\n", "clear".bright_green());
}

pub fn report_source() {
    println!("{}", "source".bright_green());
}

pub fn report_error(error: &str) {
    eprintln!("{}", format!("Error: {error}").bright_red());
}

pub fn report_unhandled_error(error: &str) {
    eprintln!(
        "{}",
        format!("An unhandled error occured.\nThis is a bug, please open an issue.\n\nCause: {error}").bright_red()
    );
}

pub fn report_info(error: &str) {
    eprintln!("{}", error.bright_blue());
}

pub fn report_repl_error(error: &str) {
    eprintln!("{}\n", format!("Error: {error}").bright_red(),);
}

pub fn report_unsupported_shell(shell: &str) {
    eprintln!(
        "{}\n{}\n",
        format!("Unknown or unsupported shell: '{shell}'").bright_red(),
        "Try one of: 'bash', 'zsh', 'fish', 'elvish', 'powershell'"
            .to_owned()
            .bright_blue()
    );
}

const MAX_TEST_INPUT_PREVIEW: usize = 10;

pub fn report_test_result(matched: bool, input: &str) {
    let shortened = if input.chars().count() > MAX_TEST_INPUT_PREVIEW {
        format!("{}...", input.chars().take(10).collect::<String>())
    } else {
        input.to_owned()
    };

    let result = if matched {
        "matched".bright_green()
    } else {
        "did not match".bright_red()
    };

    println!("'{shortened}' {result}");
}

pub fn report_test_result_file(matched: bool, file_path: &str) {
    let result = if matched {
        "matched".bright_green()
    } else {
        "did not match".bright_red()
    };

    println!("{file_path} {result}");
}