fn fmt()

in tools/hakari/src/explain/display.rs [52:150]
86 lines of code
8 McCabe index (conditional complexity)

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut table = Table::new("  {:^}  |  {:^}  {:^}  {:^}");
        // header row
        let row = Row::new()
            .with_ansi_cell("package".style(self.styles.header_style))
            .with_ansi_cell("include dev?".style(self.styles.header_style))
            .with_ansi_cell("features".style(self.styles.header_style))
            .with_ansi_cell("platform".style(self.styles.header_style));
        table.add_row(row);

        for (build_platform, explain_map) in self.explain.explain_maps() {
            for (&features, inner) in explain_map {
                let heading = format!(
                    "\non the {} platform, feature set {} was built by:\n",
                    build_platform.style(self.styles.build_platform_style),
                    FeatureDisplay { features }.style(self.styles.feature_style),
                );
                table.add_heading(heading);

                let package_set = self
                    .explain
                    .graph
                    .resolve_ids(inner.workspace_packages.keys().copied())
                    .expect("keys derived from package graph");

                // Print output in reverse dependency order within the workspace.
                for package_id in package_set.package_ids(DependencyDirection::Reverse) {
                    let inner_value = &inner.workspace_packages[package_id];

                    let name = inner_value.metadata.name();
                    let name_display = name.style(self.styles.package_name_style);
                    for (idx, (include_dev, standard_features, platform_idx)) in
                        inner_value.sets.iter().enumerate()
                    {
                        let include_dev_display =
                            include_dev.display_with(&self.styles.star_style, |include_dev, f| {
                                match include_dev {
                                    true => write!(f, "{}", "yes".style(self.styles.yes_style)),
                                    false => write!(f, "{}", "no".style(self.styles.no_style)),
                                }
                            });
                        let features_display = standard_features.display_with(
                            &self.styles.star_style,
                            |features, f| {
                                let features_str = match features {
                                    StandardFeatures::None => "none",
                                    StandardFeatures::Default => "default",
                                    StandardFeatures::All => "all",
                                };
                                write!(
                                    f,
                                    "{}",
                                    features_str.style(self.styles.standard_features_style)
                                )
                            },
                        );

                        let platform_display = platform_idx
                            .display_with(&self.styles.star_style, |&platform_idx, f| {
                                self.display_platform_str(platform_idx, f)
                            });

                        let mut row = Row::new();
                        if idx == 0 {
                            row.add_ansi_cell(&name_display);
                        } else {
                            row.add_ansi_cell(DITTO_MARK.style(self.styles.ditto_style));
                        }

                        row.add_ansi_cell(include_dev_display)
                            .add_ansi_cell(features_display)
                            .add_ansi_cell(platform_display);
                        table.add_row(row);
                    }
                }

                for (idx, platform_idx) in inner.fixup_platforms.iter().enumerate() {
                    let mut row = Row::new();
                    if idx == 0 {
                        row.add_ansi_cell("post-compute fixup");
                    } else {
                        row.add_ansi_cell(DITTO_MARK.style(self.styles.ditto_style));
                    }

                    let platform_display = platform_idx
                        .display_with(&self.styles.star_style, |&platform_idx, f| {
                            self.display_platform_str(platform_idx, f)
                        });

                    row.add_ansi_cell("-")
                        .add_ansi_cell("-")
                        .add_ansi_cell(platform_display);
                    table.add_row(row);
                }
            }
        }

        writeln!(f, "{}", table)
    }