Make modules with tests runnable

farodin91 · farodin91 · commit cdde466ee698 · 2018-11-12T20:57:28.000+01:00
Fixes #154
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
@@ -220,6 +220,34 @@ impl AnalysisImpl {
         let source_root = self.db.file_source_root(file_id);
         self.db.module_tree(source_root)
     }
+    pub(crate) fn module_path(&self, position: FilePosition) -> Cancelable<String> {
+        let mut current_position = position;
+        let mut path = "".to_string();
+
+        loop {
+            println!("current_position {:?}", current_position);
+            if let Some((file_id, file_symbol)) = self.parent_module(current_position)?.first() {
+                println!("parent_module {:?} {:?}",file_id, file_symbol);
+                let file = self.db.file_syntax(*file_id);
+                let module = find_node_at_offset::<ast::Module>(file.syntax(),file_symbol.node_range.start()).unwrap().syntax().range().start();
+                println!("{:?}", module);
+                path = format!("{}::{}", file_symbol.name, path);
+                current_position = FilePosition {
+                    file_id: *file_id,
+                    offset: if module == TextUnit::from_usize(0) { 
+                        TextUnit::from_usize(0) 
+                    } else { 
+                        module - TextUnit::from_usize(1)
+                    },
+                };
+            } else {
+                break;
+            }
+        }
+
+        Ok(path.to_string())
+    }
+    
     pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         let module_tree = self.module_tree(position.file_id)?;
         let file = self.db.file_syntax(position.file_id);
@@ -229,6 +257,7 @@ impl AnalysisImpl {
             _ => ModuleSource::SourceFile(position.file_id),
         };
 
+        println!("{:#?}", module_tree);
         let res = module_tree
             .modules_for_source(module_source)
             .into_iter()
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
@@ -8,6 +8,8 @@ extern crate rayon;
 extern crate relative_path;
 extern crate rustc_hash;
 extern crate salsa;
+#[cfg(test)]
+extern crate test_utils as test_utils;
 
 mod db;
 mod input;
@@ -17,6 +19,7 @@ mod descriptors;
 mod symbol_index;
 mod syntax_ptr;
 pub mod mock_analysis;
+mod runnables;
 
 use std::{fmt, sync::Arc};
 
@@ -33,9 +36,10 @@ pub use crate::{
     completion::CompletionItem,
     descriptors::function::FnDescriptor,
     input::{CrateGraph, CrateId, FileId, FileResolver},
+    runnables::{Runnable, RunnableKind}
 };
 pub use ra_editor::{
-    FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, Runnable, RunnableKind, StructureNode,
+    FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, StructureNode,
 };
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -268,6 +272,9 @@ impl Analysis {
     pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> {
         self.imp.parent_module(position)
     }
+    pub fn module_path(&self, position: FilePosition) -> Cancelable<String> {
+        self.imp.module_path(position)
+    }
     pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
         self.imp.crate_for(file_id)
     }
@@ -276,7 +283,7 @@ impl Analysis {
     }
     pub fn runnables(&self, file_id: FileId) -> Cancelable<Vec<Runnable>> {
         let file = self.imp.file_syntax(file_id);
-        Ok(ra_editor::runnables(&file))
+        Ok(runnables::runnables(self, &file, file_id))
     }
     pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
         let file = self.imp.file_syntax(file_id);
diff --git a/crates/ra_analysis/src/runnables.rs b/crates/ra_analysis/src/runnables.rs
@@ -0,0 +1,69 @@
+use ra_syntax::{
+    ast::{self, AstNode, NameOwner, ModuleItemOwner},
+    SourceFileNode, TextRange, SyntaxNodeRef
+};
+use crate::{
+    Analysis, FileId, FilePosition
+};
+
+#[derive(Debug)]
+pub struct Runnable {
+    pub range: TextRange,
+    pub kind: RunnableKind,
+}
+
+#[derive(Debug)]
+pub enum RunnableKind {
+    Test { name: String },
+    TestMod { path: String },
+    Bin,
+}
+
+pub fn runnables(analysis: &Analysis, file_node: &SourceFileNode, file_id: FileId) -> Vec<Runnable> {
+    file_node.syntax()
+        .descendants()
+        .filter_map(|i| runnable(analysis, i, file_id))
+        .collect()
+}
+
+fn runnable<'a>(analysis: &Analysis, item: SyntaxNodeRef<'a>, file_id: FileId) -> Option<Runnable> {
+    if let Some(f) = ast::FnDef::cast(item) {
+        let name = f.name()?.text();
+        let kind = if name == "main" {
+            RunnableKind::Bin
+        } else if f.has_atom_attr("test") {
+            RunnableKind::Test {
+                name: name.to_string(),
+            }
+        } else {
+            return None;
+        };
+        Some(Runnable {
+            range: f.syntax().range(),
+            kind,
+        })
+    } else if let Some(m) = ast::Module::cast(item) {
+        let name = m.name()?.text();
+        if m.item_list()?
+            .items()
+            .map(ast::ModuleItem::syntax)
+            .filter_map(ast::FnDef::cast)
+            .any(|f| f.has_atom_attr("test")) {
+            let postition = FilePosition {
+                file_id: file_id, 
+                offset: m.syntax().range().start()
+            };
+            let path = analysis.module_path(postition).unwrap();
+            Some(Runnable {
+                range: m.syntax().range(),
+                kind: RunnableKind::TestMod {
+                    path: format!("{}{}", path, name),
+                }
+            })
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
diff --git a/crates/ra_analysis/tests/runnables.rs b/crates/ra_analysis/tests/runnables.rs
@@ -0,0 +1,113 @@
+extern crate ra_analysis;
+extern crate ra_editor;
+extern crate ra_syntax;
+extern crate relative_path;
+extern crate rustc_hash;
+extern crate test_utils;
+
+use test_utils::assert_eq_dbg;
+
+use ra_analysis::{
+    mock_analysis::{analysis_and_position},
+};
+
+#[test]
+fn test_runnables() {
+    let (analysis, pos) = analysis_and_position(
+        r#"
+        //- /lib.rs
+        <|> //empty
+        fn main() {}
+
+        #[test]
+        fn test_foo() {}
+
+        #[test]
+        #[ignore]
+        fn test_foo() {}
+        "#);
+    let runnables = analysis.runnables(pos.file_id).unwrap();
+    assert_eq_dbg(
+        r#"[Runnable { range: [1; 21), kind: Bin },
+                Runnable { range: [22; 46), kind: Test { name: "test_foo" } },
+                Runnable { range: [47; 81), kind: Test { name: "test_foo" } }]"#,
+        &runnables,
+    )
+}
+
+#[test]
+fn test_runnables_module() {
+    let (analysis, pos) = analysis_and_position(
+        r#"
+        //- /lib.rs
+        <|> //empty
+        mod test_mod {
+            #[test]
+            fn test_foo1() {}
+        }
+        "#);
+    let runnables = analysis.runnables(pos.file_id).unwrap();
+    assert_eq_dbg(
+        r#"[Runnable { range: [1; 59), kind: TestMod { path: "test_mod::test_mod" } },
+                Runnable { range: [28; 57), kind: Test { name: "test_foo1" } }]"#,
+        &runnables,
+    )
+}
+
+#[test]
+fn test_runnables_one_depth_layer_module() {
+    let (analysis, pos) = analysis_and_position(
+        r#"
+        //- /lib.rs
+        <|> //empty
+        mod foo {
+            mod test_mod {
+                #[test]
+                fn test_foo1() {}
+            }
+        }
+        "#);
+    let runnables = analysis.runnables(pos.file_id).unwrap();
+    assert_eq_dbg(
+        r#"[Runnable { range: [23; 85), kind: TestMod { path: "foo::test_mod" } },
+                Runnable { range: [46; 79), kind: Test { name: "test_foo1" } }]"#,
+        &runnables,
+    )
+}
+
+#[test]
+fn test_runnables_multiple_depth_module() {
+    let (analysis, pos) = analysis_and_position(
+        r#"
+        //- /lib.rs
+        <|> //empty
+        mod foo {
+            mod bar {
+                mod test_mod {
+                    #[test]
+                    fn test_foo1() {}
+                }
+            }
+        }
+        "#);
+    let runnables = analysis.runnables(pos.file_id).unwrap();
+    assert_eq_dbg(
+        r#"[Runnable { range: [41; 115), kind: TestMod { path: "foo::bar::test_mod" } },
+                Runnable { range: [68; 105), kind: Test { name: "test_foo1" } }]"#,
+        &runnables,
+    )
+}
+
+#[test]
+fn test_runnables_no_test_function_in_module() {
+    let (analysis, pos) = analysis_and_position(
+        r#"
+        //- /lib.rs
+        <|> //empty
+        mod test_mod {
+            fn foo1() {}
+        }
+        "#);
+    let runnables = analysis.runnables(pos.file_id).unwrap();
+    assert_eq_dbg(r#"[]"#, &runnables)
+}
diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/tests.rs
@@ -111,6 +111,79 @@ fn test_resolve_parent_module_for_inline() {
     );
 }
 
+#[test]
+fn test_resolve_parent_module_for_inline_to_lib() {
+    let (analysis, pos) = analysis_and_position(
+        "
+        //- /lib.rs
+        mod foo {
+            <|>
+        }
+    ",
+    );
+    let symbols = analysis.parent_module(pos).unwrap();
+    assert_eq_dbg(
+        r#"[]"#,
+        &symbols,
+    );
+}
+
+#[test]
+fn test_path_one_layer() {
+    let (analysis, pos) = analysis_and_position(
+        "
+        //- /lib.rs
+        mod foo;
+        //- /foo/mod.rs
+        mod bla;
+        //- /foo/bla.rs
+        <|> //empty
+    ");
+    let symbols = analysis.module_path(pos).unwrap();
+    assert_eq!(
+        "foo::bla",
+        &symbols,
+    );
+}
+
+#[test]
+fn test_path_two_layer() {
+    let (analysis, pos) = analysis_and_position(
+        "
+        //- /lib.rs
+        mod foo;
+        //- /foo/mod.rs
+        mod bla;
+        //- /foo/bla/mod.rs
+        mod more;
+        //- /foo/bla/more.rs
+        <|> //empty
+    ");
+    let symbols = analysis.module_path(pos).unwrap();
+    assert_eq!(
+        "foo::bla::more",
+        &symbols,
+    );
+}
+
+#[test]
+fn test_path_in_file_mod() {
+    let (analysis, pos) = analysis_and_position(
+        "
+        //- /lib.rs
+        mod foo;
+        //- /foo.rs
+        mod bar {
+            <|> //empty
+        }
+    ");
+    let symbols = analysis.module_path(pos).unwrap();
+    assert_eq!(
+        "foo::bar",
+        &symbols,
+    );
+}
+
 #[test]
 fn test_resolve_crate_root() {
     let mock = MockAnalysis::with_files(
diff --git a/crates/ra_editor/src/lib.rs b/crates/ra_editor/src/lib.rs
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
