k

Author: juleswritescode

crates/pgls_hover/src/hoverables/table.rs

@@ -68,6 +68,20 @@ impl ToHoverMarkdown for Table {
                 write!(writer, "typeid:{}", column.type_id)?;
             }
 
+            if column.is_nullable {
+                write!(writer, " - nullable")?;
+            } else {
+                write!(writer, " - not null")?;
+            }
+
+            if let Some(default_expr) = column
+                .default_expr
+                .as_deref()
+                .and_then(extract_basic_default_literal)
+            {
+                write!(writer, " - default: {default_expr}")?;
+            }
+
             writeln!(writer)?;
         }
 
@@ -99,6 +113,258 @@ impl ToHoverMarkdown for Table {
     }
 }
 
+fn extract_basic_default_literal(default_expr: &str) -> Option<String> {
+    let mut candidate = default_expr.trim();
+
+    loop {
+        let mut changed = false;
+
+        if let Some(unwrapped) = strip_outer_parentheses(candidate) {
+            candidate = unwrapped.trim();
+            changed = true;
+        }
+
+        if let Some(without_cast) = strip_trailing_top_level_casts(candidate) {
+            candidate = without_cast.trim();
+            changed = true;
+        }
+
+        if !changed {
+            break;
+        }
+    }
+
+    if is_basic_literal(candidate) {
+        Some(candidate.to_string())
+    } else {
+        None
+    }
+}
+
+fn strip_outer_parentheses(value: &str) -> Option<&str> {
+    let value = value.trim();
+
+    if !value.starts_with('(') || !value.ends_with(')') {
+        return None;
+    }
+
+    let mut depth = 0_i32;
+    let mut in_single_quote = false;
+    let mut in_double_quote = false;
+    let bytes = value.as_bytes();
+    let mut idx = 0_usize;
+
+    while idx < bytes.len() {
+        let ch = bytes[idx] as char;
+
+        if in_single_quote {
+            if ch == '\'' {
+                if idx + 1 < bytes.len() && bytes[idx + 1] as char == '\'' {
+                    idx += 2;
+                    continue;
+                }
+
+                in_single_quote = false;
+            }
+
+            idx += 1;
+            continue;
+        }
+
+        if in_double_quote {
+            if ch == '"' {
+                in_double_quote = false;
+            }
+
+            idx += 1;
+            continue;
+        }
+
+        match ch {
+            '\'' => in_single_quote = true,
+            '"' => in_double_quote = true,
+            '(' => depth += 1,
+            ')' => {
+                depth -= 1;
+                if depth == 0 && idx != bytes.len() - 1 {
+                    return None;
+                }
+            }
+            _ => {}
+        }
+
+        idx += 1;
+    }
+
+    if depth != 0 || in_single_quote || in_double_quote {
+        return None;
+    }
+
+    Some(&value[1..value.len() - 1])
+}
+
+fn strip_trailing_top_level_casts(value: &str) -> Option<&str> {
+    let bytes = value.as_bytes();
+    let mut depth = 0_i32;
+    let mut in_single_quote = false;
+    let mut in_double_quote = false;
+    let mut idx = 0_usize;
+
+    while idx + 1 < bytes.len() {
+        let ch = bytes[idx] as char;
+
+        if in_single_quote {
+            if ch == '\'' {
+                if idx + 1 < bytes.len() && bytes[idx + 1] as char == '\'' {
+                    idx += 2;
+                    continue;
+                }
+                in_single_quote = false;
+            }
+            idx += 1;
+            continue;
+        }
+
+        if in_double_quote {
+            if ch == '"' {
+                in_double_quote = false;
+            }
+            idx += 1;
+            continue;
+        }
+
+        match ch {
+            '\'' => {
+                in_single_quote = true;
+                idx += 1;
+                continue;
+            }
+            '"' => {
+                in_double_quote = true;
+                idx += 1;
+                continue;
+            }
+            '(' => {
+                depth += 1;
+                idx += 1;
+                continue;
+            }
+            ')' => {
+                depth -= 1;
+                idx += 1;
+                continue;
+            }
+            ':' if depth == 0 && bytes[idx + 1] as char == ':' => {
+                let suffix = &value[idx..];
+                if suffix
+                    .chars()
+                    .all(|c| c.is_ascii_alphanumeric() || ":_\".()[] ,\t".contains(c))
+                {
+                    return Some(value[..idx].trim_end());
+                }
+                return None;
+            }
+            _ => {
+                idx += 1;
+                continue;
+            }
+        }
+    }
+
+    None
+}
+
+fn is_basic_literal(value: &str) -> bool {
+    let value = value.trim();
+
+    if value.eq_ignore_ascii_case("true")
+        || value.eq_ignore_ascii_case("false")
+        || value.eq_ignore_ascii_case("null")
+    {
+        return true;
+    }
+
+    is_numeric_literal(value) || is_single_quoted_literal(value)
+}
+
+fn is_single_quoted_literal(value: &str) -> bool {
+    let bytes = value.as_bytes();
+
+    if bytes.len() < 2 || bytes.first() != Some(&b'\'') || bytes.last() != Some(&b'\'') {
+        return false;
+    }
+
+    let mut idx = 1_usize;
+    let end = bytes.len() - 1;
+
+    while idx < end {
+        if bytes[idx] == b'\'' {
+            if idx + 1 < end && bytes[idx + 1] == b'\'' {
+                idx += 2;
+            } else {
+                return false;
+            }
+        } else {
+            idx += 1;
+        }
+    }
+
+    true
+}
+
+fn is_numeric_literal(value: &str) -> bool {
+    let bytes = value.as_bytes();
+    if bytes.is_empty() {
+        return false;
+    }
+
+    let mut idx = 0_usize;
+
+    if matches!(bytes[idx], b'+' | b'-') {
+        idx += 1;
+        if idx >= bytes.len() {
+            return false;
+        }
+    }
+
+    let integer_start = idx;
+    while idx < bytes.len() && bytes[idx].is_ascii_digit() {
+        idx += 1;
+    }
+    let has_integer_digits = idx > integer_start;
+
+    if idx < bytes.len() && bytes[idx] == b'.' {
+        idx += 1;
+        let fractional_start = idx;
+        while idx < bytes.len() && bytes[idx].is_ascii_digit() {
+            idx += 1;
+        }
+        if !has_integer_digits && idx == fractional_start {
+            return false;
+        }
+    } else if !has_integer_digits {
+        return false;
+    }
+
+    if idx < bytes.len() && matches!(bytes[idx], b'e' | b'E') {
+        idx += 1;
+        if idx < bytes.len() && matches!(bytes[idx], b'+' | b'-') {
+            idx += 1;
+        }
+
+        let exponent_start = idx;
+        while idx < bytes.len() && bytes[idx].is_ascii_digit() {
+            idx += 1;
+        }
+
+        if idx == exponent_start {
+            return false;
+        }
+    }
+
+    idx == bytes.len()
+}
+
 impl ContextualPriority for Table {
     fn relevance_score(&self, ctx: &TreesitterContext) -> f32 {
         let mut score = 0.0;
@@ -127,3 +393,38 @@ impl ContextualPriority for Table {
         score
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::extract_basic_default_literal;
+
+    #[test]
+    fn extracts_basic_defaults_with_optional_casts() {
+        assert_eq!(
+            extract_basic_default_literal("'anonymous'::text"),
+            Some("'anonymous'".to_string())
+        );
+        assert_eq!(extract_basic_default_literal("(42)::int8"), Some("42".to_string()));
+        assert_eq!(
+            extract_basic_default_literal("NULL::character varying"),
+            Some("NULL".to_string())
+        );
+        assert_eq!(
+            extract_basic_default_literal("false::boolean"),
+            Some("false".to_string())
+        );
+    }
+
+    #[test]
+    fn ignores_non_basic_defaults() {
+        assert_eq!(
+            extract_basic_default_literal("nextval('users_id_seq'::regclass)"),
+            None
+        );
+        assert_eq!(extract_basic_default_literal("now()"), None);
+        assert_eq!(
+            extract_basic_default_literal("'a'::text || 'b'::text"),
+            None
+        );
+    }
+}

crates/pgls_hover/tests/hover_integration_tests.rs

@@ -217,6 +217,32 @@ async fn test_table_hover_select_star(test_db: PgPool) {
     test_hover_at_cursor("table_hover_select_star", query, Some(setup), &test_db).await;
 }
 
+#[sqlx::test(migrator = "pgls_test_utils::MIGRATIONS")]
+async fn test_table_hover_shows_nullable_and_basic_defaults(test_db: PgPool) {
+    let setup = r#"
+        create table users (
+            id serial primary key,
+            name text default 'anonymous',
+            score int default 0,
+            enabled bool default false,
+            created_at timestamptz default now()
+        );
+    "#;
+
+    let query = format!(
+        "select * from use{}rs",
+        QueryWithCursorPosition::cursor_marker()
+    );
+
+    test_hover_at_cursor(
+        "table_hover_nullable_and_basic_defaults",
+        query,
+        Some(setup),
+        &test_db,
+    )
+    .await;
+}
+
 #[sqlx::test(migrator = "pgls_test_utils::MIGRATIONS")]
 async fn test_no_hover_on_keyword(test_db: PgPool) {
     let setup = r#"

crates/pgls_hover/tests/snapshots/create_policy.snap

@@ -12,8 +12,8 @@ create policy "my cool pol" on users for all to public with check (true);
 ### `public.users` - 🔓 RLS disabled  
 ```plain  
 Columns:
-- id: int4
-- name: text
+- id: int4 - not null
+- name: text - nullable
   
 ```  
 ---    

crates/pgls_hover/tests/snapshots/grant_select.snap

@@ -12,8 +12,8 @@ grant select on users to public;
 ### `public.users` - 🔓 RLS disabled  
 ```plain  
 Columns:
-- id: int4
-- name: text
+- id: int4 - not null
+- name: text - nullable
   
 ```  
 ---    

crates/pgls_hover/tests/snapshots/revoke_select.snap

@@ -12,8 +12,8 @@ revoke select on users from public;
 ### `public.users` - 🔓 RLS disabled  
 ```plain  
 Columns:
-- id: int4
-- name: text
+- id: int4 - not null
+- name: text - nullable
   
 ```  
 ---    

crates/pgls_hover/tests/snapshots/table_hover.snap

@@ -12,8 +12,8 @@ select id from users
 ### `public.users` - 🔓 RLS disabled  
 ```plain  
 Columns:
-- id: int4
-- email: varchar(255)
+- id: int4 - not null
+- email: varchar(255) - not null
   
 ```  
 ---