git.delta.rocks / jrsonnet / refs/commits / 58696dc4e430

72					if matches!(loc, CommentLocation::ItemInline) {72					if matches!(loc, CommentLocation::ItemInline) {
73						p!(pi: str(" "));73						p!(pi: str(" "));
74					}74					}
75					p!(pi: str("/* ") string(lines[0].trim().to_string()) str(" */"))75					p!(pi: str("/* ") string(lines[0].trim().to_string()) str(" */") nl)
76				} else if !lines.is_empty() {76				} else if !lines.is_empty() {
77					fn common_ws_prefix<'a>(a: &'a str, b: &str) -> &'a str {77					fn common_ws_prefix<'a>(a: &'a str, b: &str) -> &'a str {
78						let offset = a78						let offset = a

372					return p!(new: str("{ }"));372					return p!(new: str("{ }"));
373				}373				}
374				let mut pi = p!(new: str("{") >i nl);374				let mut pi = p!(new: str("{") >i nl);
375				for mem in children.into_iter() {375				for (i, mem) in children.into_iter().enumerate() {
376					if mem.should_start_with_newline {376					if mem.should_start_with_newline && i != 0 {
377						p!(pi: nl);377						p!(pi: nl);
378					}378					}
379					p!(pi: items(format_comments(&mem.before_trivia, CommentLocation::AboveItem)));379					p!(pi: items(format_comments(&mem.before_trivia, CommentLocation::AboveItem)));

6};6};
7use jrsonnet_stdlib::{TomlFormat, YamlFormat};7use jrsonnet_stdlib::{TomlFormat, YamlFormat};
88
9#[derive(Clone, ValueEnum)]9#[derive(Clone, Copy, ValueEnum)]
10pub enum ManifestFormatName {10pub enum ManifestFormatName {
11	/// Expect string as output, and write them directly11	/// Expect string as output, and write them directly
12	String,12	String,
18#[derive(Parser)]18#[derive(Parser)]
19#[clap(next_help_heading = "MANIFESTIFICATION OUTPUT")]19#[clap(next_help_heading = "MANIFESTIFICATION OUTPUT")]
20pub struct ManifestOpts {20pub struct ManifestOpts {
21	/// Output format, wraps resulting value to corresponding std.manifest call.21	/// Output format, wraps resulting value to corresponding std.manifest call
22	///
23	/// [default: json, yaml when -y is used]
22	#[clap(long, short = 'f', default_value = "json")]24	#[clap(long, short = 'f')]
23	format: ManifestFormatName,25	format: Option<ManifestFormatName>,
24	/// Expect plain string as output.26	/// Expect plain string as output.
25	/// Mutually exclusive with `--format`27	/// Mutually exclusive with `--format`
26	#[clap(long, short = 'S', conflicts_with = "format")]28	#[clap(long, short = 'S', conflicts_with = "format")]
29	#[clap(long, short = 'y', conflicts_with = "string")]31	#[clap(long, short = 'y', conflicts_with = "string")]
30	yaml_stream: bool,32	yaml_stream: bool,
31	/// Number of spaces to pad output manifest with.33	/// Number of spaces to pad output manifest with.
32	/// `0` for hard tabs, `-1` for single line output [default: 3 for json, 2 for yaml/toml]34	/// `0` for hard tabs, `-1` for single line output
35	///
36	/// [default: 3 for json, 2 for yaml/toml]
33	#[clap(long)]37	#[clap(long)]
34	line_padding: Option<usize>,38	line_padding: Option<usize>,
35	/// Preserve order in object manifestification39	/// Preserve order in object manifestification
44		} else {48		} else {
45			#[cfg(feature = "exp-preserve-order")]49			#[cfg(feature = "exp-preserve-order")]
46			let preserve_order = self.preserve_order;50			let preserve_order = self.preserve_order;
51			let format = match self.format {
52				Some(v) => v,
53				None if self.yaml_stream => ManifestFormatName::Yaml,
54				None => ManifestFormatName::Json,
55			};
47			match self.format {56			match format {
48				ManifestFormatName::String => Box::new(ToStringFormat),57				ManifestFormatName::String => Box::new(ToStringFormat),
49				ManifestFormatName::Json => Box::new(JsonFormat::cli(58				ManifestFormatName::Json => Box::new(JsonFormat::cli(
50					self.line_padding.unwrap_or(3),59					self.line_padding.unwrap_or(3),

372	pub fn new_inclusive(start: i32, end: i32) -> Self {372	pub fn new_inclusive(start: i32, end: i32) -> Self {
373		Self { start, end }373		Self { start, end }
374	}374	}
375	fn range(&self) -> impl Iterator<Item = i32> + ExactSizeIterator + DoubleEndedIterator {375	fn range(&self) -> impl ExactSizeIterator<Item = i32> + DoubleEndedIterator {
376		WithExactSize(376		WithExactSize(
377			self.start..=self.end,377			self.start..=self.end,
378			(self.end as usize)378			(self.end as usize)
461			ArrayThunk::Waiting(..) => {}461			ArrayThunk::Waiting(..) => {}
462		};462		};
463463
464		let ArrayThunk::Waiting(_) =464		let ArrayThunk::Waiting(()) =
465			replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)465			replace(&mut self.cached.borrow_mut()[index], ArrayThunk::Pending)
466		else {466		else {
467			unreachable!()467			unreachable!()
508		match &self.cached.borrow()[index] {508		match &self.cached.borrow()[index] {
509			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),509			ArrayThunk::Computed(c) => return Some(Thunk::evaluated(c.clone())),
510			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),510			ArrayThunk::Errored(e) => return Some(Thunk::errored(e.clone())),
511			ArrayThunk::Waiting(_) | ArrayThunk::Pending => {}511			ArrayThunk::Waiting(()) | ArrayThunk::Pending => {}
512		};512		};
513513
514		Some(Thunk::new(ArrayElement {514		Some(Thunk::new(ArrayElement {
597	}597	}
598598
599	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {599	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
600		let Some(key) = self.keys.get(index) else {600		let key = self.keys.get(index)?;
601			return None;
602		};
603		Some(self.obj.get_lazy_or_bail(key.clone()))601		Some(self.obj.get_lazy_or_bail(key.clone()))
604	}602	}
605603
649	}647	}
650648
651	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {649	fn get_lazy(&self, index: usize) -> Option<Thunk<Val>> {
652		let Some(key) = self.keys.get(index) else {650		let key = self.keys.get(index)?;
653			return None;
654		};
655		// Nothing can fail in the key part, yet value is still651		// Nothing can fail in the key part, yet value is still
656		// lazy-evaluated652		// lazy-evaluated
657		Some(Thunk::evaluated(653		Some(Thunk::evaluated(

89	specs: &[CompSpec],89	specs: &[CompSpec],
90	callback: &mut impl FnMut(Context) -> Result<()>,90	callback: &mut impl FnMut(Context) -> Result<()>,
91) -> Result<()> {91) -> Result<()> {
92	match specs.get(0) {92	match specs.first() {
93		None => callback(ctx)?,93		None => callback(ctx)?,
94		Some(CompSpec::IfSpec(IfSpecData(cond))) => {94		Some(CompSpec::IfSpec(IfSpecData(cond))) => {
95			if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {95			if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {

6use super::{arglike::ArgsLike, parse::parse_builtin_call, CallLocation};6use super::{arglike::ArgsLike, parse::parse_builtin_call, CallLocation};
7use crate::{gc::TraceBox, tb, Context, Result, Val};7use crate::{gc::TraceBox, tb, Context, Result, Val};
88
9/// Can't have str | IStr, because constant BuiltinParam causes9/// Can't have `str` | `IStr`, because constant `BuiltinParam` causes
10/// E0492: constant functions cannot refer to interior mutable data10/// `E0492: constant functions cannot refer to interior mutable data`
11#[derive(Clone, Trace)]11#[derive(Clone, Trace)]
12pub struct ParamName(Option<Cow<'static, str>>);12pub struct ParamName(Option<Cow<'static, str>>);
13impl ParamName {13impl ParamName {
27}27}
28impl PartialEq<IStr> for ParamName {28impl PartialEq<IStr> for ParamName {
29	fn eq(&self, other: &IStr) -> bool {29	fn eq(&self, other: &IStr) -> bool {
30		match &self.0 {30		self.0
31			.as_ref()
31			Some(s) => s.as_bytes() == other.as_bytes(),32			.map_or(false, |s| s.as_bytes() == other.as_bytes())
32			None => false,
33		}
34	}33	}
35}34}
3635
87			params: params86			params: params
88				.into_iter()87				.into_iter()
89				.map(|n| BuiltinParam {88				.map(|n| BuiltinParam {
90					name: ParamName::new_dynamic(n.to_string()),89					name: ParamName::new_dynamic(n),
91					has_default: false,90					has_default: false,
92				})91				})
93				.collect(),92				.collect(),

159			Val::Null => serializer.serialize_none(),159			Val::Null => serializer.serialize_none(),
160			Val::Str(s) => serializer.serialize_str(&s.clone().into_flat()),160			Val::Str(s) => serializer.serialize_str(&s.clone().into_flat()),
161			Val::Num(n) => {161			Val::Num(n) => {
162				if n.fract() != 0.0 {162				if n.fract() == 0.0 {
163					serializer.serialize_f64(*n)
164				} else {
165					let n = *n as i64;163					let n = *n as i64;
166					serializer.serialize_i64(n)164					serializer.serialize_i64(n)
167				}165				} else {
166					serializer.serialize_f64(*n)
167				}
168			}168			}
169			#[cfg(feature = "exp-bigint")]169			#[cfg(feature = "exp-bigint")]
170			Val::BigInt(b) => b.serialize(serializer),170			Val::BigInt(b) => b.serialize(serializer),

45    // such cases, but it doesn't work:45	// such cases, but it doesn't work:
46    // https://github.com/rust-lang/rust-clippy/issues/980146	// https://github.com/rust-lang/rust-clippy/issues/9801
47    clippy::mutable_key_type,47	clippy::mutable_key_type,
48	// false positives
49	clippy::redundant_pub_crate,
48)]50)]
4951
50// For jrsonnet-macros52// For jrsonnet-macros

176	Ok(out)176	Ok(out)
177}177}
178
179#[allow(clippy::too_many_lines)]
178fn manifest_json_ex_buf(180fn manifest_json_ex_buf(
179	val: &Val,181	val: &Val,
180	buf: &mut String,182	buf: &mut String,

171			// .field("assertions_ran", &self.assertions_ran)171			// .field("assertions_ran", &self.assertions_ran)
172			.field("this_entries", &self.this_entries)172			.field("this_entries", &self.this_entries)
173			// .field("value_cache", &self.value_cache)173			// .field("value_cache", &self.value_cache)
174			.finish()174			.finish_non_exhaustive()
175	}175	}
176}176}
177177
347		out.with_super(self);347		out.with_super(self);
348		let mut member = out.field(key);348		let mut member = out.field(key);
349		if value.flags.add() {349		if value.flags.add() {
350			member = member.add()350			member = member.add();
351		}351		}
352		if let Some(loc) = value.location {352		if let Some(loc) = value.location {
353			member = member.with_location(loc);353			member = member.with_location(loc);
395395
396	pub fn get(&self, key: IStr) -> Result<Option<Val>> {396	pub fn get(&self, key: IStr) -> Result<Option<Val>> {
397		self.run_assertions()?;397		self.run_assertions()?;
398		self.get_for(key, self.0.this().unwrap_or(self.clone()))398		self.get_for(key, self.0.this().unwrap_or_else(|| self.clone()))
399	}399	}
400400
401	pub fn get_for(&self, key: IStr, this: ObjValue) -> Result<Option<Val>> {401	pub fn get_for(&self, key: IStr, this: ObjValue) -> Result<Option<Val>> {
474			type Output = Val;474			type Output = Val;
475475
476			fn get(self: Box<Self>) -> Result<Self::Output> {476			fn get(self: Box<Self>) -> Result<Self::Output> {
477				Ok(self.obj.get_or_bail(self.key)?)477				self.obj.get_or_bail(self.key)
478			}478			}
479		}479		}
480480
495			SuperDepth::default(),495			SuperDepth::default(),
496			&mut |depth, index, name, visibility| {496			&mut |depth, index, name, visibility| {
497				let new_sort_key = FieldSortKey::new(depth, index);497				let new_sort_key = FieldSortKey::new(depth, index);
498				let entry = out.entry(name.clone());498				let entry = out.entry(name);
499				let (visible, _) = entry.or_insert((true, new_sort_key));499				let (visible, _) = entry.or_insert((true, new_sort_key));
500				match visibility {500				match visibility {
501					Visibility::Normal => {}501					Visibility::Normal => {}
634			SuperDepth::default(),634			SuperDepth::default(),
635			&mut |depth, index, name, visibility| {635			&mut |depth, index, name, visibility| {
636				let new_sort_key = FieldSortKey::new(depth, index);636				let new_sort_key = FieldSortKey::new(depth, index);
637				let entry = out.entry(name.clone());637				let entry = out.entry(name);
638				let (visible, _) = entry.or_insert((true, new_sort_key));638				let (visible, _) = entry.or_insert((true, new_sort_key));
639				match visibility {639				match visibility {
640					Visibility::Normal => {}640					Visibility::Normal => {}

248	let (cflags, str) = try_parse_cflags(str)?;248	let (cflags, str) = try_parse_cflags(str)?;
249	let (width, str) = try_parse_field_width(str)?;249	let (width, str) = try_parse_field_width(str)?;
250	let (precision, str) = try_parse_precision(str)?;250	let (precision, str) = try_parse_precision(str)?;
251	let (_, str) = try_parse_length_modifier(str)?;251	let ((), str) = try_parse_length_modifier(str)?;
252	let (convtype, str) = parse_conversion_type(str)?;252	let (convtype, str) = parse_conversion_type(str)?;
253253
254	Ok((254	Ok((

449	}449	}
450450
451	fn from_untyped(value: Val) -> Result<Self> {451	fn from_untyped(value: Val) -> Result<Self> {
452		match &value {452		let Val::Arr(a) = &value else {
453			Val::Arr(a) => {453			<Self as Typed>::TYPE.check(&value)?;
454			unreachable!()
455		};
454				if let Some(bytes) = a.as_any().downcast_ref::<BytesArray>() {456		if let Some(bytes) = a.as_any().downcast_ref::<BytesArray>() {
455					return Ok(bytes.0.as_slice().into());457			return Ok(bytes.0.as_slice().into());
456				};458		};
462					out.push(u8::from_untyped(r)?);464			out.push(u8::from_untyped(r)?);
463				}465		}
464				Ok(out.as_slice().into())466		Ok(out.as_slice().into())
465			}
466			_ => {
467				<Self as Typed>::TYPE.check(&value)?;
468				unreachable!()
469			}
470		}
471	}467	}
472}468}
473469

90	item: impl Fn() -> Result<()>,90	item: impl Fn() -> Result<()>,
91) -> Result<()> {91) -> Result<()> {
92	State::push_description(error_reason, || match item() {92	State::push_description(error_reason, || match item() {
93		Ok(_) => Ok(()),93		Ok(()) => Ok(()),
94		Err(mut e) => {94		Err(mut e) => {
95			if let ErrorKind::TypeError(e) = &mut e.error_mut() {95			if let ErrorKind::TypeError(e) = &mut e.error_mut() {
96				(e.1).0.push(path());96				(e.1).0.push(path());

351	}351	}
352}352}
353impl PartialEq for StrValue {353impl PartialEq for StrValue {
354	// False positive, into_flat returns not StrValue, but IStr, thus no infinite recursion here.
355	#[allow(clippy::unconditional_recursion)]
354	fn eq(&self, other: &Self) -> bool {356	fn eq(&self, other: &Self) -> bool {
355		let a = self.clone().into_flat();357		let a = self.clone().into_flat();
356		let b = other.clone().into_flat();358		let b = other.clone().into_flat();

6#![warn(clippy::pedantic, clippy::nursery)]6#![warn(clippy::pedantic, clippy::nursery)]
7#![allow(clippy::missing_const_for_fn)]7#![allow(clippy::missing_const_for_fn)]
8use std::{8use std::{
9	borrow::{Borrow, Cow},9	borrow::Cow,
10	cell::RefCell,10	cell::RefCell,
11	fmt::{self, Display},11	fmt::{self, Display},
12	hash::{BuildHasherDefault, Hash, Hasher},12	hash::{BuildHasherDefault, Hash, Hasher},
13	ops::Deref,13	ops::Deref,
14	str,14	str,
15};15};
1616
17use hashbrown::HashMap;17use hashbrown::{hash_map::RawEntryMut, HashMap};
18use jrsonnet_gcmodule::Trace;18use jrsonnet_gcmodule::Trace;
19use rustc_hash::FxHasher;19use rustc_hash::FxHasher;
2020
57	}57	}
58}58}
59
60impl Borrow<str> for IStr {
61	fn borrow(&self) -> &str {
62		self.as_str()
63	}
64}
65impl Borrow<[u8]> for IStr {
66	fn borrow(&self) -> &[u8] {
67		self.as_bytes()
68	}
69}
7059
71impl PartialEq for IStr {60impl PartialEq for IStr {
72	fn eq(&self, other: &Self) -> bool {61	fn eq(&self, other: &Self) -> bool {
146	}135	}
147}136}
148
149impl Borrow<[u8]> for IBytes {
150	fn borrow(&self) -> &[u8] {
151		self.0.as_slice()
152	}
153}
154137
155impl PartialEq for IBytes {138impl PartialEq for IBytes {
156	fn eq(&self, other: &Self) -> bool {139	fn eq(&self, other: &Self) -> bool {
285		let mut pool = pool.borrow_mut();268		let mut pool = pool.borrow_mut();
286		let entry = pool.raw_entry_mut().from_key(bytes);269		let entry = pool.raw_entry_mut().from_key(bytes);
287		match entry {270		match entry {
288			hashbrown::hash_map::RawEntryMut::Occupied(i) => IBytes(i.get_key_value().0.clone()),271			RawEntryMut::Occupied(i) => IBytes(i.get_key_value().0.clone()),
289			hashbrown::hash_map::RawEntryMut::Vacant(e) => {272			RawEntryMut::Vacant(e) => {
290				let (k, _) = e.insert(Inner::new_bytes(bytes), ());273				let (k, ()) = e.insert(Inner::new_bytes(bytes), ());
291				IBytes(k.clone())274				IBytes(k.clone())
292			}275			}
293		}276		}

374				fn params(&self) -> &[BuiltinParam] {374				fn params(&self) -> &[BuiltinParam] {
375					PARAMS375					PARAMS
376				}376				}
377				#[allow(unused_variable)]
377				fn call(&self, ctx: Context, location: CallLocation, args: &dyn ArgsLike) -> Result<Val> {378				fn call(&self, ctx: Context, location: CallLocation, args: &dyn ArgsLike) -> Result<Val> {
378					let parsed = parse_builtin_call(ctx.clone(), &PARAMS, args, false)?;379					let parsed = parse_builtin_call(ctx.clone(), &PARAMS, args, false)?;
379380

39	let bytes = STANDARD39	let bytes = STANDARD
40		.decode(str.as_bytes())40		.decode(str.as_bytes())
41		.map_err(|e| runtime_error!("invalid base64: {e}"))?;41		.map_err(|e| runtime_error!("invalid base64: {e}"))?;
42	Ok(String::from_utf8(bytes).map_err(|_| runtime_error!("bad utf8"))?)42	String::from_utf8(bytes).map_err(|_| runtime_error!("bad utf8"))
43}43}
4444

134					buf.push_str(&options.padding);134					buf.push_str(&options.padding);
135					buf.push_str(line);135					buf.push_str(line);
136				}136				}
137			} else if !options.quote_keys && !yaml_needs_quotes(&s) {137			} else if s.contains('\n') {
138				buf.push_str("|-");
139				for line in s.split('\n') {
140					buf.push('\n');
141					buf.push_str(cur_padding);
142					buf.push_str(&options.padding);
143					buf.push_str(line);
144				}
145			} else if !options.quote_keys && !yaml_needs_quotes(&s) {
138				buf.push_str(&s);146				buf.push_str(&s);
139			} else {147			} else {
140				escape_string_json_buf(&s, buf);148				escape_string_json_buf(&s, buf);

47		.ext_natives47		.ext_natives
48		.get(&x)48		.get(&x)
49		.cloned()49		.cloned()
50		.map_or(Val::Null, |v| Val::Func(v))50		.map_or(Val::Null, Val::Func)
51}51}
5252
53#[builtin(fields(53#[builtin(fields(

5        "systems": "systems"5        "systems": "systems"
6      },6      },
7      "locked": {7      "locked": {
8        "lastModified": 1694529238,8        "lastModified": 1705309234,
9        "narHash": "sha256-zsNZZGTGnMOf9YpHKJqMSsa0dXbfmxeoJ7xHlrt+xmY=",9        "narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
10        "owner": "numtide",10        "owner": "numtide",
11        "repo": "flake-utils",11        "repo": "flake-utils",
12        "rev": "ff7b65b44d01cf9ba6a71320833626af21126384",12        "rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
13        "type": "github"13        "type": "github"
14      },14      },
15      "original": {15      "original": {
20    },20    },
21    "nixpkgs": {21    "nixpkgs": {
22      "locked": {22      "locked": {
23        "lastModified": 1701376520,23        "lastModified": 1705391267,
24        "narHash": "sha256-U3iGiOZqgu7wvVzgfoQzGGFMqNsDj/q/6zPIjCy7ajg=",24        "narHash": "sha256-gGVm9QudiRtYTX8PN9cTTy7uuJcL4I2lRMoPx496kXk=",
25        "owner": "nixos",25        "owner": "nixos",
26        "repo": "nixpkgs",26        "repo": "nixpkgs",
27        "rev": "c74cc3c3db2ed5e68895953d75c397797d499133",27        "rev": "41a9a7f170c740acb24f3390323877d11c69d5ee",
28        "type": "github"28        "type": "github"
29      },29      },
30      "original": {30      "original": {
50        ]50        ]
51      },51      },
52      "locked": {52      "locked": {
53        "lastModified": 1701310566,53        "lastModified": 1705371439,
54        "narHash": "sha256-CL9J3xUR2Ejni4LysrEGX0IdO+Y4BXCiH/By0lmF3eQ=",54        "narHash": "sha256-P1kulUXpYWkcrjiX3sV4j8ACJZh9XXSaaD+jDLBDLKo=",
55        "owner": "oxalica",55        "owner": "oxalica",
56        "repo": "rust-overlay",56        "repo": "rust-overlay",
57        "rev": "6d3c6e185198b8bf7ad639f22404a75aa9a09bff",57        "rev": "b21f3c0d5bf0f0179f5f0140e8e0cd099618bd04",
58        "type": "github"58        "type": "github"
59      },59      },
60      "original": {60      "original": {

25        lib = pkgs.lib;25        lib = pkgs.lib;
26        rust =26        rust =
27          (pkgs.rustChannelOf {27          (pkgs.rustChannelOf {
28            date = "2023-10-28";28            date = "2024-01-10";
29            channel = "nightly";29            channel = "nightly";
30          })30          })
31          .default31          .default
32          .override {32          .override {
33            extensions = ["rust-src" "miri" "rust-analyzer" "clippy"];33            extensions = ["rust-src" "miri" "rust-analyzer" "clippy"];
34          };34          };
35      in rec {35      in {
36        packages = rec {36        packages = rec {
37          go-jsonnet = pkgs.callPackage ./nix/go-jsonnet.nix {};37          go-jsonnet = pkgs.callPackage ./nix/go-jsonnet.nix {};
38          sjsonnet = pkgs.callPackage ./nix/sjsonnet.nix {};38          sjsonnet = pkgs.callPackage ./nix/sjsonnet.nix {};

103    asin: ['x'],103    asin: ['x'],
104    acos: ['x'],104    acos: ['x'],
105    atan: ['x'],105    atan: ['x'],
106    atan2: ['y', 'x'],
106    type: ['x'],107    type: ['x'],
107    filter: ['func', 'arr'],108    filter: ['func', 'arr'],
108    objectHasEx: ['obj', 'fname', 'hidden'],109    objectHasEx: ['obj', 'fname', 'hidden'],