rgx-cli 0.11.0

A terminal regex tester with real-time matching, multi-engine support, and plain-English explanations
Documentation 
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! grex overlay widget — lets users enter example strings and load a generated regex into the main editor.

use std::time::Instant;

use ratatui::layout::Rect;
use ratatui::style::{Modifier, Style};
use ratatui::text::{Line, Span};
use ratatui::widgets::{Block, BorderType, Borders, Paragraph, Wrap};
use ratatui::Frame;

use crate::grex_integration::GrexOptions;
use crate::input::editor::Editor;
use crate::ui::{centered_overlay, theme};

#[derive(Default)]
pub struct GrexOverlayState {
    pub editor: Editor,
    pub options: GrexOptions,
    pub generated_pattern: Option<String>,
    pub generation_counter: u64,
    pub debounce_deadline: Option<Instant>,
}

pub fn render(frame: &mut Frame, area: Rect, state: &GrexOverlayState) {
    render_with_border(frame, area, state, BorderType::Plain);
}

pub fn render_with_border(frame: &mut Frame, area: Rect, state: &GrexOverlayState, bt: BorderType) {
    let width = area.width.clamp(60, 80);
    let height = area.height.saturating_sub(4).clamp(12, 18);
    let overlay_area = centered_overlay(frame, area, width, height);

    let dim = Style::default().fg(theme::SUBTEXT);
    let title_style = Style::default()
        .fg(theme::BLUE)
        .add_modifier(Modifier::BOLD);
    let label_style = Style::default().fg(theme::MAUVE);

    let mut lines: Vec<Line<'static>> = Vec::with_capacity(16);
    lines.push(Line::from(Span::styled(
        "Generate Regex from Examples",
        title_style,
    )));
    lines.push(Line::from(""));
    lines.push(build_flag_row(&state.options));
    lines.push(Line::from(""));
    lines.push(Line::from(Span::styled(
        "Examples (one per line):",
        label_style,
    )));

    let content = state.editor.content();
    if content.is_empty() {
        lines.push(Line::from(Span::styled(
            "  Enter one example per line. Tab to accept.",
            dim,
        )));
    } else {
        for line in content.lines() {
            lines.push(Line::from(format!("  {line}")));
        }
    }

    lines.push(Line::from(""));
    lines.push(Line::from(Span::styled("Generated pattern:", label_style)));
    match state.generated_pattern.as_deref() {
        Some(p) if !p.is_empty() => {
            lines.push(Line::from(Span::styled(
                format!("  {p}"),
                Style::default().fg(theme::GREEN),
            )));
        }
        _ => {
            lines.push(Line::from(Span::styled("  (none yet)", dim)));
        }
    }

    lines.push(Line::from(""));
    lines.push(Line::from(Span::styled(
        "Alt+d/a/c: toggle flags    Tab: accept    Esc: cancel",
        dim,
    )));

    let block = Block::default()
        .borders(Borders::ALL)
        .border_type(bt)
        .border_style(Style::default().fg(theme::BLUE))
        .title(Span::styled(
            " Generate Regex from Examples (Ctrl+X) ",
            Style::default().fg(theme::TEXT),
        ))
        .style(Style::default().bg(theme::BASE));

    let paragraph = Paragraph::new(lines)
        .block(block)
        .wrap(Wrap { trim: false });

    frame.render_widget(paragraph, overlay_area);
}

fn build_flag_row(options: &GrexOptions) -> Line<'static> {
    fn flag_span(label: &'static str, on: bool) -> Vec<Span<'static>> {
        let marker = if on { "●" } else { "○" };
        let style = if on {
            Style::default().fg(theme::GREEN)
        } else {
            Style::default().fg(theme::SUBTEXT)
        };
        vec![
            Span::raw(label),
            Span::raw(" "),
            Span::styled(marker, style),
        ]
    }
    let mut spans: Vec<Span<'static>> =
        vec![Span::styled("Flags:  ", Style::default().fg(theme::MAUVE))];
    spans.extend(flag_span("[D]igit", options.digit));
    spans.push(Span::raw("   "));
    spans.extend(flag_span("[A]nchors", options.anchors));
    spans.push(Span::raw("   "));
    spans.extend(flag_span("[C]ase-insensitive", options.case_insensitive));
    Line::from(spans)
}