commit 051c142e43f89caa51957529ae858ea9a5a490b1 · veryroundbird.house/core

+25

appview/db/pulls.go

···

       947
       947
        
       	return err

     

       948
       948
        
       }

     

       949
       949
        
       

     

       950
       950
       +
       // Only used when stacking to update contents in the event of a rebase (the interdiff should be empty).

     

       951
       951
       +
       // otherwise submissions are immutable

     

       952
       952
       +
       func UpdatePull(e Execer, newPatch, sourceRev string, filters ...filter) error {

     

       953
       953
       +
       	var conditions []string

     

       954
       954
       +
       	var args []any

     

       955
       955
       +
       

     

       956
       956
       +
       	args = append(args, sourceRev)

     

       957
       957
       +
       	args = append(args, newPatch)

     

       958
       958
       +
       

     

       959
       959
       +
       	for _, filter := range filters {

     

       960
       960
       +
       		conditions = append(conditions, filter.Condition())

     

       961
       961
       +
       		args = append(args, filter.arg)

     

       962
       962
       +
       	}

     

       963
       963
       +
       

     

       964
       964
       +
       	whereClause := ""

     

       965
       965
       +
       	if conditions != nil {

     

       966
       966
       +
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       967
       967
       +
       	}

     

       968
       968
       +
       

     

       969
       969
       +
       	query := fmt.Sprintf("update pull_submissions set source_rev = ?, patch = ? %s", whereClause)

     

       970
       970
       +
       	_, err := e.Exec(query, args...)

     

       971
       971
       +
       

     

       972
       972
       +
       	return err

     

       973
       973
       +
       }

     

       974
       974
       +
       

     

       950
       975
        
       type PullCount struct {

     

       951
       976
        
       	Open    int

     

       952
       977
        
       	Merged  int

+46 -2

appview/state/pull.go

···

       273
       273
        
       		latestSourceRev = top.Submissions[top.LastRoundNumber()].SourceRev

     

       274
       274
        
       	}

     

       275
       275
        
       

     

       276
       276
       +
       	log.Println(latestSourceRev, result.Branch.Hash)

     

       277
       277
       +
       

     

       276
       278
        
       	if latestSourceRev != result.Branch.Hash {

     

       277
       277
       -
       		log.Println(latestSourceRev, result.Branch.Hash)

     

       278
       279
        
       		return pages.ShouldResubmit

     

       279
       280
        
       	}

     

       280
       281
        
       

     
···

       1676
       1677
        
       			patchutil.SortPatch(origFiles)

     

       1677
       1678
        
       

     

       1678
       1679
        
       			// text content of patch may be identical, but a jj rebase might have forwarded it

     

       1679
       1679
       -
       			if patchutil.Equal(newFiles, origFiles) && origHeader.SHA == newHeader.SHA {

     

       1680
       1680
       +
       			//

     

       1681
       1681
       +
       			// we still need to update the hash in submission.Patch and submission.SourceRev

     

       1682
       1682
       +
       			if patchutil.Equal(newFiles, origFiles) &&

     

       1683
       1683
       +
       				origHeader.Title == newHeader.Title &&

     

       1684
       1684
       +
       				origHeader.Body == newHeader.Body {

     

       1680
       1685
        
       				unchanged[op.ChangeId] = struct{}{}

     

       1681
       1686
        
       			} else {

     

       1682
       1687
        
       				updated[op.ChangeId] = struct{}{}

     
···

       1750
       1755
        
       

     

       1751
       1756
        
       		record := op.AsRecord()

     

       1752
       1757
        
       		record.Patch = submission.Patch

     

       1758
       1758
       +
       

     

       1759
       1759
       +
       		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{

     

       1760
       1760
       +
       			RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{

     

       1761
       1761
       +
       				Collection: tangled.RepoPullNSID,

     

       1762
       1762
       +
       				Rkey:       op.Rkey,

     

       1763
       1763
       +
       				Value: &lexutil.LexiconTypeDecoder{

     

       1764
       1764
       +
       					Val: &record,

     

       1765
       1765
       +
       				},

     

       1766
       1766
       +
       			},

     

       1767
       1767
       +
       		})

     

       1768
       1768
       +
       	}

     

       1769
       1769
       +
       

     

       1770
       1770
       +
       	// unchanged pulls are edited without starting a new round

     

       1771
       1771
       +
       	//

     

       1772
       1772
       +
       	// update source-revs & patches without advancing rounds

     

       1773
       1773
       +
       	for changeId := range unchanged {

     

       1774
       1774
       +
       		op, _ := origById[changeId]

     

       1775
       1775
       +
       		np, _ := newById[changeId]

     

       1776
       1776
       +
       

     

       1777
       1777
       +
       		origSubmission := op.Submissions[op.LastRoundNumber()]

     

       1778
       1778
       +
       		newSubmission := np.Submissions[np.LastRoundNumber()]

     

       1779
       1779
       +
       

     

       1780
       1780
       +
       		log.Println("moving unchanged change id : ", changeId)

     

       1781
       1781
       +
       

     

       1782
       1782
       +
       		err := db.UpdatePull(

     

       1783
       1783
       +
       			tx,

     

       1784
       1784
       +
       			newSubmission.Patch,

     

       1785
       1785
       +
       			newSubmission.SourceRev,

     

       1786
       1786
       +
       			db.FilterEq("id", origSubmission.ID),

     

       1787
       1787
       +
       		)

     

       1788
       1788
       +
       

     

       1789
       1789
       +
       		if err != nil {

     

       1790
       1790
       +
       			log.Println("failed to update pull", err, op.PullId)

     

       1791
       1791
       +
       			s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")

     

       1792
       1792
       +
       			return

     

       1793
       1793
       +
       		}

     

       1794
       1794
       +
       

     

       1795
       1795
       +
       		record := op.AsRecord()

     

       1796
       1796
       +
       		record.Patch = newSubmission.Patch

     

       1753
       1797
        
       

     

       1754
       1798
        
       		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{

     

       1755
       1799
        
       			RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{