splice 2.6.2

Span-safe refactoring kernel for 7 languages with Magellan code graph integration
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

//! Integration tests for --impact-graph flag on various commands

use splice::cli::{CallDirection, Commands, OutputFormat, ReachabilityDirection};
use std::path::PathBuf;

/// Helper function to verify DOT format is valid
/// DOT format must start with "digraph" and contain valid node/edge declarations
fn is_valid_dot(dot: &str) -> bool {
    let lines: Vec<&str> = dot.lines().collect();
    if lines.is_empty() {
        return false;
    }
    // Must start with digraph declaration
    let first_line = lines[0].trim();
    if !first_line.starts_with("digraph") {
        return false;
    }
    // Must contain closing brace
    let last_line = lines.last().unwrap().trim();
    if !last_line.starts_with('}') {
        return false;
    }
    // Must contain node or edge declarations
    let has_content = lines.iter().any(|line| {
        let trimmed = line.trim();
        trimmed.contains('[') || trimmed.contains("->")
    });
    has_content
}

#[test]
fn test_refs_command_has_impact_graph_flag() {
    // Verify Refs command struct has impact_graph field
    let refs_cmd = Commands::Refs {
        db: PathBuf::from("/tmp/test.db"),
        name: "test".to_string(),
        path: PathBuf::from("/tmp/test.rs"),
        direction: CallDirection::Both,
        output: OutputFormat::Human,
        impact_graph: true, // This field must exist
    };

    // If we reach here, the Refs command has impact_graph field
    match refs_cmd {
        Commands::Refs { impact_graph, .. } => {
            assert!(impact_graph, "impact_graph flag should be true");
        }
        _ => panic!("Expected Refs command"),
    }
}

#[test]
fn test_reachable_command_has_impact_graph_flag() {
    // Verify Reachable command struct has impact_graph field
    let reachable_cmd = Commands::Reachable {
        symbol: "test".to_string(),
        path: PathBuf::from("/tmp/test.rs"),
        db: PathBuf::from("/tmp/test.db"),
        direction: ReachabilityDirection::Forward,
        max_depth: 10,
        output: OutputFormat::Human,
        impact_graph: true, // This field must exist
    };

    match reachable_cmd {
        Commands::Reachable { impact_graph, .. } => {
            assert!(impact_graph, "impact_graph flag should be true");
        }
        _ => panic!("Expected Reachable command"),
    }
}

#[test]
fn test_rename_command_has_impact_graph_flag() {
    // Verify Rename command struct has impact_graph field
    let rename_cmd = Commands::Rename {
        symbol: Some("abc123".to_string()),
        name: None,
        file: None,
        to: "new_name".to_string(),
        db: PathBuf::from("/tmp/test.db"),
        preview: true,
        proof: false,
        backup_dir: None,
        no_backup: false,
        create_backup: true,
        snapshot_before: false,
        impact_graph: true, // This field must exist
    };

    match rename_cmd {
        Commands::Rename { impact_graph, .. } => {
            assert!(impact_graph, "impact_graph flag should be true");
        }
        _ => panic!("Expected Rename command"),
    }
}

#[test]
fn test_patch_command_has_impact_graph_flag() {
    // Verify Patch command struct has impact_graph field
    let patch_cmd = Commands::Patch {
        file: Some(PathBuf::from("/tmp/test.rs")),
        symbol: Some("test_fn".to_string()),
        kind: None,
        analyzer: None,
        analyzer_binary: None,
        with_: Some(PathBuf::from("/tmp/patch_content.rs")),
        language: None,
        batch: None,
        context_after: 0,
        context_before: 0,
        context_both: 0,
        preview: true,
        unified: 3,
        create_backup: false,
        relationships: false,
        operation_id: None,
        metadata: None,
        db: Some(PathBuf::from("/tmp/test.db")),
        snapshot_before: false,
        impact_graph: true, // This field must exist
    };

    match patch_cmd {
        Commands::Patch { impact_graph, .. } => {
            assert!(impact_graph, "impact_graph flag should be true");
        }
        _ => panic!("Expected Patch command"),
    }
}