Parse testing inputs

Author: jm8

Cargo.lock

@@ -11,6 +11,7 @@ crossbeam = "0.8.4"
 dashmap = "6.1.0"
 expect-test = "1.5.1"
 futures = "0.3.31"
+indoc = "2.0.6"
 itertools = "0.14.0"
 lazy-regex = "3.4.1"
 lazy_static = "1.5.0"

Cargo.toml

@@ -211,7 +211,7 @@ mod test {
         .await;
     }
 
-    async fn check_complete_flake(source: &str, _old_lock_file: Option<&str>, expected: Expect) {
+    async fn check_complete_files(source: &str, expected: Expect) {
         let (left, right) = source.split("$0").collect_tuple().unwrap();
         let offset = left.len() as u32;
 
@@ -936,37 +936,6 @@ mod test {
         .await;
     }
 
-    #[test_log::test(tokio::test)]
-    async fn test_complete_flake_inputs() {
-        check_complete_flake(
-            r#"
-            {
-              inputs.flake-utils.url = "github:numtide/flake-utils?rev=919d646de7be200f3bf08cb76ae1f09402b6f9b4";
-              outputs = {flake-utils}: flake-utils.lib.$0
-            }
-            "#,
-            None,
-            expect![[r#"
-                [
-                    "allSystems",
-                    "check-utils",
-                    "defaultSystems",
-                    "eachDefaultSystem",
-                    "eachDefaultSystemMap",
-                    "eachSystem",
-                    "eachSystemMap",
-                    "filterPackages",
-                    "flattenTree",
-                    "meld",
-                    "mkApp",
-                    "simpleFlake",
-                    "system",
-                ]
-            "#]],
-        )
-        .await;
-    }
-
     #[test_log::test(tokio::test)]
     async fn test_complete_system() {
         check_complete(

src/completion.rs

@@ -15,6 +15,7 @@ mod modules;
 mod safe_stringification;
 mod schema;
 mod syntax;
+mod testing;
 mod walk_attrs;
 
 use anyhow::Result;

src/main.rs

@@ -0,0 +1,89 @@
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
+
+use ropey::Rope;
+
+use crate::syntax::rope_offset_to_position;
+
+#[derive(Debug)]
+pub struct Location {
+    pub path: PathBuf,
+    pub line: u32,
+    pub col: u32,
+}
+
+#[derive(Debug)]
+pub struct TestInput {
+    pub files: HashMap<PathBuf, String>,
+    pub location: Option<Location>,
+}
+
+fn parse_test_input(input: &str) -> TestInput {
+    let mut files = HashMap::new();
+    let mut lines = input.lines().peekable();
+    let mut current_path = PathBuf::from("/nowhere.nix");
+    let mut current_content = Vec::new();
+    let mut location = None;
+
+    let mut add_file = |current_path: &Path, current_content: &[String]| {
+        if !current_content.is_empty() {
+            let mut content = current_content.join("\n");
+            if let Some(offset) = content.find("$0") {
+                content = format!("{}{}", &content[0..offset], &content[offset + 2..]);
+                let rope = Rope::from_str(&content);
+                let position = rope_offset_to_position(&rope, offset);
+                location = Some(Location {
+                    path: current_path.to_path_buf(),
+                    line: position.line,
+                    col: position.character,
+                })
+            }
+            files.insert(current_path.to_path_buf(), content);
+        }
+    };
+
+    while let Some(line) = lines.next() {
+        eprintln!("LINE = {:?}", line);
+        if line.starts_with("## ") {
+            add_file(&current_path, &current_content);
+            current_content.clear();
+            current_path = PathBuf::from(line[2..].trim());
+        } else {
+            current_content.push(line.to_string());
+        }
+    }
+
+    add_file(&current_path, &current_content);
+
+    TestInput { files, location }
+}
+
+#[cfg(test)]
+mod test {
+    use expect_test::{expect, Expect};
+    use indoc::indoc;
+
+    use super::parse_test_input;
+
+    fn check_parse_test_input(input: &str, expected: Expect) {
+        expected.assert_debug_eq(&parse_test_input(input.trim()));
+    }
+
+    #[test]
+    fn test_parse_test_input() {
+        check_parse_test_input(
+            indoc! {r#"
+            ## /test.nix
+            aaaaaaaaaaaaaaa
+            bbbbbb
+            cccccccc
+            ## /your mother.nix
+            aaaaaaaaaaaaaaaaaaaazzzzzzzzzzzzz
+            xyz.$0cyz
+            "# },
+            expect![[]],
+        );
+    }
+}