fn exec()

in tools/cargo-hakari/src/command.rs [274:410]
131 lines of code
11 McCabe index (conditional complexity)

    fn exec(
        self,
        builder: HakariBuilder<'_>,
        hakari_output: HakariOutputOptions,
        output: OutputContext,
    ) -> Result<i32> {
        let hakari_package = *builder
            .hakari_package()
            .expect("hakari-package must be specified in hakari.toml");

        match self {
            CommandWithBuilder::Generate { diff } => {
                let package_graph = builder.graph();
                let hakari = builder.compute();
                let toml_out = match hakari.to_toml_string(&hakari_output) {
                    Ok(toml_out) => toml_out,
                    Err(TomlOutError::UnrecognizedRegistry {
                        package_id,
                        registry_url,
                    }) => {
                        // Print out a better error message for this more common use case.
                        let package = package_graph
                            .metadata(&package_id)
                            .expect("package ID obtained from the same graph");
                        error!(
                            "unrecognized registry URL {} found for {} v{}\n\
                             (add to [registries] section of {})",
                            registry_url.style(output.styles.registry_url),
                            package.name().style(output.styles.package_name),
                            package.version().style(output.styles.package_version),
                            "hakari.toml".style(output.styles.config_path),
                        );
                        // 102 is picked pretty arbitrarily because regular errors exit with 101.
                        return Ok(102);
                    }
                    Err(err) => Err(err).with_context(|| "error generating new hakari.toml")?,
                };

                let existing_toml = hakari
                    .read_toml()
                    .expect("hakari-package must be specified")?;

                write_to_cargo_toml(existing_toml, &toml_out, diff, output)
            }
            CommandWithBuilder::Verify => match builder.verify() {
                Ok(()) => {
                    info!(
                        "{} works correctly",
                        hakari_package.name().style(output.styles.package_name),
                    );
                    Ok(0)
                }
                Err(errs) => {
                    let mut display = errs.display();
                    if output.color.is_enabled() {
                        display.colorize();
                    }
                    info!(
                        "{} didn't work correctly:\n{}",
                        hakari_package.name().style(output.styles.package_name),
                        display,
                    );
                    Ok(1)
                }
            },
            CommandWithBuilder::ManageDeps {
                packages,
                dry_run,
                yes,
            } => {
                let ops = builder
                    .manage_dep_ops(&packages.to_package_set(builder.graph())?)
                    .expect("hakari-package must be specified in hakari.toml");
                if ops.is_empty() {
                    info!("no operations to perform");
                    return Ok(0);
                }

                apply_on_dialog(dry_run, yes, &ops, &output, || {
                    regenerate_lockfile(output.clone())
                })
            }
            CommandWithBuilder::RemoveDeps {
                packages,
                dry_run,
                yes,
            } => {
                let ops = builder
                    .remove_dep_ops(&packages.to_package_set(builder.graph())?, false)
                    .expect("hakari-package must be specified in hakari.toml");
                if ops.is_empty() {
                    info!("no operations to perform");
                    return Ok(0);
                }

                apply_on_dialog(dry_run, yes, &ops, &output, || {
                    regenerate_lockfile(output.clone())
                })
            }
            CommandWithBuilder::Explain {
                dep_name: crate_name,
            } => {
                let hakari = builder.compute();
                let toml_name_map = hakari.toml_name_map();
                let dep = toml_name_map.get(crate_name.as_str()).ok_or_else(|| {
                    eyre!(
                        "crate name '{}' not found in workspace-hack\n\
                        (hint: check spelling, or regenerate workspace-hack with `cargo hakari generate`)",
                        crate_name
                    )
                })?;

                let explain = hakari
                    .explain(dep.id())
                    .expect("package ID should be known since it was in the output");
                let mut display = explain.display();
                if output.color.is_enabled() {
                    display.colorize();
                }
                info!("\n{}", display);
                Ok(0)
            }
            CommandWithBuilder::Publish {
                package,
                pass_through,
            } => {
                publish_hakari(&package, builder, &pass_through, output)?;
                Ok(0)
            }
            CommandWithBuilder::Disable { diff } => {
                let existing_toml = builder
                    .read_toml()
                    .expect("hakari-package must be specified")?;
                write_to_cargo_toml(existing_toml, DISABLE_MESSAGE, diff, output)
            }
        }
    }