fn fmt()

in guppy/src/errors.rs [90:150]
61 lines of code
7 McCabe index (conditional complexity)

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CommandError(_) => write!(f, "`cargo metadata` execution failed"),
            MetadataParseError(_) => write!(f, "`cargo metadata` returned invalid JSON output"),
            MetadataSerializeError(_) => write!(f, "failed to serialize `cargo metadata` to JSON"),
            PackageGraphConstructError(s) => write!(f, "failed to construct package graph: {}", s),
            UnknownPackageId(id) => write!(f, "unknown package ID: {}", id),
            UnknownFeatureId(package_id, feature) => {
                write!(f, "unknown feature ID: '{}/{}'", package_id, feature)
            }
            UnknownWorkspacePath(path) => write!(f, "unknown workspace path: {}", path),
            UnknownWorkspaceName(name) => write!(f, "unknown workspace package name: {}", name),
            TargetSpecError(msg, _) => write!(f, "target spec error while {}", msg),
            PackageGraphInternalError(msg) => write!(f, "internal error in package graph: {}", msg),
            FeatureGraphInternalError(msg) => write!(f, "internal error in feature graph: {}", msg),
            #[cfg(feature = "summaries")]
            UnknownSummaryId(summary_id) => write!(f, "unknown summary ID: {}", summary_id),
            #[cfg(feature = "summaries")]
            UnknownPackageSetSummary {
                message,
                unknown_summary_ids,
                unknown_workspace_members,
                unknown_third_party,
            } => {
                writeln!(f, "unknown elements: {}", message)?;
                if !unknown_summary_ids.is_empty() {
                    writeln!(f, "* unknown summary IDs:")?;
                    for summary_id in unknown_summary_ids {
                        writeln!(f, "  - {}", summary_id)?;
                    }
                }
                if !unknown_workspace_members.is_empty() {
                    writeln!(f, "* unknown workspace names:")?;
                    for workspace_member in unknown_workspace_members {
                        writeln!(f, "  - {}", workspace_member)?;
                    }
                }
                if !unknown_third_party.is_empty() {
                    writeln!(f, "* unknown third-party:")?;
                    for third_party in unknown_third_party {
                        writeln!(f, "  - {}", third_party)?;
                    }
                }
                Ok(())
            }
            #[cfg(feature = "summaries")]
            UnknownRegistryName {
                message,
                summary,
                registry_name,
            } => {
                writeln!(
                    f,
                    "unknown registry name: {}\n* for third-party: {}\n* name: {}\n",
                    message, summary, registry_name
                )
            }
            #[cfg(feature = "summaries")]
            TomlSerializeError(_) => write!(f, "failed to serialize to TOML"),
        }
    }