Function list_extensions

dsc/src/subcommand.rs:618–682

(dsc: &mut DscManager, extension_name: &TypeNameFilter, format: Option<&ListOutputFormat>, progress_format: ProgressFormat)

}

fn list_extensions(dsc: &mut DscManager, extension_name: &TypeNameFilter, format: Option<&ListOutputFormat>, progress_format: ProgressFormat) {
    let mut write_table = false;
    let mut table = Table::new(&[
        t!("subcommand.tableHeader_type").to_string().as_ref(),
        t!("subcommand.tableHeader_version").to_string().as_ref(),
        t!("subcommand.tableHeader_capabilities").to_string().as_ref(),
        t!("subcommand.tableHeader_description").to_string().as_ref(),
    ]);
    if 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;

    for manifest_resource in dsc.list_available(&DiscoveryKind::Extension, extension_name, None, progress_format) {
        if let ImportedManifest::Extension(extension) = manifest_resource {
            let capability_types = [
                (ExtensionCapability::Discover, "d"),
                (ExtensionCapability::Secret, "s"),
                (ExtensionCapability::Import, "i"),
            ];
            let mut capabilities = "-".repeat(capability_types.len());

            for (i, (capability, letter)) in capability_types.iter().enumerate() {
                if extension.capabilities.contains(capability) {
                    capabilities.replace_range(i..=i, letter);
                }
            }

            if write_table {
                table.add_row(vec![
                    extension.type_name.to_string(),
                    extension.version.to_string(),
                    capabilities,
                    extension.description.unwrap_or_default()
                ]);
            }
            else {
                // convert to json
                let json = match serde_json::to_string(&extension) {
                    Ok(json) => json,
                    Err(err) => {
                        error!("JSON: {err}");
                        exit(EXIT_JSON_ERROR);
                    }
                };
                let format = match format {
                    Some(ListOutputFormat::Json) => Some(OutputFormat::Json),
                    Some(ListOutputFormat::PrettyJson) => Some(OutputFormat::PrettyJson),
                    Some(ListOutputFormat::Yaml) => Some(OutputFormat::Yaml),
                    _ => None,
                };
                write_object(&json, format.as_ref(), include_separator);
                include_separator = true;
                // insert newline separating instances if writing to console
                if io::stdout().is_terminal() { println!(); }
            }
        }