jrsonnet_cli/
stdlib.rs

1use std::{fs::read_to_string, str::FromStr};
2
3use clap::Parser;
4use jrsonnet_evaluator::{trace::PathResolver, Result};
5use jrsonnet_stdlib::ContextInitializer;
6
7#[derive(Clone)]
8pub struct ExtStr {
9	pub name: String,
10	pub value: String,
11}
12
13/// Parses a string like `name=<value>`, or `name` and reads value from env variable.
14/// With no value it will be read from env variable.
15/// If env variable is not found then it will be an error.
16/// Value can contain `=` symbol.
17///
18/// ```
19/// use std::str::FromStr;
20/// use jrsonnet_cli::ExtStr;
21///
22/// let ext = ExtStr::from_str("name=value").unwrap();
23/// assert_eq!(ext.name, "name");
24/// assert_eq!(ext.value, "value");
25///
26/// std::env::set_var("name", "value");
27///
28/// let ext = ExtStr::from_str("name").unwrap();
29/// assert_eq!(ext.name, "name");
30/// assert_eq!(ext.value, "value");
31///
32/// let ext = ExtStr::from_str("name=value=with=equals").unwrap();
33/// assert_eq!(ext.name, "name");
34/// assert_eq!(ext.value, "value=with=equals");
35/// ```
36///
37impl FromStr for ExtStr {
38	type Err = &'static str;
39
40	fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
41		match s.find('=') {
42			Some(idx) => Ok(Self {
43				name: s[..idx].to_owned(),
44				value: s[idx + 1..].to_owned(),
45			}),
46			None => Ok(Self {
47				name: s.to_owned(),
48				value: std::env::var(s).or(Err("missing env var"))?,
49			}),
50		}
51	}
52}
53
54#[derive(Clone)]
55pub struct ExtFile {
56	pub name: String,
57	pub value: String,
58}
59
60impl FromStr for ExtFile {
61	type Err = String;
62
63	fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
64		let out: Vec<&str> = s.split('=').collect();
65		if out.len() != 2 {
66			return Err("bad ext-file syntax".to_owned());
67		}
68		let file = read_to_string(out[1]);
69		match file {
70			Ok(content) => Ok(Self {
71				name: out[0].into(),
72				value: content,
73			}),
74			Err(e) => Err(format!("{e}")),
75		}
76	}
77}
78
79#[derive(Parser)]
80#[clap(next_help_heading = "STANDARD LIBRARY")]
81pub struct StdOpts {
82	/// Disable standard library.
83	/// By default standard library will be available via global `std` variable.
84	#[clap(long)]
85	no_stdlib: bool,
86	/// Add string external variable.
87	/// External variables are globally available so it is preferred
88	/// to use top level arguments whenever it's possible.
89	/// If [=data] is not set then it will be read from `name` env variable.
90	/// Can be accessed from code via `std.extVar("name")`.
91	#[clap(long, short = 'V', name = "name[=var data]", number_of_values = 1)]
92	ext_str: Vec<ExtStr>,
93	/// Read string external variable from file.
94	/// See also `--ext-str`
95	#[clap(long, name = "name=var path", number_of_values = 1)]
96	ext_str_file: Vec<ExtFile>,
97	/// Add external variable from code.
98	/// See also `--ext-str`
99	#[clap(long, name = "name[=var source]", number_of_values = 1)]
100	ext_code: Vec<ExtStr>,
101	/// Read string external variable from file.
102	/// See also `--ext-str`
103	#[clap(long, name = "name=var code path", number_of_values = 1)]
104	ext_code_file: Vec<ExtFile>,
105}
106impl StdOpts {
107	pub fn context_initializer(&self) -> Result<Option<ContextInitializer>> {
108		if self.no_stdlib {
109			return Ok(None);
110		}
111		let ctx = ContextInitializer::new(PathResolver::new_cwd_fallback());
112		for ext in &self.ext_str {
113			ctx.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());
114		}
115		for ext in &self.ext_str_file {
116			ctx.add_ext_str((&ext.name as &str).into(), (&ext.value as &str).into());
117		}
118		for ext in &self.ext_code {
119			ctx.add_ext_code(&ext.name as &str, &ext.value as &str)?;
120		}
121		for ext in &self.ext_code_file {
122			ctx.add_ext_code(&ext.name as &str, &ext.value as &str)?;
123		}
124		Ok(Some(ctx))
125	}
126}