Reproducibility can be tedious, cabinets makes it easier! cabinets creates project specific file structure templates that can be referenced at the start of any R session. These templates can then be used to initiate future projects with the option for them to be initiatied with a git repository. cabinets works by writing project specific file templates to the .Rprofile file of the default working directory. Doing so allows the templates to be accessed in new R sessions without having to redefine them.
cabinets has two main functions: create_cabinet()
and
new_cabinet_proj()
. create_cabinet()
constructs an R6 object of
class FileCabinet
which is then written to a .Rprofile file. At the
start of fresh R sessions, the .Rprofile file loads the previously
created cabinets for further use. new_cabinet_proj()
can then be used
to create future projects based on a cabinet template. Projects have the
option of being created with an RStudio project and a git repository.
Users will be prompted for explicit permission to write to .Rprofile on
first use. Permission to write can be revoked at any time by setting the
permission option in the .Rprofile file to FALSE
. Due to these
explicit permission requirements, cabinets will only work in
interactive R sessions.
You can install the released version of cabinets from CRAN with:
install.packages("cabinets")
And the development version from GitHub with:
# install.packages("devtools")
devtools::install_github("nt-williams/cabinets@dev")
Different organizations, research groups, projects, etc. have different standard directories. One organization might have the standard file structure:
├── data
│ ├── derived
│ └── source
├── code
├── reports
├── documents
└── log
While another uses a structure like this:
├── Code
│ ├── ReportsCode
│ └── AnalysisCode
├── Notes
└── Log
cabinets makes it easy to define these templates once and then call them for use whenever starting new projects in R.
A cabinet has three components: a name, a location, and a file structure. The location defines where new directories will be created from a cabinet template. The file structure defines, well, the structure of this directory. We use a list to define the structure, where the name of each list index is a unique relative path within the new directory. Using the first project file structure described above, lets create a new cabinet.
loc <- "~/Desktop"
file_str <- list(
'data' = NULL,
'code' = NULL,
'data/derived' = NULL,
'data/source' = NULL,
'reports' = NULL,
'documents' = NULL,
'log' = NULL
)
create_cabinet(name = "contract",
directory = loc,
structure = file_str)
#> ✓ Checking for permissions
#> ✓ Checking for .Rprofile
#> ✓ Checking cabinet name
#> ✓ Cabinet .contract created
#> ● Restart R for changes to take effect
#> ● Cabinet can be called with .contract
The cabinet is now created and doesn’t have to be redefined in future R sessions. To examine the cabinet we just call it.
.contract
#> Cabinet name: contract
#> Cabinet path: ~/Desktop
#> Cabinet structure:
#> ├── data
#> │ ├── derived
#> │ └── source
#> ├── code
#> ├── reports
#> ├── documents
#> └── log
new_cabinet_proj()
is then used to create a new directory from a
cabinet template.
new_cabinet_proj(cabinet = .contract,
project_name = "project",
git = TRUE,
git_ignore = "data",
renv = TRUE)
Similar implementations exist elsewhere. cabinets is unique for giving the user the ability to design their own project templates. These are all great packages, use what’s best for you!
Please note that the cabinets project is released with a Contributor Code of Conduct. By contributing to this project, you agree to abide by its terms.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.