Function list_functions

dsc/src/subcommand.rs:684–774

(functions: &FunctionDispatcher, function_name: Option<&String>, output_format: Option<&ListOutputFormat>)

}

fn list_functions(functions: &FunctionDispatcher, function_name: Option<&String>, output_format: Option<&ListOutputFormat>) {
    let mut write_table = false;
    let mut table = Table::new(&[
        t!("subcommand.tableHeader_functionCategory").to_string().as_ref(),
        t!("subcommand.tableHeader_functionName").to_string().as_ref(),
        t!("subcommand.tableHeader_minArgs").to_string().as_ref(),
        t!("subcommand.tableHeader_maxArgs").to_string().as_ref(),
        t!("subcommand.tableHeader_argTypes").to_string().as_ref(),
        t!("subcommand.tableHeader_description").to_string().as_ref(),
    ]);
    if output_format.is_none() && io::stdout().is_terminal() {
        // write as table if format is not specified and interactive
        write_table = true;
    }
    let mut include_separator = false;
    let returned_types= [
        (FunctionArgKind::Array, "a"),
        (FunctionArgKind::Boolean, "b"),
        (FunctionArgKind::Lambda, "l"),
        (FunctionArgKind::Number, "n"),
        (FunctionArgKind::String, "s"),
        (FunctionArgKind::Object, "o"),
    ];

    let asterisks = String::from("*");
    let name = function_name.unwrap_or(&asterisks);
    let regex_str = convert_wildcard_to_regex(name);
    let mut regex_builder = RegexBuilder::new(&regex_str);
    regex_builder.case_insensitive(true);
    let Ok(regex) = regex_builder.build() else {
        error!("{}: {}", t!("subcommand.invalidFunctionFilter"), regex_str);
        exit(EXIT_INVALID_ARGS);
    };

    let mut functions_list = functions.list();
    functions_list.sort();
    for function in functions_list {
        if !regex.is_match(&function.name) {
            continue;
        }

        if write_table {
            // construct arg_types from '-' times number of accepted_arg_types
            let mut arg_types = "-".repeat(returned_types.len());
            for (i, (arg_type, letter)) in returned_types.iter().enumerate() {
                if function.return_types.contains(arg_type) {
                    arg_types.replace_range(i..=i, letter);
                }
            }

            let max_args = if function.max_args == usize::MAX {
                t!("subcommand.maxInt").to_string()
            } else {
                function.max_args.to_string()
            };

            table.add_row(vec![
                function.category.iter().map(std::string::ToString::to_string).collect::<Vec<String>>().join(", "),