Improve readability of conditional expressions split across lines by rustfmt

[coderabbitai]

After configuring nightly rustfmt in PR #48, some conditional expressions are now awkwardly split across lines (e.g. if let ... && ...). These could be improved by extracting relevant conditionals as predicate functions to enhance code readability.

Background
This issue arose from the rustfmt formatting changes introduced in PR #48.

Backlinks

• Original PR: Configure nightly rustfmt #48
• Comment: Configure nightly rustfmt #48 (comment)

Requested by: @leynos

[leynos]

@coderabbitai please identify some specific points in the codebase at which this issue applies.

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
# First, let's explore the repository structure to understand the codebase
echo "=== Repository structure ==="
find . -name "*.rs" -type f | head -20

echo -e "\n=== Searching for if let patterns with && operators ==="
# Search for if let patterns that might be split across lines
rg -A 5 -B 2 "if let.*&&" --type rust

echo -e "\n=== Searching for multi-line conditionals ==="
# Search for if statements that span multiple lines
rg -A 10 -B 2 "if\s+" --type rust | grep -A 10 -B 2 "&&\||\|"

echo -e "\n=== Using ast-grep to find complex conditional patterns ==="
# Search for if let patterns with logical operators
ast-grep --pattern $'if let $_ = $_ && $_'

echo -e "\n=== Search for other complex conditionals ==="
# Search for if statements with multiple conditions
ast-grep --pattern $'if $_ && $_ && $_'

Length of output: 34910

---

🏁 Script executed:

#!/bin/bash
echo "=== Looking for the specific if let && pattern found ==="
# Let's examine the specific pattern from src/lib.rs more closely
rg -A 10 -B 5 "if let Some.*chars\.peek" --type rust

echo -e "\n=== Searching for multi-line if statements ==="
# Search for if statements that might be split across lines
rg -U -A 3 -B 1 "if\s+.*\n\s*&&" --type rust

echo -e "\n=== Looking for other potential complex conditionals ==="
# Search for patterns that might be split by rustfmt
rg -A 5 -B 2 "if.*\n.*&&" --type rust

echo -e "\n=== Examining the html.rs file for complex conditionals ==="
# Check html.rs for multi-line conditionals
rg -A 8 -B 2 "tag\.eq_ignore_ascii_case" src/html.rs

Length of output: 2817

---

🏁 Script executed:

#!/bin/bash
echo "=== Looking for more multi-line conditionals with multiline mode ==="
# Search for patterns that might be split by rustfmt using multiline mode
rg -U -A 5 -B 2 "if.*\n.*(\|\||&&)" --type rust

echo -e "\n=== Looking for while loops with complex conditions ==="
# Search for while loops that might also be affected
rg -A 5 -B 2 "while.*&&" --type rust

echo -e "\n=== Looking for match statements with complex conditions ==="
# Search for match patterns that might be split
rg -A 5 -B 2 "match.*\n.*\|" --type rust

echo -e "\n=== Examining reflow.rs for conditional patterns ==="
# Check reflow.rs for any complex conditionals
cat src/reflow.rs | grep -A 5 -B 5 "if.*&&\|if.*||"

echo -e "\n=== Looking for function calls with complex conditionals ==="
# Check for function calls that might have complex boolean logic
rg -A 3 -B 2 "\.is_some.*&&\|\.is_none.*&&" --type rust

Length of output: 4765

---

🏁 Script executed:

#!/bin/bash
echo "=== Getting exact line numbers and context for specific issues ==="

echo "1. src/lib.rs - if let with && pattern:"
rg -n -A 3 -B 2 "if let Some.*chars\.peek" src/lib.rs

echo -e "\n2. src/html.rs - Multi-line tag checking in collect_text:"
rg -n -A 8 -B 2 "tag\.eq_ignore_ascii_case.*script" src/html.rs

echo -e "\n3. src/html.rs - Multi-line tag checking in contains_strong:"
rg -n -A 3 -B 2 "tag\.eq_ignore_ascii_case.*strong.*tag\.eq_ignore_ascii_case.*b" src/html.rs

echo -e "\n4. src/html.rs - Single line function with || operator:"
rg -n -A 1 -B 1 "is_element.*td.*is_element.*th" src/html.rs

echo -e "\n5. src/reflow.rs - Complex conditional with &&:"
rg -n -A 3 -B 2 "sep_invalid.*second_row_is_separator" src/reflow.rs

Length of output: 2559

---

@leynos, I've identified several specific points in the codebase where conditional expressions are split across lines by rustfmt that could be improved with predicate functions:

1. src/lib.rs:49-51 - Escape sequence checking

if let Some(&next) = chars.peek()
    && next == '|'
{

Improvement: Extract into a predicate function:

fn is_escaped_pipe(chars: &mut std::iter::Peekable<std::str::Chars>) -> bool {
    chars.peek() == Some(&'|')
}

// Usage:
if let Some(&next) = chars.peek() && is_escaped_pipe(&mut chars) {

2. src/html.rs:51-56 - HTML tag filtering

if tag.eq_ignore_ascii_case("script")
    || tag.eq_ignore_ascii_case("style")
    || tag.eq_ignore_ascii_case("noscript")
    || tag.eq_ignore_ascii_case("template")
    || tag.eq_ignore_ascii_case("head")
{

Improvement: Extract into a predicate function:

fn is_ignored_tag(tag: &str) -> bool {
    matches!(tag.to_ascii_lowercase().as_str(), 
        "script" | "style" | "noscript" | "template" | "head")
}

// Usage:
if is_ignored_tag(tag) {

3. src/html.rs:108 - Bold tag detection

if tag.eq_ignore_ascii_case("strong") || tag.eq_ignore_ascii_case("b") {

Improvement: Extract into a predicate function:

fn is_bold_tag(tag: &str) -> bool {
    tag.eq_ignore_ascii_case("strong") || tag.eq_ignore_ascii_case("b")
}

// Usage:
if is_bold_tag(tag) {

4. src/reflow.rs:117 - Separator validation

if sep_invalid && second_row_is_separator(rows) {

Improvement: Extract into a predicate function:

fn should_use_second_row_as_separator(sep_invalid: bool, rows: &[Vec<String>]) -> bool {
    sep_invalid && second_row_is_separator(rows)
}

// Usage:
if should_use_second_row_as_separator(sep_invalid, rows) {

5. src/html.rs:82 - Good example (already a predicate)

fn is_table_cell(handle: &Handle) -> bool { is_element(handle, "td") || is_element(handle, "th") }

This is already well-structured as a predicate function.

These improvements would enhance code readability by giving meaningful names to complex boolean logic and reducing the visual noise of multi-line conditional expressions.