styler 1.3.0

March 14, 2020
By

[This article was first published on Posts on Lorenz Walthert, and kindly contributed to R-bloggers]. (You can report issue about the content on this page here)
Want to share your content on R-bloggers? click here if you have a blog, or here if you don't.

I am pleased to announce that styler 1.3.2 is
available on CRAN. An emergency release and a maintenance release required from
the CRAN team followed quickly after 1.3.0, so please make sure you use version
1.3.2. There are two major new features. Caching to make repeated styling
quicker and stylerignore, the feature for turning styler off for selected
lines. Let’s get started:

install.packages("styler")
library(styler)

Caching

Conceptual

When we created styler, it was a design principle to make it non-invasive,
flexible and maintainable. The downside of this is that it is slow. The natural
solution to this problem is caching. styler does not store any formatted code
anywhere, it simply hashes the input and checks if this was the output of
formatting before. If so, it returns the code. the package implements caching on
two layers. Whole input and by top-level expression. Let’s say you want to style
the below text:

1 + 1
a <- 3

If it was previously styled, the second time you style it, it will just return
the input immediately. If you change the code to

1 + 1
a = 3

the first layer of the cache (the whole input) won’t be used, because the text
input is not the same. However, the first expression 1 + 1 is the same, so it
will use the cache for this expression and only run a=3 through the full
processing engine. The bigger the cached expressions, the more this matters. And
typically, you have

# in package code
f <- function() {
  # long function declaration here
}

# in analysis code
data %>%
  long() %>%
  pipe(expressions) %>%
  here(all = chained) 

These are two top-level expressions (if you ignore the two top-level comments).
If you style your code regularly and you do only modify a subset of all
top-level expressions without touching the majority of them, you will benefit a
lot from caching. In particular when you run functions like style_pkg(),
because all unmodified files will pass through very quickly.

Usage

Caching is enabled by default and you will be asked once to let the caching
backend of styler (R.cache) create a cache permanent directory. This will enable
caching across R sessions, not just within a session. The cache is shared across
all APIs (style_text(), style_file(), style_dir(), style_pkg(), Addin).
You can easily check details of the cache as follows:

cache_info()
## Size:        0 bytes (0 cached expressions)
## Last modified:   NA
## Created: 2020-03-14 14:53:23
## Location:    /tmp/RtmpyGP7aD/.Rcache/styler/1.3.2
## Activated:   TRUE

There are utilities to deactivate the cache with cache_deactivate() or clear
it with cache_clear(). You can also use use multiple caches, see
?cache_activate(). Caches are version and style guide dependent, so when you
update the styler package in the future, the cache will be rebuilt as you go. We
wanted to make sure the cache does not grow large on your disk, which is the
case with the above described approach that does not store any code. We simply
hash the styled code and create an empty file with the hash as a name. This
literally takes zero bytes on disk, plus the size of the inode (which is
negligible).

If you want use styler in a CI/CD workflow or non-interactively, please see
?caching for details.

stylerignore

I am personally not a big fan of this idea, but now you can make styler ignore
some lines:

blibala= 3
# styler: off
I_have(good+reasons, to = turn_off,
    styler
)
# styler: on
some_call()

If you feed the above into styler, it will not change the code between the
comments. To use something else than # styler: on and # styler: off as
markers, set the R options styler.ignore_start and styler.ignore_stop using
options(). You can also use the start marker inline on the same line as the
expression you want to stylerignore.

ignore( this) # styler: off
f() # not ignored anymore

You can put markers in arbitrary places:

call(
  # styler: off
  1 + 
  # styler: on
    3 ,
  22
)

Also note that as of styler v1.1.1.9002, we support alignment
detection
for function
calls, so styler won’t modify the below code and stylerignore is not
necessary.

call(
  a  = 222,
  ab =   2
)

To leave a comment for the author, please follow the link and comment on their blog: Posts on Lorenz Walthert.

R-bloggers.com offers daily e-mail updates about R news and tutorials about learning R and many other topics. Click here if you're looking to post or find an R/data-science job.
Want to share your content on R-bloggers? click here if you have a blog, or here if you don't.



If you got this far, why not subscribe for updates from the site? Choose your flavor: e-mail, twitter, RSS, or facebook...

Comments are closed.

Search R-bloggers

Sponsors

Never miss an update!
Subscribe to R-bloggers to receive
e-mails with the latest R posts.
(You will not see this message again.)

Click here to close (This popup will not appear again)