Put doc coverage data into a new DocCoverage struct

Author: GuillaumeGomez

src/db/add_package.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use crate::{
-    docbuilder::BuildResult,
+    docbuilder::{BuildResult, DocCoverage},
     error::Result,
     index::api::{CrateData, CrateOwner, ReleaseData},
     storage::CompressionAlgorithm,
@@ -133,8 +133,7 @@ pub(crate) fn add_package_into_database(
 pub(crate) fn add_doc_coverage(
     conn: &mut Client,
     release_id: i32,
-    total_items: i32,
-    documented_items: i32,
+    doc_coverage: DocCoverage,
 ) -> Result<i32> {
     debug!("Adding doc coverage into database");
     let rows = conn.query(
@@ -145,7 +144,7 @@ pub(crate) fn add_doc_coverage(
                     total_items = $2,
                     documented_items = $3
             RETURNING release_id",
-        &[&release_id, &total_items, &documented_items],
+        &[&release_id, &doc_coverage.total_items, &doc_coverage.documented_items],
     )?;
     Ok(rows[0].get(0))
 }

src/docbuilder/mod.rs

@@ -7,7 +7,7 @@ mod rustwide_builder;
 
 pub(crate) use self::limits::Limits;
 pub(self) use self::metadata::Metadata;
-pub(crate) use self::rustwide_builder::BuildResult;
+pub(crate) use self::rustwide_builder::{BuildResult, DocCoverage};
 pub use self::rustwide_builder::RustwideBuilder;
 
 use crate::db::Pool;

src/docbuilder/rustwide_builder.rs

@@ -429,10 +429,8 @@ impl RustwideBuilder {
                     algs,
                 )?;
 
-                if let (Some(total), Some(documented)) =
-                    (res.result.total_items, res.result.documented_items)
-                {
-                    add_doc_coverage(&mut conn, release_id, total, documented)?;
+                if let Some(doc_coverage) = res.result.doc_coverage {
+                    add_doc_coverage(&mut conn, release_id, doc_coverage)?;
                 }
 
                 add_build_into_database(&mut conn, release_id, &res.result)?;
@@ -648,14 +646,15 @@ impl RustwideBuilder {
                         .run()
                         .is_ok()
                 });
-                let mut total_items = None;
-                let mut documented_items = None;
+                let mut doc_coverage = None;
                 if successful {
-                    if let Some((total, documented)) =
+                    if let Some((total_items, documented_items)) =
                         self.get_coverage(target, build, metadata, limits)?
                     {
-                        total_items = Some(total);
-                        documented_items = Some(documented);
+                        doc_coverage = Some(DocCoverage {
+                            total_items,
+                            documented_items,
+                        });
                     }
                 }
                 // If we're passed a default_target which requires a cross-compile,
@@ -677,8 +676,7 @@ impl RustwideBuilder {
                         rustc_version: self.rustc_version.clone(),
                         docsrs_version: format!("docsrs {}", crate::BUILD_VERSION),
                         successful,
-                        total_items,
-                        documented_items,
+                        doc_coverage
                     },
                     cargo_metadata,
                     target: target.to_string(),
@@ -732,14 +730,19 @@ struct FullBuildResult {
     cargo_metadata: CargoMetadata,
 }
 
+#[derive(Clone, Copy)]
+pub(crate) struct DocCoverage {
+    /// The total items that could be documented in the current crate, used to calculate
+    /// documentation coverage.
+    pub(crate) total_items: i32,
+    /// The items of the crate that are documented, used to calculate documentation coverage.
+    pub(crate) documented_items: i32,
+}
+
 pub(crate) struct BuildResult {
     pub(crate) rustc_version: String,
     pub(crate) docsrs_version: String,
     pub(crate) build_log: String,
     pub(crate) successful: bool,
-    /// The total items that could be documented in the current crate, used to calculate
-    /// documentation coverage.
-    pub(crate) total_items: Option<i32>,
-    /// The items of the crate that are documented, used to calculate documentation coverage.
-    pub(crate) documented_items: Option<i32>,
+    pub(crate) doc_coverage: Option<DocCoverage>,
 }