progress

Author: psteinroe

crates/pgt_fs/src/fs.rs

@@ -89,11 +89,6 @@ pub trait FileSystem: Send + Sync + RefUnwindSafe {
             // Iterate all possible file names
             for file_name in file_names {
                 let file_path = curret_search_dir.join(file_name);
-                println!(
-                    "Checking for file: {:?} in directory: {:?}",
-                    file_path,
-                    curret_search_dir.display()
-                );
                 match self.read_file_from_path(&file_path) {
                     Ok(content) => {
                         if is_searching_in_parent_dir {

crates/pgt_fs/src/fs/memory.rs

@@ -234,6 +234,7 @@ impl FileSystem for MemoryFileSystem {
         _specifier: &str,
         _path: &Path,
     ) -> Result<Resolution, ResolveError> {
+        // not needed for the memory file system
         todo!()
     }
 }

crates/pgt_workspace/src/settings.rs

@@ -51,18 +51,16 @@ impl WorkspaceSettings {
 
     pub fn get_current_project_path(&self) -> Option<&PgTPath> {
         trace!("Current key {:?}", self.current_project);
-        let data = self.data.get(self.current_project);
-        if let Some(data) = data {
-            Some(&data.path)
-        } else {
-            None
-        }
+        self.data
+            .get(self.current_project)
+            .as_ref()
+            .map(|d| &d.path)
     }
 
     pub fn get_current_project_data_mut(&mut self) -> &mut ProjectData {
         self.data
             .get_mut(self.current_project)
-            .expect("You must have at least one workspace.")
+            .expect("Current project not configured")
     }
 
     /// Retrieves the settings of the current workspace folder

crates/pgt_workspace/src/workspace/server.rs

@@ -68,7 +68,6 @@ pub(super) struct WorkspaceServer {
     settings: RwLock<WorkspaceSettings>,
 
     /// Stores the schema cache for this workspace
-    /// TODO: store this per connection
     schema_cache: SchemaCacheManager,
 
     parsed_documents: DashMap<PgTPath, ParsedDocument>,
@@ -133,7 +132,7 @@ impl WorkspaceServer {
         workspace_mut.set_current_project(project_key);
     }
 
-    /// Checks whether, if the current path belongs to the current project.
+    /// Checks whether the current path belongs to the current project.
     ///
     /// If there's a match, and the match **isn't** the current project, it returns the new key.
     fn path_belongs_to_current_workspace(&self, path: &PgTPath) -> Option<ProjectKey> {
@@ -213,6 +212,10 @@ impl Workspace for WorkspaceServer {
 
         let is_new_path = match (current_project_path.as_deref(), params.path.as_ref()) {
             (Some(current_project_path), Some(params_path)) => current_project_path != params_path,
+            (Some(_), None) => {
+                // If the current project is set, but no path is provided, we assume it's a new project
+                true
+            }
             _ => true,
         };
 
@@ -410,9 +413,19 @@ impl Workspace for WorkspaceServer {
         params: PullDiagnosticsParams,
     ) -> Result<PullDiagnosticsResult, WorkspaceError> {
         let settings = self.workspaces();
-        // TODO: not sure how we should handle this
-        // maybe fallback to default settings? or return an error?
-        let settings = settings.settings().expect("Settings should be initialized");
+
+        let settings = match settings.settings() {
+            Some(settings) => settings,
+            None => {
+                // return an empty result if no settings are available
+                // we might want to return an error here in the future
+                return Ok(PullDiagnosticsResult {
+                    diagnostics: Vec::new(),
+                    errors: 0,
+                    skipped_diagnostics: 0,
+                });
+            }
+        };
 
         // create analyser for this run
         // first, collect enabled and disabled rules from the workspace settings

crates/pgt_workspace/src/workspace/server/schema_cache_manager.rs

@@ -27,10 +27,21 @@ impl SchemaCacheManager {
             return Ok(Arc::clone(&*cache));
         }
 
-        let schema_cache = Arc::new(run_async(async move { SchemaCache::load(&pool).await })??);
-
-        self.schemas.insert(key, Arc::clone(&schema_cache));
-
-        Ok(schema_cache)
+        let schema_cache = self
+            .schemas
+            .entry(key)
+            .or_try_insert_with::<WorkspaceError>(|| {
+                // This closure will only be called once per key if multiple threads
+                // try to access the same key simultaneously
+                let pool_clone = pool.clone();
+                let schema_cache =
+                    Arc::new(run_async(
+                        async move { SchemaCache::load(&pool_clone).await },
+                    )??);
+
+                Ok(schema_cache)
+            })?;
+
+        Ok(Arc::clone(&schema_cache))
     }
 }