achore: djust lints, refactor completion_relevance

Author: juleswritescode

crates/pg_completions/src/builder.rs

@@ -28,7 +28,7 @@ impl CompletionBuilder {
             .enumerate()
             .map(|(idx, mut item)| {
                 if idx == 0 {
-                    item.preselected = Some(should_preselect_first_item);
+                    item.preselected = should_preselect_first_item;
                 }
                 item
             })

crates/pg_completions/src/item.rs

@@ -9,6 +9,6 @@ pub struct CompletionItem {
     pub label: String,
     pub(crate) score: i32,
     pub description: String,
-    pub preselected: Option<bool>,
+    pub preselected: bool,
     pub kind: CompletionItemKind,
 }

crates/pg_completions/src/providers/functions.rs

@@ -10,10 +10,10 @@ pub fn complete_functions(ctx: &CompletionContext, builder: &mut CompletionBuild
     let completion_items: Vec<CompletionItem> = available_functions
         .iter()
         .map(|foo| CompletionItem {
-            label: foo.name,
+            label: foo.name.clone(),
             score: get_score(ctx, foo),
             description: format!("Schema: {}", foo.schema),
-            preselected: None,
+            preselected: false,
             kind: CompletionItemKind::Function,
         })
         .collect();
@@ -31,17 +31,23 @@ fn get_score(ctx: &CompletionContext, foo: &Function) -> i32 {
 mod tests {
     use crate::{
         context::CompletionContext,
-        providers::complete_tables,
+        providers::complete_functions,
         test_helper::{get_test_deps, get_test_params, CURSOR_POS},
+        CompletionItem,
     };
 
     #[tokio::test]
     async fn completes_fn() {
         let setup = r#"
-          create or replace function cool() returns trigger
-          begin;
-            ## Yeahhhh
+          create or replace function cool() 
+          returns trigger
+          language plpgsql
+          security invoker
+          as $$
+          begin
+            raise exception 'dont matter';
           end;
+          $$;
         "#;
 
         let query = format!("select coo{}", CURSOR_POS);
@@ -50,6 +56,15 @@ mod tests {
         let params = get_test_params(&tree, &cache, &query);
         let ctx = CompletionContext::new(&params);
 
-        complete_tables(&ctx, &mut builder);
+        complete_functions(&ctx, &mut builder);
+
+        let results = builder.finish();
+
+        let CompletionItem { label, .. } = results
+            .into_iter()
+            .next()
+            .expect("Should return at least one completion item");
+
+        assert_eq!(label, "cool");
     }
 }

crates/pg_completions/src/providers/tables.rs

@@ -1,10 +1,8 @@
-use pg_schema_cache::Table;
-
 use crate::{
     builder::CompletionBuilder,
     context::CompletionContext,
     item::{CompletionItem, CompletionItemKind},
-    relevance::CompletionRelevance,
+    relevance::CompletionRelevanceData,
 };
 
 pub fn complete_tables(ctx: &CompletionContext, builder: &mut CompletionBuilder) {
@@ -14,9 +12,9 @@ pub fn complete_tables(ctx: &CompletionContext, builder: &mut CompletionBuilder)
         .iter()
         .map(|table| CompletionItem {
             label: table.name.clone(),
-            score: get_score(ctx, table),
+            score: CompletionRelevanceData::Table(table).get_score(ctx),
             description: format!("Schema: {}", table.schema),
-            preselected: None,
+            preselected: false,
             kind: CompletionItemKind::Table,
         })
         .collect();
@@ -25,13 +23,3 @@ pub fn complete_tables(ctx: &CompletionContext, builder: &mut CompletionBuilder)
         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/relevance.rs

@@ -1,23 +1,54 @@
 use crate::context::CompletionContext;
 
-#[derive(Debug, Default)]
-pub(crate) struct CompletionRelevance {
+#[derive(Debug)]
+pub(crate) enum CompletionRelevanceData<'a> {
+    Table(&'a pg_schema_cache::Table),
+    Function(&'a pg_schema_cache::Function),
+}
+
+impl<'a> CompletionRelevanceData<'a> {
+    pub fn get_score(self, ctx: &CompletionContext) -> i32 {
+        CompletionRelevance::from(self).into_score(ctx)
+    }
+}
+
+impl<'a> From<CompletionRelevanceData<'a>> for CompletionRelevance<'a> {
+    fn from(value: CompletionRelevanceData<'a>) -> Self {
+        Self {
+            score: 0,
+            data: value,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct CompletionRelevance<'a> {
     score: i32,
+    data: CompletionRelevanceData<'a>,
 }
 
-impl CompletionRelevance {
-    pub fn score(&self) -> i32 {
+impl<'a> CompletionRelevance<'a> {
+    pub fn into_score(mut self, ctx: &CompletionContext) -> i32 {
+        self.check_matches_schema(ctx);
+        self.check_matches_query_input(ctx);
+        self.check_if_catalog(ctx);
+
         self.score
     }
 
-    pub fn check_matches_query_input(&mut self, ctx: &CompletionContext, name: &str) {
+    fn check_matches_query_input(&mut self, ctx: &CompletionContext) {
         let node = ctx.ts_node.unwrap();
 
         let content = match ctx.get_ts_node_content(node) {
             Some(c) => c,
             None => return,
         };
 
+        let name = match self.data {
+            CompletionRelevanceData::Function(f) => f.name.as_str(),
+            CompletionRelevanceData::Table(t) => t.name.as_str(),
+        };
+
         if name.starts_with(content) {
             let len: i32 = content
                 .len()
@@ -28,21 +59,25 @@ impl CompletionRelevance {
         };
     }
 
-    pub fn check_matches_schema(&mut self, ctx: &CompletionContext, schema: &str) {
-        if ctx.schema_name.is_none() {
-            return;
-        }
+    fn check_matches_schema(&mut self, ctx: &CompletionContext) {
+        let schema_name = match ctx.schema_name.as_ref() {
+            None => return,
+            Some(n) => n,
+        };
 
-        let name = ctx.schema_name.as_ref().unwrap();
+        let data_schema = match self.data {
+            CompletionRelevanceData::Function(f) => f.schema.as_str(),
+            CompletionRelevanceData::Table(t) => t.schema.as_str(),
+        };
 
-        if name == schema {
+        if schema_name == data_schema {
             self.score += 25;
         } else {
             self.score -= 10;
         }
     }
 
-    pub fn check_if_catalog(&mut self, ctx: &CompletionContext) {
+    fn check_if_catalog(&mut self, ctx: &CompletionContext) {
         if ctx.schema_name.as_ref().is_some_and(|n| n == "pg_catalog") {
             return;
         }

crates/pg_type_resolver/src/functions.rs

@@ -51,11 +51,11 @@ fn function_matches(
     name: &str,
     arg_types: Vec<PossibleType>,
 ) -> bool {
-    if func.name.as_deref() != Some(name) {
+    if func.name != name {
         return false;
     }
 
-    if schema.is_some() && func.schema.as_deref() != schema {
+    if schema.is_some() && Some(func.schema.as_str()) != schema {
         return false;
     }