patch of lexicons: pulls: add stack information to pull records · round #2 · pull #405 · tangled.org/core

+202 -1

api/tangled/cbor_gen.go

···

       6939
       6939
        
       

     

       6940
       6940
        
       	return nil

     

       6941
       6941
        
       }

     

       6942
       6942
       +
       func (t *RepoPull_StackInfo) MarshalCBOR(w io.Writer) error {

     

       6943
       6943
       +
       	if t == nil {

     

       6944
       6944
       +
       		_, err := w.Write(cbg.CborNull)

     

       6945
       6945
       +
       		return err

     

       6946
       6946
       +
       	}

     

       6947
       6947
       +
       

     

       6948
       6948
       +
       	cw := cbg.NewCborWriter(w)

     

       6949
       6949
       +
       	fieldCount := 2

     

       6950
       6950
       +
       

     

       6951
       6951
       +
       	if t.Parent == nil {

     

       6952
       6952
       +
       		fieldCount--

     

       6953
       6953
       +
       	}

     

       6954
       6954
       +
       

     

       6955
       6955
       +
       	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {

     

       6956
       6956
       +
       		return err

     

       6957
       6957
       +
       	}

     

       6958
       6958
       +
       

     

       6959
       6959
       +
       	// t.Parent (string) (string)

     

       6960
       6960
       +
       	if t.Parent != nil {

     

       6961
       6961
       +
       

     

       6962
       6962
       +
       		if len("parent") > 1000000 {

     

       6963
       6963
       +
       			return xerrors.Errorf("Value in field \"parent\" was too long")

     

       6964
       6964
       +
       		}

     

       6965
       6965
       +
       

     

       6966
       6966
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("parent"))); err != nil {

     

       6967
       6967
       +
       			return err

     

       6968
       6968
       +
       		}

     

       6969
       6969
       +
       		if _, err := cw.WriteString(string("parent")); err != nil {

     

       6970
       6970
       +
       			return err

     

       6971
       6971
       +
       		}

     

       6972
       6972
       +
       

     

       6973
       6973
       +
       		if t.Parent == nil {

     

       6974
       6974
       +
       			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       6975
       6975
       +
       				return err

     

       6976
       6976
       +
       			}

     

       6977
       6977
       +
       		} else {

     

       6978
       6978
       +
       			if len(*t.Parent) > 1000000 {

     

       6979
       6979
       +
       				return xerrors.Errorf("Value in field t.Parent was too long")

     

       6980
       6980
       +
       			}

     

       6981
       6981
       +
       

     

       6982
       6982
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Parent))); err != nil {

     

       6983
       6983
       +
       				return err

     

       6984
       6984
       +
       			}

     

       6985
       6985
       +
       			if _, err := cw.WriteString(string(*t.Parent)); err != nil {

     

       6986
       6986
       +
       				return err

     

       6987
       6987
       +
       			}

     

       6988
       6988
       +
       		}

     

       6989
       6989
       +
       	}

     

       6990
       6990
       +
       

     

       6991
       6991
       +
       	// t.ChangeId (string) (string)

     

       6992
       6992
       +
       	if len("changeId") > 1000000 {

     

       6993
       6993
       +
       		return xerrors.Errorf("Value in field \"changeId\" was too long")

     

       6994
       6994
       +
       	}

     

       6995
       6995
       +
       

     

       6996
       6996
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("changeId"))); err != nil {

     

       6997
       6997
       +
       		return err

     

       6998
       6998
       +
       	}

     

       6999
       6999
       +
       	if _, err := cw.WriteString(string("changeId")); err != nil {

     

       7000
       7000
       +
       		return err

     

       7001
       7001
       +
       	}

     

       7002
       7002
       +
       

     

       7003
       7003
       +
       	if len(t.ChangeId) > 1000000 {

     

       7004
       7004
       +
       		return xerrors.Errorf("Value in field t.ChangeId was too long")

     

       7005
       7005
       +
       	}

     

       7006
       7006
       +
       

     

       7007
       7007
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ChangeId))); err != nil {

     

       7008
       7008
       +
       		return err

     

       7009
       7009
       +
       	}

     

       7010
       7010
       +
       	if _, err := cw.WriteString(string(t.ChangeId)); err != nil {

     

       7011
       7011
       +
       		return err

     

       7012
       7012
       +
       	}

     

       7013
       7013
       +
       	return nil

     

       7014
       7014
       +
       }

     

       7015
       7015
       +
       

     

       7016
       7016
       +
       func (t *RepoPull_StackInfo) UnmarshalCBOR(r io.Reader) (err error) {

     

       7017
       7017
       +
       	*t = RepoPull_StackInfo{}

     

       7018
       7018
       +
       

     

       7019
       7019
       +
       	cr := cbg.NewCborReader(r)

     

       7020
       7020
       +
       

     

       7021
       7021
       +
       	maj, extra, err := cr.ReadHeader()

     

       7022
       7022
       +
       	if err != nil {

     

       7023
       7023
       +
       		return err

     

       7024
       7024
       +
       	}

     

       7025
       7025
       +
       	defer func() {

     

       7026
       7026
       +
       		if err == io.EOF {

     

       7027
       7027
       +
       			err = io.ErrUnexpectedEOF

     

       7028
       7028
       +
       		}

     

       7029
       7029
       +
       	}()

     

       7030
       7030
       +
       

     

       7031
       7031
       +
       	if maj != cbg.MajMap {

     

       7032
       7032
       +
       		return fmt.Errorf("cbor input should be of type map")

     

       7033
       7033
       +
       	}

     

       7034
       7034
       +
       

     

       7035
       7035
       +
       	if extra > cbg.MaxLength {

     

       7036
       7036
       +
       		return fmt.Errorf("RepoPull_StackInfo: map struct too large (%d)", extra)

     

       7037
       7037
       +
       	}

     

       7038
       7038
       +
       

     

       7039
       7039
       +
       	n := extra

     

       7040
       7040
       +
       

     

       7041
       7041
       +
       	nameBuf := make([]byte, 8)

     

       7042
       7042
       +
       	for i := uint64(0); i < n; i++ {

     

       7043
       7043
       +
       		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       7044
       7044
       +
       		if err != nil {

     

       7045
       7045
       +
       			return err

     

       7046
       7046
       +
       		}

     

       7047
       7047
       +
       

     

       7048
       7048
       +
       		if !ok {

     

       7049
       7049
       +
       			// Field doesn't exist on this type, so ignore it

     

       7050
       7050
       +
       			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {

     

       7051
       7051
       +
       				return err

     

       7052
       7052
       +
       			}

     

       7053
       7053
       +
       			continue

     

       7054
       7054
       +
       		}

     

       7055
       7055
       +
       

     

       7056
       7056
       +
       		switch string(nameBuf[:nameLen]) {

     

       7057
       7057
       +
       		// t.Parent (string) (string)

     

       7058
       7058
       +
       		case "parent":

     

       7059
       7059
       +
       

     

       7060
       7060
       +
       			{

     

       7061
       7061
       +
       				b, err := cr.ReadByte()

     

       7062
       7062
       +
       				if err != nil {

     

       7063
       7063
       +
       					return err

     

       7064
       7064
       +
       				}

     

       7065
       7065
       +
       				if b != cbg.CborNull[0] {

     

       7066
       7066
       +
       					if err := cr.UnreadByte(); err != nil {

     

       7067
       7067
       +
       						return err

     

       7068
       7068
       +
       					}

     

       7069
       7069
       +
       

     

       7070
       7070
       +
       					sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       7071
       7071
       +
       					if err != nil {

     

       7072
       7072
       +
       						return err

     

       7073
       7073
       +
       					}

     

       7074
       7074
       +
       

     

       7075
       7075
       +
       					t.Parent = (*string)(&sval)

     

       7076
       7076
       +
       				}

     

       7077
       7077
       +
       			}

     

       7078
       7078
       +
       			// t.ChangeId (string) (string)

     

       7079
       7079
       +
       		case "changeId":

     

       7080
       7080
       +
       

     

       7081
       7081
       +
       			{

     

       7082
       7082
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       7083
       7083
       +
       				if err != nil {

     

       7084
       7084
       +
       					return err

     

       7085
       7085
       +
       				}

     

       7086
       7086
       +
       

     

       7087
       7087
       +
       				t.ChangeId = string(sval)

     

       7088
       7088
       +
       			}

     

       7089
       7089
       +
       

     

       7090
       7090
       +
       		default:

     

       7091
       7091
       +
       			// Field doesn't exist on this type, so ignore it

     

       7092
       7092
       +
       			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {

     

       7093
       7093
       +
       				return err

     

       7094
       7094
       +
       			}

     

       7095
       7095
       +
       		}

     

       7096
       7096
       +
       	}

     

       7097
       7097
       +
       

     

       7098
       7098
       +
       	return nil

     

       7099
       7099
       +
       }

     

       6942
       7100
        
       func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {

     

       6943
       7101
        
       	if t == nil {

     

       6944
       7102
        
       		_, err := w.Write(cbg.CborNull)

     
···

       7080
       7238
        
       	}

     

       7081
       7239
        
       

     

       7082
       7240
        
       	cw := cbg.NewCborWriter(w)

     

       7083
       7083
       -
       	fieldCount := 7

     

       7241
       7241
       +
       	fieldCount := 8

     

       7084
       7242
        
       

     

       7085
       7243
        
       	if t.Body == nil {

     

       7086
       7244
        
       		fieldCount--

     
···

       7090
       7248
        
       		fieldCount--

     

       7091
       7249
        
       	}

     

       7092
       7250
        
       

     

       7251
       7251
       +
       	if t.StackInfo == nil {

     

       7252
       7252
       +
       		fieldCount--

     

       7253
       7253
       +
       	}

     

       7254
       7254
       +
       

     

       7093
       7255
        
       	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {

     

       7094
       7256
        
       		return err

     

       7095
       7257
        
       	}

     
···

       7248
       7410
        
       	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {

     

       7249
       7411
        
       		return err

     

       7250
       7412
        
       	}

     

       7413
       7413
       +
       

     

       7414
       7414
       +
       	// t.StackInfo (tangled.RepoPull_StackInfo) (struct)

     

       7415
       7415
       +
       	if t.StackInfo != nil {

     

       7416
       7416
       +
       

     

       7417
       7417
       +
       		if len("stackInfo") > 1000000 {

     

       7418
       7418
       +
       			return xerrors.Errorf("Value in field \"stackInfo\" was too long")

     

       7419
       7419
       +
       		}

     

       7420
       7420
       +
       

     

       7421
       7421
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stackInfo"))); err != nil {

     

       7422
       7422
       +
       			return err

     

       7423
       7423
       +
       		}

     

       7424
       7424
       +
       		if _, err := cw.WriteString(string("stackInfo")); err != nil {

     

       7425
       7425
       +
       			return err

     

       7426
       7426
       +
       		}

     

       7427
       7427
       +
       

     

       7428
       7428
       +
       		if err := t.StackInfo.MarshalCBOR(cw); err != nil {

     

       7429
       7429
       +
       			return err

     

       7430
       7430
       +
       		}

     

       7431
       7431
       +
       	}

     

       7251
       7432
        
       	return nil

     

       7252
       7433
        
       }

     

       7253
       7434
        
       

     
···

       7397
       7578
        
       

     

       7398
       7579
        
       				t.CreatedAt = string(sval)

     

       7399
       7580
        
       			}

     

       7581
       7581
       +
       			// t.StackInfo (tangled.RepoPull_StackInfo) (struct)

     

       7582
       7582
       +
       		case "stackInfo":

     

       7583
       7583
       +
       

     

       7584
       7584
       +
       			{

     

       7585
       7585
       +
       

     

       7586
       7586
       +
       				b, err := cr.ReadByte()

     

       7587
       7587
       +
       				if err != nil {

     

       7588
       7588
       +
       					return err

     

       7589
       7589
       +
       				}

     

       7590
       7590
       +
       				if b != cbg.CborNull[0] {

     

       7591
       7591
       +
       					if err := cr.UnreadByte(); err != nil {

     

       7592
       7592
       +
       						return err

     

       7593
       7593
       +
       					}

     

       7594
       7594
       +
       					t.StackInfo = new(RepoPull_StackInfo)

     

       7595
       7595
       +
       					if err := t.StackInfo.UnmarshalCBOR(cr); err != nil {

     

       7596
       7596
       +
       						return xerrors.Errorf("unmarshaling t.StackInfo pointer: %w", err)

     

       7597
       7597
       +
       					}

     

       7598
       7598
       +
       				}

     

       7599
       7599
       +
       

     

       7600
       7600
       +
       			}

     

       7400
       7601
        
       

     

       7401
       7602
        
       		default:

     

       7402
       7603
        
       			// Field doesn't exist on this type, so ignore it

+16 -7

api/tangled/repopull.go

···

       17
       17
        
       } //

     

       18
       18
        
       // RECORDTYPE: RepoPull

     

       19
       19
        
       type RepoPull struct {

     

       20
       20
       -
       	LexiconTypeID string           `json:"$type,const=sh.tangled.repo.pull" cborgen:"$type,const=sh.tangled.repo.pull"`

     

       21
       21
       -
       	Body          *string          `json:"body,omitempty" cborgen:"body,omitempty"`

     

       22
       22
       -
       	CreatedAt     string           `json:"createdAt" cborgen:"createdAt"`

     

       23
       23
       -
       	Patch         string           `json:"patch" cborgen:"patch"`

     

       24
       24
       -
       	Source        *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`

     

       25
       25
       -
       	Target        *RepoPull_Target `json:"target" cborgen:"target"`

     

       26
       26
       -
       	Title         string           `json:"title" cborgen:"title"`

     

       20
       20
       +
       	LexiconTypeID string              `json:"$type,const=sh.tangled.repo.pull" cborgen:"$type,const=sh.tangled.repo.pull"`

     

       21
       21
       +
       	Body          *string             `json:"body,omitempty" cborgen:"body,omitempty"`

     

       22
       22
       +
       	CreatedAt     string              `json:"createdAt" cborgen:"createdAt"`

     

       23
       23
       +
       	Patch         string              `json:"patch" cborgen:"patch"`

     

       24
       24
       +
       	Source        *RepoPull_Source    `json:"source,omitempty" cborgen:"source,omitempty"`

     

       25
       25
       +
       	StackInfo     *RepoPull_StackInfo `json:"stackInfo,omitempty" cborgen:"stackInfo,omitempty"`

     

       26
       26
       +
       	Target        *RepoPull_Target    `json:"target" cborgen:"target"`

     

       27
       27
       +
       	Title         string              `json:"title" cborgen:"title"`

     

       27
       28
        
       }

     

       28
       29
        
       

     

       29
       30
        
       // RepoPull_Source is a "source" in the sh.tangled.repo.pull schema.

     
···

       33
       34
        
       	Sha    string  `json:"sha" cborgen:"sha"`

     

       34
       35
        
       }

     

       35
       36
        
       

     

       37
       37
       +
       // RepoPull_StackInfo is a "stackInfo" in the sh.tangled.repo.pull schema.

     

       38
       38
       +
       type RepoPull_StackInfo struct {

     

       39
       39
       +
       	// changeId: Change ID of this commit/change. Principly also available in the patch itself as a line in the commit footer.

     

       40
       40
       +
       	ChangeId string `json:"changeId" cborgen:"changeId"`

     

       41
       41
       +
       	// parent: AT-URI of the PR for the parent commit/change in the change stack.

     

       42
       42
       +
       	Parent *string `json:"parent,omitempty" cborgen:"parent,omitempty"`

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       36
       45
        
       // RepoPull_Target is a "target" in the sh.tangled.repo.pull schema.

     

       37
       46
        
       type RepoPull_Target struct {

     

       38
       47
        
       	Branch string `json:"branch" cborgen:"branch"`

appview/db/db.go

···

       655
       655
        
       		return err

     

       656
       656
        
       	})

     

       657
       657
        
       

     

       658
       658
       +
       

     

       659
       659
       +
       	runMigration(db, "add-parent-at-for-stacks-to-pulls", func(tx *sql.Tx) error {

     

       660
       660
       +
       		_, err := tx.Exec(`

     

       661
       661
       +
       			alter table pulls add column parent_at text;

     

       662
       662
       +
       		`)

     

       663
       663
       +
       		return err

     

       664
       664
       +
       	})

     

       665
       665
       +
       

     

       658
       666
        
       	return &DB{db}, nil

     

       659
       667
        
       }

     

       660
       668

+37 -10

appview/db/pulls.go

···

       72
       72
        
       	// stacking

     

       73
       73
        
       	StackId        string // nullable string

     

       74
       74
        
       	ChangeId       string // nullable string

     

       75
       75
       +
       	ParentAt       *syntax.ATURI

     

       75
       76
        
       	ParentChangeId string // nullable string

     

       76
       77
        
       

     

       77
       78
        
       	// meta

     
···

       91
       92
        
       	}

     

       92
       93
        
       

     

       93
       94
        
       	record := tangled.RepoPull{

     

       94
       94
       -
       		Title:        p.Title,

     

       95
       95
       -
       		Body:         &p.Body,

     

       96
       96
       -
       		CreatedAt:    p.Created.Format(time.RFC3339),

     

       95
       95
       +
       		Title:     p.Title,

     

       96
       96
       +
       		Body:      &p.Body,

     

       97
       97
       +
       		CreatedAt: p.Created.Format(time.RFC3339),

     

       97
       98
        
       		Target: &tangled.RepoPull_Target{

     

       98
       99
        
       			Repo:   p.RepoAt.String(),

     

       99
       100
        
       			Branch: p.TargetBranch,

     

       100
       101
        
       		},

     

       101
       101
       -
       		Patch:        p.LatestPatch(),

     

       102
       102
       -
       		Source:       source,

     

       102
       102
       +
       		Patch:  p.LatestPatch(),

     

       103
       103
       +
       		Source: source,

     

       104
       104
       +
       		StackInfo: &tangled.RepoPull_StackInfo{

     

       105
       105
       +
       			ChangeId: p.ChangeId,

     

       106
       106
       +
       			Parent:   (*string)(p.ParentAt),

     

       107
       107
       +
       		},

     

       103
       108
        
       	}

     

       104
       109
        
       	return record

     

       105
       110
        
       }

     
···

       255
       260
        
       		}

     

       256
       261
        
       	}

     

       257
       262
        
       

     

       258
       258
       -
       	var stackId, changeId, parentChangeId *string

     

       263
       263
       +
       	var stackId, changeId, parentAt, parentChangeId *string

     

       259
       264
        
       	if pull.StackId != "" {

     

       260
       265
        
       		stackId = &pull.StackId

     

       261
       266
        
       	}

     

       262
       267
        
       	if pull.ChangeId != "" {

     

       263
       268
        
       		changeId = &pull.ChangeId

     

       264
       269
        
       	}

     

       270
       270
       +
       	if pull.ParentAt != nil {

     

       271
       271
       +
       		parentAt = (*string)(pull.ParentAt)

     

       272
       272
       +
       	}

     

       265
       273
        
       	if pull.ParentChangeId != "" {

     

       266
       274
        
       		parentChangeId = &pull.ParentChangeId

     

       267
       275
        
       	}

     
···

       269
       277
        
       	_, err = tx.Exec(

     

       270
       278
        
       		`

     

       271
       279
        
       		insert into pulls (

     

       272
       272
       -
       			repo_at, owner_did, pull_id, title, target_branch, body, rkey, state, source_branch, source_repo_at, stack_id, change_id, parent_change_id

     

       280
       280
       +
       			repo_at, owner_did, pull_id, title, target_branch, body, rkey, state, source_branch, source_repo_at, stack_id, change_id, parent_at, parent_change_id

     

       273
       281
        
       		)

     

       274
       274
       -
       		values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,

     

       282
       282
       +
       		values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,

     

       275
       283
        
       		pull.RepoAt,

     

       276
       284
        
       		pull.OwnerDid,

     

       277
       285
        
       		pull.PullId,

     
···

       284
       292
        
       		sourceRepoAt,

     

       285
       293
        
       		stackId,

     

       286
       294
        
       		changeId,

     

       295
       295
       +
       		parentAt,

     

       287
       296
        
       		parentChangeId,

     

       288
       297
        
       	)

     

       289
       298
        
       	if err != nil {

     
···

       341
       350
        
       			source_repo_at,

     

       342
       351
        
       			stack_id,

     

       343
       352
        
       			change_id,

     

       353
       353
       +
       			parent_at,

     

       344
       354
        
       			parent_change_id

     

       345
       355
        
       		from

     

       346
       356
        
       			pulls

     
···

       356
       366
        
       	for rows.Next() {

     

       357
       367
        
       		var pull Pull

     

       358
       368
        
       		var createdAt string

     

       359
       359
       -
       		var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString

     

       369
       369
       +
       		var sourceBranch, sourceRepoAt, stackId, changeId, parentAt, parentChangeId sql.NullString

     

       360
       370
        
       		err := rows.Scan(

     

       361
       371
        
       			&pull.OwnerDid,

     

       362
       372
        
       			&pull.RepoAt,

     
···

       371
       381
        
       			&sourceRepoAt,

     

       372
       382
        
       			&stackId,

     

       373
       383
        
       			&changeId,

     

       384
       384
       +
       			&parentAt,

     

       374
       385
        
       			&parentChangeId,

     

       375
       386
        
       		)

     

       376
       387
        
       		if err != nil {

     
···

       402
       413
        
       		if changeId.Valid {

     

       403
       414
        
       			pull.ChangeId = changeId.String

     

       404
       415
        
       		}

     

       416
       416
       +
       		if parentAt.Valid {

     

       417
       417
       +
       			parentAtParsed, err := syntax.ParseATURI(parentAt.String)

     

       418
       418
       +
       			if err != nil {

     

       419
       419
       +
       				return nil, err

     

       420
       420
       +
       			}

     

       421
       421
       +
       			pull.ParentAt = &parentAtParsed

     

       422
       422
       +
       		}

     

       405
       423
        
       		if parentChangeId.Valid {

     

       406
       424
        
       			pull.ParentChangeId = parentChangeId.String

     

       407
       425
        
       		}

     
···

       530
       548
        
       			source_repo_at,

     

       531
       549
        
       			stack_id,

     

       532
       550
        
       			change_id,

     

       551
       551
       +
       			parent_at,

     

       533
       552
        
       			parent_change_id

     

       534
       553
        
       		from

     

       535
       554
        
       			pulls

     
···

       540
       559
        
       

     

       541
       560
        
       	var pull Pull

     

       542
       561
        
       	var createdAt string

     

       543
       543
       -
       	var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString

     

       562
       562
       +
       	var sourceBranch, sourceRepoAt, stackId, changeId, parentAt, parentChangeId sql.NullString

     

       544
       563
        
       	err := row.Scan(

     

       545
       564
        
       		&pull.OwnerDid,

     

       546
       565
        
       		&pull.PullId,

     
···

       555
       574
        
       		&sourceRepoAt,

     

       556
       575
        
       		&stackId,

     

       557
       576
        
       		&changeId,

     

       577
       577
       +
       		&parentAt,

     

       558
       578
        
       		&parentChangeId,

     

       559
       579
        
       	)

     

       560
       580
        
       	if err != nil {

     
···

       587
       607
        
       	if changeId.Valid {

     

       588
       608
        
       		pull.ChangeId = changeId.String

     

       589
       609
        
       	}

     

       610
       610
       +
       	if parentAt.Valid {

     

       611
       611
       +
       		parsedParentAt, err := syntax.ParseATURI(parentAt.String)

     

       612
       612
       +
       		if err != nil {

     

       613
       613
       +
       			return nil, err

     

       614
       614
       +
       		}

     

       615
       615
       +
       		pull.ParentAt = &parsedParentAt

     

       616
       616
       +
       	}

     

       590
       617
        
       	if parentChangeId.Valid {

     

       591
       618
        
       		pull.ParentChangeId = parentChangeId.String

     

       592
       619
        
       	}

+21 -2

appview/pulls/pulls.go

···

       1632
       1632
        
       	newStack, err := newStack(f, user, targetBranch, patch, pull.PullSource, stackId)

     

       1633
       1633
        
       	if err != nil {

     

       1634
       1634
        
       		log.Println("failed to create resubmitted stack", err)

     

       1635
       1635
       -
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     

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

     

       1636
       1636
        
       		return

     

       1637
       1637
        
       	}

     

       1638
       1638
        
       

     

       1639
       1639
        
       	// find the diff between the stacks, first, map them by changeId

     

       1640
       1640
        
       	origById := make(map[string]*db.Pull)

     

       1641
       1641
        
       	newById := make(map[string]*db.Pull)

     

       1642
       1642
       +
       	chIdToAtUri := make(map[string]*syntax.ATURI)

     

       1642
       1643
        
       	for _, p := range origStack {

     

       1643
       1644
        
       		origById[p.ChangeId] = p

     

       1645
       1645
       +
       

     

       1646
       1646
       +
       		// build map from change id to existing at uris (ignore error as it shouldnt be possible here)

     

       1647
       1647
       +
       		pAtUri, _ := syntax.ParseATURI(fmt.Sprintf("at://%s/%s/%s", user.Did, tangled.RepoPullNSID, p.Rkey))

     

       1648
       1648
       +
       		chIdToAtUri[p.ChangeId] = &pAtUri

     

       1644
       1649
        
       	}

     

       1645
       1650
        
       	for _, p := range newStack {

     

       1651
       1651
       +
       		// if change id has already been given a PR use its at uri instead of the newly created (and thus incorrect)

     

       1652
       1652
       +
       		// one made by newStack

     

       1653
       1653
       +
       		if ppAt, ok := chIdToAtUri[p.ParentChangeId]; ok {

     

       1654
       1654
       +
       			p.ParentAt = ppAt

     

       1655
       1655
       +
       		}

     

       1656
       1656
       +
       

     

       1646
       1657
        
       		newById[p.ChangeId] = p

     

       1647
       1658
        
       	}

     

       1648
       1659
        
       

     
···

       1690
       1701
        
       			// we still need to update the hash in submission.Patch and submission.SourceRev

     

       1691
       1702
        
       			if patchutil.Equal(newFiles, origFiles) &&

     

       1692
       1703
        
       				origHeader.Title == newHeader.Title &&

     

       1693
       1693
       -
       				origHeader.Body == newHeader.Body {

     

       1704
       1704
       +
       				origHeader.Body == newHeader.Body &&

     

       1705
       1705
       +
       				op.ParentChangeId == np.ParentChangeId {

     

       1694
       1706
        
       				unchanged[op.ChangeId] = struct{}{}

     

       1695
       1707
        
       			} else {

     

       1696
       1708
        
       				updated[op.ChangeId] = struct{}{}

     
···

       1764
       1776
        
       

     

       1765
       1777
        
       		record := op.AsRecord()

     

       1766
       1778
        
       		record.Patch = submission.Patch

     

       1779
       1779
       +
       		record.StackInfo.Parent = (*string)(np.ParentAt)

     

       1767
       1780
        
       

     

       1768
       1781
        
       		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{

     

       1769
       1782
        
       			RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{

     
···

       2112
       2125
        
       	// the stack is identified by a UUID

     

       2113
       2126
        
       	var stack db.Stack

     

       2114
       2127
        
       	parentChangeId := ""

     

       2128
       2128
       +
       	var parentAt *syntax.ATURI = nil

     

       2115
       2129
        
       	for _, fp := range formatPatches {

     

       2116
       2130
        
       		//  all patches must have a jj change-id

     

       2117
       2131
        
       		changeId, err := fp.ChangeId()

     
···

       2142
       2156
        
       

     

       2143
       2157
        
       			StackId:        stackId,

     

       2144
       2158
        
       			ChangeId:       changeId,

     

       2159
       2159
       +
       			ParentAt:       parentAt,

     

       2145
       2160
        
       			ParentChangeId: parentChangeId,

     

       2146
       2161
        
       		}

     

       2147
       2162
        
       

     

       2148
       2163
        
       		stack = append(stack, &pull)

     

       2149
       2164
        
       

     

       2150
       2165
        
       		parentChangeId = changeId

     

       2166
       2166
       +
       		// this is a bit of an ugly way to create the ATURI but its the best we can do with the data flow here

     

       2167
       2167
       +
       		// (igore error as it shouldnt be possible here)

     

       2168
       2168
       +
       		parsedParentAt, _ := syntax.ParseATURI(fmt.Sprintf("at://%s/%s/%s", user.Did, tangled.RepoPullNSID, pull.Rkey));

     

       2169
       2169
       +
       		parentAt = &parsedParentAt

     

       2151
       2170
        
       	}

     

       2152
       2171
        
       

     

       2153
       2172
        
       	return stack, nil

cmd/gen.go

···

       46
       46
        
       		tangled.RepoIssueState{},

     

       47
       47
        
       		tangled.RepoPull{},

     

       48
       48
        
       		tangled.RepoPullComment{},

     

       49
       49
       +
       		tangled.RepoPull_StackInfo{},

     

       49
       50
        
       		tangled.RepoPull_Source{},

     

       50
       51
        
       		tangled.RepoPull_Target{},

     

       51
       52
        
       		tangled.RepoPullStatus{},

+21

lexicons/pulls/pull.json

···

       29
       29
        
                 "patch": {

     

       30
       30
        
                   "type": "string"

     

       31
       31
        
                 },

     

       32
       32
       +
                 "stackInfo": {

     

       33
       33
       +
                   "type": "ref",

     

       34
       34
       +
                   "ref": "#stackInfo"

     

       35
       35
       +
                 },

     

       32
       36
        
                 "source": {

     

       33
       37
        
                   "type": "ref",

     

       34
       38
        
                   "ref": "#source"

     
···

       76
       80
        
                 "format": "at-uri"

     

       77
       81
        
               }

     

       78
       82
        
             }

     

       83
       83
       +
           },

     

       84
       84
       +
           "stackInfo": {

     

       85
       85
       +
             "type": "object",

     

       86
       86
       +
             "required": [

     

       87
       87
       +
               "changeId"

     

       88
       88
       +
             ],

     

       89
       89
       +
             "properties": {

     

       90
       90
       +
               "changeId": {

     

       91
       91
       +
                 "type": "string",

     

       92
       92
       +
                 "description": "Change ID of this commit/change."

     

       93
       93
       +
               },

     

       94
       94
       +
               "parent": {

     

       95
       95
       +
                 "type": "string",

     

       96
       96
       +
                 "description": "AT-URI of the PR for the parent commit/change in the change stack.",

     

       97
       97
       +
                 "format": "at-uri"

     

       98
       98
       +
               }

     

       99
       99
       +
             }

     

       79
       100
        
           }

     

       80
       101
        
         }

     

       81
       102
        
       }