fixes system-time dependent unit tests that broke due to year change

Author: Stefan Fleck

DESCRIPTION

@@ -1,7 +1,7 @@
 Type: Package
 Package: rotor
 Title: Log Rotation and Conditional Backups
-Version: 0.2.3
+Version: 0.2.4
 Authors@R: 
     person(given = "Stefan",
            family = "Fleck",
@@ -29,4 +29,4 @@ Suggests:
 Encoding: UTF-8
 LazyData: true
 Roxygen: list(markdown = TRUE)
-RoxygenNote: 6.1.1
+RoxygenNote: 7.0.2.9000

NEWS.md

@@ -1,3 +1,8 @@
+# rotor 0.2.4
+
+* Fixes unit tests sensitive to year change.
+
+
 # rotor 0.2.3
 
 * Changed default behaviour of `rotate_date()`, `rotate_time()`, etc...: If

R/utils-sfmisc.R

@@ -1,4 +1,4 @@
-# sfmisc utils 0.0.1.9028
+# sfmisc utils 0.0.1.9031
 
 
 
@@ -19,7 +19,7 @@
 #' @return a `character` scalar
 #' @noRd
 #'
-#' @example
+#' @examples
 #'   ptrunc(month.abb)
 #'   ptrunc(month.abb, month.name)
 #'
@@ -536,6 +536,12 @@ is_distinct_from <- function(x, y){
 
 
 
+is_windows_path <- function(x){
+  nchar(x) >= 2 & grepl("^[A-Za-z].*", x) & substr(x, 2, 2) == ":"
+}
+
+
+
 # equalish ----------------------------------------------------------------
 
 #' Check for equality within a tolerance level
@@ -764,4 +770,35 @@ preview_object <- function(
 
 
 
+#' Clean up paths to make them comparable, inspired by fs::path_tidy
+#'
+#' @param x `character` vector
+#'
+#' @return a `character` vector
+#' @noRd
+path_tidy <- function(x){
+  x <- gsub("\\\\", "/", x)
+  x <- gsub("(?!^)/+", "/", x, perl = TRUE)
+
+  sel <- x != "/"
+  x[sel] <- gsub("/$", "", x[sel])
+
+  sel <- is_windows_path(x)
+
+  if (any(sel)){
+    clean_win <- function(.x){
+      substr(.x, 1, 1)  <- toupper(substr(.x, 1 ,1))
+      .sel <- nchar(.x) == 2
+      .x[.sel] <- paste0(.x[.sel], "/")
+      .x
+    }
+
+    x[sel] <- clean_win(x[sel])
+  }
+
+  x
+}
+
+
+
 # nocov end

README.md

@@ -0,0 +1,218 @@
+
+<!-- README.md is generated from README.Rmd. Please edit that file -->
+
+# rotor
+
+<!-- badges: start -->
+
+[![Travis build
+status](https://travis-ci.org/s-fleck/rotor.svg?branch=master)](https://travis-ci.org/s-fleck/rotor)
+[![Lifecycle:
+maturing](https://img.shields.io/badge/lifecycle-maturing-blue.svg)](https://www.tidyverse.org/lifecycle/#maturing)
+[![Codecov test
+coverage](https://codecov.io/gh/s-fleck/rotor/branch/master/graph/badge.svg)](https://codecov.io/gh/s-fleck/rotor?branch=master)
+[![CRAN
+status](https://www.r-pkg.org/badges/version/rotor)](https://cran.r-project.org/package=rotor)
+<!-- badges: end -->
+
+**rotor** provides a cross platform R reimagination of
+[logrotate](https://linux.die.net/man/8/logrotate). It is a companion
+package to the logging package [lgr](https://github.com/s-fleck/lgr). In
+contrast to logrotate, rotor relies solely on information encoded in a
+suffixes of file names for conditionally creating backups (i.e. a
+timestamp or index). It therefore also works with backups created by
+other tools, as long as the filename has a format that rotor can
+understand.
+
+`rotate()`, `rotate_date()`, and `rotate_time()` move a file and insert
+a suffix (either an integer or a timestamp) into the filename. In
+addition, they create an empty file in place of the original one. This
+is useful for log rotation. `backup()`, `backup_date()` and
+`backup_time()` do the same but keep the original file.
+
+rotor also includes utility functions for finding and examining the
+backups of a file: `list_backups()`, `backup_info()`, `n_backups`,
+`newest_backup()`, `oldest_backup()`. See the [function
+reference](https://s-fleck.github.io/rotor/reference/index.html) for
+details.
+
+## Installation
+
+You can install the released version of rotor from
+[CRAN](https://CRAN.R-project.org) with:
+
+``` r
+install.packages("rotor")
+```
+
+And the development version from [GitHub](https://github.com/) with:
+
+``` r
+# install.packages("remotes")
+remotes::install_github("s-fleck/rotor")
+```
+
+## Example
+
+First we create a temporary directory for the files created by the code
+examples
+
+``` r
+library(rotor)
+
+# create a directory
+td <- file.path(tempdir(), "rotor")
+dir.create(td, recursive = TRUE)
+
+# create an example logfile
+tf <- file.path(td, "mylogfile.log")
+writeLines("An important message", tf)
+```
+
+### Indexed backups
+
+`backup()` makes a copy of a file and inserts an index between the
+filename and the file extension. The file with the index `1` is always
+the most recently made backup.
+
+``` r
+backup(tf)
+
+# backup and rotate also support compression
+backup(tf, compression = TRUE) 
+
+# display backups of a file
+list_backups(tf)  
+#> [1] "/tmp/RtmpTB9vY3/rotor/mylogfile.1.log.zip"
+#> [2] "/tmp/RtmpTB9vY3/rotor/mylogfile.2.log"
+```
+
+`rotate()` also backs up a file, but replaces the original file with an
+empty one.
+
+``` r
+rotate(tf)
+list_backups(tf)
+#> [1] "/tmp/RtmpTB9vY3/rotor/mylogfile.1.log"    
+#> [2] "/tmp/RtmpTB9vY3/rotor/mylogfile.2.log.zip"
+#> [3] "/tmp/RtmpTB9vY3/rotor/mylogfile.3.log"
+
+# the original file is now empty
+readLines(tf)
+#> character(0)
+
+# its content was moved to the first backup
+readLines(list_backups(tf)[[1]])
+#> [1] "An important message"
+
+# we can now safely write to the original file
+writeLines("another important message", tf)
+```
+
+The `max_backups` parameter limits the maximum number of backups rotor
+will keep of a file. Notice how the zipped backup we created above moves
+to index 4 as we create two new backups.
+
+``` r
+backup(tf, max_backups = 4)
+backup(tf, max_backups = 4)
+
+list_backups(tf)
+#> [1] "/tmp/RtmpTB9vY3/rotor/mylogfile.1.log"    
+#> [2] "/tmp/RtmpTB9vY3/rotor/mylogfile.2.log"    
+#> [3] "/tmp/RtmpTB9vY3/rotor/mylogfile.3.log"    
+#> [4] "/tmp/RtmpTB9vY3/rotor/mylogfile.4.log.zip"
+```
+
+We can also use `prune_backups()` to delete old backups. Other than
+ensuring that no new backups is created, it works identically to using
+`backup()` with the `max_backups` parameter. By setting it to `0`, we
+delete all backups.
+
+``` r
+prune_backups(tf, max_backups = 0)
+```
+
+## Timestamped backups
+
+**rotor** can also create timestamped backups. `backup_date()` creates
+uses a Date (`yyyy-mm-dd`) timestamp, `backup_time()` uses a full
+datetime-stamp by default (`yyyy-mm-dd--hh-mm-ss`). The format of the
+timestamp can be modified with a subset of the formatting tokens
+understood by `strftime()` (within certain restrictions). Backups
+created with both functions are compatible with each other (but not with
+those created with
+`backup_index()`).
+
+``` r
+# be default backup_date() only makes a backup if the last backups is younger
+# than 1 day, so we set `age` to -1 for this example
+backup_date(tf, age = -1)  
+backup_date(tf, format = "%Y-%m", age = -1)
+backup_time(tf)
+backup_time(tf, format = "%Y-%m-%d_%H-%M-%S")  # Python logging
+backup_time(tf, format = "%Y%m%dT%H%M%S")  # ISO 8601 compatible
+
+backup_info(tf)
+#>                                                       path      name
+#> 1  /tmp/RtmpTB9vY3/rotor/mylogfile.2020-01-02_10-05-52.log mylogfile
+#> 2 /tmp/RtmpTB9vY3/rotor/mylogfile.2020-01-02--10-05-52.log mylogfile
+#> 5      /tmp/RtmpTB9vY3/rotor/mylogfile.20200102T100552.log mylogfile
+#> 3           /tmp/RtmpTB9vY3/rotor/mylogfile.2020-01-02.log mylogfile
+#> 4              /tmp/RtmpTB9vY3/rotor/mylogfile.2020-01.log mylogfile
+#>                    sfx ext size isdir mode               mtime
+#> 1  2020-01-02_10-05-52 log   26 FALSE  664 2020-01-02 10:05:52
+#> 2 2020-01-02--10-05-52 log   26 FALSE  664 2020-01-02 10:05:52
+#> 5      20200102T100552 log   26 FALSE  664 2020-01-02 10:05:52
+#> 3           2020-01-02 log   26 FALSE  664 2020-01-02 10:05:52
+#> 4              2020-01 log   26 FALSE  664 2020-01-02 10:05:52
+#>                 ctime               atime  uid  gid uname grname
+#> 1 2020-01-02 10:05:52 2020-01-02 10:05:52 1032 1032 fleck  fleck
+#> 2 2020-01-02 10:05:52 2020-01-02 10:05:52 1032 1032 fleck  fleck
+#> 5 2020-01-02 10:05:52 2020-01-02 10:05:52 1032 1032 fleck  fleck
+#> 3 2020-01-02 10:05:52 2020-01-02 10:05:52 1032 1032 fleck  fleck
+#> 4 2020-01-02 10:05:52 2020-01-02 10:05:52 1032 1032 fleck  fleck
+#>             timestamp
+#> 1 2020-01-02 10:05:52
+#> 2 2020-01-02 10:05:52
+#> 5 2020-01-02 10:05:52
+#> 3 2020-01-02 00:00:00
+#> 4 2020-01-01 00:00:00
+```
+
+If we examine the “timestamp” column in the example above, we see that
+missing date information is always interpreted as the start of the
+period; i.e. so `"2019-01"` is equivalent to `"2019-01-01--00--00--00"`
+for all intents and purposes.
+
+``` r
+prune_backups(tf, max_backups = 0)  # cleanup
+list_backups(tf)
+#> character(0)
+```
+
+Besides passing a total number of backups to keep, `max_backups` can
+also be a period or a date / datetime for timestamped backups.
+
+``` r
+# keep all backups younger than one year
+prune_backups(tf, "1 year") 
+  
+# keep all backups from April 4th, 2018 and onwards
+prune_backups(tf, "2018-04-01")  
+```
+
+# Dependencies
+
+**rotor**’s dependencies are intentionally kept slim. It only comes with
+two non-base dependencies:
+
+  - [R6](https://github.com/r-lib/R6): A light weight system for
+    encapsulated object-oriented programming.
+  - [dint](https://github.com/s-fleck/dint): A toolkit for working
+    year-quarter and year-month dates that I am also the author of. It
+    is used by `rotate_date()` and `rotate_time()` to deal with calendar
+    periods (such as weeks or months).
+
+Both packages have no transitive dependencies (i.e they do not depend on
+anything outside of base R)

cran-comments.md

@@ -9,5 +9,4 @@
 
 0 errors | 0 warnings | 0 notes
 
-maintenance release with saner default behaviour for rotate() and backup() if
-no backups exist yet
+fixes system-time dependent unit tests that broke due to year change