added toml/data validation and new binary just for that

Author: kyclark

AUTHORS

@@ -1,2 +1,2 @@
-Susan Student <susan.student@umontana.edu>
-Travis Wheeler <travis.wheeler@umontana.edu>
+Ken Youens-Clark <kyclark@arizona.edu>
+Travis Wheeler <twheeler@arizona.edu>

Cargo.lock

@@ -21,4 +21,5 @@ serde_with = "3.16.1"
 sha1 = "0.10.6"
 toml = "0.9.11"
 urlencoding = "2.1.3"
+validator = { version = "0.20.0", features = ["derive"] }
 which = "8.0.0"

Cargo.toml

@@ -0,0 +1,26 @@
+use anyhow::Result;
+use clap::Parser;
+use mdr::metadata::Meta;
+use std::path::PathBuf;
+
+// --------------------------------------------------
+#[derive(Parser, Debug)]
+pub struct Args {
+    #[arg()]
+    pub filename: PathBuf,
+}
+
+// --------------------------------------------------
+fn main() {
+    if let Err(e) = run(Args::parse()) {
+        eprintln!("{e}");
+        std::process::exit(1);
+    }
+}
+
+// --------------------------------------------------
+fn run(args: Args) -> Result<()> {
+    let meta = Meta::from_file(&args.filename)?;
+    println!("{}", meta.check().join("\n"));
+    Ok(())
+}

src/bin/mdr-toml.rs

@@ -4,7 +4,7 @@ use regex::Regex;
 use std::{
     fs::{self, File},
     io::Write,
-    path::PathBuf,
+    path::{Path, PathBuf},
     process::Command,
 };
 use which::which;
@@ -24,7 +24,7 @@ pub fn read_file(path: &PathBuf) -> Result<String> {
 }
 
 // --------------------------------------------------
-pub fn get_md5(path: &PathBuf) -> Result<String> {
+pub fn get_md5(path: &Path) -> Result<String> {
     info!("Getting MD5 '{}'", path.display());
     let input_dir = path.parent().unwrap();
     let filename = path.file_name().unwrap().to_string_lossy().to_string();

src/common.rs

@@ -1,2 +1,85 @@
+use regex::Regex;
+use std::sync::LazyLock;
+
 pub const MAX_FILE_SIZE_GB: u64 = 40;
 pub const MAX_FILE_SIZE_BYTES: u64 = MAX_FILE_SIZE_GB * 10u64.pow(9);
+
+pub static ORCID_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^\d{4}-\d{4}-\d{4}-[A-Z\d]{4}$").unwrap());
+
+pub static PDB_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^[A-Za-z0-9]{4}$").unwrap());
+
+pub static DOI_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^(10\.\d{4,5}\/[\S]+[^;,.\s])$").unwrap());
+
+pub static NOT_WHITESPACE_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"\S+").unwrap());
+
+pub const SOLVENT_CONCENTRATION_MIN: f64 = 0.;
+pub const SOLVENT_CONCENTRATION_MAX: f64 = 1.;
+pub const WATER_DENSITY_MIN: f32 = 900.;
+pub const WATER_DENSITY_MAX: f32 = 1100.;
+pub const METADATA_TOML_VERSION: u32 = 2;
+pub const TEMP_K_MIN: u32 = 275;
+pub const TEMP_K_MAX: u32 = 700;
+pub const TIMESTEP_FS_MIN: u32 = 0;
+pub const TIMESTEP_FS_MAX: u32 = 4;
+pub const VALID_WATER_MODEL: &[&str] = &[
+    "AMOEBA",
+    "BF",
+    "BK3",
+    "BMW",
+    "COS/G2",
+    "COS/G3",
+    "CVFF",
+    "DC",
+    "ELBA",
+    "EVB",
+    "F3C",
+    "HIPPO",
+    "iAMOEBA",
+    "KKY",
+    "LEWIS",
+    "MARTINI polarizable water",
+    "MARTINI water",
+    "MB-pol",
+    "MCY",
+    "MS-EVB",
+    "mW",
+    "OPC",
+    "OPC3",
+    "OSS2",
+    "POL3",
+    "q-SPC/Fw",
+    "q-TIP4P/F",
+    "ReaxFF",
+    "RWK",
+    "SCME",
+    "SDK/CMM",
+    "SPC",
+    "SPC/E",
+    "SPC/Fd",
+    "SPC/Fw",
+    "SPC/Fw",
+    "ST2",
+    "SWM4-NDP",
+    "SWM6",
+    "TIP3P-FB",
+    "TIP3P",
+    "TIP3P/Fs",
+    "TIP4P",
+    "TIP4P-CG",
+    "TIP4P-D",
+    "TIP4P-FB",
+    "TIP4P/2005",
+    "TIP4P/Ew",
+    "TIP4P/Ice",
+    "TIP5P",
+    "TIP5P/2018",
+    "TIP5P/E",
+    "TIP6P",
+    "TTM2-F",
+    "TTM3-F",
+    "TTM4-F",
+];

src/constants.rs

@@ -0,0 +1,8 @@
+pub mod common;
+pub mod constants;
+pub mod metadata;
+pub mod process;
+pub mod reprocess;
+pub mod ticket;
+pub mod types;
+pub mod validate;

src/lib.rs

@@ -1,18 +1,13 @@
-mod common;
-mod constants;
-mod metadata;
-mod process;
-mod reprocess;
-mod ticket;
-mod types;
-mod validate;
-
 use anyhow::Result;
 use clap::Parser;
-//use diesel::prelude::*;
-use metadata::Meta;
+use mdr::{
+    metadata::Meta,
+    process, reprocess, ticket,
+    types::{Cli, Command, LogLevel},
+    validate,
+};
 use std::{fs::File, io::BufWriter};
-use types::{Cli, Command, LogLevel};
+//use validator::Validate;
 
 // --------------------------------------------------
 fn main() {
@@ -50,9 +45,27 @@ fn run(args: Cli) -> Result<()> {
             Ok(())
         }
         Some(Command::MetaCheck(args)) => {
-            let meta = Meta::from_file(&args.filename)?;
-            dbg!(&meta);
-            println!("{} OK", args.filename.display());
+            let messages = match Meta::from_file(&args.filename) {
+                Ok(meta) => meta.check(),
+                Err(e) => vec![format!(
+                    "Unable to parse {}: {}",
+                    args.filename.display(),
+                    e.to_string()
+                )],
+                //Ok(meta) => match meta.validate() {
+                //    Ok(()) => vec![],
+                //    Err(errors) => {
+                //        dbg!(&errors);
+                //        let mut ret = vec![];
+                //        for (field, _val) in errors.errors() {
+                //            ret.push(format!("{field}"));
+                //        }
+                //        ret
+                //    }
+                //},
+            };
+
+            println!("{}", messages.join("\n"));
             Ok(())
         }
         Some(Command::Ticket(args)) => {