simplify, keep api boundary, add traits

Author: juleswritescode

crates/pg_completions/src/builder.rs

@@ -1,28 +1,23 @@
-use tower_lsp::lsp_types::CompletionItem;
-
-use crate::{item::CompletionItemWithScore, CompletionResult};
+use crate::{item::CompletionItem, CompletionResult};
 
 pub(crate) struct CompletionBuilder {
-    items: Vec<CompletionItemWithScore>,
+    items: Vec<CompletionItem>,
 }
 
 impl CompletionBuilder {
     pub fn new() -> Self {
         CompletionBuilder { items: vec![] }
     }
 
-    pub fn add_item(&mut self, item: CompletionItemWithScore) {
+    pub fn add_item(&mut self, item: CompletionItem) {
         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()))
-        });
+        self.items
+            .sort_by(|a, b| b.score.cmp(&a.score).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 should_preselect_first_item = self.should_preselect_first_item();
@@ -33,7 +28,7 @@ impl CompletionBuilder {
             .enumerate()
             .map(|(idx, mut item)| {
                 if idx == 0 {
-                    item.set_preselected(should_preselect_first_item);
+                    item.preselected = Some(should_preselect_first_item);
                 }
                 item.into()
             })

crates/pg_completions/src/complete.rs

@@ -1,7 +1,9 @@
 use text_size::TextSize;
-use tower_lsp::lsp_types::CompletionItem;
 
-use crate::{builder::CompletionBuilder, context::CompletionContext, providers::complete_tables};
+use crate::{
+    builder::CompletionBuilder, context::CompletionContext, item::CompletionItem,
+    providers::complete_tables,
+};
 
 pub const LIMIT: usize = 50;
 
@@ -18,6 +20,14 @@ pub struct CompletionResult {
     pub items: Vec<CompletionItem>,
 }
 
+impl IntoIterator for CompletionResult {
+    type Item = CompletionItem;
+    type IntoIter = <Vec<CompletionItem> as IntoIterator>::IntoIter;
+    fn into_iter(self) -> Self::IntoIter {
+        self.items.into_iter()
+    }
+}
+
 pub fn complete(params: CompletionParams) -> CompletionResult {
     let ctx = CompletionContext::new(&params);
 

crates/pg_completions/src/data.rs

@@ -1,32 +1,49 @@
-use tower_lsp::lsp_types::{self, CompletionItem};
-
-use crate::{data::CompletionItemData, relevance::CompletionRelevance};
+#[derive(Debug)]
+pub enum CompletionItemKind {
+    Table,
+}
 
 #[derive(Debug)]
-pub struct CompletionItemWithScore {
-    pub item: lsp_types::CompletionItem,
-    pub score: i32,
+pub struct CompletionItem {
+    pub label: String,
+    pub(crate) score: i32,
+    pub description: String,
+    pub preselected: Option<bool>,
+    pub kind: CompletionItemKind,
 }
 
-impl CompletionItemWithScore {
-    pub(crate) fn new(data: CompletionItemData, relevance: CompletionRelevance) -> Self {
-        Self {
-            item: data.into(),
-            score: relevance.score(),
+impl From<CompletionItem> for tower_lsp::lsp_types::CompletionItem {
+    fn from(i: CompletionItem) -> Self {
+        tower_lsp::lsp_types::CompletionItem {
+            label: i.label,
+            label_details: Some(tower_lsp::lsp_types::CompletionItemLabelDetails {
+                description: Some(i.description),
+                detail: None,
+            }),
+            kind: Some(i.kind.into()),
+            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,
         }
     }
-
-    pub(crate) fn label(&self) -> &str {
-        &self.item.label
-    }
-
-    pub(crate) fn set_preselected(&mut self, is_preselected: bool) {
-        self.item.preselect = Some(is_preselected)
-    }
 }
 
-impl Into<CompletionItem> for CompletionItemWithScore {
-    fn into(self) -> CompletionItem {
-        self.item
+impl From<CompletionItemKind> for tower_lsp::lsp_types::CompletionItemKind {
+    fn from(value: CompletionItemKind) -> Self {
+        match value {
+            CompletionItemKind::Table => tower_lsp::lsp_types::CompletionItemKind::CLASS,
+        }
     }
 }

crates/pg_completions/src/item.rs

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

crates/pg_completions/src/lib.rs

@@ -1,21 +1,37 @@
+use pg_schema_cache::Table;
+
 use crate::{
-    builder::CompletionBuilder, context::CompletionContext, data::CompletionItemData,
-    item::CompletionItemWithScore, relevance::CompletionRelevance,
+    builder::CompletionBuilder,
+    context::CompletionContext,
+    item::{CompletionItem, CompletionItemKind},
+    relevance::CompletionRelevance,
 };
 
 pub fn complete_tables(ctx: &CompletionContext, builder: &mut CompletionBuilder) {
     let available_tables = &ctx.schema_cache.tables;
 
-    let completion_items: Vec<CompletionItemWithScore> = available_tables
+    let completion_items: Vec<CompletionItem> = available_tables
         .iter()
-        .map(|table| {
-            let data = CompletionItemData::Table(table);
-            let relevance = CompletionRelevance::new(&data, ctx);
-            CompletionItemWithScore::new(data, relevance)
+        .map(|table| CompletionItem {
+            label: table.name.clone(),
+            score: get_score(ctx, table),
+            description: format!("Schema: {}", table.schema),
+            preselected: None,
+            kind: CompletionItemKind::Table,
         })
         .collect();
 
     for item in completion_items {
         builder.add_item(item);
     }
 }
+
+fn get_score(ctx: &CompletionContext, table: &Table) -> i32 {
+    let mut relevance = CompletionRelevance::default();
+
+    relevance.check_matches_query_input(ctx, &table.name);
+    relevance.check_matches_schema(ctx, &table.schema);
+    relevance.check_if_catalog(ctx);
+
+    relevance.score()
+}

crates/pg_completions/src/providers/tables.rs

@@ -1,4 +1,4 @@
-use crate::{context::CompletionContext, data::CompletionItemData};
+use crate::context::CompletionContext;
 
 #[derive(Debug, Default)]
 pub(crate) struct CompletionRelevance {
@@ -10,21 +10,7 @@ impl CompletionRelevance {
         self.score
     }
 
-    pub fn new(data: &CompletionItemData, ctx: &CompletionContext) -> Self {
-        let mut relevance = CompletionRelevance::default();
-
-        match data {
-            CompletionItemData::Table(tb) => {
-                relevance.check_if_catalog(ctx);
-                relevance.check_matches_schema(ctx, &tb.schema);
-                relevance.check_matches_query_input(ctx, &tb.name);
-            }
-        }
-
-        relevance
-    }
-
-    fn check_matches_query_input(&mut self, ctx: &CompletionContext, name: &str) {
+    pub fn check_matches_query_input(&mut self, ctx: &CompletionContext, name: &str) {
         let node = ctx.ts_node.unwrap();
 
         let content = match ctx.get_ts_node_content(node) {
@@ -42,7 +28,7 @@ impl CompletionRelevance {
         };
     }
 
-    fn check_matches_schema(&mut self, ctx: &CompletionContext, schema: &str) {
+    pub fn check_matches_schema(&mut self, ctx: &CompletionContext, schema: &str) {
         if ctx.schema_name.is_none() {
             return;
         }
@@ -56,7 +42,7 @@ impl CompletionRelevance {
         }
     }
 
-    fn check_if_catalog(&mut self, ctx: &CompletionContext) {
+    pub fn check_if_catalog(&mut self, ctx: &CompletionContext) {
         if ctx.schema_name.as_ref().is_some_and(|n| n == "pg_catalog") {
             return;
         }

crates/pg_completions/src/relevance.rs

@@ -10,8 +10,8 @@ use pg_workspace::Workspace;
 use text_size::TextSize;
 use tokio::sync::RwLock;
 use tower_lsp::lsp_types::{
-    CodeActionOrCommand, CompletionItem, CompletionItemKind, CompletionList, Hover, HoverContents,
-    InlayHint, InlayHintKind, InlayHintLabel, MarkedString, Position, Range,
+    CodeActionOrCommand, CompletionItem, CompletionList, Hover, HoverContents, InlayHint,
+    InlayHintKind, InlayHintLabel, MarkedString, Position, Range,
 };
 
 use crate::{db_connection::DbConnection, utils::line_index_ext::LineIndexExt};
@@ -235,7 +235,7 @@ impl Session {
 
         let schema_cache = ide.schema_cache.read().expect("No Schema Cache");
 
-        let completion_items = pg_completions::complete(CompletionParams {
+        let completion_items: Vec<CompletionItem> = pg_completions::complete(CompletionParams {
             position: offset - range.start() - TextSize::from(1),
             text: &stmt.text,
             tree: ide
@@ -245,29 +245,8 @@ impl Session {
                 .and_then(|t| Some(t.as_ref())),
             schema: &schema_cache,
         })
-        .items
         .into_iter()
-        .map(|i| CompletionItem {
-            // TODO: add more data
-            label: i.label,
-            label_details: 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,
-        })
+        .map(|i| i.into())
         .collect();
 
         Some(CompletionList {