pklrust 0.9.0

Rust bindings for Apple Pkl configuration language
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

use std::collections::HashMap;

use crate::message::ProjectOrDependency;
use crate::reader::{ModuleReader, ResourceReader};

/// Options for creating a new evaluator.
#[derive(Default)]
pub struct EvaluatorOptions {
    pub allowed_modules: Option<Vec<String>>,
    pub allowed_resources: Option<Vec<String>>,
    pub module_paths: Option<Vec<String>>,
    pub env: Option<HashMap<String, String>>,
    pub properties: Option<HashMap<String, String>>,
    pub timeout_seconds: Option<i64>,
    pub root_dir: Option<String>,
    pub cache_dir: Option<String>,
    pub output_format: Option<String>,
    pub project: Option<ProjectOrDependency>,
    pub module_readers: Vec<Box<dyn ModuleReader>>,
    pub resource_readers: Vec<Box<dyn ResourceReader>>,
}

impl EvaluatorOptions {
    pub fn new() -> Self {
        Self::default()
    }

    /// Create options with sensible defaults for evaluating local .pkl files.
    pub fn preconfigured() -> Self {
        Self {
            allowed_modules: Some(vec![
                "pkl:".into(),
                "repl:".into(),
                "file:".into(),
                "package:".into(),
                "projectpackage:".into(),
                "https:".into(),
            ]),
            allowed_resources: Some(vec![
                "env:".into(),
                "prop:".into(),
                "package:".into(),
                "projectpackage:".into(),
                "https:".into(),
                "file:".into(),
            ]),
            ..Default::default()
        }
    }

    pub fn allowed_modules(mut self, modules: Vec<String>) -> Self {
        self.allowed_modules = Some(modules);
        self
    }

    pub fn allowed_resources(mut self, resources: Vec<String>) -> Self {
        self.allowed_resources = Some(resources);
        self
    }

    pub fn env(mut self, env: HashMap<String, String>) -> Self {
        self.env = Some(env);
        self
    }

    pub fn properties(mut self, props: HashMap<String, String>) -> Self {
        self.properties = Some(props);
        self
    }

    pub fn timeout_seconds(mut self, seconds: i64) -> Self {
        self.timeout_seconds = Some(seconds);
        self
    }

    pub fn root_dir(mut self, dir: impl Into<String>) -> Self {
        self.root_dir = Some(dir.into());
        self
    }

    pub fn cache_dir(mut self, dir: impl Into<String>) -> Self {
        self.cache_dir = Some(dir.into());
        self
    }

    pub fn output_format(mut self, format: impl Into<String>) -> Self {
        self.output_format = Some(format.into());
        self
    }

    pub fn add_module_reader(mut self, reader: Box<dyn ModuleReader>) -> Self {
        self.module_readers.push(reader);
        self
    }

    pub fn add_resource_reader(mut self, reader: Box<dyn ResourceReader>) -> Self {
        self.resource_readers.push(reader);
        self
    }
}