cuke-dedup 0.12.0

Static analysis for duplicate and reusable Cucumber step definitions
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

//! Ruby comparison policy and native regex execution contract.

use crate::source_adapter::semantics::{
    AnalysisProfile, CaptureContext, ComparisonDomain, HandlerDomain, RegexDialect,
};

struct RubyRegex;
static REGEX: RubyRegex = RubyRegex;

impl RegexDialect for RubyRegex {
    fn expression(&self, matcher: &str, flags: &str) -> Option<String> {
        super::regex_expression(matcher, flags)
    }
    fn normalized_flags<'a>(&self, flags: &'a str) -> Option<&'a str> {
        Some(flags)
    }
    fn similarity_flags_match(&self, left: &str, right: &str) -> bool {
        left == right
    }
}

/// Enables event overlap only for complete Ruby effect streams.
pub(crate) fn profile(definition: &crate::model::StepDefinition) -> AnalysisProfile {
    let marker = |name: &str| {
        definition
            .handler
            .behavior_signature
            .iter()
            .any(|event| event == name)
    };
    let complete_events = marker("method:ruby:complete-events");
    let action_events = marker("method:ruby:action-events");
    AnalysisProfile {
        comparison_domain: ComparisonDomain::Ruby,
        handler_domain: HandlerDomain::Shared,
        global_matchers: true,
        near_requires_same_handler: !complete_events && !action_events,
        event_similarity: complete_events || action_events,
        near_requires_distinct_events: action_events,
        indirect_usage: true,
        dialect: &REGEX,
        capture_context: |definition| {
            if definition.method_semantics().is_some_and(|context| {
                context == "ruby:lexical-file" || context.starts_with("ruby:lexical-file:")
            }) {
                CaptureContext::LexicalFile
            } else {
                CaptureContext::Unrestricted
            }
        },
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::model::Rule;
    use crate::source_adapter::{SourceFile, SourceLanguage};

    /// Checks exact-handler fallback for legacy streams without losing positive findings.
    #[test]
    fn legacy_partial_events_keep_exact_policy_and_positive_controls() {
        let root = tempfile::tempdir().unwrap();
        let config = crate::config::Config::load(root.path(), Default::default()).unwrap();
        let file = SourceFile {
            path: root.path().join("steps.rb"),
            language: SourceLanguage::Ruby,
        };
        for (second, expected) in [("first", true), ("second", false)] {
            let source = format!("Given('the parcel status is verified') {{ first() }}; Then('the parcel status is now verified') {{ {second}() }}");
            let (mut extracted, _) = super::super::extract(&source, &file).unwrap();
            for definition in &mut extracted.definitions {
                definition.handler.behavior_signature = vec!["call:shared".into()];
                assert!(!profile(definition).event_similarity);
                assert!(profile(definition).near_requires_same_handler);
            }
            let outcome = crate::analysis::analyze_with_step_usage(
                extracted.definitions,
                vec![],
                &config,
                &Default::default(),
            )
            .unwrap();
            assert!(outcome.incomplete.is_empty());
            let result = outcome.result;
            assert_eq!(
                result.findings.iter().any(|finding| matches!(
                    finding.rule,
                    Rule::DuplicateHandler
                        | Rule::NearDuplicateStep
                        | Rule::ParameterizationCandidate
                )),
                expected
            );
        }
    }
}