CopilotForXcode/Core/Sources/SuggestionWidget/NES/NESDiffView.swift at main · github/CopilotForXcode · GitHub

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
149
150
import SwiftUI
import ComposableArchitecture
import SuggestionBasic

struct NESDiffView: View {
    var store: StoreOf<NESSuggestionPanelFeature>

    var body: some View {
        WithPerceptionTracking {
            if store.isPanelDisplayed,
               !store.isPanelOutOfFrame,
               let nesContent = store.nesContent,
               let originalCodeSnippet = nesContent.getOriginalCodeSnippet()
            {
                let nesCode = nesContent.code

                ScrollView(showsIndicators: true) {
                    Group {
                        if nesContent.range.isOneLine && nesCode.components(separatedBy: .newlines).count <= 1 {
                            InlineDiffView(
                                store: store,
                                segments: DiffBuilder.inlineSegments(
                                    oldLine: originalCodeSnippet,
                                    newLine: nesCode
                                )
                            )
                        } else {
                            LineDiffView(
                                store: store,
                                segments: DiffBuilder.lineSegments(
                                    oldContent: originalCodeSnippet,
                                    newContent: nesCode
                                )
                            )
                        }
                    }
                }
                .padding(.leading, 12 * store.fontSizeScale)
                .padding(.trailing, 10 * store.fontSizeScale)
                .padding(.vertical, 4 * store.fontSizeScale)
                .xcodeStyleFrame()
                .opacity(store.diffViewOpacity)
            }
        }
    }
}


private struct AccentStrip: View {
    let store: StoreOf<NESSuggestionPanelFeature>
    var body: some View {
        RoundedRectangle(cornerRadius: 4)
            .fill(.blue)
            .frame(width: 4 * store.fontSizeScale)
    }
}

struct InlineDiffView: View {
    let store: StoreOf<NESSuggestionPanelFeature>
    let segments: [DiffSegment]

    var body: some View {
        HStack(spacing: 0) {
            AccentStrip(store: store)

            ScrollView(.horizontal, showsIndicators: false) {
                HStack(spacing: 0) {
                    ForEach(Array(segments.enumerated()), id: \.offset) { _, segment in
                        buildSegmentView(segment)
                    }
                }
                .frame(maxWidth: .infinity, alignment: .leading)
            }
            .frame(maxWidth: .infinity, alignment: .leading)
        }
    }

    @ViewBuilder
    func buildSegmentView(_ segment: DiffSegment) -> some View {
        Text(verbatim: segment.text.diffDisplayEscaped())
            .lineLimit(1)
            .font(.system(size: store.lineFontSize, weight: .medium))
            .padding(.vertical, 4 * store.fontSizeScale)
            .background(
                Rectangle()
                    .fill(segment.backgroundColor)
            )
            .alignmentGuide(.firstTextBaseline) { d in
                d[.firstTextBaseline]
            }
    }
}


struct LineDiffView: View {
    let store: StoreOf<NESSuggestionPanelFeature>
    let segments: [DiffSegment]

    var body: some View {
        HStack(spacing: 0) {
            AccentStrip(store: store)

            VStack(alignment: .leading, spacing: 0) {
                ForEach(Array(segments.enumerated()), id: \.offset) { _, segment in
                    buildSegmentView(segment)
                }
            }
            .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .leading)
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .leading)
    }

    @ViewBuilder
    func buildSegmentView(_ segment: DiffSegment) -> some View {
        Text(segment.text.diffDisplayEscaped())
            .font(.system(size: store.lineFontSize, weight: .medium))
            .multilineTextAlignment(.leading)
            .padding(.vertical, 4 * store.fontSizeScale)
            .background(
                Rectangle()
                    .fill(segment.backgroundColor)
            )
    }
}


extension DiffSegment {
    var backgroundColor: Color {
        switch change {
        case .added: return Color("editor.focusedStackFrameHighlightBackground")
        case .removed: return Color("editorOverviewRuler.inlineChatRemoved")
        case .unchanged: return .clear
        }
    }
}

private extension String {
    func diffDisplayEscaped() -> String {
        var escaped = ""
        for scalar in unicodeScalars {
            switch scalar {
            case "\n": escaped.append("\\n")
            case "\r": escaped.append("\\r")
            case "\t": escaped.append("\\t")
            default: escaped.append(Character(scalar))
            }
        }
        return escaped
    }
}