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
132
133
134
135
136

//! Integration tests for checksum fields in SpanResult.

use splice::checksum::{checksum_file, checksum_span};
use splice::output::SpanResult;
use std::io::Write;
use tempfile::NamedTempFile;

#[test]
fn test_span_result_with_checksums() {
    let mut file = NamedTempFile::new().unwrap();
    writeln!(file, "line 1").unwrap();
    writeln!(file, "line 2").unwrap();
    writeln!(file, "line 3").unwrap();

    let byte_start = 8; // Start of "line 2"
    let byte_end = 14; // End of "line 2"

    // Create span with checksums
    let span = SpanResult::from_byte_span(
        file.path().to_string_lossy().to_string(),
        byte_start,
        byte_end,
    );

    // Compute checksums
    let span_checksum = checksum_span(file.path(), byte_start, byte_end).unwrap();
    let file_checksum = checksum_file(file.path()).unwrap();

    // Add checksums to span
    let span = span.with_both_checksums(span_checksum.as_hex(), file_checksum.as_hex());

    // Verify checksums are set
    assert_eq!(
        span.checksums
            .as_ref()
            .and_then(|c| c.checksum_before.clone()),
        Some(format!("sha256:{}", span_checksum.as_hex()))
    );
    assert_eq!(
        span.checksums
            .as_ref()
            .and_then(|c| c.file_checksum_before.clone()),
        Some(format!("sha256:{}", file_checksum.as_hex()))
    );
}

#[test]
fn test_span_result_checksums_serialize_to_json() {
    let mut file = NamedTempFile::new().unwrap();
    writeln!(file, "line 1").unwrap();
    writeln!(file, "line 2").unwrap();

    let byte_start = 0;
    let byte_end = 14;

    let mut span = SpanResult::from_byte_span(
        file.path().to_string_lossy().to_string(),
        byte_start,
        byte_end,
    );

    let span_checksum = checksum_span(file.path(), byte_start, byte_end).unwrap();
    let file_checksum = checksum_file(file.path()).unwrap();

    span = span.with_both_checksums(span_checksum.as_hex(), file_checksum.as_hex());

    // Serialize to JSON
    let json = serde_json::to_string(&span).unwrap();

    // Verify checksum fields are in JSON
    assert!(json.contains("\"checksums\""));
    assert!(json.contains("\"checksum_before\""));
    assert!(json.contains("\"file_checksum_before\""));
    assert!(json.contains(&format!("sha256:{}", span_checksum.as_hex())));
}

#[test]
fn test_span_result_without_checksums_omits_fields() {
    let span = SpanResult::from_byte_span("test.rs".to_string(), 0, 10);

    // Serialize to JSON
    let json = serde_json::to_string(&span).unwrap();

    // Verify checksum fields are NOT in JSON when None (due to skip_serializing_if)
    assert!(!json.contains("\"checksums\""));
    assert!(!json.contains("\"checksum_before\""));
    assert!(!json.contains("\"file_checksum_before\""));
}

#[test]
fn test_checksum_fields_are_independent() {
    // Verify checksum_before and checksum_after coexist with file_checksum_before
    let mut file = NamedTempFile::new().unwrap();
    writeln!(file, "content").unwrap();

    let byte_start = 0;
    let byte_end = 7;

    let span_checksum = checksum_span(file.path(), byte_start, byte_end).unwrap();
    let file_checksum = checksum_file(file.path()).unwrap();

    let mut span = SpanResult::from_byte_span(
        file.path().to_string_lossy().to_string(),
        byte_start,
        byte_end,
    );

    // Use the new with_both_checksums method
    span = span.with_both_checksums(span_checksum.as_hex(), file_checksum.as_hex());

    // Also use the older with_span_checksums method
    span = span.with_span_checksums(
        "old_span_checksum".to_string(),
        "old_span_after".to_string(),
    );

    // All fields should be set independently
    assert_eq!(
        span.checksums
            .as_ref()
            .and_then(|c| c.checksum_before.clone()),
        Some("sha256:old_span_checksum".to_string())
    );
    assert_eq!(
        span.checksums
            .as_ref()
            .and_then(|c| c.checksum_after.clone()),
        Some("sha256:old_span_after".to_string())
    );
    assert_eq!(
        span.checksums
            .as_ref()
            .and_then(|c| c.file_checksum_before.clone()),
        Some(format!("sha256:{}", file_checksum.as_hex()))
    );
}