pray-core 1.13.0

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
121

use crate::literal::LiteralValue;
use crate::package_spec::PackageSpec;
use std::collections::BTreeMap;

#[path = "package_spec_serialize_maps.rs"]
mod maps;

pub fn render_package_spec(spec: &PackageSpec) -> String {
    let mut lines = vec!["Package::Specification.new do |spec|".to_string()];
    push_assignment(&mut lines, "name", &spec.name);
    push_assignment(&mut lines, "version", &spec.version);
    push_optional(&mut lines, "summary", spec.summary.as_deref());
    push_optional(&mut lines, "description", spec.description.as_deref());
    if !spec.authors.is_empty() {
        push_array(&mut lines, "authors", &spec.authors);
    }
    push_optional(&mut lines, "license", spec.license.as_deref());
    push_optional(&mut lines, "homepage", spec.homepage.as_deref());
    push_optional(
        &mut lines,
        "source_code_uri",
        spec.source_code_uri.as_deref(),
    );
    push_optional(&mut lines, "changelog_uri", spec.changelog_uri.as_deref());
    push_optional(
        &mut lines,
        "prayfile_version",
        spec.prayfile_version.as_deref(),
    );
    push_array(&mut lines, "files", &spec.files);
    maps::push_exports(&mut lines, &spec.exports);
    maps::push_skills(&mut lines, &spec.skills);
    maps::push_templates(&mut lines, &spec.templates);
    maps::push_strings(&mut lines, "adapters", &spec.adapters);
    if !spec.targets.is_empty() {
        push_array(&mut lines, "targets", &spec.targets);
    }
    for dependency in &spec.dependencies {
        let method = if dependency.optional {
            "add_optional_dependency"
        } else {
            "add_dependency"
        };
        lines.push(format!(
            "  spec.{method} {}, {}",
            quote(&dependency.name),
            quote(&dependency.constraint)
        ));
    }
    if !spec.metadata.is_empty() {
        lines.push(format!("  spec.metadata = {}", literal_map(&spec.metadata)));
    }
    if let Some(upstream) = &spec.upstream {
        lines.push(format!(
            "  spec.upstream {}, {}",
            quote(&upstream.name),
            quote(&upstream.constraint)
        ));
    }
    lines.push("end".to_string());
    lines.push(String::new());
    lines.join("\n")
}

fn push_assignment(lines: &mut Vec<String>, field: &str, value: &str) {
    lines.push(format!("  spec.{field} = {}", quote(value)));
}

fn push_optional(lines: &mut Vec<String>, field: &str, value: Option<&str>) {
    if let Some(value) = value {
        push_assignment(lines, field, value);
    }
}

fn push_array(lines: &mut Vec<String>, field: &str, values: &[String]) {
    lines.push(format!("  spec.{field} = [{}]", string_array(values)));
}

pub(super) fn string_array(values: &[String]) -> String {
    values
        .iter()
        .map(|value| quote(value))
        .collect::<Vec<_>>()
        .join(", ")
}

pub(super) fn quote(value: &str) -> String {
    let escaped = value
        .replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n")
        .replace('\r', "\\r")
        .replace('\t', "\\t");
    format!("\"{escaped}\"")
}

fn literal_map(entries: &BTreeMap<String, LiteralValue>) -> String {
    let values = entries
        .iter()
        .map(|(name, value)| format!("{} => {}", quote(name), literal(value)))
        .collect::<Vec<_>>()
        .join(", ");
    format!("{{ {values} }}")
}

fn literal(value: &LiteralValue) -> String {
    match value {
        LiteralValue::String(value) => quote(value),
        LiteralValue::Symbol(value) => format!(":{value}"),
        LiteralValue::Bool(value) => value.to_string(),
        LiteralValue::Null => "nil".to_string(),
        LiteralValue::Integer(value) => value.to_string(),
        LiteralValue::Array(values) => {
            format!(
                "[{}]",
                values.iter().map(literal).collect::<Vec<_>>().join(", ")
            )
        }
        LiteralValue::Map(entries) => literal_map(entries),
    }
}