Add read/write for Dockerfiles

Author: coatless

NAMESPACE

@@ -43,5 +43,7 @@ export(get_package_manager)
 export(has_instruction)
 export(is_dockerfile)
 export(is_dockerignore)
+export(read_dockerfile)
 export(read_dockerignore)
+export(write_dockerfile)
 export(write_dockerignore)

R/dockerfile-io.R

@@ -0,0 +1,98 @@
+#' Read a Dockerfile from a file
+#'
+#' @param file Path to Dockerfile
+#' @return A dockerfile object
+#' @export
+read_dockerfile <- function(file) {
+  if (!file.exists(file)) {
+    cli::cli_abort("File not found: {file}")
+  }
+  
+  # Read lines from file
+  lines <- readLines(file)
+  
+  # Create a new dockerfile object
+  df <- dockerfile()
+  
+  # Process continuation lines
+  i <- 1
+  while (i <= length(lines)) {
+    line <- lines[i]
+    
+    # Skip empty lines and comments
+    if (grepl("^\\s*$", line) || grepl("^\\s*#", line)) {
+      i <- i + 1
+      next
+    }
+    
+    # Check for continuation character at the end
+    while (grepl("\\\\\\s*$", line) && i < length(lines)) {
+      # Remove continuation character
+      line <- sub("\\\\\\s*$", " ", line)
+      # Add next line
+      i <- i + 1
+      line <- paste0(line, lines[i])
+    }
+    
+    # Add processed line to dockerfile
+    df$lines <- c(df$lines, line)
+    
+    # Update metadata
+    if (grepl("^FROM ", line, ignore.case = TRUE)) {
+      base_image <- sub("^FROM\\s+([^\\s]+).*$", "\\1", line, ignore.case = TRUE)
+      df$metadata$base_image <- base_image
+      df$metadata$package_manager <- get_package_manager(base_image)
+      
+      # Try to extract R version from rocker images
+      if (grepl("^rocker/r-ver:", base_image)) {
+        r_ver <- sub("^rocker/r-ver:", "", base_image)
+        df$metadata$r_version <- r_ver
+      }
+    }
+    
+    i <- i + 1
+  }
+  
+  df
+}
+
+#' Write a dockerfile to a file
+#'
+#' @param dockerfile A dockerfile object
+#' @param file Output file path (default: "Dockerfile")
+#' @param multiline Logical indicating if long RUN commands should be split (default: TRUE)
+#' @return Invisible dockerfile object
+#' @export
+write_dockerfile <- function(dockerfile, file = "Dockerfile", multiline = TRUE) {
+  check_dockerfile(dockerfile)
+  
+  if (multiline) {
+    # Process lines for better formatting
+    formatted_lines <- character(length(dockerfile$lines))
+    
+    for (i in seq_along(dockerfile$lines)) {
+      line <- dockerfile$lines[i]
+      
+      # Check if it's a RUN command with && that could be split
+      if (grepl("^RUN ", line) && nchar(line) > 80 && grepl(" && ", line)) {
+        parts <- strsplit(line, " && ")[[1]]
+        formatted_line <- paste0(
+          "RUN ", parts[1], " && \\\n",
+          paste0("    ", parts[-1], collapse = " && \\\n")
+        )
+        formatted_lines[i] <- formatted_line
+      } else {
+        formatted_lines[i] <- line
+      }
+    }
+    
+    # Write to file
+    writeLines(formatted_lines, file)
+  } else {
+    # Write directly without formatting
+    writeLines(dockerfile$lines, file)
+  }
+  
+  cli::cli_alert_success("Dockerfile written to {file}")
+  invisible(dockerfile)
+}

man/print.dockerfile.Rd

@@ -0,0 +1,70 @@
+# Test read_dockerfile() ----
+test_that("read_dockerfile(): reads Dockerfile correctly", {
+  # Create a temporary Dockerfile for testing
+  dockerfile_path <- tempfile(fileext = "")
+  writeLines(c(
+    "FROM ubuntu:24.10",
+    "RUN apt-get update && \\",
+    "    apt-get install -y curl",
+    "WORKDIR /app",
+    "COPY . /app/",
+    "CMD [\"bash\"]"
+  ), dockerfile_path)
+  
+  # Read the Dockerfile
+  df <- read_dockerfile(dockerfile_path)
+  expect_true(is_dockerfile(df))
+  expect_equal(length(df$lines), 5) # 5 lines after processing continuations
+  expect_equal(df$metadata$base_image, "ubuntu:24.10")
+  expect_equal(df$metadata$package_manager, "apt")
+  
+  # Test error for missing file
+  expect_error(read_dockerfile("nonexistent_dockerfile"), "File not found")
+  
+  # Clean up
+  unlink(dockerfile_path)
+})
+
+# Test write_dockerfile() ----
+test_that("write_dockerfile(): writes Dockerfile correctly", {
+  # Create a dockerfile
+  df <- dockerfile() |>
+    dfi_from("ubuntu:24.10") |>
+    dfi_run("apt-get update && apt-get install -y curl") |>
+    dfi_workdir("/app") |>
+    dfi_cmd("bash")
+  
+  # Write to temporary file
+  dockerfile_path <- tempfile(fileext = "")
+  expect_message(
+    write_dockerfile(df, dockerfile_path)
+  )
+  
+  # Check that file exists
+  expect_true(file.exists(dockerfile_path))
+  
+  # Read the file back
+  lines <- readLines(dockerfile_path)
+  expect_true(any(grepl("^FROM ubuntu:24.10", lines)))
+  expect_true(any(grepl("^RUN apt-get update", lines)))
+  expect_true(any(grepl("^WORKDIR /app", lines)))
+  expect_true(any(grepl("^CMD bash", lines)))
+  
+  # Test multiline formatting
+  multiline_df <- dockerfile() |>
+    dfi_from("ubuntu:24.10") |>
+    dfi_run("apt-get update && apt-get install -y curl && apt-get clean && rm -rf /var/lib/apt/lists/*")
+  
+  multiline_path <- tempfile(fileext = "")
+  expect_message(
+    write_dockerfile(multiline_df, multiline_path, multiline = TRUE)
+  )
+  
+  # Check that the long RUN command was split
+  multilines <- readLines(multiline_path)
+  expect_true(any(grepl("\\\\$", multilines))) # Check for continuation characters
+  
+  # Clean up
+  unlink(dockerfile_path)
+  unlink(multiline_path)
+})