impl From<Scratch> for PR

Author: juleswritescode

crates/pg_completions/src/builder.rs

@@ -1,19 +1,19 @@
-use crate::{CompletionItem, CompletionResult};
+use crate::{item::CompletionItem, CompletionResult};
 
-pub struct CompletionBuilder<'a> {
-    pub items: Vec<CompletionItem<'a>>,
+pub struct CompletionBuilder {
+    pub items: Vec<CompletionItem>,
 }
 
 pub struct CompletionConfig {}
 
-impl<'a> From<&'a CompletionConfig> for CompletionBuilder<'a> {
+impl From<&CompletionConfig> for CompletionBuilder {
     fn from(_config: &CompletionConfig) -> Self {
         Self { items: Vec::new() }
     }
 }
 
-impl<'a> CompletionBuilder<'a> {
-    pub fn finish(mut self) -> CompletionResult<'a> {
+impl CompletionBuilder {
+    pub fn finish(mut self) -> CompletionResult {
         self.items.sort_by(|a, b| {
             b.preselect
                 .cmp(&a.preselect)

crates/pg_completions/src/complete.rs

@@ -0,0 +1,128 @@
+use text_size::TextSize;
+
+use crate::{builder, context::CompletionContext, item::CompletionItem};
+
+pub const LIMIT: usize = 50;
+
+#[derive(Debug)]
+pub struct CompletionParams<'a> {
+    pub position: TextSize,
+    pub schema: &'a pg_schema_cache::SchemaCache,
+    pub text: &'a str,
+    pub tree: Option<&'a tree_sitter::Tree>,
+}
+
+#[derive(Debug, Default)]
+pub struct CompletionResult {
+    pub items: Vec<CompletionItem>,
+}
+
+pub fn complete(params: &CompletionParams) -> CompletionResult {
+    let ctx = CompletionContext::new(params);
+    let mut builder = builder::CompletionBuilder::from(&builder::CompletionConfig {});
+
+    builder.finish()
+}
+
+#[cfg(test)]
+mod tests {
+    use pg_schema_cache::SchemaCache;
+    use pg_test_utils::test_database::*;
+
+    use sqlx::Executor;
+
+    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);
+
+        assert!(result.items.len() > 0);
+    }
+
+    #[tokio::test]
+    async fn test_complete_two() {
+        let pool = get_new_test_db().await;
+
+        let input = "select id, name, test1231234123, unknown from co;";
+
+        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: 47.into(),
+            schema: &schema_cache,
+            text: input,
+            tree: Some(&tree),
+        };
+
+        let result = complete(&p);
+
+        assert!(result.items.len() > 0);
+    }
+
+    #[tokio::test]
+    async fn test_complete_three() {
+        let test_db = get_new_test_db().await;
+
+        let setup = r#"
+            create table users (
+                id serial primary key,
+                name text,
+                password text
+            );
+        "#;
+
+        test_db
+            .execute(setup)
+            .await
+            .expect("Failed to execute setup query");
+
+        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(&test_db).await;
+
+        let p = CompletionParams {
+            position: ((input.len() - 1) as u32).into(),
+            schema: &schema_cache,
+            text: input,
+            tree: Some(&tree),
+        };
+
+        let result = complete(&p);
+
+        // TODO: actually assert that we get good autocompletion suggestions
+        assert!(result.items.len() > 0);
+    }
+}

crates/pg_completions/src/context.rs

@@ -0,0 +1,9 @@
+use crate::CompletionParams;
+
+pub struct CompletionContext {}
+
+impl CompletionContext {
+    pub fn new(params: &CompletionParams) -> Self {
+        todo!()
+    }
+}

crates/pg_completions/src/item.rs

@@ -0,0 +1,33 @@
+use text_size::TextRange;
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum CompletionItemData {
+    Table(pg_schema_cache::Table),
+}
+
+impl CompletionItemData {
+    pub fn label(&self) -> &str {
+        match self {
+            CompletionItemData::Table(t) => t.name.as_str(),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct CompletionItem {
+    pub score: i32,
+    pub range: TextRange,
+    pub preselect: bool,
+    pub data: CompletionItemData,
+}
+
+impl CompletionItem {
+    pub fn new_simple(score: i32, range: TextRange, data: CompletionItemData) -> Self {
+        Self {
+            score,
+            range,
+            preselect: false,
+            data,
+        }
+    }
+}

crates/pg_completions/src/lib.rs

@@ -1,165 +1,7 @@
 mod builder;
-mod providers;
+mod complete;
+mod context;
+mod item;
+mod relevance;
 
-pub use providers::CompletionProviderParams;
-use text_size::{TextRange, TextSize};
-
-pub const LIMIT: usize = 50;
-
-#[derive(Debug)]
-pub struct CompletionParams<'a> {
-    pub position: TextSize,
-    pub schema: &'a pg_schema_cache::SchemaCache,
-    pub text: &'a str,
-    pub tree: Option<&'a tree_sitter::Tree>,
-}
-
-#[derive(Debug, Default)]
-pub struct CompletionResult<'a> {
-    pub items: Vec<CompletionItem<'a>>,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct CompletionItem<'a> {
-    pub score: i32,
-    pub range: TextRange,
-    pub preselect: bool,
-    pub data: CompletionItemData<'a>,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum CompletionItemData<'a> {
-    Table(&'a pg_schema_cache::Table),
-}
-
-impl<'a> CompletionItemData<'a> {
-    pub fn label(&self) -> &'a str {
-        match self {
-            CompletionItemData::Table(t) => t.name.as_str(),
-        }
-    }
-}
-
-impl<'a> CompletionItem<'a> {
-    pub fn new_simple(score: i32, range: TextRange, data: CompletionItemData<'a>) -> Self {
-        Self {
-            score,
-            range,
-            preselect: false,
-            data,
-        }
-    }
-}
-
-pub fn complete<'a>(params: &'a CompletionParams<'a>) -> CompletionResult<'a> {
-    let mut builder = builder::CompletionBuilder::from(&builder::CompletionConfig {});
-
-    let params = CompletionProviderParams::from(params);
-
-    providers::complete_tables(params, &mut builder);
-
-    builder.finish()
-}
-
-#[cfg(test)]
-mod tests {
-    use pg_schema_cache::SchemaCache;
-    use pg_test_utils::test_database::*;
-
-    use sqlx::Executor;
-
-    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);
-
-        assert!(result.items.len() > 0);
-    }
-
-    #[tokio::test]
-    async fn test_complete_two() {
-        let pool = get_new_test_db().await;
-
-        let input = "select id, name, test1231234123, unknown from co;";
-
-        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: 47.into(),
-            schema: &schema_cache,
-            text: input,
-            tree: Some(&tree),
-        };
-
-        let result = complete(&p);
-
-        assert!(result.items.len() > 0);
-    }
-
-    #[tokio::test]
-    async fn test_complete_three() {
-        let test_db = get_new_test_db().await;
-
-        let setup = r#"
-            create table users (
-                id serial primary key,
-                name text,
-                password text
-            );
-        "#;
-
-        test_db
-            .execute(setup)
-            .await
-            .expect("Failed to execute setup query");
-
-        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(&test_db).await;
-
-        let p = CompletionParams {
-            position: ((input.len() - 1) as u32).into(),
-            schema: &schema_cache,
-            text: input,
-            tree: Some(&tree),
-        };
-
-        let result = complete(&p);
-
-        // TODO: actually assert that we get good autocompletion suggestions
-        assert!(result.items.len() > 0);
-    }
-}
+pub use complete::*;