boxmux 0.240.3373

YAML-driven terminal UI framework for rich, interactive CLI applications and dashboards with PTY support
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
124

use crate::components::choice_menu::ChoiceMenu;
use crate::components::renderable_content::RenderableContent;
use crate::model::choice::Choice;
use crate::model::common::Bounds;

#[test]
fn test_choice_sensitive_zones_generation() {
    // T000060: Unit test to debug sensitive zone generation
    println!("=== DEBUG: Testing ChoiceMenu sensitive zones generation ===");

    // Create test choices
    use crate::model::common::ExecutionMode;
    let choices = vec![
        Choice {
            id: "choice1".to_string(),
            content: Some("First Choice".to_string()),
            script: None,
            redirect_output: None,
            append_output: None,
            execution_mode: ExecutionMode::default(),
            selected: false,
            hovered: false,
            waiting: false,
        },
        Choice {
            id: "choice2".to_string(),
            content: Some("Second Choice".to_string()),
            script: None,
            redirect_output: None,
            append_output: None,
            execution_mode: ExecutionMode::default(),
            selected: false,
            hovered: false,
            waiting: false,
        },
    ];

    // Create ChoiceMenu component
    let choice_menu = ChoiceMenu::new("test_menu".to_string(), &choices);

    // Create test bounds - simulating a muxbox similar to the test
    // Using bounds from the test: x1=2, y1=2, x2=25, y2=8
    let bounds = Bounds::new(2, 2, 23, 6); // x=2, y=2, width=23, height=6

    println!(
        "Muxbox bounds: left={}, top={}, right={}, bottom={}, width={}, height={}",
        bounds.left(),
        bounds.top(),
        bounds.right(),
        bounds.bottom(),
        bounds.width(),
        bounds.height()
    );

    // Get sensitive zones
    let zones = choice_menu.get_box_relative_sensitive_zones();

    println!("Generated {} sensitive zones", zones.len());
    for (i, zone) in zones.iter().enumerate() {
        println!(
            "Zone {}: bounds=({},{} to {},{}), content_id={}, width={}, height={}",
            i,
            zone.bounds.x1,
            zone.bounds.y1,
            zone.bounds.x2,
            zone.bounds.y2,
            zone.content_id,
            zone.bounds.width(),
            zone.bounds.height()
        );
    }

    // Test clicking on first choice
    // ChoiceMenu returns content-relative coordinates (0,0 is top-left of content area)
    // First choice is at content coordinate (2, 0) - accounting for 2-char left padding within content area
    let expected_click_x = 2; // Content area x + 2 char padding
    let expected_click_y = 0; // First choice at content row 0

    println!(
        "Testing click at ({}, {}) for first choice",
        expected_click_x, expected_click_y
    );

    let clicked_zone = zones.iter().find(|zone| {
        let contains = zone
            .bounds
            .contains_point(expected_click_x, expected_click_y);
        println!(
            "Zone {} contains point ({}, {}): {}",
            zone.content_id, expected_click_x, expected_click_y, contains
        );
        contains
    });

    if let Some(zone) = clicked_zone {
        println!("SUCCESS: Found clicked zone: {}", zone.content_id);
        assert_eq!(zone.content_id, "choice_0", "Should click on first choice");
    } else {
        println!(
            "FAILURE: No sensitive zone found at ({}, {})",
            expected_click_x, expected_click_y
        );
        panic!("Should find a sensitive zone at expected coordinates");
    }

    // Test second choice
    let second_choice_y = 1; // Second choice at content row 1
    println!(
        "Testing click at ({}, {}) for second choice",
        expected_click_x, second_choice_y
    );

    let second_clicked_zone = zones.iter().find(|zone| {
        zone.bounds
            .contains_point(expected_click_x, second_choice_y)
    });

    if let Some(zone) = second_clicked_zone {
        println!("SUCCESS: Found second clicked zone: {}", zone.content_id);
        assert_eq!(zone.content_id, "choice_1", "Should click on second choice");
    } else {
        println!("FAILURE: No sensitive zone found for second choice");
    }
}