Add the has_viewer method (#773)

Co-authored-by: Copilot <[email protected]>
Co-authored-by: Davis Vaughan <[email protected]>

Author: 3 people

crates/ark/src/methods.rs

@@ -39,6 +39,9 @@ pub enum ArkGenerics {
 
     #[strum(serialize = "ark_positron_variable_get_children")]
     VariableGetChildren,
+
+    #[strum(serialize = "ark_positron_variable_has_viewer")]
+    VariableHasViewer,
 }
 
 impl ArkGenerics {

crates/ark/src/modules/positron/methods.R

@@ -22,6 +22,9 @@ ark_methods_table$ark_positron_variable_get_child_at <- new.env(
 ark_methods_table$ark_positron_variable_get_children <- new.env(
     parent = emptyenv()
 )
+ark_methods_table$ark_positron_variable_has_viewer <- new.env(
+    parent = emptyenv()
+)
 lockEnvironment(ark_methods_table, TRUE)
 
 ark_methods_allowed_packages <- c("torch", "reticulate", "duckplyr")

crates/ark/src/variables/variable.rs

@@ -588,6 +588,28 @@ fn has_children(value: SEXP) -> bool {
     }
 }
 
+fn has_viewer(value: SEXP) -> bool {
+    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
+    match ArkGenerics::VariableHasViewer.try_dispatch::<bool>(value, vec![]) {
+        Err(err) => {
+            log::error!(
+                "Error from '{}' method: {err}",
+                ArkGenerics::VariableHasViewer.to_string()
+            );
+            // 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,
+    }
+}
+
 enum EnvironmentVariableNode {
     Concrete { object: RObject },
     R6Node { object: RObject, name: String },
@@ -653,7 +675,7 @@ impl PositronVariable {
                 size: 0, // It's up to the caller to set the size.
                 has_children: has_children(x),
                 is_truncated,
-                has_viewer: r_is_data_frame(x) || r_is_matrix(x),
+                has_viewer: has_viewer(x),
                 updated_time: Self::update_timestamp(),
             },
         }
@@ -1681,6 +1703,10 @@ mod tests {
                     "other"
                 })
 
+                .ark.register_method("ark_positron_variable_has_viewer", "foo", function(x) {
+                    TRUE
+                })
+
                 .ark.register_method("ark_positron_variable_get_children", "foo", function(x) {
                     children <- list(
                         "hello" = list(a = 1, b = 2),
@@ -1741,6 +1767,10 @@ 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);
+
             // Now inspect `x`
             let path = vec![String::from("x")];
             let variables = PositronVariable::inspect(env.clone(), &path).unwrap();
@@ -1766,6 +1796,7 @@ mod tests {
                 .ark.unregister_method("ark_positron_variable_display_value", "foo")
                 .ark.unregister_method("ark_positron_variable_display_type", "foo")
                 .ark.unregister_method("ark_positron_variable_has_children", "foo")
+                .ark.unregister_method("ark_positron_variable_has_viewer", "foo")
                 .ark.unregister_method("ark_positron_variable_kind", "foo")
                 .ark.unregister_method("ark_positron_variable_get_children", "foo")
                 .ark.unregister_method("ark_positron_variable_get_child_at", "foo")
@@ -1775,6 +1806,52 @@ mod tests {
         })
     }
 
+    #[test]
+    fn test_has_viewer_data_frame_subclass() {
+        r_task(|| {
+            // Create an object with that class in an env.
+            let env = harp::parse_eval_base(
+                r#"
+            local({
+                env <- new.env(parent = emptyenv())
+                env$x <- structure(data.frame(x = 1, y = 2), class = c("foo", "data.frame"))
+                env
+            })
+            "#,
+            )
+            .unwrap();
+
+            let has_viewer = || {
+                let path = vec![];
+                let variables = PositronVariable::inspect(env.clone(), &path).unwrap();
+
+                assert_eq!(variables.len(), 1);
+                let variable = variables[0].clone();
+                variable.has_viewer
+            };
+
+            assert!(has_viewer());
+
+            harp::parse_eval_global(
+                r#"
+                .ark.register_method("ark_positron_variable_has_viewer", "foo", function(x) {
+                    FALSE
+                })
+                "#,
+            )
+            .unwrap();
+
+            assert!(!has_viewer());
+
+            harp::parse_eval_global(
+                r#"
+                .ark.unregister_method("ark_positron_variable_has_viewer", "foo")
+                "#,
+            )
+            .unwrap();
+        })
+    }
+
     #[test]
     fn test_inspect_r6() {
         r_task(|| {

doc/variables-pane-extending.md

@@ -26,14 +26,15 @@ You can also register a method outside an R package using `.ps.register_ark_meth
 
 ## Available Methods
 
-Ark currently supports six methods with the following signatures:
+Ark currently supports seven methods with the following signatures:
 
 - `ark_positron_variable_display_value(x, ..., width = getOption("width"))`
 - `ark_positron_variable_display_type(x, ..., include_length = TRUE)`
 - `ark_positron_variable_kind(x, ...)`
 - `ark_positron_variable_has_children(x, ...)`
 - `ark_positron_variable_get_children(x, ...)`
 - `ark_positron_variable_get_child_at(x, ..., index, name)`
+- `ark_positron_variable_has_viewer(x, ...)`
 
 ### Customizing Display Value
 
@@ -77,6 +78,23 @@ ark_positron_variable_kind.foo <- function(x, ...) {
 }
 ```
 
+### Disabling the Viewer action
+
+The `ark_positron_variable_has_viewer` can be used to disable the `View` actions for `data.frame` and `matrix`
+objects that don't support it. This method is only called for such objects, other objects are not supported
+by Positron yet.
+
+Example:
+
+```r
+#' @param x Object to check for Viewer support
+ark_positron_variable_has_viewer.foo <- function(x, ...) {
+    # The viewer will not be enabled for `foo` objects.
+    # This is only called if `foo` is a subclass of a data.frame or matrix.
+    FALSE
+}
+```
+
 ## Inspecting Objects
 
 Package authors can also implement methods that allow users to inspect R objects, similar to how the `str()` function works in R. This enables displaying object structures in the variables pane.