+2 -69

appview/db/pulls.go

··· 9 9 "strings" 10 10 "time" 11 11 12 12 - "github.com/bluekeyes/go-gitdiff/gitdiff" 13 12 "github.com/bluesky-social/indigo/atproto/syntax" 14 13 "tangled.sh/tangled.sh/core/api/tangled" 15 14 "tangled.sh/tangled.sh/core/patchutil" ··· 203 202 return p.StackId != "" 204 203 } 205 204 206 206 - func (s PullSubmission) AsDiff(targetBranch string) ([]*gitdiff.File, error) { 207 207 - patch := s.Patch 208 208 - 209 209 - // if format-patch; then extract each patch 210 210 - var diffs []*gitdiff.File 211 211 - if patchutil.IsFormatPatch(patch) { 212 212 - patches, err := patchutil.ExtractPatches(patch) 213 213 - if err != nil { 214 214 - return nil, err 215 215 - } 216 216 - var ps [][]*gitdiff.File 217 217 - for _, p := range patches { 218 218 - ps = append(ps, p.Files) 219 219 - } 220 220 - 221 221 - diffs = patchutil.CombineDiff(ps...) 222 222 - } else { 223 223 - d, _, err := gitdiff.Parse(strings.NewReader(patch)) 224 224 - if err != nil { 225 225 - return nil, err 226 226 - } 227 227 - diffs = d 228 228 - } 229 229 - 230 230 - return diffs, nil 231 231 - } 232 232 - 233 233 - func (s PullSubmission) AsNiceDiff(targetBranch string) types.NiceDiff { 234 234 - diffs, err := s.AsDiff(targetBranch) 235 235 - if err != nil { 236 236 - log.Println(err) 237 237 - } 238 238 - 239 239 - nd := types.NiceDiff{} 240 240 - nd.Commit.Parent = targetBranch 241 241 - 242 242 - for _, d := range diffs { 243 243 - ndiff := types.Diff{} 244 244 - ndiff.Name.New = d.NewName 245 245 - ndiff.Name.Old = d.OldName 246 246 - ndiff.IsBinary = d.IsBinary 247 247 - ndiff.IsNew = d.IsNew 248 248 - ndiff.IsDelete = d.IsDelete 249 249 - ndiff.IsCopy = d.IsCopy 250 250 - ndiff.IsRename = d.IsRename 251 251 - 252 252 - for _, tf := range d.TextFragments { 253 253 - ndiff.TextFragments = append(ndiff.TextFragments, *tf) 254 254 - for _, l := range tf.Lines { 255 255 - switch l.Op { 256 256 - case gitdiff.OpAdd: 257 257 - nd.Stat.Insertions += 1 258 258 - case gitdiff.OpDelete: 259 259 - nd.Stat.Deletions += 1 260 260 - } 261 261 - } 262 262 - } 263 263 - 264 264 - nd.Diff = append(nd.Diff, ndiff) 265 265 - } 266 266 - 267 267 - nd.Stat.FilesChanged = len(diffs) 268 268 - 269 269 - return nd 270 270 - } 271 271 - 272 205 func (s PullSubmission) IsFormatPatch() bool { 273 206 return patchutil.IsFormatPatch(s.Patch) 274 207 } 275 208 276 276 - func (s PullSubmission) AsFormatPatch() []patchutil.FormatPatch { 209 209 + func (s PullSubmission) AsFormatPatch() []types.FormatPatch { 277 210 patches, err := patchutil.ExtractPatches(s.Patch) 278 211 if err != nil { 279 212 log.Println("error extracting patches from submission:", err) 280 280 - return []patchutil.FormatPatch{} 213 213 + return []types.FormatPatch{} 281 214 } 282 215 283 216 return patches

+6 -5

appview/state/pull.go

··· 305 305 } 306 306 } 307 307 308 308 - diff := pull.Submissions[roundIdInt].AsNiceDiff(pull.TargetBranch) 308 308 + patch := pull.Submissions[roundIdInt].Patch 309 309 + diff := patchutil.AsNiceDiff(patch, pull.TargetBranch) 309 310 310 311 s.pages.RepoPullPatchPage(w, pages.RepoPullPatchParams{ 311 312 LoggedInUser: user, ··· 361 362 } 362 363 } 363 364 364 364 - currentPatch, err := pull.Submissions[roundIdInt].AsDiff(pull.TargetBranch) 365 365 + currentPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt].Patch) 365 366 if err != nil { 366 367 log.Println("failed to interdiff; current patch malformed") 367 368 s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; current patch is invalid.") 368 369 return 369 370 } 370 371 371 371 - previousPatch, err := pull.Submissions[roundIdInt-1].AsDiff(pull.TargetBranch) 372 372 + previousPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt-1].Patch) 372 373 if err != nil { 373 374 log.Println("failed to interdiff; previous patch malformed") 374 375 s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; previous patch is invalid.") ··· 1143 1144 return 1144 1145 } 1145 1146 1146 1146 - branches := result.Branches 1147 1147 + branches := result.Branches 1147 1148 sort.Slice(branches, func(i int, j int) bool { 1148 1149 return branches[i].Commit.Committer.When.After(branches[j].Commit.Committer.When) 1149 1150 }) ··· 1233 1234 1234 1235 s.pages.PullCompareForkBranchesFragment(w, pages.PullCompareForkBranchesParams{ 1235 1236 RepoInfo: f.RepoInfo(s, user), 1236 1236 - SourceBranches: sourceResult.Branches, 1237 1237 + SourceBranches: sourceBranches, 1237 1238 TargetBranches: targetResult.Branches, 1238 1239 }) 1239 1240 }

+9 -5

appview/state/repo.go

··· 2084 2084 return 2085 2085 } 2086 2086 2087 2087 - forks, err := db.GetForksByDid(s.db, user.Did) 2088 2088 - if err != nil { 2089 2089 - s.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 2090 2090 - log.Println("failed to get forks", err) 2091 2091 - return 2087 2087 + var forks []db.Repo 2088 2088 + if user != nil { 2089 2089 + var err error 2090 2090 + forks, err = db.GetForksByDid(s.db, user.Did) 2091 2091 + if err != nil { 2092 2092 + s.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 2093 2093 + log.Println("failed to get forks", err) 2094 2094 + return 2095 2095 + } 2092 2096 } 2093 2097 2094 2098 s.pages.RepoCompare(w, pages.RepoCompareParams{

+3 -3

knotserver/git/diff.go

··· 127 127 128 128 // FormatPatch generates a git-format-patch output between two commits, 129 129 // and returns the raw format-patch series, a parsed FormatPatch and an error. 130 130 - func (g *GitRepo) formatSinglePatch(base, commit2 plumbing.Hash, extraArgs ...string) (string, *patchutil.FormatPatch, error) { 130 130 + func (g *GitRepo) formatSinglePatch(base, commit2 plumbing.Hash, extraArgs ...string) (string, *types.FormatPatch, error) { 131 131 var stdout bytes.Buffer 132 132 133 133 args := []string{ ··· 222 222 return commits, nil 223 223 } 224 224 225 225 - func (g *GitRepo) FormatPatch(base, commit2 *object.Commit) (string, []patchutil.FormatPatch, error) { 225 225 + func (g *GitRepo) FormatPatch(base, commit2 *object.Commit) (string, []types.FormatPatch, error) { 226 226 // get list of commits between commir2 and base 227 227 commits, err := g.commitsBetween(commit2, base) 228 228 if err != nil { ··· 233 233 slices.Reverse(commits) 234 234 235 235 var allPatchesContent strings.Builder 236 236 - var allPatches []patchutil.FormatPatch 236 236 + var allPatches []types.FormatPatch 237 237 238 238 for _, commit := range commits { 239 239 changeId := ""

+69 -16

patchutil/patchutil.go

··· 2 2 3 3 import ( 4 4 "fmt" 5 5 + "log" 5 6 "os" 6 7 "os/exec" 7 8 "regexp" ··· 9 10 "strings" 10 11 11 12 "github.com/bluekeyes/go-gitdiff/gitdiff" 13 13 + "tangled.sh/tangled.sh/core/types" 12 14 ) 13 15 14 14 - type FormatPatch struct { 15 15 - Files []*gitdiff.File 16 16 - *gitdiff.PatchHeader 17 17 - Raw string 18 18 - } 19 19 - 20 20 - func (f FormatPatch) ChangeId() (string, error) { 21 21 - if vals, ok := f.RawHeaders["Change-Id"]; ok && len(vals) == 1 { 22 22 - return vals[0], nil 23 23 - } 24 24 - return "", fmt.Errorf("no change-id found") 25 25 - } 26 26 - 27 27 - func ExtractPatches(formatPatch string) ([]FormatPatch, error) { 16 16 + func ExtractPatches(formatPatch string) ([]types.FormatPatch, error) { 28 17 patches := splitFormatPatch(formatPatch) 29 18 30 30 - result := []FormatPatch{} 19 19 + result := []types.FormatPatch{} 31 20 32 21 for _, patch := range patches { 33 22 files, headerStr, err := gitdiff.Parse(strings.NewReader(patch)) ··· 40 29 return nil, fmt.Errorf("failed to parse patch header: %w", err) 41 30 } 42 31 43 43 - result = append(result, FormatPatch{ 32 32 + result = append(result, types.FormatPatch{ 44 33 Files: files, 45 34 PatchHeader: header, 46 35 Raw: patch, ··· 263 252 return strings.Compare(bestName(a), bestName(b)) 264 253 }) 265 254 } 255 255 + 256 256 + func AsDiff(patch string) ([]*gitdiff.File, error) { 257 257 + // if format-patch; then extract each patch 258 258 + var diffs []*gitdiff.File 259 259 + if IsFormatPatch(patch) { 260 260 + patches, err := ExtractPatches(patch) 261 261 + if err != nil { 262 262 + return nil, err 263 263 + } 264 264 + var ps [][]*gitdiff.File 265 265 + for _, p := range patches { 266 266 + ps = append(ps, p.Files) 267 267 + } 268 268 + 269 269 + diffs = CombineDiff(ps...) 270 270 + } else { 271 271 + d, _, err := gitdiff.Parse(strings.NewReader(patch)) 272 272 + if err != nil { 273 273 + return nil, err 274 274 + } 275 275 + diffs = d 276 276 + } 277 277 + 278 278 + return diffs, nil 279 279 + } 280 280 + 281 281 + func AsNiceDiff(patch, targetBranch string) types.NiceDiff { 282 282 + diffs, err := AsDiff(patch) 283 283 + if err != nil { 284 284 + log.Println(err) 285 285 + } 286 286 + 287 287 + nd := types.NiceDiff{} 288 288 + nd.Commit.Parent = targetBranch 289 289 + 290 290 + for _, d := range diffs { 291 291 + ndiff := types.Diff{} 292 292 + ndiff.Name.New = d.NewName 293 293 + ndiff.Name.Old = d.OldName 294 294 + ndiff.IsBinary = d.IsBinary 295 295 + ndiff.IsNew = d.IsNew 296 296 + ndiff.IsDelete = d.IsDelete 297 297 + ndiff.IsCopy = d.IsCopy 298 298 + ndiff.IsRename = d.IsRename 299 299 + 300 300 + for _, tf := range d.TextFragments { 301 301 + ndiff.TextFragments = append(ndiff.TextFragments, *tf) 302 302 + for _, l := range tf.Lines { 303 303 + switch l.Op { 304 304 + case gitdiff.OpAdd: 305 305 + nd.Stat.Insertions += 1 306 306 + case gitdiff.OpDelete: 307 307 + nd.Stat.Deletions += 1 308 308 + } 309 309 + } 310 310 + } 311 311 + 312 312 + nd.Diff = append(nd.Diff, ndiff) 313 313 + } 314 314 + 315 315 + nd.Stat.FilesChanged = len(diffs) 316 316 + 317 317 + return nd 318 318 + }

+20

types/patch.go

··· 1 1 + package types 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + 6 6 + "github.com/bluekeyes/go-gitdiff/gitdiff" 7 7 + ) 8 8 + 9 9 + type FormatPatch struct { 10 10 + Files []*gitdiff.File 11 11 + *gitdiff.PatchHeader 12 12 + Raw string 13 13 + } 14 14 + 15 15 + func (f FormatPatch) ChangeId() (string, error) { 16 16 + if vals, ok := f.RawHeaders["Change-Id"]; ok && len(vals) == 1 { 17 17 + return vals[0], nil 18 18 + } 19 19 + return "", fmt.Errorf("no change-id found") 20 20 + }

+5 -6

types/repo.go

··· 2 2 3 3 import ( 4 4 "github.com/go-git/go-git/v5/plumbing/object" 5 5 - "tangled.sh/tangled.sh/core/patchutil" 6 5 ) 7 6 8 7 type RepoIndexResponse struct { ··· 34 33 } 35 34 36 35 type RepoFormatPatchResponse struct { 37 37 - Rev1 string `json:"rev1,omitempty"` 38 38 - Rev2 string `json:"rev2,omitempty"` 39 39 - FormatPatch []patchutil.FormatPatch `json:"format_patch,omitempty"` 40 40 - MergeBase string `json:"merge_base,omitempty"` 41 41 - Patch string `json:"patch,omitempty"` 36 36 + Rev1 string `json:"rev1,omitempty"` 37 37 + Rev2 string `json:"rev2,omitempty"` 38 38 + FormatPatch []FormatPatch `json:"format_patch,omitempty"` 39 39 + MergeBase string `json:"merge_base,omitempty"` 40 40 + Patch string `json:"patch,omitempty"` 42 41 } 43 42 44 43 type RepoTreeResponse struct {