whitaker-common 0.2.6

Internal common utilities for Whitaker lints
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
147
148

//! Behaviour-driven coverage for cognitive complexity computation.

use rstest::fixture;
use rstest_bdd_macros::{given, scenario, then, when};
use std::cell::{Cell, RefCell};
use whitaker_common::brain_type_metrics::cognitive_complexity::CognitiveComplexityBuilder;

#[derive(Debug)]
struct CcWorld {
    builder: RefCell<Option<CognitiveComplexityBuilder>>,
    score_result: Cell<Option<usize>>,
}

impl Default for CcWorld {
    fn default() -> Self {
        Self {
            builder: RefCell::new(Some(CognitiveComplexityBuilder::new())),
            score_result: Cell::new(None),
        }
    }
}

#[fixture]
fn world() -> CcWorld {
    CcWorld::default()
}

// --- Helpers ---

/// Borrows the builder mutably and applies a closure to it.
fn with_builder(world: &CcWorld, f: impl FnOnce(&mut CognitiveComplexityBuilder)) {
    let mut slot = world.builder.borrow_mut();
    f(slot
        .as_mut()
        .unwrap_or_else(|| panic!("builder already consumed")));
}

// --- Given steps ---

#[given("a new complexity builder")]
fn given_new_builder(world: &CcWorld) {
    // The builder is created by Default; nothing to do.
    let _ = world;
}

#[given("a structural increment not from expansion")]
fn given_structural_not_expanded(world: &CcWorld) {
    with_builder(world, |b| b.record_structural_increment(false));
}

#[given("a structural increment from expansion")]
fn given_structural_expanded(world: &CcWorld) {
    with_builder(world, |b| b.record_structural_increment(true));
}

#[given("a nesting increment not from expansion")]
fn given_nesting_not_expanded(world: &CcWorld) {
    with_builder(world, |b| b.record_nesting_increment(false));
}

#[given("a fundamental increment not from expansion")]
fn given_fundamental_not_expanded(world: &CcWorld) {
    with_builder(world, |b| b.record_fundamental_increment(false));
}

#[given("a fundamental increment from expansion")]
fn given_fundamental_expanded(world: &CcWorld) {
    with_builder(world, |b| b.record_fundamental_increment(true));
}

#[given("nesting is pushed not from expansion")]
fn given_push_nesting_not_expanded(world: &CcWorld) {
    with_builder(world, |b| b.push_nesting(false));
}

#[given("nesting is pushed from expansion")]
fn given_push_nesting_expanded(world: &CcWorld) {
    with_builder(world, |b| b.push_nesting(true));
}

#[given("nesting is popped")]
fn given_pop_nesting(world: &CcWorld) {
    with_builder(world, |b| b.pop_nesting());
}

// --- When steps ---

#[when("the complexity is finalised")]
fn when_finalised(world: &CcWorld) {
    let builder = world
        .builder
        .borrow_mut()
        .take()
        .unwrap_or_else(|| panic!("builder already consumed"));
    world.score_result.set(Some(builder.build()));
}

// --- Then steps ---

#[then("the complexity score is {expected}")]
fn then_score_is(world: &CcWorld, expected: usize) {
    assert_eq!(world.score_result.get(), Some(expected));
}

// Scenario indices must match their declaration order in
// `tests/features/cognitive_complexity.feature`. Adding, removing, or
// reordering scenarios in the feature file requires updating the indices
// here.

#[scenario(path = "tests/features/cognitive_complexity.feature", index = 0)]
fn scenario_empty_function(world: CcWorld) {
    let _ = world;
}

#[scenario(path = "tests/features/cognitive_complexity.feature", index = 1)]
fn scenario_single_if(world: CcWorld) {
    let _ = world;
}

#[scenario(path = "tests/features/cognitive_complexity.feature", index = 2)]
fn scenario_nested_if(world: CcWorld) {
    let _ = world;
}

#[scenario(path = "tests/features/cognitive_complexity.feature", index = 3)]
fn scenario_macro_structural_excluded(world: CcWorld) {
    let _ = world;
}

#[scenario(path = "tests/features/cognitive_complexity.feature", index = 4)]
fn scenario_macro_nesting_no_inflate(world: CcWorld) {
    let _ = world;
}

#[scenario(path = "tests/features/cognitive_complexity.feature", index = 5)]
fn scenario_boolean_operators(world: CcWorld) {
    let _ = world;
}

#[scenario(path = "tests/features/cognitive_complexity.feature", index = 6)]
fn scenario_mixed_real_and_expansion(world: CcWorld) {
    let _ = world;
}

#[scenario(path = "tests/features/cognitive_complexity.feature", index = 7)]
fn scenario_fundamental_from_expansion_excluded(world: CcWorld) {
    let _ = world;
}