ServerWorld

crates/server/src/server_world.rs

@@ -0,0 +1,117 @@
+use std::{
+    path::{PathBuf, Path},
+    collections::HashMap,
+};
+
+use languageserver_types::Url;
+use libanalysis::{FileId, WorldState, World};
+
+use {
+    Result,
+    path_map::PathMap,
+    vfs::{FileEvent, FileEventKind},
+};
+
+#[derive(Debug)]
+pub struct ServerWorldState {
+    pub analysis: WorldState,
+    pub path_map: PathMap,
+    pub mem_map: HashMap<FileId, Option<String>>,
+}
+
+#[derive(Clone)]
+pub struct ServerWorld {
+    pub analysis: World,
+    pub path_map: PathMap,
+}
+
+impl ServerWorldState {
+    pub fn new() -> ServerWorldState {
+        ServerWorldState {
+            analysis: WorldState::new(),
+            path_map: PathMap::new(),
+            mem_map: HashMap::new(),
+        }
+    }
+
+    pub fn apply_fs_changes(&mut self, events: Vec<FileEvent>) {
+        let pm = &mut self.path_map;
+        let mm = &mut self.mem_map;
+        let changes = events.into_iter()
+            .map(|event| {
+                let text = match event.kind {
+                    FileEventKind::Add(text) => Some(text),
+                    FileEventKind::Remove => None,
+                };
+                (event.path, text)
+            })
+            .map(|(path, text)| {
+                (pm.get_or_insert(path), text)
+            })
+            .filter_map(|(id, text)| {
+                if mm.contains_key(&id) {
+                    mm.insert(id, text);
+                    None
+                } else {
+                    Some((id, text))
+                }
+            });
+
+        self.analysis.change_files(changes);
+    }
+
+    pub fn add_mem_file(&mut self, path: PathBuf, text: String) {
+        let file_id = self.path_map.get_or_insert(path);
+        self.mem_map.insert(file_id, None);
+        self.analysis.change_file(file_id, Some(text));
+    }
+
+    pub fn change_mem_file(&mut self, path: &Path, text: String) -> Result<()> {
+        let file_id = self.path_map.get_id(path).ok_or_else(|| {
+            format_err!("change to unknown file: {}", path.display())
+        })?;
+        self.analysis.change_file(file_id, Some(text));
+        Ok(())
+    }
+
+    pub fn remove_mem_file(&mut self, path: &Path) -> Result<()> {
+        let file_id = self.path_map.get_id(path).ok_or_else(|| {
+            format_err!("change to unknown file: {}", path.display())
+        })?;
+        let text = match self.mem_map.remove(&file_id) {
+            Some(text) => text,
+            None => bail!("unmatched close notification"),
+        };
+        self.analysis.change_file(file_id, text);
+        Ok(())
+    }
+
+    pub fn snapshot(&self) -> ServerWorld {
+        let pm = self.path_map.clone();
+        ServerWorld {
+            analysis: self.analysis.snapshot(move |id, path| {
+                pm.resolve(id, path)
+            }),
+            path_map: self.path_map.clone()
+        }
+    }
+}
+
+impl ServerWorld {
+    pub fn analysis(&self) -> &World {
+        &self.analysis
+    }
+
+    pub fn uri_to_file_id(&self, uri: &Url) -> Result<FileId> {
+        let path = uri.to_file_path()
+            .map_err(|()| format_err!("invalid uri: {}", uri))?;
+        self.path_map.get_id(&path).ok_or_else(|| format_err!("unknown file: {}", path.display()))
+    }
+
+    pub fn file_id_to_uri(&self, id: FileId) -> Result<Url> {
+        let path = self.path_map.get_path(id);
+        let url = Url::from_file_path(path)
+            .map_err(|()| format_err!("can't convert path to url: {}", path.display()))?;
+        Ok(url)
+    }
+}