check-config 0.9.0a2__tar.gz → 0.9.1__tar.gz

{check_config-0.9.0a2 → check_config-0.9.1}/CHANGES.md

@@ -1,6 +1,10 @@
 # CHANGES
 
-## 0.9.0.alpha.1
+## 0.9.1
+
+- Feat: add dir_present
+
+## 0.9.0
 
 - BREAKING: refactor the check-config toml files. See documentation for new format.
 

{check_config-0.9.0a2 → check_config-0.9.1}/Cargo.lock

@@ -178,7 +178,7 @@ checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
 
 [[package]]
 name = "check-config"
-version = "0.9.0-alpha.2"
+version = "0.9.1"
 dependencies = [
  "clap",
  "clap-verbosity-flag",

{check_config-0.9.0a2 → check_config-0.9.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "check-config"
-version = "0.9.0-alpha.2"
+version = "0.9.1"
 edition = "2024"
 license = "MIT"
 homepage = "https://pypi.org/project/check-config/"

{check_config-0.9.0a2 → check_config-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: check-config
-Version: 0.9.0a2
+Version: 0.9.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{check_config-0.9.0a2 → check_config-0.9.1}/docs/checkers.md

@@ -9,13 +9,15 @@ There are several checker types (and more to come):
 | [file_present](#file-present)                       | the file must be present, indifferent the content                                           | yes     |
 | [key_absent](#key-absent)                           | a specified key must be absent in a toml / yaml / json file                                 | yes     |
 | [key_value_present](#key-value-present)             | a specified key with a specified value must be present in a toml / yaml / json file         | yes     |
-| [key_value_regex_matched](#key-value-regex-matched) | the value of a specified key must be match the specified regex in a toml / yaml / json file | no      |
+| [key_value_regex_matched](#key-value-regex-matched) | the value of a specified key must be match the specified regex in a toml / yaml / json file | no (unless placeholder is given)     |
 | [entry_absent](#entry-absent)                       | a specified entry must be absent in the array of a toml / yaml / json file                  | yes     |
 | [entry_present](#entry-present)                     | a specified entry must be present in the of a toml / yaml / json file                       | yes     |
 | [lines_absent](#lines-absent)                       | the specified lines must be absent                                                          | yes     |
 | [lines_present](#lines-present)                     | the specified lines must be present                                                         | yes     |
 | [file_unpacked](#file-unpacked)                     | the file must be unpacked                                                                   | yes     |
 | [file_copied](file-copied)                          | the file must be copied                                                                     | yes     |
+| [dir_copied](dir-copied)                            | the dir must be copied                                                                      | yes     |
+| [dir_present](dir-present)                            | the dir must be present                                                                      | yes     |
 | [git_fetched](#get-fetched)                         | the git repo must be present and fetched                                                    | yes     |
 
 ## check-config.toml
@@ -65,19 +67,19 @@ tags = ["linux"]
 lines = ".cache"
 ```
 
-### Fixable
+### Check-Only
 
 When `--fix` is given on the cli, `check-config` will try to fix the checkers. However,
 sometimes you do not want a fix a violation, but just check if a previous fix is
 performed correct. For example: you unzip a file in one checker and want to check
 whether a file is unpacked from the zip. In that case you do not want to create
 an empty file by the checker which checks for the unpacked file. To do so, add
-`fixable = false` to your checker, like:
+`check_only = true` to your checker, like:
 
 ```toml
 [[file_present]]
 file = "path/to/unpacked_file"
-fixable = false
+check_only = true
 ```
 
 ## File Absent
@@ -182,6 +184,36 @@ When`destination`is given,`destination_dir` is ignored.
 
 When the parent dir of the `destination` does not exists, the dir is created.
 
+## Dir Copied
+
+`dir_copied` will check that the dir including all contents is copied.
+
+```toml
+[[dir_copied]]
+source = "path to dir"
+destination_dir = "dir on local filesystem in which the contents are copied"
+destination = "dir on local filesystem in which the source directory is copied"
+
+```
+
+Only on `destination` and `destination_dir`` needs to be specified.
+When`destination_dir`is given, the`destination`is created by appending the filename
+from the source to the`destination`.
+When`destination`is given,`destination_dir` is ignored.
+
+When the parent dir of the `destination` does not exists, the dir is created.
+
+## Dir Present
+
+`dir_present` will check if the dir including the parent directories is present.
+When `permissions` are given, it will also check the permissions.
+
+```toml
+[[dir_present]]
+dir = "path to dir"
+permissions = "755" # optional
+```
+
 ## File Unpacked
 
 `file_unpacked` will check that the file is unpacked. It can unpack zip, tar.gz and tar files.
@@ -287,13 +319,16 @@ This checker type can handle different kind of [mapping file types](#mapping-fil
 
 `key_value_regex_matched` will check that the keys specified are present and the value matches the specified regex.
 Of course, the regex can only match string values.
-Keys may be nested. Intermediate keys has to have mappings as values. When intermediate values
+
+This checker can only fix when a placeholder is present, otherwise it's check-only. Keys may be nested.
+Intermediate keys has to have mappings as values. When intermediate values
 are not present, they will be added.
 
 ```toml
 [[key_value_regex_matched]]
 file = "test/present.toml"
 key.key = 'v.*'
+placeholder = "v1.1"  # optional
 ```
 
 Note: specify the regex as a raw string (single quotes) to be prevent escaping.
@@ -421,3 +456,11 @@ file = "test/present.toml"
 file_type = "json"
 key.key = 1
 ```
+
+The indentation can be changed by specifying the indentation per checker:
+
+```toml
+[[key_value_present]]
+...
+indent = 2
+```

{check_config-0.9.0a2 → check_config-0.9.1}/docs/usage.md

@@ -138,7 +138,7 @@ you want to use:
 ```yaml
 repos:
   - repo: https://github.com/mrijken/check-config
-    rev: v0.9.0-alpha.2
+    rev: v0.9.1
     hooks:
       # Install via Cargo and execute `check-config --fix`
       - id: check_config_fix_install_via_rust

{check_config-0.9.0a2 → check_config-0.9.1}/example/checkers/check-config.toml

@@ -6,6 +6,9 @@ include = [
   "unpack.toml",
 ]
 
+[[dir_present]]
+dir = "output/created_dir"
+
 [[file_absent]]
 file = "output/to_be_removed"
 
@@ -70,6 +73,21 @@ key.added.key = "value"
 file = "output/test.yaml"
 key.to_be_kept.key = "value"
 
+[[key_value_regex_matched]]
+file = "output/test.json"
+key.placeholder_regex = "m[a-z]tches"
+placeholder = "matches"
+
+[[key_value_regex_matched]]
+file = "output/test.toml"
+key.placeholder_regex = "m[a-z]tches"
+placeholder = "matches"
+
+[[key_value_regex_matched]]
+file = "output/test.yaml"
+key.placeholder_regex = "m[a-z]tches"
+placeholder = "matches"
+
 [[entry_absent]]
 file = "output/absent.json"
 entry.list2 = ["already_absent"]

{check_config-0.9.0a2 → check_config-0.9.1}/example/checkers/copy.toml

@@ -10,8 +10,8 @@ source = "config:python-logo.svg"
 
 [[file_present]]
 file = "output/rust-logo.svg"
-fixable = false
+check_only = true
 
 [[file_present]]
 file = "output/python-logo.svg"
-fixable = false
+check_only = true

{check_config-0.9.0a2 → check_config-0.9.1}/example/checkers/unpack.toml

@@ -16,11 +16,11 @@ destination_dir = "output/unpack/tar.gz"
 
 [[file_present]]
 file = "output/unpack/zip/test/sample"
-fixable = false
+check_only = true
 
 [[file_present]]
 file = "output/unpack/tar.gz/test/sample"
-fixable = false
+check_only = true
 
 [[file_absent]]
 file = "temp/test.zip"

{check_config-0.9.0a2 → check_config-0.9.1}/example/expected_output/.bashrc

@@ -1,2 +1,3 @@
 export KEY="SAMPLE"
+
 alias ll='ls -alF'

{check_config-0.9.0a2 → check_config-0.9.1}/example/expected_output/test.json

@@ -9,6 +9,7 @@
     "list2": [
         "already_present"
     ],
+    "placeholder_regex": "matches",
     "regex": "matches",
     "to_be_added": "value",
     "to_be_kept": {

{check_config-0.9.0a2 → check_config-0.9.1}/example/expected_output/test.toml

@@ -1,7 +1,8 @@
 regex = "matches"
-list = [ "to_be_kept","to_be_added"]
+list = ["to_be_kept", "to_be_added"]
 list2 = ["already_present"]
 to_be_added = "value"
+placeholder_regex = "matches"
 
 [to_be_kept]
 key = "value"

check_config-0.9.1/example/expected_output/test.yaml

@@ -0,0 +1,10 @@
+regex: matches
+to_be_kept:
+  key: value
+list:
+  - to_be_kept
+  - to_be_added
+list2:
+  - already_present
+to_be_added: value
+placeholder_regex: matches

{check_config-0.9.0a2 → check_config-0.9.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "check-config"
-version = "0.9.0-alpha.2"
+version = "0.9.1"
 description = "Check configuration files."
 readme = "README.md"
 requires-python = ">=3.10"

check_config-0.9.1/src/checkers/file/dir_copied.rs

@@ -0,0 +1,201 @@
+use crate::{
+    checkers::{base::CheckResult, file::get_string_value_from_checktable},
+    uri::{ReadPath, WritablePath},
+};
+
+use super::super::{
+    GenericChecker,
+    base::{CheckConstructor, CheckDefinitionError, CheckError, Checker},
+};
+
+#[derive(Debug)]
+pub(crate) struct DirCopied {
+    source: WritablePath,
+    destination: WritablePath,
+    generic_check: GenericChecker,
+}
+
+//[[dir_copied]]
+// source = "path directory to copy"
+// destination = "path in which the directory contents will be copied"
+// desintation_dir = "path in which the directory will be copied"
+//
+// check if file is copied
+// if source is a relative path, it's relative to the check file, so the dir
+// which contain the file which defines this check.
+impl CheckConstructor for DirCopied {
+    type Output = Self;
+
+    fn from_check_table(
+        generic_check: GenericChecker,
+        check_table: toml_edit::Table,
+    ) -> Result<Self::Output, CheckDefinitionError> {
+        let source = WritablePath::from_string(
+            get_string_value_from_checktable(&check_table, "source")?.as_str(),
+        )
+        .map_err(|_| CheckDefinitionError::InvalidDefinition("invalid source url".into()))?;
+
+        let destination = if check_table.contains_key("destination") {
+            WritablePath::from_string(
+                get_string_value_from_checktable(&check_table, "destination")?.as_str(),
+            )
+            .map_err(|_| {
+                CheckDefinitionError::InvalidDefinition("invalid destination path".into())
+            })?
+        } else {
+            let destination_dir = WritablePath::from_string(
+                get_string_value_from_checktable(&check_table, "destination_dir")?.as_str(),
+            )
+            .map_err(|_| {
+                CheckDefinitionError::InvalidDefinition("invalid destination_dir path".into())
+            })?;
+
+            let file_name = match source.as_ref().file_name() {
+                Some(filename) => filename,
+                None => {
+                    return Err(CheckDefinitionError::InvalidDefinition(
+                        "Source has to filename".into(),
+                    ));
+                }
+            };
+
+            WritablePath::new(destination_dir.as_ref().join(file_name))
+        };
+
+        Ok(Self {
+            destination,
+            source,
+            generic_check,
+        })
+    }
+}
+
+/// Recursively copy all contents of `src` into `dst`.
+fn copy_dir_contents(src: &std::path::Path, dst: &std::path::Path) -> std::io::Result<()> {
+    // Create destination directory if it doesn’t exist
+    if !dst.exists() {
+        std::fs::create_dir_all(dst)?;
+    }
+
+    for entry in std::fs::read_dir(src)? {
+        let entry = entry?;
+        let path = entry.path();
+        let dest_path = dst.join(entry.file_name());
+
+        if path.is_dir() {
+            // Recurse into subdirectory
+            copy_dir_contents(&path, &dest_path)?;
+        } else {
+            // Copy file
+            std::fs::copy(&path, &dest_path)?;
+        }
+    }
+
+    Ok(())
+}
+
+impl Checker for DirCopied {
+    fn checker_type(&self) -> String {
+        "dir_copied".to_string()
+    }
+
+    fn generic_checker(&self) -> &GenericChecker {
+        &self.generic_check
+    }
+    fn checker_object(&self) -> String {
+        self.source.as_ref().to_string_lossy().to_string()
+    }
+    fn check_(&self, fix: bool) -> Result<crate::checkers::base::CheckResult, CheckError> {
+        // todo check whether the file is changed
+        let mut action_messages: Vec<String> = vec![];
+
+        match self.source.exists() {
+            Ok(false) => return Err(CheckError::String("source dir does not exists".into())),
+            Ok(true) => (),
+            Err(e) => return Err(CheckError::String(e.to_string())),
+        }
+
+        // todo: check also all subdirs and files
+        let copy_dir_needed = !self.destination.as_ref().exists();
+
+        if copy_dir_needed {
+            action_messages.push("copy dir".into());
+        }
+        let action_message = action_messages.join("\n");
+
+        let check_result = match (copy_dir_needed, fix) {
+            (false, _) => CheckResult::NoFixNeeded,
+            (true, false) => CheckResult::FixNeeded(action_message),
+            (true, true) => {
+                match copy_dir_contents(self.source.as_ref(), self.destination.as_ref()) {
+                    Ok(_) => CheckResult::FixExecuted(action_message),
+                    Err(e) => return Err(CheckError::String(e.to_string())),
+                }
+            }
+        };
+
+        Ok(check_result)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use std::fs::write;
+
+    use crate::checkers::{base::CheckResult, test_helpers};
+
+    use super::*;
+
+    use tempfile::tempdir;
+
+    fn get_dir_copied_check_with_result()
+    -> (Result<DirCopied, CheckDefinitionError>, tempfile::TempDir) {
+        let generic_check = test_helpers::get_generic_check();
+
+        let mut check_table = toml_edit::Table::new();
+        let dir = tempdir().unwrap();
+        let source = dir.path().join("source");
+        let subdir = source.join("subdir");
+        std::fs::create_dir_all(&subdir).unwrap();
+        std::fs::create_dir(&subdir);
+        let file = subdir.join("file");
+        std::fs::File::create(file).unwrap();
+        let destination = dir.path().join("destination");
+        check_table.insert(
+            "destination",
+            destination.to_string_lossy().to_string().into(),
+        );
+        check_table.insert("source", source.to_string_lossy().to_string().into());
+        (DirCopied::from_check_table(generic_check, check_table), dir)
+    }
+
+    #[test]
+    fn test_dir_copied_from_fs() {
+        let (dir_copied_check, _tempdir) = get_dir_copied_check_with_result();
+        let dir_copied_check = dir_copied_check.expect("no errors");
+
+        assert_eq!(
+            dir_copied_check.check_(false).unwrap(),
+            CheckResult::FixNeeded("copy dir".into())
+        );
+
+        assert_eq!(
+            dir_copied_check.check_(true).unwrap(),
+            CheckResult::FixExecuted("copy dir".into())
+        );
+        assert_eq!(
+            dir_copied_check.check_(false).unwrap(),
+            CheckResult::NoFixNeeded
+        );
+
+        assert!(dir_copied_check.destination.as_ref().exists());
+        assert!(
+            dir_copied_check
+                .destination
+                .as_ref()
+                .join("subdir/file")
+                .exists()
+        );
+    }
+}

check_config-0.9.1/src/checkers/file/dir_present.rs

@@ -0,0 +1,201 @@
+use std::fs;
+#[cfg(not(target_os = "windows"))]
+use std::os::unix::fs::PermissionsExt;
+
+use crate::{
+    checkers::{
+        base::CheckResult,
+        file::{
+            FileCheck, file_present::get_permissions_from_checktable,
+            get_option_string_value_from_checktable, get_string_value_from_checktable,
+        },
+    },
+    uri::WritablePath,
+};
+
+use super::super::{
+    GenericChecker,
+    base::{CheckConstructor, CheckDefinitionError, CheckError, Checker},
+};
+
+#[derive(Debug)]
+pub(crate) struct DirPresent {
+    generic_check: GenericChecker,
+    dir: WritablePath,
+    permissions: Option<std::fs::Permissions>,
+}
+
+//[[dir_present]]
+// dir = "dir"
+// permissions = "755"  # optional
+
+impl CheckConstructor for DirPresent {
+    type Output = Self;
+
+    fn from_check_table(
+        generic_check: GenericChecker,
+        check_table: toml_edit::Table,
+    ) -> Result<Self::Output, CheckDefinitionError> {
+        let dir = WritablePath::from_string(
+            get_string_value_from_checktable(&check_table, "dir")?.as_str(),
+        )
+        .map_err(|_| CheckDefinitionError::InvalidDefinition("invalid destination path".into()))?;
+
+        let permissions = get_permissions_from_checktable(&check_table)?;
+
+        Ok(Self {
+            generic_check,
+            dir,
+            permissions,
+        })
+    }
+}
+impl Checker for DirPresent {
+    fn checker_type(&self) -> String {
+        "dir_present".to_string()
+    }
+
+    fn generic_checker(&self) -> &GenericChecker {
+        &self.generic_check
+    }
+    fn checker_object(&self) -> String {
+        self.dir.to_string()
+    }
+    fn check_(&self, fix: bool) -> Result<crate::checkers::base::CheckResult, CheckError> {
+        let mut action_messages: Vec<String> = vec![];
+
+        let create_dir = !self.dir.as_ref().exists();
+
+        if create_dir {
+            action_messages.push("create dir".into());
+        }
+
+        let fix_permissions = if let Some(permissions) = self.permissions.clone() {
+            #[cfg(target_os = "windows")]
+            {
+                false
+            }
+
+            #[cfg(not(target_os = "windows"))]
+            {
+                if create_dir {
+                    true
+                } else {
+                    let current_permissions = match self.dir.as_ref().metadata() {
+                        Err(_) => {
+                            return Err(CheckError::PermissionsNotAccessable);
+                        }
+                        Ok(metadata) => metadata.permissions(),
+                    };
+
+                    // we only check for the last 3 octal digits
+
+                    (current_permissions.mode() & 0o777) != (permissions.mode() & 0o777)
+                }
+            }
+        } else {
+            false
+        };
+
+        #[cfg(not(target_os = "windows"))]
+        if fix_permissions {
+            action_messages.push(format!(
+                "fix permissions to {:o}",
+                self.permissions.clone().unwrap().to_owned().mode()
+            ));
+        }
+
+        let action_message = action_messages.join("\n");
+
+        let check_result = match (create_dir || fix_permissions, fix) {
+            (false, _) => CheckResult::NoFixNeeded,
+            (true, false) => CheckResult::FixNeeded(action_message),
+            (true, true) => {
+                fs::create_dir_all(self.dir.as_ref())?;
+                if fix_permissions {
+                    fs::set_permissions(self.dir.as_ref(), self.permissions.clone().unwrap())?;
+                }
+                CheckResult::FixExecuted(action_message)
+            }
+        };
+
+        Ok(check_result)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use std::fs::write;
+
+    use crate::checkers::{base::CheckResult, test_helpers};
+
+    use super::*;
+
+    use tempfile::tempdir;
+
+    fn get_dir_present_check_present_check_with_result(
+        permissions: Option<String>,
+    ) -> (Result<DirPresent, CheckDefinitionError>, tempfile::TempDir) {
+        let generic_check = test_helpers::get_generic_check();
+
+        let mut check_table = toml_edit::Table::new();
+        let dir = tempdir().unwrap();
+        let dir_to_check = dir.path().join("dir_to_check");
+        check_table.insert("dir", dir_to_check.to_string_lossy().to_string().into());
+
+        if let Some(permissions) = permissions {
+            check_table.insert("permissions", permissions.into());
+        }
+
+        (
+            DirPresent::from_check_table(generic_check, check_table),
+            dir,
+        )
+    }
+
+    fn get_dir_present_check(permissions: Option<String>) -> (DirPresent, tempfile::TempDir) {
+        let (dir_present_with_result, tempdir) =
+            get_dir_present_check_present_check_with_result(permissions);
+
+        (dir_present_with_result.unwrap(), tempdir)
+    }
+    #[test]
+    fn test_dir_present() {
+        let (dir_present_check, _tempdir) = get_dir_present_check(None);
+
+        assert_eq!(
+            dir_present_check.check_(false).unwrap(),
+            CheckResult::FixNeeded("create dir".into())
+        );
+
+        assert_eq!(
+            dir_present_check.check_(true).unwrap(),
+            CheckResult::FixExecuted("create dir".into())
+        );
+        assert_eq!(
+            dir_present_check.check_(false).unwrap(),
+            CheckResult::NoFixNeeded
+        );
+    }
+
+    #[test]
+    fn test_dir_present_with_permissions() {
+        let (dir_present_check, _tempdir) = get_dir_present_check(Some("777".into()));
+
+        assert_eq!(
+            dir_present_check.check_(false).unwrap(),
+            CheckResult::FixNeeded("create dir\nfix permissions to 777".into())
+        );
+
+        assert_eq!(
+            dir_present_check.check_(true).unwrap(),
+            CheckResult::FixExecuted("create dir\nfix permissions to 777".into())
+        );
+
+        assert_eq!(
+            dir_present_check.check_(false).unwrap(),
+            CheckResult::NoFixNeeded
+        );
+    }
+}