dampen-cli 0.3.2

Developer CLI for Dampen UI framework
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

// Unit tests for theme validation
use dampen_cli::commands::check::errors::CheckError;
use dampen_cli::commands::check::themes::ThemeValidator;

#[test]
fn test_invalid_theme_property_detection() {
    // Test detection of invalid theme property (e.g., negative font size)
    let mut validator = ThemeValidator::new();

    // Add a theme with invalid property
    let result = validator.add_invalid_theme_property(
        "test_theme",
        "font_size_base",
        "-16.0",
        "test.dampen",
        10,
        5,
    );

    // Should detect the invalid property
    assert!(result.is_err());

    let errors = validator.validate();
    assert!(!errors.is_empty());

    // Check that we have an InvalidThemeProperty error
    let has_invalid_property = errors
        .iter()
        .any(|e| matches!(e, CheckError::InvalidThemeProperty { .. }));
    assert!(
        has_invalid_property,
        "Expected invalid theme property error"
    );
}

#[test]
fn test_circular_dependency_detection() {
    // Test detection of circular dependencies in style class inheritance
    let mut validator = ThemeValidator::new();

    // Create style classes with circular dependency:
    // class_a extends class_b
    // class_b extends class_c
    // class_c extends class_a (circular!)

    validator.add_style_class("class_a", vec!["class_b".to_string()], "test.dampen", 5, 1);
    validator.add_style_class("class_b", vec!["class_c".to_string()], "test.dampen", 10, 1);
    validator.add_style_class("class_c", vec!["class_a".to_string()], "test.dampen", 15, 1);

    // Validate should detect circular dependency
    let errors = validator.validate();
    assert!(!errors.is_empty());

    // Check that we have a circular dependency error
    let has_circular_error = errors
        .iter()
        .any(|e| matches!(e, CheckError::ThemeCircularDependency { .. }));
    assert!(has_circular_error, "Expected circular dependency error");
}

#[test]
fn test_valid_theme() {
    // Test that a valid theme passes validation
    let validator = ThemeValidator::new();

    // No invalid themes or style classes added
    let errors = validator.validate();
    assert!(errors.is_empty(), "Expected no errors for valid theme");
}

#[test]
fn test_style_class_extends_nonexistent() {
    // Test that extending a non-existent style class produces an error
    let mut validator = ThemeValidator::new();

    validator.add_style_class(
        "child_class",
        vec!["nonexistent_parent".to_string()],
        "test.dampen",
        5,
        1,
    );

    // Validate should detect missing parent class
    let errors = validator.validate();
    assert!(!errors.is_empty());

    let has_invalid_property = errors
        .iter()
        .any(|e| matches!(e, CheckError::InvalidThemeProperty { .. }));
    assert!(
        has_invalid_property,
        "Expected invalid theme property error for missing parent"
    );
}

#[test]
fn test_multiple_circular_dependencies() {
    // Test detection of multiple circular dependencies
    let mut validator = ThemeValidator::new();

    // First circular dependency: a -> b -> a
    validator.add_style_class("class_a", vec!["class_b".to_string()], "test.dampen", 5, 1);
    validator.add_style_class("class_b", vec!["class_a".to_string()], "test.dampen", 10, 1);

    // Second circular dependency: c -> d -> e -> c
    validator.add_style_class("class_c", vec!["class_d".to_string()], "test.dampen", 15, 1);
    validator.add_style_class("class_d", vec!["class_e".to_string()], "test.dampen", 20, 1);
    validator.add_style_class("class_e", vec!["class_c".to_string()], "test.dampen", 25, 1);

    let errors = validator.validate();

    // Should have at least 2 circular dependency errors
    let circular_error_count = errors
        .iter()
        .filter(|e| matches!(e, CheckError::ThemeCircularDependency { .. }))
        .count();
    assert!(
        circular_error_count >= 2,
        "Expected at least 2 circular dependency errors, got {}",
        circular_error_count
    );
}

#[test]
fn test_deep_inheritance_without_cycle() {
    // Test that deep inheritance without cycles is valid
    let mut validator = ThemeValidator::new();

    // Create a chain: a -> b -> c -> d (no cycle)
    validator.add_style_class("class_a", vec!["class_b".to_string()], "test.dampen", 5, 1);
    validator.add_style_class("class_b", vec!["class_c".to_string()], "test.dampen", 10, 1);
    validator.add_style_class("class_c", vec!["class_d".to_string()], "test.dampen", 15, 1);
    validator.add_style_class("class_d", vec![], "test.dampen", 20, 1);

    let errors = validator.validate();

    // Should have no circular dependency errors
    let has_circular_error = errors
        .iter()
        .any(|e| matches!(e, CheckError::ThemeCircularDependency { .. }));
    assert!(
        !has_circular_error,
        "Expected no circular dependency error for valid inheritance chain"
    );
}