Practical Examples¶

Real-world examples demonstrating advanced pattern techniques.

Choosing the Right Flags¶

Understanding which flags to use for different search scenarios:

flowchart TD
    Start[Pattern Type] --> Multi{"Spans multiple
lines?"}

    Multi -->|Yes| Dotall{"Need . to
match newlines?"}
    Multi -->|No| Features{"Need lookaround
or backrefs?"}

    Dotall -->|Yes| UseDotall["Use: -U --multiline-dotall
or -U '(?s)pattern'"]
    Dotall -->|No| UseMulti["Use: -U pattern"]

    Features -->|Yes| UsePCRE["Use: -P pattern"]
    Features -->|No| UseDefault["Use: pattern
(default engine)"]

    UsePCRE --> PCREMulti{Also multiline?}
    PCREMulti -->|Yes| UsePU["Use: -PU pattern"]
    PCREMulti -->|No| End[Execute Search]

    UseDotall --> End
    UseMulti --> End
    UseDefault --> End

    style UsePCRE fill:#fff3e0
    style UsePU fill:#fff3e0
    style UseMulti fill:#e1f5ff
    style UseDotall fill:#e1f5ff
    style UseDefault fill:#e8f5e9

Figure: Decision flow for selecting the appropriate ripgrep flags based on pattern requirements.

Multi-line Log Parsing¶

Find ERROR entries with their stack traces:

# Find ERROR with following context lines
rg -U 'ERROR.*\n.*stack trace'  # (1)!

# Find ERROR with complete stack trace (multiple lines)
rg -U --multiline-dotall 'ERROR.*?at .*?\)'  # (2)!

1. -U enables multiline mode; \n explicitly matches the newline character
2. --multiline-dotall makes . match newlines; .*? is non-greedy (stops at first match)

app.log:15:ERROR: Database connection failed
app.log:16:  stack trace: at connect() /src/db.rs:42

Function Usage Analysis¶

Find function definitions that use specific features:

# Find functions using a specific API (requires PCRE2 + multiline)
rg -UP '(?s)fn (\w+).*?\{(?=.*use_api).*?\}'  # (1)!

# Find functions with TODO comments
rg -UP '(?s)fn (\w+).*?\{(?=.*TODO).*?\}'  # (2)!

1. (?s) enables dotall mode inline; (?=.*use_api) is a lookahead that checks if use_api appears anywhere in the function body
2. Lookahead doesn't consume characters, so it finds functions containing TODO without including TODO in the match

src/api.rs:45:fn initialize_client() {
src/api.rs:46:    use_api::connect();
src/api.rs:47:    // ...
src/api.rs:48:}

Extracting Specific Content¶

Use lookaround with --only-matching for precise extraction:

rg -Po '(?<=\$)\d+\.?\d*'

invoice.txt:42.99
invoice.txt:17.50
invoice.txt:199

rg -Po '\w+(?=@\w+\.com)'

contacts.txt:john
contacts.txt:alice

rg -Po '(?<=").*?(?=")'

config.json:database_url
config.json:secret_key

rg -Po '(?<=<title>).*?(?=</title>)'

page.html:Welcome to My Site
doc.xml:Introduction

Finding Repeated Patterns¶

Use backreferences to find duplications:

# Find repeated words
rg -P '\b(\w+)\s+\1\b'  # (1)!

# Find repeated numbers
rg -P '(\d{3})-\1'  # (2)!

# Find repeated lines (requires multiline)
rg -UP '^(.+)$\n\1$'  # (3)!

1. (\w+) captures a word; \1 references the first capture group, matching the same word again
2. (\d{3}) captures three digits; \1 ensures the same three digits appear after the hyphen
3. ^(.+)$ captures an entire line; \n\1$ matches a newline followed by the exact same line

document.txt:42:The the quick brown fox
document.txt:89:You can can use this feature
ids.txt:15:123-123 (repeated number pattern)
log.txt:ERROR: Connection timeout
log.txt:ERROR: Connection timeout

Unicode Script Searches¶

Search for specific writing systems:

# Find Chinese text
rg '\p{Han}+'

# Find mixed script text (Latin + Cyrillic)
rg '\p{Latin}.*\p{Cyrillic}'

# Find emoji
rg '\p{Emoji}'

# Find right-to-left script (Arabic, Hebrew)
rg '\p{Arabic}|\p{Hebrew}'

multilang.txt:5:你好世界 (Chinese: Hello World)
docs.txt:12:Introduction Введение (Mixed Latin-Cyrillic)
messages.txt:8:Great work! 🎉
greetings.txt:3:مرحبا (Arabic: Hello)

Complex Replacements¶

Use named captures for readable transformations:

rg '(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})' -r '$month/$day/$year'

rg '(?P<user>\w+)@(?P<domain>\w+)\.com' -r 'User: $user, Domain: $domain'

rg '(?P<time>\d{2}:\d{2}:\d{2}) (?P<level>\w+) (?P<msg>.+)' \
   -r '[$level] $time - $msg'

Combining Multiline and PCRE2¶

Powerful queries combining multiple features:

# Find struct definitions with specific fields (multiline + lookahead)
rg -UP '(?s)struct (\w+).*?\{(?=.*field_name).*?\}'  # (1)!

# Find functions calling deprecated APIs with context
rg -UP '(?s)fn (\w+).*?\{(?=.*deprecated_api).*?\}' -A 2 -B 2  # (2)!

# Match code blocks with specific patterns
rg -UP '(?s)fn test_\w+.*?\{(?=.*assert).*?\}'  # (3)!

1. Combines -P (PCRE2 for lookahead), -U (multiline), (?s) (dotall), and (?=...) (lookahead)
2. -A 2 -B 2 shows 2 lines of context before and after matches for debugging
3. test_\w+ matches test function names; lookahead ensures they contain assertions

src/models.rs:23:struct Config {
src/models.rs:24:    field_name: String,
src/models.rs:25:    // ...
src/models.rs:26:}

Limitations and Gotchas¶

Common pitfalls and limitations when using advanced regex features.

PCRE2 Silent Failures¶

# May not work as expected
rg -P 'foo\nbar'

# Correct: use both -P and -U
rg -PU 'foo\nbar'

Dotall Confusion¶

# FAILS - . doesn't match \n
rg -U 'foo.+bar'

# SUCCEEDS - need --multiline-dotall
rg -U --multiline-dotall 'foo.+bar'

# ALTERNATIVE - use (?s) inline flag
rg -U '(?s)foo.+bar'

# ALTERNATIVE - use \p{any}
rg -U 'foo\p{any}+bar'

Forgetting -P Flag¶

# ERROR - lookahead requires PCRE2
rg 'foo(?=bar)'

# CORRECT
rg -P 'foo(?=bar)'

Unicode Scope¶

# Both patterns are ASCII-only
rg --no-unicode -e 'pattern1' -e 'pattern2'

Regex Size Limits¶

# Error: "compiled regex exceeds size limit"
# Solution: use --regex-size-limit
rg --regex-size-limit 100M 'extremely_complex_pattern'

Engine-Specific Behavior¶