git.delta.rocks / jrsonnet / refs/commits / a9b3ad095ce8

7# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html7# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
88
9[features]9[features]
10default = ["serialized-stdlib"]10default = ["serialized-stdlib", "faster"]
11serialized-stdlib = ["serde", "bincode"]11serialized-stdlib = ["serde", "bincode"]
12# Replace some standard library functions with faster implementations
13faster = []
1214
13[dependencies]15[dependencies]
14jsonnet-parser = { path = "../jsonnet-parser" }16jsonnet-parser = { path = "../jsonnet-parser" }

1use bincode::serialize;1use bincode::serialize;
2use jsonnet_parser::{parse, ParserSettings};2use jsonnet_parser::{
3	parse, Expr, FieldMember, FieldName, LocExpr, Member, ObjBody, ParserSettings,
4};
3use jsonnet_stdlib::STDLIB_STR;5use jsonnet_stdlib::STDLIB_STR;
4use std::{6use std::{
5	env,7	env,
6	fs::File,8	fs::File,
7	io::Write,9	io::Write,
8	path::{Path, PathBuf},10	path::{Path, PathBuf},
11	rc::Rc,
9};12};
1013
11fn main() {14fn main() {
18	)21	)
19	.expect("parse");22	.expect("parse");
23
24	let parsed = if cfg!(feature = "faster") {
25		let LocExpr(expr, location) = parsed;
26		LocExpr(
27			Rc::new(match Rc::try_unwrap(expr).unwrap() {
28				Expr::Obj(ObjBody::MemberList(members)) => Expr::Obj(ObjBody::MemberList(
29					members
30						.into_iter()
31						.filter(|p| {
32							!matches!(
33								p,
34								Member::Field(FieldMember {
35									name: FieldName::Fixed(name),
36									..
37								}) if name == "join"
38							)
39						})
40						.collect(),
41				)),
42				_ => panic!("std value should be object"),
43			}),
44			location,
45		)
46	} else {
47		parsed
48	};
2049
21	let out_dir = env::var("OUT_DIR").unwrap();50	let out_dir = env::var("OUT_DIR").unwrap();
22	let dest_path = Path::new(&out_dir).join("stdlib.bincode");51	let dest_path = Path::new(&out_dir).join("stdlib.bincode");

661							panic!("bad extVar call");661							panic!("bad extVar call");
662						}662						}
663					}663					}
664					("std", "filter") => {
665						assert_eq!(args.len(), 2);
666						if let (Val::Func(predicate), Val::Arr(arr)) = (
667							evaluate(context, &args[0].1)?,
668							evaluate(context, &args[1].1)?,
669						) {
670							Val::Arr(
671								arr.into_iter()
672									.filter(|e| {
673										predicate
674											.evaluate_values(&context, &[e.clone()])
675											.unwrap()
676											.try_cast_bool("filter predicate")
677											.unwrap()
678									})
679									.collect(),
680							)
681						} else {
682							panic!("bad filter call");
683						}
684					}
685					// faster
686					("std", "join") => {
687						assert_eq!(args.len(), 2);
688						let joiner = evaluate(context, &args[0].1)?.unwrap_if_lazy()?;
689						let items = evaluate(context, &args[1].1)?.unwrap_if_lazy()?;
690						println!("Before");
691						let result = match (joiner, items) {
692							(Val::Arr(joiner_items), Val::Arr(items)) => {
693								// TODO: Minimal size should be known
694								let mut out = Vec::new();
695
696								let mut first = true;
697								for item in items {
698									if let Val::Arr(items) = item.unwrap_if_lazy()? {
699										if !first {
700											out.extend(joiner_items.iter().cloned());
701										}
702										first = false;
703										out.extend(items);
704									} else {
705										panic!("all array items should be arrays")
706									}
707								}
708
709								Val::Arr(out)
710							}
711							(Val::Str(joiner), Val::Arr(items)) => {
712								let mut out = String::new();
713
714								let mut first = true;
715								for item in items {
716									if let Val::Str(item) = item.unwrap_if_lazy()? {
717										if !first {
718											out += &joiner;
719										}
720										first = false;
721										out += &item;
722									} else {
723										panic!("all array items should be strings")
724									}
725								}
726
727								Val::Str(out)
728							}
729							(joiner, items) => panic!("bad join call: {:?} {:?}", joiner, items),
730						};
731						println!("After");
732						result
733					}
664					(ns, name) => panic!("Intristic not found: {}.{}", ns, name),734					(ns, name) => panic!("Intristic not found: {}.{}", ns, name),
665				},735				},
666				Val::Func(f) => {736				Val::Func(f) => {