Automate file management in R with the {fs} package

Imagine you’re working on a project, and you receive a folder filled with subfolders and files named in different styles: some in uppercase, some in lowercase, and with a mixture of spaces, dashes, and underscores.

This disorganized chaos can make it hard to find anything, but the {fs} lets you quickly rename and organize everything to a consistent case and format. This guide will show you how to use {fs} to automate tedious tasks like creating, renaming, moving, and deleting files and folders with just a few lines of code.

{fs}has very nice, consistent syntax with the following four main categories of functions:

• path_for manipulating and constructing paths

• file_for files

• dir_for directories (this guide uses the terms folders and directories interchangeably)

• link_for links

dir_for directories (this guide uses the terms folders and directories interchangeably)

Directories and links are special types of files, so file_ functions will generally also work when applied to a directory or link.

Throughout this guide, we’ll use {fs} for file/directory handling and stringr for string manipulation.

Create an example messy folder

To demonstrate the power of {fs} for efficient file management, we first need to create a messy folder with inconsistently named files.

Let’s first create our example directory with nothing in it using dir_create() , and then check that it exists with dir_exists() .

Next, we’ll add some poorly named files with inconsistent case and delimiters (spaces, underscores, and dashes) without any subfolder organization. All {fs} functions are vectorized, so we can pass multiple file names to the path argument of file_create() to create all our files at once in our fs-example folder.

A cool safety feature of {fs} is the *_create() functions will not overwrite existing files or folders.

Standardize file name case and format

Now we have a messy folder to clean up! Let’s take a look using one of my favorite functions: dir_tree() . It provides a nicely formatted directory tree and is a great sanity check before and after file manipulation.

We’re ready to make our file names more consistent in case and format! Allison Horst created this beautiful graphic that demonstrates the different case styles typically used in file naming conventions and programming in general.

Let’s get all the files in our directory into a character vector called files_old using dir_ls() . Then, we’ll use str_replace_all() to standardize the file name case and format to snake case, which uses all lower case and dashes as the delimiter.

To actually rename these files, we’ll use file_move() , and then print the file names again to check it worked.

Our files are looking much more consistent and readable!

Create subfolders and move files

To make the directory easier to navigate, we can create subfolders for our R scripts, data, and reports.

We can use dir_ls() with the glob argument to filter the file paths to just one file type so we can easily move them into the appropriate subfolder with file_move() .

A glob is a pattern to expand wildcards (an asterisk * ) in a filepath. Since globs are case-sensitive, in our first example below, we combine two globs: *.r and *.R with the | OR operator to get the filepaths of all R scripts, regardless if the extension is upper or lower case.

Let’s take a look at our directory tree to check our files are named and organized as expected.

Beautiful! Much more tidy!

Delete files and directory

Lastly, let’s use dir_delete() to remove our entire example folder. If we only wanted to delete a file or two, we could instead use file_delete() . But here we’ll use dir_delete() :

Use functions to easily repeat this process

As a bonus, we can package this code into two functions that we can incorporate into our workflow or reuse for many folders:

clean_file_names()will rename all files in a given directory to be all lowercase and use only dashes as the delimiter.

organize_files()will create new folders for R scripts, data, and reports, and then move all files with the appropriate extensions into those subfolders.

Here, we change the code in the file_move() functions to make it work within our custom function’s new folder argument. We use str_glue() to glue together the folder and subfolder, which creates the string "fs-example/R" . However, this string is not a filepath, so we have to wrap this with the path() function (also from {fs} ) to turn the string into a complete filepath.

You can easily adapt these two functions for your own work by changing the str_ functions and arguments in clean_file_names() to use your preferred case and delimiter. Or, in organize_files() , you can create other subdirectories, call them something different, or add more file extensions to be moved into those subfolders.

Caution: when adapting the above functions, make a copy of the folder and files you want to rename and organize to experiment with. There is no “undo” button, so test the function first on this copy to be sure you are happy with the results.

Conclusion

We hope this guide helps you with your file cleaning and organizing endeavors! While we focused mostly on creating, renaming, moving, and deleting files and directories, {fs} can also help you programmatically query and change file permissions and metadata. Learn more about these functions through the package documentation and Tidyverse blog. And, for an even deeper dive on the {fs} package, check out this blog post by Danielle Navarro.