This package contains the core functionality for the rebus package. It is primarily intended for other R package developers. For interactive use, try rebus instead.
Regular expressions are a very powerful tool, but the syntax is terse enough to be difficult to read. This makes bugs easy to introduce and hard to find. This package contains functions to make building regular expressions easier.
To install the stable version, type:
install.packages("rebus.base")
To install the development version, you first need the devtools package.
install.packages("devtools")
Then you can install the rebus.base package using
library(devtools)
install_github("richierocks/rebus.base")
Character classes to both constant and functional forms, the latter allowing matching of repeated values. For example, ALPHA
represents an alphabetic character (equivalent to [:alpha:]
), whereas alpha(3, 6)
matches between 3 and 6 alphabetic characters (equivalent to [[:alpha:]]{3,6}
).
All the POSIX classes described on the ?regex
page are supported, along with generic shorthand classes, and some character ranges. For example DIGIT
is the R-specifc form of a number (equivalent to [:digit:]
), DGT
represents the shorthand class (equivalent to \\d
), and ASCII_DIGIT
uses a number range (equivalent to [0-9]
). See rebus.unicode for Unicode General Categories and Unicode Properties which are preferred over POSIX classes for stringi and stringr.
Custom character classes can be created using char_class
. For example, to match lower case letters and punctuation, you can use char_class(LOWER %R% PUNCT)
(equivalent to [[:lower:][:punct:]]
). Here, %R%
is a regular expression concatenation operator.
Pre-escaped constants are available for special characters. For example DOT
is \\.
, BACKSLASH
is \\\\
.
Note the difference between the special character CARET
(\\^
) and the anchor START
(^
).
escape_special
is a functional form for creating those constants.
You can manually apply repetition using repeated
. For example, repeated(ALPHA, 2, 8)
or repeated(alpha(), 2, 8)
(both equivalent to [[:alpha:]]{2,8}
). This makes most sense for custom character classes.
group
creates a group within the regular expression. capture
does the same, but captures it for matching. For example, group("groupies")
(equivalent to (?:groupies)
) and capture("groupies")
(equivalent to (groupies)
).
engroup
takes a capture
argument and calls capture
when it is TRUE
and group
when it is FALSE
.
You can match one string or another using or
. For example, or("dog", "cat", "hippopotamus")
(equivalent to (?:dog|cat|hippopotamus)
).
or1
does the same as or
, but takes a single character vector as an input. For example, or1(c("dog", "cat", "hippopotamus"))
is the same as the previous example.
The %|%
operator does the same for the special case of two inputs, without grouping. For example, "dog" %|% "cat"
(equivalent to dog|cat
).
Zero-length assertions match characters then give up the match. lookahead
and negative_lookahead
match forwards, and lookbehind
and negative_lookbehind
match backwards. Note that the last two aren't supported by R's PCRE engine, only it's Perl engine and stringi/stringr's ICU engine. For example, q %R% lookahead("u")
matches "q" followed by "u", but only includes "q" in the match.
REF1
to REF9
contain references to captured groups of the form \\i
, for reuse with replacement functions and R's PRCE and PErl engines. ICU_REF1
to ICU_REF9
contain references of the form $i
, for use with the ICU engine.
case_insensitive
makes the match not care about case.
free_spacing
allows whitespace between tokens.
single_line
makes the dot match line breaks and makes the caret and dollar match the start and end of the whole string. multi_line
makes the dot not match line breaks, and makes the caret and dollar match character after/before line breaks as well as the start and end of the whole string.
duplicate_group_names
allows groups to have the same names.
no_backslash_escaping
turns off backslash escaping.
modify_mode
allows multiple mode-modifiers to be set at once.
exactly
forces a match to occur exactly, by wrapping it in start and end anchors.
literal
treats its contents are literal characters rather than special regular expression characters.