pray-core 1.9.2

Core library for Prayfile, the package manager for the language placed before inference
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

use crate::manifest::{Manifest, RenderPolicy};
use crate::paths::validate_project_relative_path;
use crate::{PrayError, PrayResult};
use std::collections::BTreeSet;

pub(crate) fn validate_manifest_semantics(manifest: &Manifest) -> PrayResult<()> {
    reject_duplicate_source_names(manifest)?;
    validate_render_policy(&manifest.render)?;
    for target in &manifest.targets {
        for output in &target.outputs {
            validate_project_relative_path(output)?;
        }
        for folder in target
            .skills
            .iter()
            .chain(target.commands.iter())
            .chain(target.rules.iter())
        {
            validate_project_relative_path(folder)?;
        }
    }
    for package in &manifest.packages {
        if let Some(path) = &package.path {
            validate_project_relative_path(path)?;
        }
        if let Some(file) = &package.file {
            validate_project_relative_path(file)?;
        }
    }
    for local in &manifest.local {
        validate_project_relative_path(&local.path)?;
    }
    Ok(())
}

fn reject_duplicate_source_names(manifest: &Manifest) -> PrayResult<()> {
    let mut seen = BTreeSet::new();
    for source in &manifest.sources {
        if !seen.insert(source.name.clone()) {
            return Err(PrayError::Manifest(format!(
                "duplicate source name: {}",
                source.name
            )));
        }
    }
    Ok(())
}

fn validate_render_policy(policy: &RenderPolicy) -> PrayResult<()> {
    let defaults = RenderPolicy::default();
    if policy.mode != defaults.mode {
        return Err(PrayError::Unsupported(format!(
            "render mode :{} is not implemented",
            policy.mode
        )));
    }
    if policy.conflict != "fail" {
        return Err(PrayError::Unsupported(format!(
            "render conflict :{} is not implemented; only :fail is supported",
            policy.conflict
        )));
    }
    if policy.churn != defaults.churn {
        return Err(PrayError::Unsupported(format!(
            "render churn :{} is not implemented",
            policy.churn
        )));
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use crate::manifest::parse_manifest;

    #[test]
    fn rejects_escaping_compose_output() {
        let error = parse_manifest(
            r#"
prayfile "1"
target :tool_a do
  output "../escape.md"
end
"#,
        )
        .expect_err("escape");
        assert!(error.to_string().contains("escapes repository root"));
    }

    #[test]
    fn rejects_duplicate_source_names() {
        let error = parse_manifest(
            r#"
prayfile "1"
source "default", "https://example.test/a"
source "default", "https://example.test/b"
target :tool_a do
  output "INSTRUCTIONS.md"
end
"#,
        )
        .expect_err("duplicate");
        assert!(error.to_string().contains("duplicate source name"));
    }

    #[test]
    fn rejects_unimplemented_conflict_policy() {
        let error = parse_manifest(
            r#"
prayfile "1"
        render conflict: :warn
target :tool_a do
  output "INSTRUCTIONS.md"
end
"#,
        )
        .expect_err("conflict");
        assert!(error.to_string().contains("not implemented"));
    }
}