duck-template 0.1.9

A cli tool for generating files from a template just with a json file
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

#[cfg(test)]
mod tests {
  use std::{
    collections::HashMap,
    fs::{self, create_dir},
    io::Write,
  };

  use tempfile::{NamedTempFile, tempdir};

  use crate::{
    config::config_structure::Source,
    template::{parse_source, replace_args},
  };

  #[test]
  fn test_replace_args_basic() {
    let mut args = HashMap::new();
    args.insert("name".to_string(), "duck".to_string());
    args.insert("lang".to_string(), "rust".to_string());

    let file_args = vec!["{name}".to_string(), "{lang}".to_string()];
    let content = "Hello, {name}! Welcome to {lang}.";

    let result = replace_args(content, &args, &file_args);
    assert_eq!(result, "Hello, duck! Welcome to rust.");
  }

  #[test]
  fn test_replace_args_missing_key() {
    let mut args = HashMap::new();
    args.insert("name".to_string(), "duck".to_string());

    let file_args = vec!["{name}".to_string(), "{lang}".to_string()];
    let content = "Hello, {name}! Welcome to {lang}.";

    let result = replace_args(content, &args, &file_args);
    assert_eq!(result, "Hello, duck! Welcome to {lang}.");
  }

  #[test]
  fn test_parse_source_file() {
    let mut file = NamedTempFile::new().unwrap();
    writeln!(file, "duck = true").unwrap();

    let path = file.path();
    let root = path.parent().unwrap();

    let source = parse_source(path, root, &vec![]);
    match source {
      Source::File(f) => {
        assert!(
          f.path
            .ends_with(file.path().file_name().unwrap().to_str().unwrap())
        );
        assert!(f.content.contains("duck = true"));
        assert_eq!(f.args, Some(vec![]));
      },
      _ => panic!("Expected Source::File"),
    }
  }

  #[test]
  fn test_parse_source_empty_folder() {
    let dir = tempdir().unwrap();
    let source = parse_source(dir.path(), dir.path(), &vec![]);

    match source {
      Source::Folder(folder) => {
        assert_eq!(folder.path, dir.path().to_str().unwrap()); // ✅ now matches absolute
        assert_eq!(folder.children.len(), 0);
      },
      _ => panic!("Expected Source::Folder"),
    }
  }

  #[test]
  fn test_parse_source_nested_structure() {
    let dir = tempdir().unwrap();
    let root = dir.path();

    // Create nested folders and files
    let nested_dir = root.join("config");
    let _ = create_dir(&nested_dir);
    let file_path = nested_dir.join("settings.toml");
    fs::write(&file_path, "key = \"value\"").unwrap();

    let source = parse_source(root, root, &vec![]);
    match source {
      Source::Folder(folder) => {
        assert_eq!(folder.path, root.to_str().unwrap());

        let config_folder = folder
          .children
          .iter()
          .find(|c| match c {
            Source::Folder(f) => f.path.ends_with("config"), // ✅ changed
            _ => false,
          })
          .expect("Missing config folder");

        match config_folder {
          Source::Folder(f) => {
            assert_eq!(f.children.len(), 1);
            match &f.children[0] {
              Source::File(f) => {
                assert!(f.path.ends_with("config/settings.toml")); // ✅ changed
                assert!(f.content.contains("key = \"value\""));
              },
              _ => panic!("Expected file in config folder"),
            }
          },
          _ => panic!("Expected config folder"),
        }
      },
      _ => panic!("Expected root folder"),
    }
  }

  #[test]
  fn test_parse_source_skips_hidden_files() {
    let dir = tempdir().unwrap();
    let hidden_file = dir.path().join(".hidden");
    fs::write(&hidden_file, "secret").unwrap();

    let source = parse_source(dir.path(), dir.path(), &vec![]);
    match source {
      Source::Folder(folder) => {
        assert_eq!(folder.children.len(), 0);
      },
      _ => panic!("Expected folder"),
    }
  }
}