db_repl behaviour changes (#95)

* Changed REPL behaviour to handle multi-line expressions in R.
Removed RStudio addins as they don't work properly and are no longer required with mulit-line expression support.

* Updating NEWS.md

---------

Co-authored-by: Zac Davies <[email protected]>

Author: zacdav-db

NEWS.md

@@ -1,3 +1,9 @@
+# brickster 0.2.8
+
+* Adjusted `db_repl` to handle mulit-line expressions (R only)
+* Removed RStudio Addins to send lines/selection/files to console
+* Moved arrow to Suggests
+
 # brickster 0.2.7
 
 * Exporting UC table functions (`db_uc_table*`) (#72)

R/remote-repl.R

@@ -28,15 +28,18 @@ db_context_manager <- R6::R6Class(
   ),
 
   public = list(
-
     #' @description Create a new context manager object.
     #' @param cluster_id The ID of the cluster to execute command on.
     #' @param language One of `r`, `py`, `scala`, `sql`, or `sh`.
     #' @param host Databricks workspace URL, defaults to calling [db_host()].
     #' @param token Databricks workspace token, defaults to calling [db_token()].
     #' @return A new `databricks_context_manager` object.
-    initialize = function(cluster_id, language = c("r", "py", "scala", "sql", "sh"),
-                          host = db_host(), token = db_token()) {
+    initialize = function(
+      cluster_id,
+      language = c("r", "py", "scala", "sql", "sh"),
+      host = db_host(),
+      token = db_token()
+    ) {
       language <- match.arg(language)
       private$cluster_id <- cluster_id
       private$host <- host
@@ -52,7 +55,7 @@ db_context_manager <- R6::R6Class(
       )
       ctx <- db_context_create(
         cluster_id = private$cluster_id,
-        language   = language,
+        language = language,
         host = host,
         token = token
       )
@@ -75,7 +78,7 @@ db_context_manager <- R6::R6Class(
     #' @param cmd code to execute against Databricks cluster
     #' @param language One of `r`, `py`, `scala`, `sql`, or `sh`.
     #' @return Command results
-    cmd_run =  function(cmd, language = c("r", "py", "scala", "sql", "sh")) {
+    cmd_run = function(cmd, language = c("r", "py", "scala", "sql", "sh")) {
       language <- match.arg(language)
       code = paste(cmd, collapse = "\n")
 
@@ -95,16 +98,11 @@ db_context_manager <- R6::R6Class(
       )
 
       cmd
-
     }
   )
 )
 # nocov end
 
-
-
-
-
 repl_prompt <- function(language) {
   glue::glue("[Databricks][{lang(language)}]> ")
 }
@@ -123,10 +121,13 @@ repl_prompt <- function(language) {
 #' @inheritParams auth_params
 #'
 #' @export
-db_repl <- function(cluster_id, language = c("r", "py", "scala", "sql", "sh"),
-                    host = db_host(), token = db_token()) {
-
-  if(!interactive()) {
+db_repl <- function(
+  cluster_id,
+  language = c("r", "py", "scala", "sql", "sh"),
+  host = db_host(),
+  token = db_token()
+) {
+  if (!interactive()) {
     cli::cli_abort("{.fn db_repl} can only be called in an interactive context")
   }
 
@@ -140,18 +141,64 @@ db_repl <- function(cluster_id, language = c("r", "py", "scala", "sql", "sh"),
   on.exit(manager$close())
   prompt <- repl_prompt(language)
 
-  while (TRUE) {
-    cmd <- readline(prompt)
-    # change language when command is `:{language}` (e.g. :py)
-    if (cmd %in% c(":r", ":py", ":scala", ":sql", ":sh")) {
-      new_lang <- substr(cmd, 2, 99)
-      language <- new_lang
-      prompt <- repl_prompt(language)
-    } else if (cmd != "") {
-      result <- manager$cmd_run(cmd, language)
-      clean_result <- trimws(result)
-      if (length(clean_result) > 0 && clean_result != "") {
-        cat(clean_result, "\n")
+  manager <- db_context_manager$new(
+    cluster_id,
+    if (language == "sh") "py" else language,
+    host = host,
+    token = token
+  )
+  on.exit(manager$close())
+
+  # prompts for current language
+  prompt_main <- repl_prompt(language)
+  prompt_cont <- sub("([> ]+)$", "+ ", prompt_main)
+  buffer <- character()
+
+  repeat {
+    # choose prompt based on R-buffer state
+    prompt <- if (language == "r" && length(buffer) > 0) prompt_cont else
+      prompt_main
+    line <- readline(prompt)
+
+    # language-switch command always applies at top-level (empty R buffer)
+    if (
+      length(buffer) == 0 && line %in% c(":r", ":py", ":scala", ":sql", ":sh")
+    ) {
+      language <- sub("^:", "", line)
+      prompt_main <- repl_prompt(language)
+      prompt_cont <- sub("([> ]+)$", "+ ", prompt_main)
+      buffer <- character() # drop any partial R buffer
+      next
+    }
+
+    if (language == "r") {
+      # buffer every R line
+      buffer <- c(buffer, line)
+      parsed <- try(parse(text = paste(buffer, collapse = "\n")), silent = TRUE)
+
+      if (inherits(parsed, "try-error")) {
+        # incomplete R block? keep reading
+        if (grepl("unexpected end of input", parsed[1])) {
+          next
+        }
+        # real syntax error: show it, reset buffer
+        cat("Syntax error:", parsed[1], "\n")
+        buffer <- character()
+        next
+      }
+
+      # complete R expression(s) - send them as one chunk
+      code <- paste(buffer, collapse = "\n")
+      res <- manager$cmd_run(code, "r")
+      out <- trimws(res)
+      if (length(out) > 0 && nzchar(out)) cat(out, "\n")
+      buffer <- character()
+    } else {
+      # non-R: single-line send
+      if (nzchar(line)) {
+        res <- manager$cmd_run(line, language)
+        out <- trimws(res)
+        if (length(out) > 0 && nzchar(out)) cat(out, "\n")
       }
     }
   }

R/rstudio-integrations.R

@@ -1,37 +0,0 @@
-# nocov start
-rstudio_editor_contents <- function(only_selected = FALSE) {
-  if (rstudioapi::isAvailable()) {
-    context <- rstudioapi::getSourceEditorContext()
-    if (only_selected) {
-      text <- context$selection[[1]]$text
-    } else {
-      text <- context$contents
-    }
-  }
-}
-
-prepare_code_for_repl <- function(text) {
-  exprs <- gsub("\\\n", "", as.character(parse(text = text)))
-  paste(exprs, collapse = "\n")
-}
-
-send_selection <- function() {
-  code <- rstudio_editor_contents(only_selected = TRUE)
-  code <- prepare_code_for_repl(code)
-  rstudioapi::sendToConsole(code = code, execute = TRUE)
-}
-
-send_document <- function() {
-  code <- rstudio_editor_contents(only_selected = FALSE)
-  code <- prepare_code_for_repl(code)
-  rstudioapi::sendToConsole(code = code, execute = TRUE)
-}
-
-send_file <- function() {
-  script <- rstudioapi::selectFile(filter = "*.R", existing = TRUE)
-  if (!is.null(script) || script != "") {
-    code <- prepare_code_for_repl(readLines(script))
-    rstudioapi::sendToConsole(code = code, execute = TRUE)
-  }
-}
-# nocov end

inst/rstudio/addins.dcf

@@ -1,14 +0,0 @@
-Name: [brickster] Send selection to console
-Description: Send selected code to console, is compatible with remote REPL
-Binding: send_selection
-Interactive: false
-
-Name: [brickster] Send current document to console
-Description: Send selected document to console, is compatible with remote REPL
-Binding: send_document
-Interactive: false
-
-Name: [brickster] Send R script to console
-Description: Send selected script to console, is compatible with remote REPL
-Binding: send_file
-Interactive: false

vignettes/remote-repl.Rmd

@@ -62,36 +62,16 @@ After successfully connecting to the cluster you can run commands against the re
 
 The REPL has a shortcut you can enter `:<language>` to change the active language. You can change between the following languages:
 
-+---------------------------------+-----------------------------------+
-| Language                        | Shortcut                          |
-+=================================+===================================+
-| R                               | `:r`                              |
-+---------------------------------+-----------------------------------+
-| Python                          | `:py`                             |
-+---------------------------------+-----------------------------------+
-| SQL                             | `:sql`                            |
-+---------------------------------+-----------------------------------+
-| Scala                           | `:scala`                          |
-+---------------------------------+-----------------------------------+
-| Shell                           | `:sh`                             |
-+---------------------------------+-----------------------------------+
+| Language | Shortcut |
+|----------|----------|
+| R        | `:r`     |
+| Python   | `:py`    |
+| SQL      | `:sql`   |
+| Scala    | `:scala` |
+| Shell    | `:sh`    |
 
 When you change between languages all variables should persist unless REPL is exited.
 
-## RStudio Addins
-
-There are three addins included with `{brickster}` for use with the REPL:
-
-1.  Send selection to console
-
-2.  Send current document to console
-
-3.  Send R script to console
-
-It's recommended that (1) and (2) be bound to a keyboard shortcut if using the REPL frequently ('Tools' \> 'Modify Keyboard Shortcuts...' \> 'Search for `brickster`').
-
-These addins behave slightly different to the standard shortcuts as they ensure that commands that span multiple lines are handled correctly via the REPL.
-
 ## Limitations
 
 -   Development environments (e.g. RStudio, Positron) won't display variables from the remote contexts in the environment pane
@@ -101,3 +81,5 @@ These addins behave slightly different to the standard shortcuts as they ensure
 -   Not designed to work with interactive serverless compute
 
 -   Cannot persist or recover sessions
+
+-   Multi-line expressions are only supported for R. Python, Scala, and SQL are limited to single line expressions.