encode config for patch

Author: burrbull

CHANGELOG-rust.md

@@ -5,6 +5,7 @@ This changelog tracks the Rust `svdtools` project. See
 
 ## [Unreleased]
 
+* update `svd-encoder`, `--format-config` and optional `out_path` for `patch`
 * add field name in enumeratedValues derive path
 
 ## [v0.3.0] 2023-03-27

Cargo.toml

@@ -27,9 +27,9 @@ edition = "2021"
 clap = { version = "4.1", features = ["derive", "cargo", "color"] }
 serde = { version = "1.0", features = ["derive"] }
 quick-xml = { version = "0.28", features = ["serialize"] }
-svd-rs = { version = "0.14.1", features = ["serde", "derive-from"] }
+svd-rs = { version = "0.14.2", features = ["serde", "derive-from"] }
 svd-parser = { version = "0.14.1", features = ["expand"] }
-svd-encoder = "0.14.1"
+svd-encoder = "0.14.3"
 yaml-rust = "0.4"
 # serde_yaml 0.9.x looks broken
 serde_yaml = "0.8.26"

src/cli.rs

@@ -14,6 +14,15 @@ enum Command {
     Patch {
         /// Path to input YAML file
         yaml_file: PathBuf,
+
+        /// Path to output file. By default it just adds `.patched` at the end
+        out_path: Option<PathBuf>,
+
+        /// Path to format config file
+        ///
+        /// If not specified, the default format config will be used.
+        #[clap(long)]
+        format_config: Option<PathBuf>,
     },
     /// Generate Make dependency file listing dependencies for a YAML file.
     Makedeps {
@@ -82,7 +91,13 @@ impl Command {
                 interrupts_cli::parse_device(svd_file, !no_gaps)?;
             }
             Self::Mmap { svd_file } => mmap_cli::parse_device(svd_file)?,
-            Self::Patch { yaml_file } => patch_cli::patch(yaml_file)?,
+            Self::Patch {
+                yaml_file,
+                out_path,
+                format_config,
+            } => {
+                patch_cli::patch(yaml_file, out_path.as_deref(), format_config.as_deref())?;
+            }
             Self::Makedeps {
                 yaml_file,
                 deps_file,

src/convert/convert_cli.rs

@@ -3,6 +3,9 @@ use std::io::{Read, Write};
 use std::str::FromStr;
 use std::{fs::File, path::Path};
 
+use crate::get_encoder_config;
+pub use crate::ConfigFormat;
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum InputFormat {
@@ -43,24 +46,6 @@ impl FromStr for OutputFormat {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-#[non_exhaustive]
-pub enum ConfigFormat {
-    Yaml,
-    Json,
-}
-
-impl FromStr for ConfigFormat {
-    type Err = anyhow::Error;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "yml" | "yaml" | "YAML" => Ok(Self::Yaml),
-            "json" | "JSON" => Ok(Self::Json),
-            _ => Err(anyhow!("Unknown config file format")),
-        }
-    }
-}
-
 pub struct ParserConfig {
     pub expand: bool,
     pub expand_properties: bool,
@@ -110,28 +95,7 @@ pub fn convert(
         device
     };
 
-    let config = if let Some(format_config) = format_config {
-        let config_format = match format_config.extension().and_then(|e| e.to_str()) {
-            Some(s) => ConfigFormat::from_str(s)?,
-            _ => return Err(anyhow!("Unknown output file format")),
-        };
-        let mut config = String::new();
-        File::open(format_config)?.read_to_string(&mut config)?;
-
-        let config_map: std::collections::HashMap<String, String> = match config_format {
-            ConfigFormat::Yaml => serde_yaml::from_str(&config)?,
-            ConfigFormat::Json => serde_json::from_str(&config)?,
-        };
-
-        let mut config = svd_encoder::Config::default();
-        config_map
-            .iter()
-            .for_each(|(name, value)| config.update(name, value));
-
-        config
-    } else {
-        svd_encoder::Config::default()
-    };
+    let config = get_encoder_config(format_config)?;
 
     let output = match output_format {
         OutputFormat::Xml => svd_encoder::encode_with_config(&device, &config)?,

src/lib.rs

@@ -1,9 +1,58 @@
+use anyhow::anyhow;
+use std::io::Read;
+use std::{fs::File, path::Path, str::FromStr};
+
 pub mod common;
 pub mod convert;
 pub mod interrupts;
 pub mod makedeps;
 pub mod mmap;
 pub mod patch;
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ConfigFormat {
+    Yaml,
+    Json,
+}
+
+impl FromStr for ConfigFormat {
+    type Err = anyhow::Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "yml" | "yaml" | "YAML" => Ok(Self::Yaml),
+            "json" | "JSON" => Ok(Self::Json),
+            _ => Err(anyhow!("Unknown config file format")),
+        }
+    }
+}
+
+pub(crate) fn get_encoder_config(
+    format_config: Option<&Path>,
+) -> anyhow::Result<svd_encoder::Config> {
+    Ok(if let Some(format_config) = format_config {
+        let config_format = match format_config.extension().and_then(|e| e.to_str()) {
+            Some(s) => ConfigFormat::from_str(s)?,
+            _ => return Err(anyhow!("Unknown output file format")),
+        };
+        let mut config = String::new();
+        File::open(format_config)?.read_to_string(&mut config)?;
+
+        let config_map: std::collections::HashMap<String, String> = match config_format {
+            ConfigFormat::Yaml => serde_yaml::from_str(&config)?,
+            ConfigFormat::Json => serde_json::from_str(&config)?,
+        };
+
+        let mut config = svd_encoder::Config::default();
+        config_map
+            .iter()
+            .for_each(|(name, value)| config.update(name, value));
+
+        config
+    } else {
+        svd_encoder::Config::default()
+    })
+}
+
 #[cfg(test)]
 mod test_utils;

src/patch/mod.rs

@@ -26,9 +26,15 @@ mod register;
 mod yaml_ext;
 use yaml_ext::{AsType, GetVal, ToYaml};
 
+use crate::get_encoder_config;
+
 const VAL_LVL: ValidateLevel = ValidateLevel::Weak;
 
-pub fn process_file(yaml_file: &Path) -> Result<()> {
+pub fn process_file(
+    yaml_file: &Path,
+    out_path: Option<&Path>,
+    format_config: Option<&Path>,
+) -> Result<()> {
     // Load the specified YAML root file
     let f = File::open(yaml_file)?;
     let mut contents = String::new();
@@ -45,8 +51,13 @@ pub fn process_file(yaml_file: &Path) -> Result<()> {
                 .ok_or_else(|| anyhow!("You must have an svd key in the root YAML file"))?,
         ),
     )?;
-    let mut svdpath_out = svdpath.clone();
-    svdpath_out.set_extension("svd.patched");
+    let svdpath_out = if let Some(out_path) = out_path {
+        out_path.to_owned()
+    } else {
+        let mut pth = svdpath.clone();
+        pth.set_extension("svd.patched");
+        pth
+    };
     let f = File::open(svdpath)?;
     let mut contents = String::new();
     (&f).read_to_string(&mut contents)?;
@@ -62,9 +73,10 @@ pub fn process_file(yaml_file: &Path) -> Result<()> {
         .with_context(|| format!("Processing device `{}`", svd.name))?;
 
     // SVD should now be updated, write it out
-    let svd_out = svd_encoder::encode(&svd)?;
+    let config = get_encoder_config(format_config)?;
+    let svd_out = svd_encoder::encode_with_config(&svd, &config)?;
 
-    let mut f = File::create(&svdpath_out)?;
+    let mut f = File::create(svdpath_out)?;
     f.write_all(svd_out.as_bytes())?;
 
     Ok(())

src/patch/patch_cli.rs

@@ -1,7 +1,11 @@
 use anyhow::Result;
 use std::path::Path;
 
-pub fn patch(yaml_file: &Path) -> Result<()> {
-    super::process_file(yaml_file)?;
+pub fn patch(
+    yaml_file: &Path,
+    out_path: Option<&Path>,
+    format_config: Option<&Path>,
+) -> Result<()> {
+    super::process_file(yaml_file, out_path, format_config)?;
     Ok(())
 }

tests/example1.rs

@@ -7,7 +7,7 @@ fn example1() {
     let expected_svd_path = test_dir.join("expected.svd");
     let expected_svd = svd_reader::device(&expected_svd_path).unwrap();
 
-    patch::patch_cli::patch(&test_dir.join("patch.yaml")).unwrap();
+    patch::patch_cli::patch(&test_dir.join("patch.yaml"), None, None).unwrap();
     let actual_svd_path = test_dir.join("stm32l4x2.svd.patched");
 
     let actual_svd = svd_reader::device(&actual_svd_path).unwrap();