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

@@ -165,11 +165,8 @@ mod test {
     use itertools::Itertools;
 
     use crate::{
-        evaluator::{Evaluator, LockFlakeRequest},
+        evaluator::Evaluator,
         file_types::{FileInfo, FileType},
-        flakes::get_flake_inputs,
-        safe_stringification::safe_stringify_flake,
-        syntax::parse,
     };
 
     use super::complete;
@@ -211,47 +208,9 @@ mod test {
         .await;
     }
 
-    async fn check_complete_flake(source: &str, _old_lock_file: Option<&str>, expected: Expect) {
-        let (left, right) = source.split("$0").collect_tuple().unwrap();
-        let offset = left.len() as u32;
-
-        let mut evaluator = Evaluator::new().await;
-
-        let source = format!("{}{}", left, right);
-
-        let lock_file = evaluator
-            .lock_flake(&LockFlakeRequest {
-                expression: safe_stringify_flake(
-                    parse(&source).expr().as_ref(),
-                    "/test/path".as_ref(),
-                ),
-                old_lock_file: None,
-            })
-            .await
-            .unwrap()
-            .lock_file;
-
-        let inputs = get_flake_inputs(&mut evaluator, &lock_file).await.unwrap();
-
-        let actual = complete(
-            &source,
-            &FileInfo {
-                file_type: FileType::Flake {
-                    locked: crate::file_types::LockedFlake::Locked { lock_file, inputs },
-                },
-                path: "/test/path/whatever.nix".into(),
-            },
-            offset,
-            &mut evaluator,
-        )
-        .await
-        .unwrap()
-        .iter()
-        .map(|item| item.label.clone())
-        .collect_vec();
-
-        expected.assert_debug_eq(&actual);
-    }
+    // async fn check_complete_files(input: &str, expected: Expect) {
+    //     // let input = par
+    // }
 
     #[test_log::test(tokio::test)]
     async fn test_complete_let_in() {
@@ -936,37 +895,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,117 @@
+use std::{
+    collections::BTreeMap,
+    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: BTreeMap<PathBuf, String>,
+    pub location: Option<Location>,
+}
+
+pub fn parse_test_input(input: &str) -> TestInput {
+    let mut files = BTreeMap::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 }
+}
+
+// pub async fn create_test_analyzer(input: &TestInput) {
+//     let evaluator = Evaluator::new().await;
+//     let (fetcher_input_send, fetcher_input_recv) = crossbeam::channel::unbounded::<FetcherInput>();
+//     let (fetcher_output_send, fetcher_output_recv) =
+//         crossbeam::channel::unbounded::<FetcherOutput>();
+
+//     let mut analyzer = Analyzer::new(evaluator, fetcher_input_send, fetcher_output_recv);
+
+//     for (path, content) in input.files.iter() {
+//         analyzer.change_file(&path, &content);
+//     }
+
+// }
+
+#[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![[r#"
+                TestInput {
+                    files: {
+                        "/test.nix": "aaaaaaaaaaaaaaa\nbbbbbb\ncccccccc",
+                        "/your mother.nix": "aaaaaaaaaaaaaaaaaaaazzzzzzzzzzzzz\nxyz.cyz",
+                    },
+                    location: Some(
+                        Location {
+                            path: "/your mother.nix",
+                            line: 1,
+                            col: 4,
+                        },
+                    ),
+                }
+            "#]],
+        );
+    }
+}