Merge pull request #54 from VolumeGraphics/file-exist-checker

File exist checker

Author: TheAdiWijaya

Cargo.toml

@@ -4,7 +4,7 @@ description = "A flexible rule-based file and folder comparison tool and crate i
 repository = "https://github.com/VolumeGraphics/havocompare"
 homepage = "https://github.com/VolumeGraphics/havocompare"
 documentation = "https://docs.rs/havocompare"
-version = "0.6.1"
+version = "0.7.0"
 edition = "2021"
 license = "MIT"
 authors = ["Volume Graphics GmbH"]
@@ -25,7 +25,7 @@ serde = "1.0"
 serde_yaml = "0.9"
 schemars = "0.8"
 schemars_derive = "0.8"
-thiserror = "1.0"
+thiserror = "2.0"
 regex = "1.10"
 image = "0.25"
 image-compare = "0.4"
@@ -35,16 +35,16 @@ serde_json = "1.0"
 glob = "0.3"
 test-log = { version = "0.2", features = ["trace"] }
 strsim = "0.11"
-itertools = "0.13"
+itertools = "0.14"
 tera = "1.19"
 sha2 = "0.10"
 data-encoding = "2.6"
 permutation = "0.4"
-pdf-extract = "0.7"
+pdf-extract = "0.9"
 vg_errortools = "0.1"
 rayon = "1.10.0"
 enable-ansi-support = "0.2"
-tempfile = "3.10"
+tempfile = "3.20"
 fs_extra = "1.3"
 opener = "0.7"
 anyhow = "1.0"

README.md

@@ -276,6 +276,26 @@ rules:
         - "ignore_this_key(s?)"
 ```
 
+#### File Exists / Directory Comparison
+
+Compares directory structure and file existence in both paths.
+
+```yaml
+rules:
+  - name: "Directory Checker"
+    # to check directory structure only (ignoring the files) use "**/*/" and remove pattern_exclude
+    # to check all files and directory use "**/*" and remove pattern_exclude
+    # to check files only uses "**/*.*" but this works only in windows. Or use "**/*" and pattern_exclude "**/*/"
+    pattern_include:
+      - "**/*"
+    pattern_exclude:
+      - "**/*/"
+    Directory:
+      # Mode Identical to check whether both paths are really the same: whether entry is missing in actual, and/or if entry exists in actual but not in nominal
+      # Mode MissingOnly to check only if entry is missing in actual, ignoring entries that exist in actual but not in nominal
+      mode: Identical
+```
+
 ### Use HavoCompare in your unit-tests
 
 1. Add havocompare to your dev-dependencies:
@@ -306,6 +326,12 @@ rules:
 
 ## Changelog
 
+### 0.7.0
+
+- add file exist checker
+- fix file property checker report that "Creation date" of "nominal" and "actual" columns are switched
+- update thiserror, itertools and pdf-extract crates
+
 ### 0.6.1
 
 - Add new version of json-diff, featuring a better API and better filtering options

src/directory.rs

@@ -0,0 +1,214 @@
+use crate::report::{DiffDetail, Difference};
+use schemars_derive::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::path;
+use std::path::{Path, PathBuf};
+use thiserror::Error;
+use tracing::error;
+
+#[derive(Debug, Error)]
+/// Errors during html / plain text checking
+pub enum Error {
+    #[error("Failed to remove path's prefix")]
+    StripPrefixError(#[from] path::StripPrefixError),
+}
+
+#[derive(JsonSchema, Deserialize, Serialize, Debug, Clone)]
+pub struct DirectoryConfig {
+    pub mode: Mode,
+}
+
+#[derive(JsonSchema, Deserialize, Serialize, Debug, Clone)]
+pub enum Mode {
+    /// check whether both paths are really the same: whether entry is missing in actual, and/or if entry exists in actual but not in nominal
+    Identical,
+    /// check only if entry is missing in actual, ignoring entries that exist in actual but not in nominal
+    MissingOnly,
+}
+
+pub(crate) fn compare_paths<P: AsRef<Path>>(
+    nominal: P,
+    actual: P,
+    nominal_entries: &[PathBuf],
+    actual_entries: &[PathBuf],
+    config: &DirectoryConfig,
+) -> Result<Difference, Error> {
+    let nominal_path = nominal.as_ref();
+    let actual_path = actual.as_ref();
+
+    let mut difference = Difference::new_for_file(nominal_path, actual_path);
+
+    //remove root paths!
+    let nominal_entries: Result<Vec<_>, path::StripPrefixError> = nominal_entries
+        .iter()
+        .map(|path| path.strip_prefix(nominal_path))
+        .collect();
+    let nominal_entries = nominal_entries?;
+
+    let actual_entries: Result<Vec<_>, path::StripPrefixError> = actual_entries
+        .iter()
+        .map(|path| path.strip_prefix(actual_path))
+        .collect();
+    let actual_entries = actual_entries?;
+
+    let mut is_the_same = true;
+    if matches!(config.mode, Mode::Identical | Mode::MissingOnly) {
+        nominal_entries.iter().for_each(|entry| {
+            let detail = if let Some(f) = actual_entries.iter().find(|a| *a == entry) {
+                (f.to_string_lossy().to_string(), false)
+            } else {
+                error!("{} doesn't exist in the actual folder", entry.display());
+                is_the_same = false;
+                ("".to_owned(), true)
+            };
+
+            difference.push_detail(DiffDetail::File {
+                nominal: entry.to_string_lossy().to_string(),
+                actual: detail.0,
+                error: detail.1,
+            });
+        });
+    }
+
+    if matches!(config.mode, Mode::Identical) {
+        actual_entries.iter().for_each(|entry| {
+            if !nominal_entries.iter().any(|n| n == entry) {
+                difference.push_detail(DiffDetail::File {
+                    nominal: "".to_owned(),
+                    actual: entry.to_string_lossy().to_string(),
+                    error: true,
+                });
+
+                error!(
+                    "Additional entry {} found in the actual folder",
+                    entry.display()
+                );
+                is_the_same = false;
+            }
+        });
+    }
+
+    if !is_the_same {
+        difference.error();
+    }
+
+    Ok(difference)
+}
+
+#[cfg(test)]
+
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_compare_directories() {
+        let nominal_dir = tempfile::tempdir().expect("Could not create nominal temp dir");
+
+        std::fs::create_dir_all(nominal_dir.path().join("dir/a/aa"))
+            .expect("Could not create directory");
+        std::fs::create_dir_all(nominal_dir.path().join("dir/b"))
+            .expect("Could not create directory");
+        std::fs::create_dir_all(nominal_dir.path().join("dir/c"))
+            .expect("Could not create directory");
+
+        let actual_dir = tempfile::tempdir().expect("Could not create actual temp dir");
+
+        std::fs::create_dir_all(actual_dir.path().join("dir/a/aa"))
+            .expect("Could not create directory");
+        std::fs::create_dir_all(actual_dir.path().join("dir/b"))
+            .expect("Could not create directory");
+        std::fs::create_dir_all(actual_dir.path().join("dir/c"))
+            .expect("Could not create directory");
+
+        let pattern_include = ["**/*/"];
+        let pattern_exclude: Vec<String> = Vec::new();
+
+        let nominal_entries = crate::get_files(&nominal_dir, &pattern_include, &pattern_exclude)
+            .expect("Could not get files");
+        let actual_entries = crate::get_files(&actual_dir, &pattern_include, &pattern_exclude)
+            .expect("Could not get files");
+
+        let result = compare_paths(
+            nominal_dir.path(),
+            actual_dir.path(),
+            &nominal_entries,
+            &actual_entries,
+            &DirectoryConfig {
+                mode: Mode::Identical,
+            },
+        )
+        .expect("Could not compare paths");
+
+        assert!(!result.is_error);
+
+        std::fs::create_dir_all(actual_dir.path().join("dir/d"))
+            .expect("Could not create directory");
+
+        let nominal_entries = crate::get_files(&nominal_dir, &pattern_include, &pattern_exclude)
+            .expect("Could not create directory");
+        let actual_entries = crate::get_files(&actual_dir, &pattern_include, &pattern_exclude)
+            .expect("Could not create directory");
+
+        let result = compare_paths(
+            nominal_dir.path(),
+            actual_dir.path(),
+            &nominal_entries,
+            &actual_entries,
+            &DirectoryConfig {
+                mode: Mode::Identical,
+            },
+        )
+        .expect("Could not compare paths");
+
+        assert!(result.is_error);
+
+        let result = compare_paths(
+            nominal_dir.path(),
+            actual_dir.path(),
+            &nominal_entries,
+            &actual_entries,
+            &DirectoryConfig {
+                mode: Mode::MissingOnly,
+            },
+        )
+        .expect("Could not compare paths");
+
+        assert!(!result.is_error);
+
+        std::fs::create_dir_all(nominal_dir.path().join("dir/d"))
+            .expect("Could not create directory");
+        std::fs::create_dir_all(nominal_dir.path().join("dir/e"))
+            .expect("Could not create directory");
+
+        let nominal_entries = crate::get_files(&nominal_dir, &pattern_include, &pattern_exclude)
+            .expect("Could not create directory");
+        let actual_entries = crate::get_files(&actual_dir, &pattern_include, &pattern_exclude)
+            .expect("Could not create directory");
+
+        let result = compare_paths(
+            nominal_dir.path(),
+            actual_dir.path(),
+            &nominal_entries,
+            &actual_entries,
+            &DirectoryConfig {
+                mode: Mode::Identical,
+            },
+        )
+        .expect("Could not compare paths");
+
+        assert!(result.is_error);
+
+        let result = compare_paths(
+            nominal_dir.path(),
+            actual_dir.path(),
+            &nominal_entries,
+            &actual_entries,
+            &DirectoryConfig {
+                mode: Mode::MissingOnly,
+            },
+        )
+        .expect("Could not compare paths");
+
+        assert!(result.is_error);
+    }
+}

src/hash.rs

@@ -8,8 +8,8 @@ use thiserror::Error;
 use vg_errortools::fat_io_wrap_std;
 use vg_errortools::FatIOError;
 
-use crate::{Deserialize, report, Serialize};
 use crate::report::{DiffDetail, Difference};
+use crate::{report, Deserialize, Serialize};
 
 #[derive(Debug, Deserialize, Serialize, JsonSchema, Clone, Copy)]
 pub enum HashFunction {

src/image.rs

@@ -7,8 +7,8 @@ use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use tracing::error;
 
-use crate::{get_file_name, report};
 use crate::report::DiffDetail;
+use crate::{get_file_name, report};
 
 #[derive(JsonSchema, Deserialize, Serialize, Debug, Clone)]
 pub enum RGBACompareMode {
@@ -27,6 +27,7 @@ impl Default for RGBACompareMode {
     }
 }
 
+#[allow(clippy::upper_case_acronyms)]
 #[derive(JsonSchema, Deserialize, Serialize, Debug, Clone, Default)]
 pub enum RGBCompareMode {
     ///Comparing rgb images using structure. RGB structure similarity is performed by doing a channel split and taking the maximum deviation (minimum similarity) for the result. The image contains the complete deviations. Algorithm: RMS
@@ -38,6 +39,7 @@ pub enum RGBCompareMode {
     Hybrid,
 }
 
+#[allow(clippy::upper_case_acronyms)]
 #[derive(JsonSchema, Deserialize, Serialize, Debug, Clone)]
 /// The distance algorithm to use for grayscale comparison, see
 /// https://github.com/ChrisRega/image-compare for equations
@@ -70,6 +72,7 @@ pub enum GrayCompareMode {
     Histogram(GrayHistogramCompareMetric),
 }
 
+#[allow(clippy::upper_case_acronyms)]
 #[derive(JsonSchema, Deserialize, Serialize, Debug, Clone)]
 pub enum CompareMode {
     /// Compare images as RGB

src/json.rs

@@ -7,8 +7,8 @@ use schemars_derive::JsonSchema;
 use serde::{Deserialize, Serialize};
 use tracing::error;
 
-use crate::Error;
 use crate::report::{DiffDetail, Difference};
+use crate::Error;
 
 #[derive(Debug, Deserialize, Serialize, JsonSchema, Clone)]
 /// configuration for the json compare module