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

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

@@ -1,6 +1,14 @@
 # CHANGES
 
-## 0.9.0.alpha.1
+## 0.9.2
+
+- Feat: add variables and templating
+
+## 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.2}/Cargo.lock

@@ -178,7 +178,7 @@ checksum = "2fd1289c04a9ea8cb22300a459a72a385d7c73d3259e2ed7dcb2af674838cfa9"
 
 [[package]]
 name = "check-config"
-version = "0.9.0-alpha.2"
+version = "0.9.2"
 dependencies = [
  "clap",
  "clap-verbosity-flag",
@@ -2311,9 +2311,9 @@ dependencies = [
 
 [[package]]
 name = "zip"
-version = "5.1.1"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f852905151ac8d4d06fdca66520a661c09730a74c6d4e2b0f27b436b382e532"
+checksum = "eb2a05c7c36fde6c09b08576c9f7fb4cda705990f73b58fe011abf7dfb24168b"
 dependencies = [
  "aes",
  "arbitrary",

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

@@ -1,15 +1,14 @@
 [package]
 name = "check-config"
-version = "0.9.0-alpha.2"
+version = "0.9.2"
 edition = "2024"
-license = "MIT"
-homepage = "https://pypi.org/project/check-config/"
+description = "Check configuration files."
 documentation = "https://check-config.readthedocs.io"
+readme = "README.md"
+homepage = "https://pypi.org/project/check-config/"
 repository = "https://github.com/mrijken/check-config"
+license = "MIT"
 keywords = ["automation", "configuration"]
-authors = ["Marc Rijken <marc@rijken.org>"]
-readme = "README.md"
-description = "Check configuration files."
 exclude = [".github/*", "videos/*"]
 
 [package.metadata.cargo-machete]
@@ -53,7 +52,7 @@ thiserror = { version = "2.0.15", default-features = false }
 toml = { version = "0.9.5", default-features = false }
 toml_edit = "0.23.3"
 url = { version = "2.5.4", default-features = false }
-zip = "5.1.1"
+zip = "6.0.0"
 
 [profile.release]
 lto = "fat"

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

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

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

@@ -3,20 +3,22 @@
 `check-config` uses `checkers` which define the desired state of the configuration files.
 There are several checker types (and more to come):
 
-| checker type                                        | description                                                                                 | fixable |
-| --------------------------------------------------- | ------------------------------------------------------------------------------------------- | ------- |
-| [file_absent](#file-absent)                         | the file must be absent                                                                     | yes     |
-| [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      |
-| [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     |
-| [git_fetched](#get-fetched)                         | the git repo must be present and fetched                                                    | yes     |
+| checker type                                        | description                                                                                 | fixable |  templating |
+| --------------------------------------------------- | ------------------------------------------------------------------------------------------- | ------- |-------------|
+| [file_absent](#file-absent)                         | the file must be absent                                                                     | yes     | no |
+| [file_present](#file-present)                       | the file must be present, indifferent the content                                           | yes     | no |
+| [key_absent](#key-absent)                           | a specified key must be absent in a toml / yaml / json file                                 | yes     | no |
+| [key_value_present](#key-value-present)             | a specified key with a specified value must be present in a toml / yaml / json file         | yes     | 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)     | no |
+| [entry_absent](#entry-absent)                       | a specified entry must be absent in the array of a toml / yaml / json file                  | yes     | no |
+| [entry_present](#entry-present)                     | a specified entry must be present in the of a toml / yaml / json file                       | yes     | no |
+| [lines_absent](#lines-absent)                       | the specified lines must be absent                                                          | yes     | yes |
+| [lines_present](#lines-present)                     | the specified lines must be present                                                         | yes     | yes |
+| [file_unpacked](#file-unpacked)                     | the file must be unpacked                                                                   | yes     | no |
+| [file_copied](file-copied)                          | the file must be copied                                                                     | yes     | yes |
+| [dir_copied](dir-copied)                            | the dir must be copied                                                                      | yes     | no |
+| [dir_present](dir-present)                            | the dir must be present                                                                      | yes     | no |
+| [git_fetched](#get-fetched)                         | the git repo must be present and fetched                                                    | yes     | no |
 
 ## check-config.toml
 
@@ -65,21 +67,58 @@ 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
 ```
 
+### Templating
+
+Some checkers support templating. When a checker supports templating, variables
+are substitued by their values. Variables are defined in the top level variables
+key in the toml files.
+
+```toml
+[variables]
+date = "2025-10-10"
+```
+
+Beside adding the variables to the config, you can add all environment variables via the
+`--env` cli option:
+
+```shell
+check-config --env
+```
+
+In your content, the variables within `${}` are replaced when `is_template` is set to true:
+
+```toml
+[[lines_present]]
+file = "test.txt"
+lines = "date: ${date}"
+is_template = true
+```
+
+You can escape variable substitution by adding a `\` ie `\${date}`. During execution
+the unescaped variant `${date}` will replace the escaped one.
+
+Notes:
+
+- order is important. If variables are inserted after the de definition of a
+  checker, they will not be available.
+- variables names are case sensitive.
+- the values of the variables must be strings.
+
 ## File Absent
 
 `file_absent` will check if the file is absent.
@@ -182,6 +221,47 @@ When`destination`is given,`destination_dir` is ignored.
 
 When the parent dir of the `destination` does not exists, the dir is created.
 
+### Templating
+
+This checker supports templating.
+
+```toml
+[[file_copied]]
+source = "url or path to file"
+destination = "path (including filename) on local filesystem"
+is_template = true
+```
+
+## 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 +367,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.
@@ -343,6 +426,17 @@ Bla
 Bla
 ```
 
+### Templating
+
+This checker supports templating.
+
+```toml
+[[lines_absent]]
+file = "test.txt"
+lines = "date: ${date}"
+is_template = true
+```
+
 ## Lines Present
 
 `lines_present` will check that the file does contain the lines as specified.
@@ -402,6 +496,17 @@ When one of the markers is not present, the markers and the lines will be append
 Note: because the checkers are executed in sequence, one can add markers in one checker, which are replaced by
 a next checker.
 
+### Templating
+
+This checker supports templating.
+
+```toml
+[[lines_present]]
+file = "test.txt"
+lines = "date: ${date}"
+is_template = true
+```
+
 ## Mapping File Types
 
 The checker types with a key (key_absent, key_value_present, key_value_regex_matched) can we used on several file types
@@ -421,3 +526,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.2}/docs/usage.md

@@ -127,6 +127,14 @@ check-config --any-tags tag1,tag2 --all-tags tag3,tag4 --skip-tags tag5,tag6
 This invocation call checkers which has one of [tag1, tag2], all of [tag3, tag4] and not one of [tag5, tag6]
 specified in their `__tags__` key.
 
+## Environment variables
+
+You can use your environment variables in templates of the checkers via the `--env` option:
+
+```shell
+check-config --env
+```
+
 ## Pre-commit
 
 [pre-commit](https://pre-commit.com/) helps checking your code before committing git, so you can catch errors
@@ -138,7 +146,7 @@ you want to use:
 ```yaml
 repos:
   - repo: https://github.com/mrijken/check-config
-    rev: v0.9.0-alpha.2
+    rev: v0.9.2
     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.2}/example/checkers/check-config.toml

@@ -1,11 +1,15 @@
 include = [
   # "https://raw.githubusercontent.com/mrijken/check-config/refs/heads/main/example/checkers/http_check_config.toml",
+  "vars.toml",
   "http_check_config.toml",
   "folder/local_file.toml",
   "copy.toml",
   "unpack.toml",
 ]
 
+[[dir_present]]
+dir = "output/created_dir"
+
 [[file_absent]]
 file = "output/to_be_removed"
 
@@ -28,6 +32,11 @@ regex = "export KEY=.*"
 file = "output/.bashrc"
 lines = "alias ll='ls -alF'"
 
+[[lines_present]]
+file = "output/.bashrc"
+lines = "export DATE=\"${date}\""
+is_template = true
+
 [[lines_absent]]
 file = "output/.bashrc"
 lines = "alias to_be_removed='ls'"
@@ -70,6 +79,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.2}/example/checkers/copy.toml

@@ -8,10 +8,14 @@ source = "https://rust-lang.org/static/images/rust-logo-blk.svg"
 destination = "output/python-logo.svg"
 source = "config:python-logo.svg"
 
+[[file_copied]]
+destination = "output/filled_template.txt"
+source = "config:template.txt"
+is_template = true
+
 [[file_present]]
 file = "output/rust-logo.svg"
-fixable = false
+check_only = true
 
 [[file_present]]
 file = "output/python-logo.svg"
-fixable = false

check_config-0.9.2/example/checkers/template.txt

@@ -0,0 +1,2 @@
+This file will be copied.
+During copy a date will be substituted for \${date}: ${date}

{check_config-0.9.0a2 → check_config-0.9.2}/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.2/example/checkers/vars.toml

@@ -0,0 +1,2 @@
+[variables]
+date = "2025-10-10"

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

@@ -1,2 +1,5 @@
 export KEY="SAMPLE"
+
 alias ll='ls -alF'
+
+export DATE="2025-10-10"

check_config-0.9.2/example/expected_output/filled_template.txt

@@ -0,0 +1,2 @@
+This file will be copied.
+During copy a date will be substituted for ${date}: 2025-10-10

{check_config-0.9.0a2 → check_config-0.9.2}/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.2}/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.2/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.2}/mkdocs.yml

@@ -23,7 +23,8 @@ theme:
     - content.code.copy
 
 markdown_extensions:
-  - include
+  - markdown_include.include:
+      base_path: docs
   - admonition
   - toc:
       permalink: true

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

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

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

@@ -0,0 +1,199 @@
+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 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();
+        let _ = 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()
+        );
+    }
+}