build(rust): vendor rnix parser crate

third_party/crates/rnix-0.14.0/src/tests.rs

@@ -0,0 +1,127 @@
+use std::{ffi::OsStr, fmt::Write, fs, path::PathBuf};
+
+use expect_test::expect_file;
+use rowan::ast::AstNode;
+
+use crate::{
+    ast::{self, HasEntry},
+    tokenize, Root, SyntaxKind,
+};
+
+#[test]
+fn interpolation() {
+    let root = ast::Root::parse(include_str!("../test_data/parser/success/interpolation.nix"))
+        .ok()
+        .unwrap();
+    let let_in = ast::LetIn::try_from(root.expr().unwrap()).unwrap();
+    let set = ast::AttrSet::try_from(let_in.body().unwrap()).unwrap();
+    let entry = set.entries().nth(1).unwrap();
+    let attrpath_value = ast::AttrpathValue::try_from(entry).unwrap();
+    let value = ast::Str::try_from(attrpath_value.value().unwrap()).unwrap();
+
+    match &*value.normalized_parts() {
+    &[
+        ast::InterpolPart::Literal(ref s1),
+        ast::InterpolPart::Interpolation(_),
+        ast::InterpolPart::Literal(ref s2),
+        ast::InterpolPart::Interpolation(_),
+        ast::InterpolPart::Literal(ref s3)
+    ]
+    if s1 == "The set's x value is: "
+        && s2 == "\n\nThis line shall have no indention\n  This line shall be indented by 2\n\n\n"
+        && s3 == "\n" => (),
+    parts => panic!("did not match: {:#?}", parts)
+}
+}
+
+#[test]
+fn inherit() {
+    let root =
+        ast::Root::parse(include_str!("../test_data/parser/success/inherit.nix")).ok().unwrap();
+    let let_in = ast::LetIn::try_from(root.expr().unwrap()).unwrap();
+    let set = ast::AttrSet::try_from(let_in.body().unwrap()).unwrap();
+    let inherit = set.inherits().nth(1).unwrap();
+
+    let from = inherit.from().unwrap().expr().unwrap();
+    let ident: ast::Ident = ast::Ident::try_from(from).unwrap();
+    assert_eq!(ident.syntax().text(), "set");
+    let mut children = inherit.attrs();
+    assert_eq!(children.next().unwrap().syntax().text(), "z");
+    assert_eq!(children.next().unwrap().syntax().text(), "a");
+    assert!(children.next().is_none());
+}
+
+#[test]
+fn math() {
+    let root = ast::Root::parse(include_str!("../test_data/parser/success/math.nix")).ok().unwrap();
+    let op1 = ast::BinOp::try_from(root.expr().unwrap()).unwrap();
+    let op2 = ast::BinOp::try_from(op1.lhs().unwrap()).unwrap();
+    assert_eq!(op1.operator().unwrap(), ast::BinOpKind::Add);
+
+    let lhs = ast::Literal::try_from(op2.lhs().unwrap()).unwrap();
+    assert_eq!(lhs.syntax().text(), "1");
+
+    let rhs = ast::BinOp::try_from(op2.rhs().unwrap()).unwrap();
+    assert_eq!(rhs.operator().unwrap(), ast::BinOpKind::Mul);
+}
+
+#[test]
+fn t_macro() {
+    assert_eq!(T![@], SyntaxKind::TOKEN_AT);
+    assert!(matches!(SyntaxKind::TOKEN_L_PAREN, T!['(']));
+}
+
+fn dir_tests<F>(dir: &str, get_actual: F)
+where
+    F: Fn(String) -> String,
+{
+    let base_path: PathBuf = [env!("CARGO_MANIFEST_DIR"), "test_data", dir].iter().collect();
+    let success_path = base_path.join("success");
+    let error_path = base_path.join("error");
+
+    let entries = success_path.read_dir().unwrap().chain(error_path.read_dir().unwrap());
+
+    for entry in entries {
+        let path = entry.unwrap().path();
+
+        if path.extension() != Some(OsStr::new("nix")) {
+            continue;
+        }
+
+        println!("testing: {}", path.display());
+
+        let mut code = fs::read_to_string(&path).unwrap();
+        if code.ends_with('\n') {
+            code.truncate(code.len() - 1);
+        }
+
+        let actual = get_actual(code);
+        expect_file![path.with_extension("expect")].assert_eq(&actual);
+    }
+}
+
+#[test]
+fn parser_dir_tests() {
+    dir_tests("parser", |code| {
+        let parse = Root::parse(&code);
+
+        let mut actual = String::new();
+        for error in parse.errors() {
+            writeln!(actual, "error: {}", error).unwrap();
+        }
+        writeln!(actual, "{:#?}", parse.syntax()).unwrap();
+
+        actual
+    })
+}
+
+#[test]
+fn tokenizer_dir_tests() {
+    dir_tests("tokenizer", |code| {
+        let mut actual = String::new();
+        for (kind, str) in tokenize(&code) {
+            writeln!(actual, "{:?}, \"{}\"", kind, str).unwrap();
+        }
+        actual
+    })
+}