Add viewer support for database connections in Variables Pane (#1004)

dfalbel · claude · web-flow · commit 615e01c23d6d · 2026-01-26T14:33:05.000-03:00
* Fix S4 class inheritance in ark method dispatch For S4 objects, `class(object)` only returns the immediate class name, not the full inheritance hierarchy like S3 objects do. This meant that methods registered for a parent S4 class would not be found when dispatching on a subclass. Now `call_ark_method` uses `methods::extends()` for S4 objects to get the complete class hierarchy including superclasses. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * Add viewer support for database connections in Variables Pane Adds the ability to view database connections (starting with ODBC) from the Variables Pane. When a user clicks to view a connection variable, it opens in the Connections Pane. Changes: - Add `VariableIsConnection` and `VariableViewConnection` to ArkGenerics - Add `is_connection()` and `view_connection()` functions in variable.rs - Modify `has_viewer()` to return true for connection objects - Modify `view()` in r_variables.rs to handle connections - Add method table entries for the new generics in methods.R - Implement ODBC connection support using `odbc:::on_connection_opened()` with reconstructed connection code from the connection info The ODBC methods are registered via setHook when the odbc package loads. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * Return success status from view_connection methods The `ark_positron_variable_view_connection` method now returns TRUE on success and FALSE on failure, allowing callers to detect and report errors. Also removes redundant `inherits()` check in OdbcConnection handler since method dispatch already ensures the correct class. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * Send focus event when a connection is opened Adds `ps_connection_focus` to send a focus event to the frontend, allowing the Connections Pane to focus on a connection. The focus event is now sent automatically whenever `connectionOpened` is called, whether for a new connection or an existing one. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * relocate changes * Skip focus event in tests when RMain is not initialized Prevents panic in connection tests by checking if RMain is initialized before attempting to send the focus event. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * Add BigQuery connection support for Variables Pane Registers methods for `BigQueryConnection` class when the bigrquery package is loaded, enabling users to view BigQuery connections in the Connections Pane from the Variables Pane. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * Make variable viewer system generic Replace connection-specific methods with generic viewer methods: - Remove `ark_positron_variable_is_connection` and `view_connection` - Add generic `ark_positron_variable_view` for custom view actions - Extend `has_viewer` to dispatch for all objects, not just data frames Connection packages now register: - `kind` returning "connection" for proper icon display - `has_viewer` returning validity check - `view` for the actual view action This allows any package to implement custom viewers for their objects. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> * Address PR review comments on naming conventions - Remove `.ps.` prefix from internal helper functions that are not exported (`odbc_connection_code`, `bigrquery_connection_code`, `connection_focus`) - Rename `try_custom_view` to `try_dispatch_view` for consistency with the `try_dispatch()` pattern Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
diff --git a/crates/ark/src/connections/r_connection.rs b/crates/ark/src/connections/r_connection.rs
@@ -358,3 +358,22 @@ pub unsafe extern "C-unwind" fn ps_connection_updated(id: SEXP) -> Result<SEXP,
 
     Ok(R_NilValue)
 }
+
+#[harp::register]
+pub unsafe extern "C-unwind" fn ps_connection_focus(id: SEXP) -> Result<SEXP, anyhow::Error> {
+    if !RMain::is_initialized() {
+        return Ok(R_NilValue);
+    }
+
+    let main = RMain::get();
+    let comm_id: String = RObject::view(id).to::<String>()?;
+
+    let event = ConnectionsFrontendEvent::Focus;
+
+    main.get_comm_manager_tx().send(CommManagerEvent::Message(
+        comm_id,
+        CommMsg::Data(serde_json::to_value(event)?),
+    ))?;
+
+    Ok(R_NilValue)
+}
diff --git a/crates/ark/src/methods.rs b/crates/ark/src/methods.rs
@@ -45,6 +45,9 @@ pub enum ArkGenerics {
 
     #[strum(serialize = "ark_positron_help_get_handler")]
     HelpGetHandler,
+
+    #[strum(serialize = "ark_positron_variable_view")]
+    VariableView,
 }
 
 impl ArkGenerics {
diff --git a/crates/ark/src/modules/positron/connection.R b/crates/ark/src/modules/positron/connection.R
@@ -21,6 +21,10 @@
     .ps.Call("ps_connection_updated", id)
 }
 
+connection_focus <- function(id) {
+    .ps.Call("ps_connection_focus", id)
+}
+
 #' @export
 .ps.connection_observer <- function() {
     connections <- new.env(parent = emptyenv())
@@ -45,6 +49,7 @@
         for (id in ls(envir = connections)) {
             con <- get(id, envir = connections)
             if (identical(con$host, host) && identical(con$type, type)) {
+                connection_focus(id)
                 return(invisible(id))
             }
         }
@@ -67,6 +72,7 @@
             # until the end of the connection.
             objectTypes = connection_flatten_object_types(listObjectTypes())
         )
+        connection_focus(id)
         invisible(id)
     }
 
@@ -170,6 +176,36 @@ connection_flatten_object_types <- function(object_tree) {
     return(TRUE)
 }
 
+# Helper to reconstruct ODBC connection code from connection info
+odbc_connection_code <- function(info) {
+    # Try to reconstruct a reasonable connection string
+    # Priority: DSN > connection string parameters
+    if (!is.null(info$sourcename) && nzchar(info$sourcename)) {
+        # DSN-based connection
+        sprintf('odbc::dbConnect(odbc::odbc(), dsn = "%s")', info$sourcename)
+    } else {
+        # Build connection string from available parameters
+        params <- character()
+
+        if (!is.null(info$servername) && nzchar(info$servername)) {
+            params <- c(params, sprintf('server = "%s"', info$servername))
+        }
+        if (!is.null(info$dbname) && nzchar(info$dbname)) {
+            params <- c(params, sprintf('database = "%s"', info$dbname))
+        }
+
+        if (length(params) > 0) {
+            sprintf(
+                "odbc::dbConnect(odbc::odbc(), %s)",
+                paste(params, collapse = ", ")
+            )
+        } else {
+            # Fallback if we can't determine connection parameters
+            "# Connection opened from Variables Pane"
+        }
+    }
+}
+
 #' @export
 .ps.connection_icon <- function(id, ...) {
     con <- get(id, getOption("connectionObserver")$.connections)
@@ -283,6 +319,107 @@ connection_flatten_object_types <- function(object_tree) {
         actions = NULL
     )
 
-    if (is.null(id)) return("hello")
+    if (is.null(id)) {
+        return("hello")
+    }
     id
 }
+
+# ODBC Connection Support
+# These methods enable viewing ODBC connections in the Connections Pane
+# from the Variables Pane
+
+# Register ODBC connection methods when the odbc package is loaded
+setHook(
+    packageEvent("odbc", "onLoad"),
+    function(...) {
+        # Mark ODBC connections as "connection" kind
+        .ark.register_method(
+            "ark_positron_variable_kind",
+            "OdbcConnection",
+            function(x) "connection"
+        )
+
+        # Enable viewer for valid ODBC connections
+        .ark.register_method(
+            "ark_positron_variable_has_viewer",
+            "OdbcConnection",
+            function(x) {
+                odbc::dbIsValid(x)
+            }
+        )
+
+        # View an ODBC connection in the Connections Pane
+        .ark.register_method(
+            "ark_positron_variable_view",
+            "OdbcConnection",
+            function(x) {
+                # Reconstruct the connection code from the connection info
+                info <- x@info
+                code <- odbc_connection_code(info)
+
+                # Use odbc's built-in connection observer integration
+                odbc:::on_connection_opened(x, code = code)
+                invisible(TRUE)
+            }
+        )
+    }
+)
+
+# BigQuery Connection Support
+# These methods enable viewing BigQuery connections in the Connections Pane
+# from the Variables Pane
+
+# Register BigQuery connection methods when the bigrquery package is loaded
+setHook(
+    packageEvent("bigrquery", "onLoad"),
+    function(...) {
+        # Mark BigQuery connections as "connection" kind
+        .ark.register_method(
+            "ark_positron_variable_kind",
+            "BigQueryConnection",
+            function(x) "connection"
+        )
+
+        # Enable viewer for valid BigQuery connections
+        .ark.register_method(
+            "ark_positron_variable_has_viewer",
+            "BigQueryConnection",
+            function(x) {
+                DBI::dbIsValid(x)
+            }
+        )
+
+        # View a BigQuery connection in the Connections Pane
+        .ark.register_method(
+            "ark_positron_variable_view",
+            "BigQueryConnection",
+            function(x) {
+                # Reconstruct the connection code
+                code <- bigrquery_connection_code(x)
+
+                # Use bigrquery's built-in connection observer integration
+                bigrquery:::on_connection_opened(x, code = code)
+                invisible(TRUE)
+            }
+        )
+    }
+)
+
+# Helper to reconstruct BigQuery connection code
+bigrquery_connection_code <- function(con) {
+    project <- con@project
+    dataset <- con@dataset
+    billing <- con@billing
+
+    params <- c(sprintf('project = "%s"', project))
+
+    if (!is.null(dataset) && nzchar(dataset)) {
+        params <- c(params, sprintf('dataset = "%s"', dataset))
+    }
+    if (!is.null(billing) && nzchar(billing) && billing != project) {
+        params <- c(params, sprintf('billing = "%s"', billing))
+    }
+
+    sprintf("DBI::dbConnect(bigrquery::bigquery(), %s)", paste(params, collapse = ", "))
+}
diff --git a/crates/ark/src/modules/positron/methods.R b/crates/ark/src/modules/positron/methods.R
@@ -92,6 +92,16 @@ ark_methods_table$ark_positron_variable_get_children <- new.env(
 ark_methods_table$ark_positron_help_get_handler <- new.env(
     parent = emptyenv()
 )
+
+#' Custom view action for objects in Variables Pane
+#'
+#' @param x Object to view
+#' @param ... Additional arguments (unused)
+#' @return Logical value: TRUE on success, FALSE otherwise
+ark_methods_table$ark_positron_variable_view <- new.env(
+    parent = emptyenv()
+)
+
 lockEnvironment(ark_methods_table, TRUE)
 
 ark_methods_allowed_packages <- c("torch", "reticulate", "duckplyr")
@@ -169,7 +179,14 @@ call_ark_method <- function(generic, object, ...) {
         return(NULL)
     }
 
-    for (cls in class(object)) {
+    # Get all classes to check, including S4 superclasses
+    classes <- class(object)
+    if (isS4(object)) {
+        # For S4 objects, get the full inheritance hierarchy
+        classes <- methods::extends(class(object))
+    }
+
+    for (cls in classes) {
         if (!is.null(method <- get0(cls, envir = methods_table))) {
             return(eval(
                 as.call(list(method, object, ...)),
diff --git a/crates/ark/src/variables/r_variables.rs b/crates/ark/src/variables/r_variables.rs
@@ -45,6 +45,7 @@ use crate::data_explorer::summary_stats::summary_stats;
 use crate::lsp::events::EVENTS;
 use crate::r_task;
 use crate::thread::RThreadSafe;
+use crate::variables::variable::try_dispatch_view;
 use crate::variables::variable::PositronVariable;
 use crate::view::view;
 
@@ -381,6 +382,11 @@ impl RVariables {
             let env = self.env.get().clone();
             let obj = PositronVariable::resolve_data_object(env.clone(), &path)?;
 
+            // Try custom view method first (e.g., for connections)
+            if try_dispatch_view(obj.sexp).map_err(harp::Error::Anyhow)? {
+                return Ok(None);
+            }
+
             if r_is_function(obj.sexp) {
                 harp::as_result(view(&obj, &path, &env))?;
                 return Ok(None);
diff --git a/crates/ark/src/variables/variable.rs b/crates/ark/src/variables/variable.rs
@@ -594,11 +594,7 @@ fn has_viewer(value: SEXP) -> bool {
         return true;
     }
 
-    if !(r_is_data_frame(value) || r_is_matrix(value)) {
-        return false;
-    }
-
-    // We have a data.frame or matrix. Dispatch to the has_viewer method
+    // Dispatch to the has_viewer method for any object
     match ArkGenerics::VariableHasViewer.try_dispatch::<bool>(value, vec![]) {
         Err(err) => {
             log::error!(
@@ -608,10 +604,30 @@ fn has_viewer(value: SEXP) -> bool {
             // The viewer method exists, but failed
             false
         },
-        // A matching viewer method was not found
-        Ok(None) => true,
         // The viewer method was found, use its result
         Ok(Some(val)) => val,
+        // No method found, fall back to default logic for data frames/matrices
+        Ok(None) => r_is_data_frame(value) || r_is_matrix(value),
+    }
+}
+
+/// Try to view an object using a custom view method.
+/// This dispatches to the `ark_positron_variable_view` method.
+/// Returns Ok(true) if a custom view was handled, Ok(false) if no method found,
+/// or Err if the method failed.
+pub fn try_dispatch_view(value: SEXP) -> anyhow::Result<bool> {
+    match ArkGenerics::VariableView.try_dispatch::<bool>(value, vec![]) {
+        Err(err) => {
+            return Err(anyhow!("Error in custom view: {err}"));
+        },
+        Ok(None) => {
+            // No custom view method found
+            Ok(false)
+        },
+        Ok(Some(false)) => {
+            return Err(anyhow!("Custom view method failed"));
+        },
+        Ok(Some(true)) => Ok(true),
     }
 }
 
@@ -1780,9 +1796,8 @@ mod tests {
 
             assert_eq!(variable.kind, VariableKind::Other);
 
-            // Even though the viewer method returns TRUE, the object is not a data.frame
-            // or matrix, so it doesn't have a viewer.
-            assert_eq!(variable.has_viewer, false);
+            // The has_viewer method returns TRUE, so the object has a viewer
+            assert_eq!(variable.has_viewer, true);
 
             // Now inspect `x`
             let path = vec![String::from("x")];

Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,9 @@ pub enum ArkGenerics {`
`45`	`45`
`46`	`46`	`#[strum(serialize = "ark_positron_help_get_handler")]`
`47`	`47`	`HelpGetHandler,`
	`48`	`+`
	`49`	`+ #[strum(serialize = "ark_positron_variable_view")]`
	`50`	`+ VariableView,`
`48`	`51`	`}`
`49`	`52`
`50`	`53`	`impl ArkGenerics {`