rrubocop 0.8.15

10x faster RuboCop drop-in. Same output format and configs, without maintaining RuboCop gems.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//! Expression evaluation for native ERB (literals / vars / ENV).

use std::collections::HashMap;
use std::sync::OnceLock;

use regex::Regex;

pub(super) fn eval_expr(expr: &str, vars: &HashMap<String, String>) -> Option<String> {
    let s = expr.trim();
    if s.is_empty() {
        return None;
    }
    if let Some(v) = string_literal(s) {
        return Some(v);
    }
    if let Some(v) = bool_or_nil(s) {
        return Some(v);
    }
    if let Some(v) = integer_literal(s) {
        return Some(v);
    }
    if s.starts_with("ENV[") || s.starts_with("ENV.fetch") {
        return env_expr(s, vars);
    }
    vars.get(s).cloned()
}

fn bool_or_nil(s: &str) -> Option<String> {
    match s {
        "true" => Some("true".to_string()),
        "false" => Some("false".to_string()),
        "nil" => Some(String::new()),
        _ => None,
    }
}

fn env_expr(expr: &str, vars: &HashMap<String, String>) -> Option<String> {
    if let Some(caps) = env_index_re().captures(expr) {
        return Some(std::env::var(&caps[1]).unwrap_or_default());
    }
    env_fetch(expr, vars)
}

fn env_fetch(expr: &str, vars: &HashMap<String, String>) -> Option<String> {
    let caps = env_fetch_re().captures(expr)?;
    if let Ok(val) = std::env::var(&caps[1]) {
        return Some(val);
    }
    caps.get(2).and_then(|d| eval_expr(d.as_str(), vars))
}

fn env_index_re() -> &'static Regex {
    static RE: OnceLock<Regex> = OnceLock::new();
    RE.get_or_init(|| Regex::new(r#"^ENV\[\s*['"]([^'"]+)['"]\s*\]$"#).unwrap())
}

fn env_fetch_re() -> &'static Regex {
    static RE: OnceLock<Regex> = OnceLock::new();
    RE.get_or_init(|| {
        Regex::new(r#"^ENV\.fetch\(\s*['"]([^'"]+)['"]\s*(?:,\s*(.+?)\s*)?\)$"#).unwrap()
    })
}

fn string_literal(s: &str) -> Option<String> {
    let quote = s.chars().next()?;
    if quote != '\'' && quote != '"' {
        return None;
    }
    let inner = s.strip_prefix(quote)?.strip_suffix(quote)?;
    if inner.contains(quote) || inner.contains('\\') {
        return None;
    }
    if quote == '"' && inner.contains("#{") {
        return None;
    }
    Some(inner.to_string())
}

fn integer_literal(s: &str) -> Option<String> {
    let digits = s.strip_prefix('-').unwrap_or(s);
    if !valid_int_digits(digits) {
        return None;
    }
    let cleaned: String = digits.chars().filter(|c| *c != '_').collect();
    if cleaned.len() > 1 && cleaned.starts_with('0') {
        return None;
    }
    Some(if s.starts_with('-') {
        format!("-{cleaned}")
    } else {
        cleaned
    })
}

fn valid_int_digits(digits: &str) -> bool {
    digits.starts_with(|c: char| c.is_ascii_digit())
        && !digits.ends_with('_')
        && !digits.contains("__")
        && digits.bytes().all(|b| b.is_ascii_digit() || b == b'_')
}

pub(super) fn is_ident(s: &str) -> bool {
    let mut chars = s.chars();
    match chars.next() {
        Some(c) if c == '_' || c.is_ascii_alphabetic() => {}
        _ => return false,
    }
    chars.all(|c| c == '_' || c.is_ascii_alphanumeric())
}