cpast 0.10.5

Run custom testcase with powerful clex language powered generated tool. Ideal for competitive coders. Can test two file and pass & match randomly generated outputs
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
148
149
150
151
152
153
154
155
156
157

use std::io;

use clap::{Command, CommandFactory, Parser, Subcommand, ValueHint};
use clap_complete::{Generator, Shell, generate};
use colored::Colorize;

const DEFAULT_ITERATIONS_COUNT: usize = 5;

#[derive(Parser)] // requires `derive` feature
#[command(name = "cpast", version, author, about, long_about = None)]
#[command(bin_name = "cpast")]
pub(crate) struct CpastCommand {
    /// Generate Shell Completions
    #[arg(long = "completions", value_enum)]
    completions: Option<Shell>,
    #[command(subcommand)]
    pub(crate) subcommand: Option<CpastSubcommands>,
}

#[derive(Subcommand)] // requires `derive` feature
pub(crate) enum CpastSubcommands {
    /// Compare two files to find the missing edge case
    #[command(author)]
    Test(TestArgs),

    /// Just generate the testcase
    #[command(author)]
    Generate(GenerateArgs),

    /// Generate clex using AI from input format and constraints
    Ai(AiArgs),
}

fn print_completions<G: Generator>(generator: G, cmd: &mut Command) {
    generate(
        generator,
        cmd,
        cmd.get_name().to_string(),
        &mut io::stdout(),
    );
}

#[derive(clap::Args)]
pub(crate) struct TestArgs {
    /// The correct file
    #[arg(short, long, value_hint = ValueHint::FilePath)]
    pub(crate) correct_file: Option<String>,

    /// The test file
    #[arg(short, long, required = true, value_hint = ValueHint::FilePath)]
    pub(crate) test_file: Option<String>,

    /// Clex for generating Tests
    #[arg(short, long, value_hint = ValueHint::Other)]
    pub(crate) generator: Option<String>,

    /// Coding Problem URL
    #[arg(short='u', long, value_hint = ValueHint::Url)]
    pub(crate) problem_url: Option<String>,

    /// Max number of times of iterations
    #[arg(short, long, default_value_t = DEFAULT_ITERATIONS_COUNT, value_hint = ValueHint::Other)]
    pub(crate) iterations: usize,

    /// Continue even after finding one edge case
    #[arg(short, long)]
    pub(crate) no_stop: bool,

    /// Force recompile code even if binaries is up to date
    #[arg(short, long)]
    pub(crate) force_recompile: bool,

    /// Debug mode for verbose output
    #[arg(short, long)]
    pub(crate) debug: bool,
}

#[derive(clap::Args)]
pub(crate) struct GenerateArgs {
    /// Write Clex for generating Tests
    pub(crate) generator: Option<String>,

    /// Copy testcases to clipboard
    #[arg(short, long)]
    pub(crate) clipboard: bool,
}

#[derive(clap::Args)]
pub(crate) struct AiArgs {
    /// Input format
    #[arg(short, long, value_hint = ValueHint::Other)]
    pub(crate) input_format: Option<String>,

    /// Constraints
    #[arg(short, long, value_hint = ValueHint::Other)]
    pub(crate) constraints: Option<String>,

    /// Problem URL
    #[arg(short='u', long, value_hint = ValueHint::Url)]
    pub(crate) problem_url: Option<String>,

    /// Copy clex to clipboard
    #[arg(long)]
    pub(crate) clipboard: bool,
}

impl CpastCommand {
    pub(crate) fn new() -> Option<Self> {
        let opt = Self::parse();

        if let Some(completions) = opt.completions {
            let mut cmd = CpastCommand::command();
            eprintln!("Generating completion file for {completions:?}...");

            print_completions(completions, &mut cmd);

            match completions {
                Shell::Zsh => {
                    eprintln!("\n\n{}\n    {}",
                        "Run the following command below to add it permanently to your shell:".bright_blue(),
                        "cpast --completions=zsh | sudo tee /usr/local/share/zsh/site-functions/_cpast".yellow()
                    );
                }
                Shell::Bash => {
                    eprintln!(
                        "\n\n{}\n    {}",
                        "Run the following command below to add it permanently to your shell:"
                            .bright_blue(),
                        "cpast --completions=bash | sudo tee /etc/bash_completion.d/cpast.bash"
                            .yellow()
                    );
                }
                Shell::Fish => {
                    eprintln!("\n\n{}\n    {}",
                        "Run the following command below to add it permanently to your shell:".bright_blue(),
                        "cpast --completions=fish > ~/.local/share/fish/generated_completions/cpast.fish".yellow()
                    );
                }
                Shell::PowerShell => {
                    eprintln!(
                        "{}\n    {}",
                        "Run the following command below to add it permanently to your shell:"
                            .bright_blue(),
                        "cpast --completions=powershell | Out-File -FilePath $PROFILE -Append"
                            .yellow()
                    );
                }
                // Figure it out yourself XD
                _ => {}
            }

            None
        } else {
            Some(opt)
        }
    }
}