commit b3941e395d46d84061bd2511d39e80699a1ca63f · julien.rbrt.fr/tangled-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

···

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

     

       261
       261
        
       	}

     

       262
       262
        
       

     

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

     

       264
       264
       +
       

     

       263
       265
        
       	if latestSourceRev != result.Branch.Hash {

     

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

     

       265
       266
        
       		return pages.ShouldResubmit

     

       266
       267
        
       	}

     

       267
       268
        
       

     
···

       1609
       1610
        
       			patchutil.SortPatch(origFiles)

     

       1610
       1611
        
       

     

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

     

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

     

       1613
       1613
       +
       			//

     

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

     

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

     

       1616
       1616
       +
       				origHeader.Title == newHeader.Title &&

     

       1617
       1617
       +
       				origHeader.Body == newHeader.Body {

     

       1613
       1618
        
       				unchanged[op.ChangeId] = struct{}{}

     

       1614
       1619
        
       			} else {

     

       1615
       1620
        
       				updated[op.ChangeId] = struct{}{}

     
···

       1683
       1688
        
       

     

       1684
       1689
        
       		record := op.AsRecord()

     

       1685
       1690
        
       		record.Patch = submission.Patch

     

       1691
       1691
       +
       

     

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

     

       1693
       1693
       +
       			RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{

     

       1694
       1694
       +
       				Collection: tangled.RepoPullNSID,

     

       1695
       1695
       +
       				Rkey:       op.Rkey,

     

       1696
       1696
       +
       				Value: &lexutil.LexiconTypeDecoder{

     

       1697
       1697
       +
       					Val: &record,

     

       1698
       1698
       +
       				},

     

       1699
       1699
       +
       			},

     

       1700
       1700
       +
       		})

     

       1701
       1701
       +
       	}

     

       1702
       1702
       +
       

     

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

     

       1704
       1704
       +
       	//

     

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

     

       1706
       1706
       +
       	for changeId := range unchanged {

     

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

     

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

     

       1709
       1709
       +
       

     

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

     

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

     

       1712
       1712
       +
       

     

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

     

       1714
       1714
       +
       

     

       1715
       1715
       +
       		err := db.UpdatePull(

     

       1716
       1716
       +
       			tx,

     

       1717
       1717
       +
       			newSubmission.Patch,

     

       1718
       1718
       +
       			newSubmission.SourceRev,

     

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

     

       1720
       1720
       +
       		)

     

       1721
       1721
       +
       

     

       1722
       1722
       +
       		if err != nil {

     

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

     

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

     

       1725
       1725
       +
       			return

     

       1726
       1726
       +
       		}

     

       1727
       1727
       +
       

     

       1728
       1728
       +
       		record := op.AsRecord()

     

       1729
       1729
       +
       		record.Patch = newSubmission.Patch

     

       1686
       1730
        
       

     

       1687
       1731
        
       		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{

     

       1688
       1732
        
       			RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{