Clean up imports and modules

Author: Xanewok

src/test/harness.rs

@@ -27,8 +27,8 @@ use rls_analysis::{AnalysisHost, Target};
 use rls_vfs::Vfs;
 use serde_json;
 
-#[path = "../../tests/support/mod.rs"]
-mod support;
+#[path = "../../tests/support/project_builder.rs"]
+mod project_builder;
 
 lazy_static! {
     static ref COUNTER: AtomicUsize = AtomicUsize::new(0);
@@ -50,7 +50,7 @@ impl Environment {
         }
 
         let fixture_dir = FIXTURES_DIR.join(fixture_dir.as_ref());
-        let project = support::ProjectBuilder::try_from_fixture(fixture_dir)
+        let project = project_builder::ProjectBuilder::try_from_fixture(fixture_dir)
             .unwrap()
             .build();
 
@@ -74,38 +74,6 @@ impl Environment {
             target_path: working_dir,
         }
     }
-
-    crate fn new(project_dir: &str) -> Self {
-        let _ = env_logger::try_init();
-        if env::var("RUSTC").is_err() {
-            env::set_var("RUSTC", "rustc");
-        }
-
-        let cur_dir = env::var_os("RLS_TEST_WORKSPACE_DIR")
-            .map(PathBuf::from)
-            .unwrap_or_else(|| MANIFEST_DIR.to_owned());
-        let project_path = cur_dir.join("test_data").join(project_dir);
-
-        let target_dir = env::var("CARGO_TARGET_DIR")
-            .map(|s| Path::new(&s).to_owned())
-            .unwrap_or_else(|_| cur_dir.join("target"));
-
-        let working_dir = target_dir
-            .join("tests")
-            .join(format!("{}", COUNTER.fetch_add(1, Ordering::Relaxed)));
-
-        let mut config = Config::default();
-        config.target_dir = Inferrable::Specified(Some(working_dir.clone()));
-        config.unstable_features = true;
-
-        let cache = Cache::new(project_path);
-
-        Self {
-            config: Some(config),
-            cache,
-            target_path: working_dir,
-        }
-    }
 }
 
 impl Environment {

src/test/mod.rs

@@ -33,9 +33,6 @@ use std::sync::{Arc, Mutex};
 use std::time::Instant;
 use url::Url;
 
-#[path = "../../tests/support/mod.rs"]
-mod support;
-
 fn initialize(id: usize, root_path: Option<String>) -> Request<ls_server::InitializeRequest> {
     initialize_with_opts(id, root_path, None)
 }

tests/support/mod.rs

@@ -9,23 +9,23 @@
 // except according to those terms.
 
 use serde_json::{self, json};
-use walkdir::WalkDir;
 
 use std::env;
-use std::fs;
 use std::io::{self, Read, Write};
 use std::mem;
 use std::panic;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::process::{Child, ChildStdin, Command, Stdio};
 use std::str;
 use std::sync::{Arc, Mutex};
 use std::thread;
 use std::time::{Duration, Instant};
 
-use self::paths::TestPathExt;
-
-pub mod paths;
+// FIXME(move unit tests here): Right now the modules are organized as follows:
+// support/mod.rs -> project_builder.rs -> paths.rs.
+// This is done so that the main binary can directly pull in project_builder.rs
+// to not duplicate logic and use it for generating data for project unit tests.
+pub mod project_builder;
 
 /// Parse valid LSP stdout into a list of json messages
 pub fn parse_messages(stdout: &str) -> Vec<String> {
@@ -289,115 +289,7 @@ impl RlsStdout {
     }
 }
 
-#[derive(PartialEq, Clone)]
-struct FileBuilder {
-    path: PathBuf,
-    body: String,
-}
-
-impl FileBuilder {
-    pub fn new(path: PathBuf, body: &str) -> FileBuilder {
-        FileBuilder {
-            path,
-            body: body.to_string(),
-        }
-    }
-
-    fn mk(&self) {
-        self.dirname().mkdir_p();
-
-        let mut file = fs::File::create(&self.path)
-            .unwrap_or_else(|e| panic!("could not create file {}: {}", self.path.display(), e));
-
-        file.write_all(self.body.as_bytes()).unwrap();
-    }
-
-    fn dirname(&self) -> &Path {
-        self.path.parent().unwrap()
-    }
-}
-
-#[derive(PartialEq, Clone)]
-pub struct Project {
-    root: PathBuf,
-}
-
-#[must_use]
-#[derive(PartialEq, Clone)]
-pub struct ProjectBuilder {
-    root: Project,
-    files: Vec<FileBuilder>,
-}
-
-impl ProjectBuilder {
-    pub fn new(root: PathBuf) -> ProjectBuilder {
-        ProjectBuilder {
-            root: Project { root },
-            files: vec![],
-        }
-    }
-
-    pub fn try_from_fixture(fixture_dir: impl AsRef<Path>) -> std::io::Result<Self> {
-        let fixture_dir = fixture_dir.as_ref();
-
-        let dirname = fixture_dir.file_name()
-            .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::NotFound, "No filename"))?;
-
-        // Generate a new, unique directory for working dir under target/
-        let genroot = paths::root();
-        let mut builder = ProjectBuilder::new(genroot.join(dirname));
-
-        // Read existing fixture data to be later copied into scratch genroot
-        for entry in WalkDir::new(fixture_dir).into_iter() {
-            let entry = entry?;
-            let path = entry.path();
-            let body = if !std::fs::metadata(path)?.is_dir() {
-                std::fs::read_to_string(path)?
-            } else {
-                continue;
-            };
-
-            let relative = entry.path().strip_prefix(fixture_dir).unwrap();
-            builder._file(relative, &body);
-        }
-
-        Ok(builder)
-    }
-
-    pub fn file<B: AsRef<Path>>(mut self, path: B, body: &str) -> Self {
-        self._file(path.as_ref(), body);
-        self
-    }
-
-    fn _file(&mut self, path: &Path, body: &str) {
-        self.files
-            .push(FileBuilder::new(self.root.root.join(path), body));
-    }
-
-    pub fn build(self) -> Project {
-        // First, clean the directory if it already exists
-        self.rm_root();
-
-        // Create the empty directory
-        self.root.root.mkdir_p();
-
-        for file in &self.files {
-            file.mk();
-        }
-
-        self.root
-    }
-
-    fn rm_root(&self) {
-        self.root.root.rm_rf()
-    }
-}
-
-impl Project {
-    pub fn root(&self) -> &Path {
-        &self.root
-    }
-
+impl project_builder::Project {
     pub fn spawn_rls(&self) -> RlsHandle {
         RlsHandle::new(
             Command::new(rls_exe())
@@ -410,11 +302,6 @@ impl Project {
     }
 }
 
-// Generates a project layout
-pub fn project(name: &str) -> ProjectBuilder {
-    ProjectBuilder::new(paths::root().join(name))
-}
-
 // Path to cargo executables
 pub fn target_conf_dir() -> PathBuf {
     let mut path = env::current_exe().unwrap();

tests/support/project_builder.rs

@@ -0,0 +1,134 @@
+//! Contains helper types that are capable of dynamically creating project
+//! layouts under target/ for testing purposes.
+//! This module is currently pulled by main binary and Cargo integration tests.
+#![allow(dead_code)]
+
+use walkdir::WalkDir;
+
+use std::path::{Path, PathBuf};
+use std::fs;
+use std::io::{Write};
+
+use self::paths::TestPathExt;
+
+// Modules are organized: support/mod.rs -> project_builder.rs -> paths.rs,
+// see note in support.mod.rs
+#[path = "paths.rs"]
+mod paths;
+
+#[derive(PartialEq, Clone)]
+struct FileBuilder {
+    path: PathBuf,
+    body: String,
+}
+
+impl FileBuilder {
+    pub fn new(path: PathBuf, body: &str) -> FileBuilder {
+        FileBuilder {
+            path,
+            body: body.to_string(),
+        }
+    }
+
+    fn mk(&self) {
+        self.dirname().mkdir_p();
+
+        let mut file = fs::File::create(&self.path)
+            .unwrap_or_else(|e| panic!("could not create file {}: {}", self.path.display(), e));
+
+        file.write_all(self.body.as_bytes()).unwrap();
+    }
+
+    fn dirname(&self) -> &Path {
+        self.path.parent().unwrap()
+    }
+}
+
+#[derive(PartialEq, Clone)]
+pub struct Project {
+    root: PathBuf,
+}
+
+#[must_use]
+#[derive(PartialEq, Clone)]
+pub struct ProjectBuilder {
+    root: Project,
+    files: Vec<FileBuilder>,
+}
+
+impl ProjectBuilder {
+    pub fn new(root: PathBuf) -> ProjectBuilder {
+        ProjectBuilder {
+            root: Project { root },
+            files: vec![],
+        }
+    }
+
+    pub fn try_from_fixture(fixture_dir: impl AsRef<Path>) -> std::io::Result<Self> {
+        let fixture_dir = fixture_dir.as_ref();
+
+        let dirname = fixture_dir.file_name()
+            .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::NotFound, "No filename"))?;
+
+        // Generate a new, unique directory for working dir under target/
+        let genroot = paths::root();
+        let mut builder = ProjectBuilder::new(genroot.join(dirname));
+
+        // Read existing fixture data to be later copied into scratch genroot
+        for entry in WalkDir::new(fixture_dir).into_iter() {
+            let entry = entry?;
+            let path = entry.path();
+            let body = if !std::fs::metadata(path)?.is_dir() {
+                std::fs::read_to_string(path)?
+            } else {
+                continue;
+            };
+
+            let relative = entry.path().strip_prefix(fixture_dir).unwrap();
+            builder._file(relative, &body);
+        }
+
+        Ok(builder)
+    }
+
+    pub fn file<B: AsRef<Path>>(mut self, path: B, body: &str) -> Self {
+        self._file(path.as_ref(), body);
+        self
+    }
+
+    fn _file(&mut self, path: &Path, body: &str) {
+        self.files
+            .push(FileBuilder::new(self.root.root.join(path), body));
+    }
+
+    pub fn build(self) -> Project {
+        // First, clean the directory if it already exists
+        self.rm_root();
+
+        // Create the empty directory
+        self.root.root.mkdir_p();
+
+        for file in &self.files {
+            file.mk();
+        }
+
+        self.root
+    }
+
+    fn rm_root(&self) {
+        self.root.root.rm_rf()
+    }
+}
+
+impl Project {
+    pub fn root(&self) -> &Path {
+        &self.root
+    }
+}
+
+// Generates a project layout
+pub fn project(name: &str) -> ProjectBuilder {
+    ProjectBuilder::new(paths::root().join(name))
+}
+
+

tests/tests.rs

@@ -8,16 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[macro_use]
-extern crate serde_json;
+use serde_json::{self, json};
 
-mod support;
-
-use self::support::{basic_bin_manifest, project};
-use crate::support::RlsStdout;
 use std::io::Write;
 use std::time::Duration;
 
+use self::support::{basic_bin_manifest, RlsStdout};
+use self::support::project_builder::project;
+
+mod support;
+
 /// Returns a timeout for waiting for rls stdout messages
 ///
 /// Env var `RLS_TEST_WAIT_FOR_AGES` allows super long waiting for CI