refactorings

Author: juleswritescode

crates/pg_completions/Cargo.toml

@@ -12,6 +12,7 @@ tree-sitter.workspace = true
 tree_sitter_sql.workspace = true
 pg_schema_cache.workspace = true
 pg_test_utils.workspace = true
+tower-lsp.workspace = true
 
 sqlx.workspace = true
 

crates/pg_completions/src/builder.rs

@@ -1,26 +1,26 @@
-use crate::{item::CompletionItem, CompletionResult};
+use crate::{item::CompletionItemWithRelevance, CompletionResult};
 
 pub(crate) struct CompletionBuilder {
-    items: Vec<CompletionItem>,
+    items: Vec<CompletionItemWithRelevance>,
 }
 
 impl CompletionBuilder {
     pub fn new() -> Self {
         CompletionBuilder { items: vec![] }
     }
 
-    pub fn add_item(&mut self, item: CompletionItem) {
+    pub fn add_item(&mut self, item: CompletionItemWithRelevance) {
         self.items.push(item)
     }
 
     pub fn finish(mut self) -> CompletionResult {
         self.items.sort_by(|a, b| {
             b.score()
                 .cmp(&a.score())
-                .then_with(|| a.label.cmp(&b.label))
+                .then_with(|| a.label().cmp(&b.label()))
         });
 
-        self.items.dedup_by(|a, b| a.label == b.label);
+        self.items.dedup_by(|a, b| a.label() == b.label());
         self.items.truncate(crate::LIMIT);
 
         let Self { items, .. } = self;

crates/pg_completions/src/complete.rs

@@ -1,7 +1,8 @@
 use text_size::TextSize;
 
 use crate::{
-    builder::CompletionBuilder, context::CompletionContext, item::CompletionItem, providers,
+    builder::CompletionBuilder, context::CompletionContext, item::CompletionItemWithRelevance,
+    providers,
 };
 
 pub const LIMIT: usize = 50;
@@ -16,7 +17,7 @@ pub struct CompletionParams<'a> {
 
 #[derive(Debug, Default)]
 pub struct CompletionResult {
-    pub items: Vec<CompletionItem>,
+    pub items: Vec<CompletionItemWithRelevance>,
 }
 
 pub fn complete(params: CompletionParams) -> CompletionResult {
@@ -45,48 +46,34 @@ mod tests {
     use crate::{complete, CompletionParams};
 
     #[tokio::test]
-    async fn test_complete() {
-        let pool = get_new_test_db().await;
-
-        let input = "select id from c;";
-
-        let mut parser = tree_sitter::Parser::new();
-        parser
-            .set_language(tree_sitter_sql::language())
-            .expect("Error loading sql language");
-
-        let tree = parser.parse(input, None).unwrap();
-
-        let schema_cache = SchemaCache::load(&pool).await;
-
-        let p = CompletionParams {
-            position: 15.into(),
-            schema: &schema_cache,
-            text: input,
-            tree: Some(&tree),
-        };
-
-        let result = complete(p);
+    async fn autocompletes_simple_table() {
+        let test_db = get_new_test_db().await;
 
-        assert!(result.items.len() > 0);
-    }
+        let setup = r#"
+            create table users (
+                id serial primary key,
+                name text,
+                password text
+            );
+        "#;
 
-    #[tokio::test]
-    async fn test_complete_two() {
-        let pool = get_new_test_db().await;
+        test_db
+            .execute(setup)
+            .await
+            .expect("Failed to execute setup query");
 
-        let input = "select id, name, test1231234123, unknown from co;";
+        let input = "select * from u";
 
         let mut parser = tree_sitter::Parser::new();
         parser
             .set_language(tree_sitter_sql::language())
             .expect("Error loading sql language");
 
         let tree = parser.parse(input, None).unwrap();
-        let schema_cache = SchemaCache::load(&pool).await;
+        let schema_cache = SchemaCache::load(&test_db).await;
 
         let p = CompletionParams {
-            position: 47.into(),
+            position: ((input.len() - 1) as u32).into(),
             schema: &schema_cache,
             text: input,
             tree: Some(&tree),
@@ -95,52 +82,71 @@ mod tests {
         let result = complete(p);
 
         assert!(result.items.len() > 0);
+
+        let best_match = &result.items[0];
+
+        assert_eq!(
+            best_match.label, "users",
+            "Does not return the expected table to autocomplete: {}",
+            best_match.label
+        )
     }
 
-    #[tokio::test]
-    async fn test_complete_three() {
+    async fn autocompletes_table_with_schema() {
         let test_db = get_new_test_db().await;
 
         let setup = r#"
-            create table users (
+            create schema public;
+            create schema private;
+
+            create table private.users (
                 id serial primary key,
                 name text,
                 password text
             );
+
+            create table public.user_requests (
+                id serial primary key,
+                request text,
+                send_at timestamp with time zone
+            );
         "#;
 
         test_db
             .execute(setup)
             .await
             .expect("Failed to execute setup query");
 
-        let input = "select * from u";
+        let schema_cache = SchemaCache::load(&test_db).await;
 
         let mut parser = tree_sitter::Parser::new();
         parser
             .set_language(tree_sitter_sql::language())
             .expect("Error loading sql language");
 
-        let tree = parser.parse(input, None).unwrap();
-        let schema_cache = SchemaCache::load(&test_db).await;
+        // testing the private schema
+        {
+            let input = "select * from private.u";
+            let tree = parser.parse(input, None).unwrap();
 
-        let p = CompletionParams {
-            position: ((input.len() - 1) as u32).into(),
-            schema: &schema_cache,
-            text: input,
-            tree: Some(&tree),
-        };
+            let p = CompletionParams {
+                position: ((input.len() - 1) as u32).into(),
+                schema: &schema_cache,
+                text: input,
+                tree: Some(&tree),
+            };
 
-        let result = complete(p);
+            let result = complete(p);
 
-        assert!(result.items.len() > 0);
+            assert!(result.items.len() > 0);
 
-        let best_match = &result.items[0];
+            let best_match = &result.items[0];
 
-        assert_eq!(
-            best_match.label, "users",
-            "Does not return the expected table to autocomplete: {}",
-            best_match.label
-        )
+            assert_eq!(
+                best_match.label, "users",
+                "Does not return the expected table to autocomplete: {}",
+                best_match.label
+            )
+        }
     }
 }

crates/pg_completions/src/data.rs

@@ -0,0 +1,36 @@
+use tower_lsp::lsp_types::{CompletionItem, CompletionItemKind, CompletionItemLabelDetails};
+
+#[derive(Debug)]
+pub(crate) enum CompletionItemData<'a> {
+    Table(&'a pg_schema_cache::Table),
+}
+
+impl<'a> Into<CompletionItem> for CompletionItemData<'a> {
+    fn into(self) -> CompletionItem {
+        match self {
+            Self::Table(tb) => CompletionItem {
+                label: tb.name.clone(),
+                label_details: Some(CompletionItemLabelDetails {
+                    description: Some(format!("Schema: {}", tb.schema)),
+                    detail: None,
+                }),
+                kind: Some(CompletionItemKind::CLASS),
+                detail: None,
+                documentation: None,
+                deprecated: None,
+                preselect: None,
+                sort_text: None,
+                filter_text: None,
+                insert_text: None,
+                insert_text_format: None,
+                insert_text_mode: None,
+                text_edit: None,
+                additional_text_edits: None,
+                commit_characters: None,
+                data: None,
+                tags: None,
+                command: None,
+            },
+        }
+    }
+}

crates/pg_completions/src/item.rs

@@ -1,41 +1,26 @@
-use text_size::TextRange;
+use tower_lsp::lsp_types;
 
-use crate::relevance::CompletionRelevance;
+use crate::{data::CompletionItemData, relevance::CompletionRelevance};
 
 #[derive(Debug)]
-pub enum CompletionItemData<'a> {
-    Table(&'a pg_schema_cache::Table),
-}
-
-impl<'a> CompletionItemData<'a> {
-    pub fn label(&self) -> String {
-        match self {
-            CompletionItemData::Table(t) => t.name.clone(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct CompletionItem {
-    pub range: TextRange,
-    pub label: String,
+pub struct CompletionItemWithRelevance {
+    item: lsp_types::CompletionItem,
     relevance: CompletionRelevance,
 }
 
-impl CompletionItem {
-    pub(crate) fn new(
-        range: TextRange,
-        data: CompletionItemData,
-        relevance: CompletionRelevance,
-    ) -> Self {
+impl CompletionItemWithRelevance {
+    pub(crate) fn new(data: CompletionItemData, relevance: CompletionRelevance) -> Self {
         Self {
-            range,
-            label: data.label(),
+            item: data.into(),
             relevance,
         }
     }
 
     pub(crate) fn score(&self) -> i32 {
         self.relevance.score()
     }
+
+    pub(crate) fn label(&self) -> &str {
+        &self.item.label
+    }
 }

crates/pg_completions/src/lib.rs

@@ -1,6 +1,7 @@
 mod builder;
 mod complete;
 mod context;
+mod data;
 mod item;
 mod providers;
 mod relevance;

crates/pg_completions/src/providers/tables.rs

@@ -1,17 +1,14 @@
 use pg_schema_cache::Table;
-use text_size::{TextRange, TextSize};
 
 use crate::{
-    builder::CompletionBuilder,
-    context::CompletionContext,
-    item::{CompletionItem, CompletionItemData},
-    relevance::CompletionRelevance,
+    builder::CompletionBuilder, context::CompletionContext, data::CompletionItemData,
+    item::CompletionItemWithRelevance, relevance::CompletionRelevance,
 };
 
 pub fn complete_tables(ctx: &CompletionContext, builder: &mut CompletionBuilder) {
     let available_tables = &ctx.schema_cache.tables;
 
-    let completion_items: Vec<CompletionItem> = available_tables
+    let completion_items: Vec<CompletionItemWithRelevance> = available_tables
         .iter()
         .map(|table| to_completion_item(ctx, table))
         .collect();
@@ -21,18 +18,8 @@ pub fn complete_tables(ctx: &CompletionContext, builder: &mut CompletionBuilder)
     }
 }
 
-fn to_completion_item(ctx: &CompletionContext, table: &Table) -> CompletionItem {
+fn to_completion_item(ctx: &CompletionContext, table: &Table) -> CompletionItemWithRelevance {
     let data = CompletionItemData::Table(table);
-
-    let start = ctx.position;
-    let end = start + TextSize::from(table.name.len() as u32);
-    let range = TextRange::new(start, end);
-
-    let mut relevance = CompletionRelevance::default();
-
-    relevance.set_is_catalog(&table.schema);
-    relevance.set_matches_prefix(ctx, &table.name);
-    relevance.set_matches_schema(ctx, &table.schema);
-
-    CompletionItem::new(range, data, relevance)
+    let relevance = CompletionRelevance::from_data_and_ctx(&data, ctx);
+    CompletionItemWithRelevance::new(data, relevance)
 }

crates/pg_completions/src/relevance.rs

@@ -1,4 +1,4 @@
-use crate::context::CompletionContext;
+use crate::{context::CompletionContext, data::CompletionItemData};
 
 #[derive(Debug, Default)]
 pub(crate) struct CompletionRelevance {
@@ -14,6 +14,20 @@ pub(crate) struct CompletionRelevance {
 }
 
 impl CompletionRelevance {
+    pub fn from_data_and_ctx(data: &CompletionItemData, ctx: &CompletionContext) -> Self {
+        let mut relevance = CompletionRelevance::default();
+
+        match data {
+            CompletionItemData::Table(tb) => {
+                relevance.set_is_catalog(&tb.schema);
+                relevance.set_matches_schema(ctx, &tb.schema);
+                relevance.set_matches_prefix(ctx, &tb.name);
+            }
+        }
+
+        relevance
+    }
+
     pub fn score(&self) -> i32 {
         let mut score: i32 = 0;
 

crates/pg_lsp/Cargo.toml

@@ -23,6 +23,7 @@ text-size = "1.1.1"
 
 line_index.workspace = true
 sqlx.workspace = true
+tower-lsp.workspace = true
 
 pg_hover.workspace = true
 pg_fs.workspace = true
@@ -35,7 +36,6 @@ pg_workspace.workspace = true
 pg_diagnostics.workspace = true
 tokio = { version = "1.40.0", features = ["io-std", "macros", "rt-multi-thread", "sync", "time"] }
 tokio-util = "0.7.12"
-tower-lsp = "0.20.0"
 tracing = "0.1.40"
 tracing-subscriber = "0.3.18"