revert logic to whitelist

Author: juleswritescode

crates/pgt_completions/src/context.rs

@@ -18,6 +18,7 @@ pub enum WrappingClause<'a> {
     },
     Update,
     Delete,
+    ColumnDefinitions,
 }
 
 #[derive(PartialEq, Eq, Debug)]
@@ -76,6 +77,7 @@ impl TryFrom<String> for WrappingNode {
     }
 }
 
+#[derive(Debug)]
 pub(crate) struct CompletionContext<'a> {
     pub node_under_cursor: Option<tree_sitter::Node<'a>>,
 
@@ -140,6 +142,13 @@ impl<'a> CompletionContext<'a> {
         ctx.gather_tree_context();
         ctx.gather_info_from_ts_queries();
 
+        if cfg!(test) {
+            println!("{:#?}", ctx.wrapping_clause_type);
+            println!("{:#?}", ctx.wrapping_node_kind);
+            println!("{:#?}", ctx.is_in_error_node);
+            println!("{:#?}", ctx.text);
+        }
+
         ctx
     }
 
@@ -303,7 +312,7 @@ impl<'a> CompletionContext<'a> {
                 }
             }
 
-            "where" | "update" | "select" | "delete" | "from" | "join" => {
+            "where" | "update" | "select" | "delete" | "from" | "join" | "column_definitions" => {
                 self.wrapping_clause_type =
                     self.get_wrapping_clause_from_current_node(current_node, &mut cursor);
             }
@@ -367,6 +376,7 @@ impl<'a> CompletionContext<'a> {
             "select" => Some(WrappingClause::Select),
             "delete" => Some(WrappingClause::Delete),
             "from" => Some(WrappingClause::From),
+            "column_definitions" => Some(WrappingClause::ColumnDefinitions),
             "join" => {
                 // sadly, we need to manually iterate over the children –
                 // `node.child_by_field_id(..)` does not work as expected

crates/pgt_completions/src/relevance/filtering.rs

@@ -24,6 +24,13 @@ impl CompletionFilter<'_> {
     }
 
     fn completable_context(&self, ctx: &CompletionContext) -> Option<()> {
+        if ctx.wrapping_node_kind.is_none()
+            && ctx.wrapping_clause_type.is_none()
+            && ctx.is_in_error_node
+        {
+            return None;
+        }
+
         let current_node_kind = ctx.node_under_cursor.map(|n| n.kind()).unwrap_or("");
 
         if current_node_kind.starts_with("keyword_")
@@ -58,44 +65,53 @@ impl CompletionFilter<'_> {
     }
 
     fn check_clause(&self, ctx: &CompletionContext) -> Option<()> {
-        let clause = ctx.wrapping_clause_type.as_ref();
-
-        match self.data {
-            CompletionRelevanceData::Table(_) => {
-                let in_select_clause = clause.is_some_and(|c| c == &WrappingClause::Select);
-                let in_where_clause = clause.is_some_and(|c| c == &WrappingClause::Where);
-
-                if in_select_clause || in_where_clause {
-                    return None;
-                };
-            }
-            CompletionRelevanceData::Column(_) => {
-                let in_from_clause = clause.is_some_and(|c| c == &WrappingClause::From);
-                if in_from_clause {
-                    return None;
-                }
-
-                // We can complete columns in JOIN cluases, but only if we are after the
-                // ON node in the "ON u.id = posts.user_id" part.
-                let in_join_clause_before_on_node = clause.is_some_and(|c| match c {
-                    // we are in a JOIN, but definitely not after an ON
-                    WrappingClause::Join { on_node: None } => true,
-
-                    WrappingClause::Join { on_node: Some(on) } => ctx
-                        .node_under_cursor
-                        .is_some_and(|n| n.end_byte() < on.start_byte()),
-
-                    _ => false,
-                });
-
-                if in_join_clause_before_on_node {
-                    return None;
+        ctx.wrapping_clause_type
+            .as_ref()
+            .map(|clause| {
+                match self.data {
+                    CompletionRelevanceData::Table(_) => match clause {
+                        WrappingClause::Select
+                        | WrappingClause::Where
+                        | WrappingClause::ColumnDefinitions => false,
+                        _ => true,
+                    },
+                    CompletionRelevanceData::Column(_) => {
+                        match clause {
+                            WrappingClause::From | WrappingClause::ColumnDefinitions => false,
+
+                            // We can complete columns in JOIN cluases, but only if we are after the
+                            // ON node in the "ON u.id = posts.user_id" part.
+                            WrappingClause::Join { on_node: Some(on) } => ctx
+                                .node_under_cursor
+                                .is_some_and(|cn| cn.start_byte() >= on.end_byte()),
+
+                            // we are in a JOIN, but definitely not after an ON
+                            WrappingClause::Join { on_node: None } => false,
+
+                            _ => true,
+                        }
+                    }
+                    CompletionRelevanceData::Function(_) => match clause {
+                        WrappingClause::From
+                        | WrappingClause::Select
+                        | WrappingClause::Where
+                        | WrappingClause::Join { .. } => true,
+
+                        _ => false,
+                    },
+                    CompletionRelevanceData::Schema(_) => match clause {
+                        WrappingClause::Select
+                        | WrappingClause::Where
+                        | WrappingClause::From
+                        | WrappingClause::Join { .. }
+                        | WrappingClause::Update
+                        | WrappingClause::Delete => true,
+
+                        WrappingClause::ColumnDefinitions => false,
+                    },
                 }
-            }
-            _ => {}
-        }
-
-        Some(())
+            })
+            .and_then(|is_ok| if is_ok { Some(()) } else { None })
     }
 
     fn check_invocation(&self, ctx: &CompletionContext) -> Option<()> {
@@ -170,4 +186,15 @@ mod tests {
         )
         .await;
     }
+
+    #[tokio::test]
+    async fn completion_after_create_table() {
+        assert_no_complete_results(format!("create table {}", CURSOR_POS).as_str(), "").await;
+    }
+
+    #[tokio::test]
+    async fn completion_in_column_definitions() {
+        let query = format!(r#"create table instruments ( {} )"#, CURSOR_POS);
+        assert_no_complete_results(query.as_str(), "").await;
+    }
 }

crates/pgt_completions/src/test_helper.rs

@@ -244,6 +244,8 @@ pub(crate) async fn assert_complete_results(
 pub(crate) async fn assert_no_complete_results(query: &str, setup: &str) {
     let (tree, cache) = get_test_deps(setup, query.into()).await;
     let params = get_test_params(&tree, &cache, query.into());
+    println!("{:#?}", params.position);
+    println!("{:#?}", params.text);
     let items = complete(params);
 
     assert_eq!(items.len(), 0)