1 
use std::{path::PathBuf, sync::Arc};
2 

            

        

            

                3
            

            

                
            

            

                
use anyhow::anyhow;

            

        

            

                4
            

            

                
            

            

                
use clap::ValueHint;

            

        

            

                5
            

            

                
            

            

                

            

        

            

                6
            

            

                
            

            

                
use conjure_cp_cli::utils::testing::{serialize_domains, serialize_model};

            

        

            

                7
            

            

                
            

            

                

            

        

            

                8
            

            

                
            

            

                
use crate::cli::{GlobalArgs, LOGGING_HELP_HEADING};

            

        

            

                9
            

            

                
            

            

                
use crate::solve::{init_context, parse};

            

        

            

                10
            

            

                
            

            

                

            

        

            

                11
            

            

                
            

            

                
#[derive(Clone, Debug, clap::Args)]

            

        

            

                12
            

            

                
            

            

                
pub struct Args {

            

        

            

                13
            

            

                
            

            

                
    /// The input Essence file

            

        

            

                14
            

            

                
            

            

                
    #[arg(value_name = "INPUT_ESSENCE", value_hint = ValueHint::FilePath)]

            

        

            

                15
            

            

                
            

            

                
    pub input_file: PathBuf,

            

        

            

                16
            

            

                
            

            

                

            

        

            

                17
            

            

                
            

            

                
    // The format you would like to print out (e.g. ast-json)

            

        

            

                18
            

            

                
            

            

                
    #[arg(long, help_heading=LOGGING_HELP_HEADING)]

            

        

            

                19
            

            

                
            

            

                
    pub output_format: String,

            

        

            

                20
            

            

                
            

            

                
}

            

        

            

                21
            

            

                
            

            

                

            

        

            

                22
            

            

                14
            

            

                
pub fn run_pretty_command(global_args: GlobalArgs, pretty_args: Args) -> anyhow::Result<()> {

            

        

            

                23
            

            

                
            

            

                
    // Preamble

            

        

            

                24
            

            

                14
            

            

                
    let input_file = pretty_args.input_file.clone();

            

        

            

                25
            

            

                14
            

            

                
    let context = init_context(&global_args, input_file)?;

            

        

            

                26
            

            

                14
            

            

                
    let model = parse(&global_args, Arc::clone(&context))?;

            

        

            

                27
            

            

                
            

            

                

            

        

            

                28
            

            

                
            

            

                
    // Running the correct method to acquire pretty string

            

        

            

                29
            

            

                14
            

            

                
    let output = match pretty_args.output_format.as_str() {

            

        

            

                30
            

            

                14
            

            

                
        "ast-json" => serialize_model(&model),

            

        

            

                31
            

            

                12
            

            

                
        "expression-domains" => serialize_domains(&model),

            

        

            

                32
            

            

                
            

            

                
        // "add_new_flag" => method(),

            

        

            

                33
            

            

                
            

            

                
        _ => {

            

        

            

                34
            

            

                
            

            

                
            return Err(anyhow!(

            

        

            

                35
            

            

                
            

            

                
                "Unknown output format {}; supports [ast-json, expression-domains]",

            

        

            

                36
            

            

                
            

            

                
                &pretty_args.output_format

            

        

            

                37
            

            

                
            

            

                
            ));

            

        

            

                38
            

            

                
            

            

                
        }

            

        

            

                39
            

            

                
            

            

                
    };

            

        

            

                40
            

            

                
            

            

                

            

        

            

                41
            

            

                14
            

            

                
    let output = output.map_err(|err| anyhow!("Could not pretty print: {err}"))?;

            

        

            

                42
            

            

                14
            

            

                
    print!("{output}");

            

        

            

                43
            

            

                14
            

            

                
    Ok(())

            

        

            

                44
            

            

                14
            

            

                
}