Make modules with tests runnable

Fixes #154

Author: farodin91

crates/ra_analysis/src/lib.rs

@@ -5,6 +5,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 input;
 mod db;
@@ -13,6 +15,7 @@ mod imp;
 mod symbol_index;
 mod completion;
 mod syntax_ptr;
+mod runnables;
 
 use std::{
     fmt,
@@ -30,11 +33,11 @@ use crate::{
 
 pub use crate::{
     descriptors::FnDescriptor,
-    input::{FileId, FileResolver, CrateGraph, CrateId}
+    input::{FileId, FileResolver, CrateGraph, CrateId},
+    runnables::{Runnable, RunnableKind}
 };
 pub use ra_editor::{
-    CompletionItem, FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, Runnable,
-    RunnableKind, StructureNode,
+    CompletionItem, FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, StructureNode,
 };
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -268,7 +271,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(&file))
     }
     pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
         let file = self.imp.file_syntax(file_id);

crates/ra_analysis/src/runnables.rs

@@ -0,0 +1,127 @@
+
+use ra_syntax::{
+    ast::{self, AstNode, NameOwner, ModuleItemOwner},
+    File, TextRange, 
+    SyntaxNodeRef
+};
+
+#[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(file: &File) -> Vec<Runnable> {
+    file.syntax()
+        .descendants()
+        .filter_map(runnable)
+        .collect()
+}
+
+fn runnable<'a>(item: SyntaxNodeRef<'a>) -> 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")) {
+            Some(Runnable {
+                range: m.syntax().range(),
+                kind: RunnableKind::TestMod {
+                    path: name.to_string()
+                }
+            })
+        }else {
+            None
+        }
+    }else {
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{assert_eq_dbg};
+
+    #[test]
+    fn test_runnables() {
+        let file = File::parse(
+            r#"
+fn main() {}
+
+#[test]
+fn test_foo() {}
+
+#[test]
+#[ignore]
+fn test_foo() {}
+"#,
+        );
+        let runnables = runnables(&file);
+        assert_eq_dbg(
+            r#"[Runnable { range: [1; 13), kind: Bin },
+                Runnable { range: [15; 39), kind: Test { name: "test_foo" } },
+                Runnable { range: [41; 75), kind: Test { name: "test_foo" } }]"#,
+            &runnables,
+        )
+    }
+
+    #[test]
+    fn test_runnables_module() {
+        let file = File::parse(
+            r#"
+mod test_mod {
+    #[test]
+    fn test_foo1() {}
+}
+"#,
+        );
+        let runnables = runnables(&file);
+        assert_eq_dbg(
+            r#"[Runnable { range: [1; 51), kind: TestMod { path: "test_mod" } },
+                Runnable { range: [20; 49), kind: Test { name: "test_foo1" } }]"#,
+            &runnables,
+        )
+    }
+
+    #[test]
+    fn test_runnables_no_test_function_in_module() {
+        let file = File::parse(
+            r#"
+mod test_mod {
+    fn foo1() {}
+}
+"#,
+        );
+        let runnables = runnables(&file);
+        assert_eq_dbg(
+            r#"[]"#,
+            &runnables,
+        )
+    }
+
+}

crates/ra_editor/src/lib.rs

@@ -50,18 +50,6 @@ pub struct Diagnostic {
     pub msg: String,
 }
 
-#[derive(Debug)]
-pub struct Runnable {
-    pub range: TextRange,
-    pub kind: RunnableKind,
-}
-
-#[derive(Debug)]
-pub enum RunnableKind {
-    Test { name: String },
-    Bin,
-}
-
 pub fn matching_brace(file: &File, offset: TextUnit) -> Option<TextUnit> {
     const BRACES: &[SyntaxKind] = &[
         L_CURLY, R_CURLY, L_BRACK, R_BRACK, L_PAREN, R_PAREN, L_ANGLE, R_ANGLE,
@@ -116,29 +104,6 @@ pub fn syntax_tree(file: &File) -> String {
     ::ra_syntax::utils::dump_tree(file.syntax())
 }
 
-pub fn runnables(file: &File) -> Vec<Runnable> {
-    file.syntax()
-        .descendants()
-        .filter_map(ast::FnDef::cast)
-        .filter_map(|f| {
-            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,
-            })
-        })
-        .collect()
-}
-
 pub fn find_node_at_offset<'a, N: AstNode<'a>>(
     syntax: SyntaxNodeRef<'a>,
     offset: TextUnit,
@@ -187,29 +152,6 @@ fn main() {}
         );
     }
 
-    #[test]
-    fn test_runnables() {
-        let file = File::parse(
-            r#"
-fn main() {}
-
-#[test]
-fn test_foo() {}
-
-#[test]
-#[ignore]
-fn test_foo() {}
-"#,
-        );
-        let runnables = runnables(&file);
-        assert_eq_dbg(
-            r#"[Runnable { range: [1; 13), kind: Bin },
-                Runnable { range: [15; 39), kind: Test { name: "test_foo" } },
-                Runnable { range: [41; 75), kind: Test { name: "test_foo" } }]"#,
-            &runnables,
-        )
-    }
-
     #[test]
     fn test_matching_brace() {
         fn do_check(before: &str, after: &str) {

crates/ra_lsp_server/src/main_loop/handlers.rs

@@ -256,6 +256,7 @@ pub fn handle_runnables(
             range: runnable.range.conv_with(&line_index),
             label: match &runnable.kind {
                 RunnableKind::Test { name } => format!("test {}", name),
+                RunnableKind::TestMod { path } => format!("test-mod {}", path),
                 RunnableKind::Bin => "run binary".to_string(),
             },
             bin: "cargo".to_string(),
@@ -303,6 +304,15 @@ pub fn handle_runnables(
                 res.push(name.to_string());
                 res.push("--nocapture".to_string());
             }
+            RunnableKind::TestMod { path } => {
+                res.push("test".to_string());
+                if let Some(spec) = spec {
+                    spec.push_to(&mut res);
+                }
+                res.push("--".to_string());
+                res.push(path.to_string());
+                res.push("--nocapture".to_string());
+            }
             RunnableKind::Bin => {
                 res.push("run".to_string());
                 if let Some(spec) = spec {