+15

appview/db/pulls.go

··· 10 10 11 11 "github.com/bluekeyes/go-gitdiff/gitdiff" 12 12 "github.com/bluesky-social/indigo/atproto/syntax" 13 13 + "tangled.sh/tangled.sh/core/patchutil" 13 14 "tangled.sh/tangled.sh/core/types" 14 15 ) 15 16 ··· 188 189 nd.Stat.FilesChanged = len(diffs) 189 190 190 191 return nd 192 192 + } 193 193 + 194 194 + func (s PullSubmission) IsFormatPatch() bool { 195 195 + return patchutil.IsFormatPatch(s.Patch) 196 196 + } 197 197 + 198 198 + func (s PullSubmission) AsFormatPatch() []patchutil.FormatPatch { 199 199 + patches, err := patchutil.ExtractPatches(s.Patch) 200 200 + if err != nil { 201 201 + log.Println("error extracting patches from submission:", err) 202 202 + return []patchutil.FormatPatch{} 203 203 + } 204 204 + 205 205 + return patches 191 206 } 192 207 193 208 func NewPull(tx *sql.Tx, pull *Pull) error {

+29 -41

appview/state/pull.go

··· 10 10 "net/http" 11 11 "net/url" 12 12 "strconv" 13 13 - "strings" 14 13 "time" 15 14 16 15 "github.com/go-chi/chi/v5" ··· 18 17 "tangled.sh/tangled.sh/core/appview/auth" 19 18 "tangled.sh/tangled.sh/core/appview/db" 20 19 "tangled.sh/tangled.sh/core/appview/pages" 20 20 + "tangled.sh/tangled.sh/core/patchutil" 21 21 "tangled.sh/tangled.sh/core/types" 22 22 23 23 comatproto "github.com/bluesky-social/indigo/api/atproto" ··· 254 254 255 255 latestSubmission := pull.Submissions[pull.LastRoundNumber()] 256 256 if latestSubmission.SourceRev != result.Branch.Hash { 257 257 + fmt.Println(latestSubmission.SourceRev, result.Branch.Hash) 257 258 return pages.ShouldResubmit 258 259 } 259 260 ··· 635 636 return 636 637 } 637 638 638 638 - diffTreeResponse, err := ksClient.Compare(f.OwnerDid(), f.RepoName, targetBranch, sourceBranch) 639 639 + comparison, err := ksClient.Compare(f.OwnerDid(), f.RepoName, targetBranch, sourceBranch) 639 640 if err != nil { 640 641 log.Println("failed to compare", err) 641 642 s.pages.Notice(w, "pull", err.Error()) 642 643 return 643 644 } 644 645 645 645 - sourceRev := diffTreeResponse.DiffTree.Rev2 646 646 - patch := diffTreeResponse.DiffTree.Patch 646 646 + sourceRev := comparison.Rev2 647 647 + patch := comparison.Patch 647 648 648 648 - if !isPatchValid(patch) { 649 649 + if !patchutil.IsPatchValid(patch) { 649 650 s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.") 650 651 return 651 652 } ··· 654 655 } 655 656 656 657 func (s *State) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, f *FullyResolvedRepo, user *auth.User, title, body, targetBranch, patch string) { 657 657 - if !isPatchValid(patch) { 658 658 + if !patchutil.IsPatchValid(patch) { 658 659 s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.") 659 660 return 660 661 } ··· 714 715 // hiddenRef: hidden/feature-1/main (on repo-fork) 715 716 // targetBranch: main (on repo-1) 716 717 // sourceBranch: feature-1 (on repo-fork) 717 717 - diffTreeResponse, err := us.Compare(user.Did, fork.Name, hiddenRef, sourceBranch) 718 718 + comparison, err := us.Compare(user.Did, fork.Name, hiddenRef, sourceBranch) 718 719 if err != nil { 719 720 log.Println("failed to compare across branches", err) 720 721 s.pages.Notice(w, "pull", err.Error()) 721 722 return 722 723 } 723 724 724 724 - sourceRev := diffTreeResponse.DiffTree.Rev2 725 725 - patch := diffTreeResponse.DiffTree.Patch 725 725 + sourceRev := comparison.Rev2 726 726 + patch := comparison.Patch 726 727 727 727 - if !isPatchValid(patch) { 728 728 + if patchutil.IsPatchValid(patch) { 728 729 s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.") 729 730 return 730 731 } ··· 742 743 }, &tangled.RepoPull_Source{Branch: sourceBranch, Repo: &fork.AtUri}) 743 744 } 744 745 745 745 - func (s *State) createPullRequest(w http.ResponseWriter, r *http.Request, f *FullyResolvedRepo, user *auth.User, title, body, targetBranch, patch, sourceRev string, pullSource *db.PullSource, recordPullSource *tangled.RepoPull_Source) { 746 746 + func (s *State) createPullRequest( 747 747 + w http.ResponseWriter, 748 748 + r *http.Request, 749 749 + f *FullyResolvedRepo, 750 750 + user *auth.User, 751 751 + title, body, targetBranch string, 752 752 + patch string, 753 753 + sourceRev string, 754 754 + pullSource *db.PullSource, 755 755 + recordPullSource *tangled.RepoPull_Source, 756 756 + ) { 746 757 tx, err := s.db.BeginTx(r.Context(), nil) 747 758 if err != nil { 748 759 log.Println("failed to start tx") ··· 1112 1123 return 1113 1124 } 1114 1125 1115 1115 - diffTreeResponse, err := ksClient.Compare(f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.PullSource.Branch) 1126 1126 + comparison, err := ksClient.Compare(f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.PullSource.Branch) 1116 1127 if err != nil { 1117 1128 log.Printf("compare request failed: %s", err) 1118 1129 s.pages.Notice(w, "resubmit-error", err.Error()) 1119 1130 return 1120 1131 } 1121 1132 1122 1122 - sourceRev := diffTreeResponse.DiffTree.Rev2 1123 1123 - patch := diffTreeResponse.DiffTree.Patch 1133 1133 + sourceRev := comparison.Rev2 1134 1134 + patch := comparison.Patch 1124 1135 1125 1136 if err = validateResubmittedPatch(pull, patch); err != nil { 1126 1137 s.pages.Notice(w, "resubmit-error", err.Error()) ··· 1249 1260 } 1250 1261 1251 1262 hiddenRef := url.QueryEscape(fmt.Sprintf("hidden/%s/%s", pull.PullSource.Branch, pull.TargetBranch)) 1252 1252 - diffTreeResponse, err := ksClient.Compare(forkRepo.Did, forkRepo.Name, hiddenRef, pull.PullSource.Branch) 1263 1263 + comparison, err := ksClient.Compare(forkRepo.Did, forkRepo.Name, hiddenRef, pull.PullSource.Branch) 1253 1264 if err != nil { 1254 1265 log.Printf("failed to compare branches: %s", err) 1255 1266 s.pages.Notice(w, "resubmit-error", err.Error()) 1256 1267 return 1257 1268 } 1258 1269 1259 1259 - sourceRev := diffTreeResponse.DiffTree.Rev2 1260 1260 - patch := diffTreeResponse.DiffTree.Patch 1270 1270 + sourceRev := comparison.Rev2 1271 1271 + patch := comparison.Patch 1261 1272 1262 1273 if err = validateResubmittedPatch(pull, patch); err != nil { 1263 1274 s.pages.Notice(w, "resubmit-error", err.Error()) ··· 1338 1349 return fmt.Errorf("Patch is identical to previous submission.") 1339 1350 } 1340 1351 1341 1341 - if !isPatchValid(patch) { 1352 1352 + if patchutil.IsPatchValid(patch) { 1342 1353 return fmt.Errorf("Invalid patch format. Please provide a valid diff.") 1343 1354 } 1344 1355 ··· 1516 1527 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId)) 1517 1528 return 1518 1529 } 1519 1519 - 1520 1520 - // Very basic validation to check if it looks like a diff/patch 1521 1521 - // A valid patch usually starts with diff or --- lines 1522 1522 - func isPatchValid(patch string) bool { 1523 1523 - // Basic validation to check if it looks like a diff/patch 1524 1524 - // A valid patch usually starts with diff or --- lines 1525 1525 - if len(patch) == 0 { 1526 1526 - return false 1527 1527 - } 1528 1528 - 1529 1529 - lines := strings.Split(patch, "\n") 1530 1530 - if len(lines) < 2 { 1531 1531 - return false 1532 1532 - } 1533 1533 - 1534 1534 - // Check for common patch format markers 1535 1535 - firstLine := strings.TrimSpace(lines[0]) 1536 1536 - return strings.HasPrefix(firstLine, "diff ") || 1537 1537 - strings.HasPrefix(firstLine, "--- ") || 1538 1538 - strings.HasPrefix(firstLine, "Index: ") || 1539 1539 - strings.HasPrefix(firstLine, "+++ ") || 1540 1540 - strings.HasPrefix(firstLine, "@@ ") 1541 1541 - }

+6 -6

appview/state/signer.go

··· 378 378 return &capabilities, nil 379 379 } 380 380 381 381 - func (us *UnsignedClient) Compare(ownerDid, repoName, rev1, rev2 string) (*types.RepoDiffTreeResponse, error) { 381 381 + func (us *UnsignedClient) Compare(ownerDid, repoName, rev1, rev2 string) (*types.RepoFormatPatchResponse, error) { 382 382 const ( 383 383 Method = "GET" 384 384 ) ··· 409 409 } 410 410 defer compareResp.Body.Close() 411 411 412 412 - var diffTreeResponse types.RepoDiffTreeResponse 413 413 - err = json.Unmarshal(respBody, &diffTreeResponse) 412 412 + var formatPatchResponse types.RepoFormatPatchResponse 413 413 + err = json.Unmarshal(respBody, &formatPatchResponse) 414 414 if err != nil { 415 415 - log.Println("failed to unmarshal diff tree response", err) 416 416 - return nil, fmt.Errorf("Failed to compare branches.") 415 415 + log.Println("failed to unmarshal format-patch response", err) 416 416 + return nil, fmt.Errorf("failed to compare branches.") 417 417 } 418 418 419 419 - return &diffTreeResponse, nil 419 419 + return &formatPatchResponse, nil 420 420 }

+6 -2

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" 5 6 ) 6 7 7 8 type RepoIndexResponse struct { ··· 32 33 Diff *NiceDiff `json:"diff,omitempty"` 33 34 } 34 35 35 35 - type RepoDiffTreeResponse struct { 36 36 - DiffTree *DiffTree `json:"difftree,omitempty"` 36 36 + 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 + Patch string `json:"patch,omitempty"` 37 41 } 38 42 39 43 type RepoTreeResponse struct {