Function get_input

dsc/src/util.rs:436–512

(input: Option<&String>, file: Option<&String>)

}

pub fn get_input(input: Option<&String>, file: Option<&String>) -> String {
    trace!("Input: {input:?}, File: {file:?}");
    let value = if let Some(input) = input {
        debug!("{}", t!("util.readingInput"));

        // see if user accidentally passed in a file path
        if Path::new(input).exists() {
            error!("{}", t!("util.inputIsFile"));
            exit(EXIT_INVALID_INPUT);
        }
        input.clone()
    } else if let Some(path) = file {
        debug!("{} {path}", t!("util.readingInputFromFile"));
        // check if need to read from STDIN
        if path == "-" {
            info!("{}", t!("util.readingInputFromStdin"));
            let mut stdin = Vec::<u8>::new();
            match std::io::stdin().read_to_end(&mut stdin) {
                Ok(_) => {
                    match String::from_utf8(stdin) {
                        Ok(input) => {
                            input
                        },
                        Err(err) => {
                            error!("{}: {err}", t!("util.invalidUtf8"));
                            exit(EXIT_INVALID_INPUT);
                        }
                    }
                },
                Err(err) => {
                    error!("{}: {err}", t!("util.failedToReadStdin"));
                    exit(EXIT_INVALID_INPUT);
                }
            }
        } else {
            // see if an extension should handle this file
            let mut discovery = Discovery::new();
            let path_buf = Path::new(path);
            for extension in discovery.get_extensions(&Capability::Import) {
                if let Ok(content) = extension.import(path_buf) {
                    return content;
                }
            }
            match std::fs::read_to_string(path) {
                Ok(input) => {
                    // check if it contains UTF-8 BOM and remove it
                    if input.as_bytes().starts_with(&[0xEF, 0xBB, 0xBF]) {
                        info!("{}", t!("util.removingUtf8Bom"));
                        input[3..].to_string()
                    } else {
                        input
                    }
                },
                Err(err) => {
                    error!("{}: {err}", t!("util.failedToReadFile"));
                    exit(EXIT_INVALID_INPUT);
                }
            }