plottery_project 0.7.0

Project management library of Plottery, a creative coding framework for generative vector graphics and pen plotting.
Documentation 
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

#[cfg(test)]
mod tests {
    use std::path::{Path, PathBuf};

    use anyhow::{Ok, Result};

    use crate::{
        cargo_project_template::generate_cargo_project_to_disk, LibSource, Project, ProjectConfig,
    };

    fn genrate_temp_project(temp_dir: PathBuf, project_name: &str) -> Result<Project> {
        // project dir should not exist
        let project_dir = temp_dir.join(project_name);
        assert!(!project_dir.exists());

        // create project object
        let project = Project::new(temp_dir, project_name);
        assert!(!project.exists());

        // get path to plottery libraries
        let cargo_workspace_path = Path::new(env!("CARGO_MANIFEST_DIR"))
            .parent()
            .unwrap()
            .to_path_buf();
        assert!(cargo_workspace_path.exists());
        println!("workspace path: {:?}", cargo_workspace_path);

        // generate to disk and check
        project.generate_to_disk(
            LibSource::Path {
                path: cargo_workspace_path,
            },
            true,
        )?;
        assert!(project.exists());

        // check if project dir was generated
        assert!(project_dir.exists());
        Ok(project)
    }

    #[test]
    fn save_project_config() -> Result<()> {
        let project_file = ProjectConfig::new("project_name");
        let project_file_path = Path::new("test_project.plottery");

        project_file.save_to_file(project_file_path)?;

        let result = std::panic::catch_unwind(|| {
            let loaded_project_file = ProjectConfig::new_from_file(project_file_path).unwrap();
            assert_eq!(project_file, loaded_project_file);
        });

        std::fs::remove_file(project_file_path)?;
        assert!(result.is_ok());

        Ok(())
    }

    #[test]
    fn generate_project() -> Result<()> {
        let project_name: &str = "test_proj";
        let temp_dir = tempfile::tempdir()?;
        let project = genrate_temp_project(temp_dir.path().to_path_buf(), project_name)?;

        // check if dir test_project/resources exists
        let resource_dir = project.dir.join("resources");
        println!("{:?}", resource_dir);
        assert!(resource_dir.exists());

        // check if file test_project/test_project.plottery exists
        let project_config_path = project.dir.join(format!("{}.plottery", project_name));
        assert!(project_config_path.exists());

        // test loading the project
        let loaded_project = Project::load_from_file(project_config_path.to_path_buf())?;
        assert_eq!(project, loaded_project);

        Ok(())
    }

    #[test]
    fn build_and_run() -> Result<()> {
        let project_name: &str = "test_proj";
        let temp_dir = tempfile::tempdir()?;
        let project = genrate_temp_project(temp_dir.path().to_path_buf(), project_name)?;
        assert!(project.exists());

        let release = true;

        // build
        project.build(release)?;

        // run to get params
        let params = project.run_get_params(release)?;
        assert!(params.list.len() == 2);

        // run
        let generated_layer = project.run(release, &params)?;
        assert!(!generated_layer.is_empty());

        // build debug
        project.build(release)?;

        // test saving svg
        let temp_svg_path = temp_dir.path().join("temp.svg");
        project.write_svg(temp_svg_path.clone(), release, &params)?;
        assert!(temp_svg_path.exists());

        // test saving png
        let temp_png_path = temp_dir.path().join("temp.png");
        project.write_png(temp_png_path.clone(), release, &params)?;
        assert!(temp_png_path.exists());

        Ok(())
    }

    #[test]
    fn test_embed_project_template_generation() -> Result<()> {
        let temp_dir = tempfile::tempdir().unwrap();
        generate_cargo_project_to_disk(
            temp_dir.path().to_path_buf(),
            "a_test_project",
            LibSource::Cargo,
        )?;

        assert!(temp_dir.path().join("Cargo.toml").exists());
        assert!(temp_dir.path().join("src").exists());
        Ok(())
    }
}