Update the configuration structs and the conversion from the CLI to config structs to match the new CLI

Shnatsel · Shnatsel · commit 680cb466f5c6 · 2024-02-28T04:58:35.000Z
Signed-off-by: Sergey "Shnatsel" Davidoff &lt;shnatsel@gmail.com&gt;
diff --git a/cargo-cyclonedx/src/cli.rs b/cargo-cyclonedx/src/cli.rs
@@ -1,7 +1,8 @@
 use cargo_cyclonedx::{
     config::{
-        CdxExtension, CustomPrefix, Describe, Features, IncludedDependencies, LicenseParserOptions,
-        OutputOptions, ParseMode, PlatformSuffix, Prefix, PrefixError, SbomConfig, Target,
+        CdxExtension, Describe, Features, FilenameOverride, FilenameOverrideError, FilenamePattern,
+        IncludedDependencies, LicenseParserOptions, OutputOptions, ParseMode, PlatformSuffix,
+        SbomConfig, Target,
     },
     format::Format,
     platform::host_platform,
@@ -104,15 +105,6 @@ impl Args {
             _ => None,
         };
 
-        let prefix = match (self.output_pattern, &self.output_prefix) {
-            (Some(pattern), _) => Some(Prefix::Pattern(pattern)),
-            (_, Some(prefix)) => {
-                let prefix = CustomPrefix::new(prefix)?;
-                Some(Prefix::Custom(prefix))
-            }
-            (_, _) => None,
-        };
-
         let features =
             if !self.all_features && !self.no_default_features && self.features.is_empty() {
                 None
@@ -155,27 +147,18 @@ impl Args {
             false => PlatformSuffix::NotIncluded,
         };
 
-        // according to the CycloneDX spec, the file has either be called 'bom.xml'
-        // or include the .cdx extension:
-        // https://cyclonedx.org/specification/overview/#recognized-file-patterns
-        if self.target_in_filename {
-            cdx_extension = Some(CdxExtension::Included)
-        }
-        // Ditto for any kind of prefix or anything not named 'bom'
-        if prefix.is_some() {
-            cdx_extension = Some(CdxExtension::Included)
+        let filename_pattern = match self.filename_override {
+            Some(string) => {
+                let name_override = FilenameOverride::new(string)?;
+                FilenamePattern::Custom(name_override);
+            }
+            None => FilenamePattern::CrateName,
         };
 
-        let output_options =
-            if cdx_extension.is_none() && prefix.is_none() && !self.target_in_filename {
-                None
-            } else {
-                Some(OutputOptions {
-                    cdx_extension: cdx_extension.unwrap_or_default(),
-                    prefix: prefix.unwrap_or_default(),
-                    platform_suffix,
-                })
-            };
+        Some(OutputOptions {
+            filename: filename_pattern,
+            platform_suffix,
+        });
 
         let license_parser = Some(LicenseParserOptions {
             mode: match self.license_strict {
@@ -202,7 +185,7 @@ impl Args {
 #[derive(Error, Debug, PartialEq, Eq)]
 pub enum ArgsError {
     #[error("Invalid prefix from CLI")]
-    CustomPrefixError(#[from] PrefixError),
+    CustomPrefixError(#[from] FilenameOverrideError),
 }
 
 #[cfg(test)]
diff --git a/cargo-cyclonedx/src/config.rs b/cargo-cyclonedx/src/config.rs
@@ -93,39 +93,12 @@ impl FromStr for IncludedDependencies {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct OutputOptions {
-    pub cdx_extension: CdxExtension,
-    pub prefix: Prefix,
+    pub filename: FilenamePattern,
     pub platform_suffix: PlatformSuffix,
 }
 
-impl Default for OutputOptions {
-    fn default() -> Self {
-        Self {
-            cdx_extension: CdxExtension::default(),
-            prefix: Prefix::Pattern(Pattern::Bom),
-            platform_suffix: PlatformSuffix::default(),
-        }
-    }
-}
-
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
-pub enum CdxExtension {
-    Included,
-    #[default]
-    NotIncluded,
-}
-
-impl CdxExtension {
-    pub fn extension(&self) -> String {
-        match &self {
-            CdxExtension::Included => ".cdx".to_string(),
-            CdxExtension::NotIncluded => "".to_string(),
-        }
-    }
-}
-
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct Features {
     pub all_features: bool,
@@ -150,14 +123,14 @@ impl Target {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Prefix {
-    Pattern(Pattern),
-    Custom(CustomPrefix),
+pub enum FilenamePattern {
+    CrateName,
+    Custom(FilenameOverride),
 }
 
-impl Default for Prefix {
+impl Default for FilenamePattern {
     fn default() -> Self {
-        Self::Pattern(Pattern::default())
+        Self::CrateName
     }
 }
 
@@ -187,14 +160,14 @@ impl FromStr for Pattern {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct CustomPrefix(String);
+pub struct FilenameOverride(String);
 
-impl CustomPrefix {
-    pub fn new(custom_prefix: impl Into<String>) -> Result<Self, PrefixError> {
+impl FilenameOverride {
+    pub fn new(custom_prefix: impl Into<String>) -> Result<Self, FilenameOverrideError> {
         let prefix = custom_prefix.into();
 
         if prefix.contains(std::path::MAIN_SEPARATOR) {
-            Err(PrefixError::CustomPrefixError(
+            Err(FilenameOverrideError::TheOne(
                 std::path::MAIN_SEPARATOR.to_string(),
             ))
         } else {
@@ -203,16 +176,16 @@ impl CustomPrefix {
     }
 }
 
-impl ToString for CustomPrefix {
+impl ToString for FilenameOverride {
     fn to_string(&self) -> String {
         self.0.clone()
     }
 }
 
 #[derive(Error, Debug, PartialEq, Eq)]
-pub enum PrefixError {
+pub enum FilenameOverrideError {
     #[error("Illegal characters in custom prefix string: {0}")]
-    CustomPrefixError(String),
+    TheOne(String),
 }
 
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
@@ -285,25 +258,25 @@ mod test {
     use super::*;
 
     #[test]
-    fn it_should_error_for_a_prefix_with_a_path_separator() {
-        let prefix = format!("directory{}prefix", std::path::MAIN_SEPARATOR);
+    fn it_should_error_for_a_filename_with_a_path_separator() {
+        let filename = format!("directory{}filename", std::path::MAIN_SEPARATOR);
 
-        let actual = CustomPrefix::new(prefix)
-            .expect_err("Should not have been able to create CustomPrefix with path separator");
+        let actual = FilenameOverride::new(filename)
+            .expect_err("Should not have been able to create Customfilename with path separator");
 
-        let expected = PrefixError::CustomPrefixError(std::path::MAIN_SEPARATOR.to_string());
+        let expected = FilenameOverrideError::TheOne(std::path::MAIN_SEPARATOR.to_string());
 
         assert_eq!(actual, expected);
     }
 
     #[test]
-    fn it_should_create_a_custom_prefix_from_a_valid_string() {
-        let prefix = "customprefix".to_string();
+    fn it_should_create_a_custom_filename_from_a_valid_string() {
+        let filename = "customfilename".to_string();
 
-        let actual = CustomPrefix::new(prefix.clone())
-            .expect("Should have been able to create CustomPrefix");
+        let actual = FilenameOverride::new(filename.clone())
+            .expect("Should have been able to create Customfilename");
 
-        let expected = CustomPrefix(prefix);
+        let expected = FilenameOverride(filename);
 
         assert_eq!(actual, expected);
     }
diff --git a/cargo-cyclonedx/src/generator.rs b/cargo-cyclonedx/src/generator.rs
@@ -15,9 +15,9 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
+use crate::config::FilenamePattern;
 use crate::config::Pattern;
 use crate::config::PlatformSuffix;
-use crate::config::Prefix;
 use crate::config::SbomConfig;
 use crate::config::{IncludedDependencies, ParseMode};
 use crate::format::Format;
@@ -690,11 +690,12 @@ impl GeneratedSbom {
     /// Writes SBOM to either a JSON or XML file in the same folder as `Cargo.toml` manifest
     pub fn write_to_files(self) -> Result<(), SbomWriterError> {
         match self.sbom_config.output_options().prefix {
-            Prefix::Pattern(Pattern::Bom | Pattern::Package) | Prefix::Custom(_) => {
+            FilenamePattern::Pattern(Pattern::Bom | Pattern::Package)
+            | FilenamePattern::Custom(_) => {
                 let path = self.manifest_path.with_file_name(self.filename(None, &[]));
                 Self::write_to_file(self.bom, &path, &self.sbom_config)
             }
-            Prefix::Pattern(pattern @ (Pattern::Binary | Pattern::CargoTarget)) => {
+            FilenamePattern::Pattern(pattern @ (Pattern::Binary | Pattern::CargoTarget)) => {
                 for (sbom, target_kind) in
                     Self::per_artifact_sboms(&self.bom, &self.target_kinds, pattern)
                 {
@@ -786,17 +787,17 @@ impl GeneratedSbom {
     fn filename(&self, binary_name: Option<&str>, target_kind: &[String]) -> String {
         let output_options = self.sbom_config.output_options();
         let prefix = match &output_options.prefix {
-            Prefix::Pattern(Pattern::Bom) => "bom".to_string(),
-            Prefix::Pattern(Pattern::Package) => self.package_name.clone(),
-            Prefix::Pattern(Pattern::Binary) => binary_name.unwrap().to_owned(),
-            Prefix::Pattern(Pattern::CargoTarget) => binary_name.unwrap().to_owned(),
-            Prefix::Custom(c) => c.to_string(),
+            FilenamePattern::Pattern(Pattern::Bom) => "bom".to_string(),
+            FilenamePattern::Pattern(Pattern::Package) => self.package_name.clone(),
+            FilenamePattern::Pattern(Pattern::Binary) => binary_name.unwrap().to_owned(),
+            FilenamePattern::Pattern(Pattern::CargoTarget) => binary_name.unwrap().to_owned(),
+            FilenamePattern::Custom(c) => c.to_string(),
         };
 
         let target_kind_suffix = if !target_kind.is_empty() {
             debug_assert!(matches!(
                 &output_options.prefix,
-                Prefix::Pattern(Pattern::Binary | Pattern::CargoTarget)
+                FilenamePattern::Pattern(Pattern::Binary | Pattern::CargoTarget)
             ));
             format!("_{}", target_kind.join("-"))
         } else {
