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

+202 -1

api/tangled/cbor_gen.go

···

       6741
       6741
        
       

     

       6742
       6742
        
       	return nil

     

       6743
       6743
        
       }

     

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

     

       6745
       6745
       +
       	if t == nil {

     

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

     

       6747
       6747
       +
       		return err

     

       6748
       6748
       +
       	}

     

       6749
       6749
       +
       

     

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

     

       6751
       6751
       +
       	fieldCount := 2

     

       6752
       6752
       +
       

     

       6753
       6753
       +
       	if t.Parent == nil {

     

       6754
       6754
       +
       		fieldCount--

     

       6755
       6755
       +
       	}

     

       6756
       6756
       +
       

     

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

     

       6758
       6758
       +
       		return err

     

       6759
       6759
       +
       	}

     

       6760
       6760
       +
       

     

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

     

       6762
       6762
       +
       	if t.Parent != nil {

     

       6763
       6763
       +
       

     

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

     

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

     

       6766
       6766
       +
       		}

     

       6767
       6767
       +
       

     

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

     

       6769
       6769
       +
       			return err

     

       6770
       6770
       +
       		}

     

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

     

       6772
       6772
       +
       			return err

     

       6773
       6773
       +
       		}

     

       6774
       6774
       +
       

     

       6775
       6775
       +
       		if t.Parent == nil {

     

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

     

       6777
       6777
       +
       				return err

     

       6778
       6778
       +
       			}

     

       6779
       6779
       +
       		} else {

     

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

     

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

     

       6782
       6782
       +
       			}

     

       6783
       6783
       +
       

     

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

     

       6785
       6785
       +
       				return err

     

       6786
       6786
       +
       			}

     

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

     

       6788
       6788
       +
       				return err

     

       6789
       6789
       +
       			}

     

       6790
       6790
       +
       		}

     

       6791
       6791
       +
       	}

     

       6792
       6792
       +
       

     

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

     

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

     

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

     

       6796
       6796
       +
       	}

     

       6797
       6797
       +
       

     

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

     

       6799
       6799
       +
       		return err

     

       6800
       6800
       +
       	}

     

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

     

       6802
       6802
       +
       		return err

     

       6803
       6803
       +
       	}

     

       6804
       6804
       +
       

     

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

     

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

     

       6807
       6807
       +
       	}

     

       6808
       6808
       +
       

     

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

     

       6810
       6810
       +
       		return err

     

       6811
       6811
       +
       	}

     

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

     

       6813
       6813
       +
       		return err

     

       6814
       6814
       +
       	}

     

       6815
       6815
       +
       	return nil

     

       6816
       6816
       +
       }

     

       6817
       6817
       +
       

     

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

     

       6819
       6819
       +
       	*t = RepoPull_StackInfo{}

     

       6820
       6820
       +
       

     

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

     

       6822
       6822
       +
       

     

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

     

       6824
       6824
       +
       	if err != nil {

     

       6825
       6825
       +
       		return err

     

       6826
       6826
       +
       	}

     

       6827
       6827
       +
       	defer func() {

     

       6828
       6828
       +
       		if err == io.EOF {

     

       6829
       6829
       +
       			err = io.ErrUnexpectedEOF

     

       6830
       6830
       +
       		}

     

       6831
       6831
       +
       	}()

     

       6832
       6832
       +
       

     

       6833
       6833
       +
       	if maj != cbg.MajMap {

     

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

     

       6835
       6835
       +
       	}

     

       6836
       6836
       +
       

     

       6837
       6837
       +
       	if extra > cbg.MaxLength {

     

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

     

       6839
       6839
       +
       	}

     

       6840
       6840
       +
       

     

       6841
       6841
       +
       	n := extra

     

       6842
       6842
       +
       

     

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

     

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

     

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

     

       6846
       6846
       +
       		if err != nil {

     

       6847
       6847
       +
       			return err

     

       6848
       6848
       +
       		}

     

       6849
       6849
       +
       

     

       6850
       6850
       +
       		if !ok {

     

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

     

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

     

       6853
       6853
       +
       				return err

     

       6854
       6854
       +
       			}

     

       6855
       6855
       +
       			continue

     

       6856
       6856
       +
       		}

     

       6857
       6857
       +
       

     

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

     

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

     

       6860
       6860
       +
       		case "parent":

     

       6861
       6861
       +
       

     

       6862
       6862
       +
       			{

     

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

     

       6864
       6864
       +
       				if err != nil {

     

       6865
       6865
       +
       					return err

     

       6866
       6866
       +
       				}

     

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

     

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

     

       6869
       6869
       +
       						return err

     

       6870
       6870
       +
       					}

     

       6871
       6871
       +
       

     

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

     

       6873
       6873
       +
       					if err != nil {

     

       6874
       6874
       +
       						return err

     

       6875
       6875
       +
       					}

     

       6876
       6876
       +
       

     

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

     

       6878
       6878
       +
       				}

     

       6879
       6879
       +
       			}

     

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

     

       6881
       6881
       +
       		case "changeId":

     

       6882
       6882
       +
       

     

       6883
       6883
       +
       			{

     

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

     

       6885
       6885
       +
       				if err != nil {

     

       6886
       6886
       +
       					return err

     

       6887
       6887
       +
       				}

     

       6888
       6888
       +
       

     

       6889
       6889
       +
       				t.ChangeId = string(sval)

     

       6890
       6890
       +
       			}

     

       6891
       6891
       +
       

     

       6892
       6892
       +
       		default:

     

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

     

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

     

       6895
       6895
       +
       				return err

     

       6896
       6896
       +
       			}

     

       6897
       6897
       +
       		}

     

       6898
       6898
       +
       	}

     

       6899
       6899
       +
       

     

       6900
       6900
       +
       	return nil

     

       6901
       6901
       +
       }

     

       6744
       6902
        
       func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {

     

       6745
       6903
        
       	if t == nil {

     

       6746
       6904
        
       		_, err := w.Write(cbg.CborNull)

     
···

       6882
       7040
        
       	}

     

       6883
       7041
        
       

     

       6884
       7042
        
       	cw := cbg.NewCborWriter(w)

     

       6885
       6885
       -
       	fieldCount := 7

     

       7043
       7043
       +
       	fieldCount := 8

     

       6886
       7044
        
       

     

       6887
       7045
        
       	if t.Body == nil {

     

       6888
       7046
        
       		fieldCount--

     
···

       6892
       7050
        
       		fieldCount--

     

       6893
       7051
        
       	}

     

       6894
       7052
        
       

     

       7053
       7053
       +
       	if t.StackInfo == nil {

     

       7054
       7054
       +
       		fieldCount--

     

       7055
       7055
       +
       	}

     

       7056
       7056
       +
       

     

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

     

       6896
       7058
        
       		return err

     

       6897
       7059
        
       	}

     
···

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

     

       7051
       7213
        
       		return err

     

       7052
       7214
        
       	}

     

       7215
       7215
       +
       

     

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

     

       7217
       7217
       +
       	if t.StackInfo != nil {

     

       7218
       7218
       +
       

     

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

     

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

     

       7221
       7221
       +
       		}

     

       7222
       7222
       +
       

     

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

     

       7224
       7224
       +
       			return err

     

       7225
       7225
       +
       		}

     

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

     

       7227
       7227
       +
       			return err

     

       7228
       7228
       +
       		}

     

       7229
       7229
       +
       

     

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

     

       7231
       7231
       +
       			return err

     

       7232
       7232
       +
       		}

     

       7233
       7233
       +
       	}

     

       7053
       7234
        
       	return nil

     

       7054
       7235
        
       }

     

       7055
       7236
        
       

     
···

       7199
       7380
        
       

     

       7200
       7381
        
       				t.CreatedAt = string(sval)

     

       7201
       7382
        
       			}

     

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

     

       7384
       7384
       +
       		case "stackInfo":

     

       7385
       7385
       +
       

     

       7386
       7386
       +
       			{

     

       7387
       7387
       +
       

     

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

     

       7389
       7389
       +
       				if err != nil {

     

       7390
       7390
       +
       					return err

     

       7391
       7391
       +
       				}

     

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

     

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

     

       7394
       7394
       +
       						return err

     

       7395
       7395
       +
       					}

     

       7396
       7396
       +
       					t.StackInfo = new(RepoPull_StackInfo)

     

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

     

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

     

       7399
       7399
       +
       					}

     

       7400
       7400
       +
       				}

     

       7401
       7401
       +
       

     

       7402
       7402
       +
       			}

     

       7202
       7403
        
       

     

       7203
       7404
        
       		default:

     

       7204
       7405
        
       			// 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

···

       578
       578
        
       		return nil

     

       579
       579
        
       	})

     

       580
       580
        
       

     

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

     

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

     

       583
       583
       +
       			alter table pulls add column parent_at text;

     

       584
       584
       +
       		`)

     

       585
       585
       +
       		return err

     

       586
       586
       +
       	})

     

       587
       587
       +
       

     

       581
       588
        
       	return &DB{db}, nil

     

       582
       589
        
       }

     

       583
       590

+38 -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 {

     

       581
       581
       +
       		fmt.Printf("its the place you think it is and heres the row %s\n", row)

     

       561
       582
        
       		return nil, err

     

       562
       583
        
       	}

     

       563
       584
        
       

     
···

       587
       608
        
       	if changeId.Valid {

     

       588
       609
        
       		pull.ChangeId = changeId.String

     

       589
       610
        
       	}

     

       611
       611
       +
       	if parentAt.Valid {

     

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

     

       613
       613
       +
       		if err != nil {

     

       614
       614
       +
       			return nil, err

     

       615
       615
       +
       		}

     

       616
       616
       +
       		pull.ParentAt = &parsedParentAt

     

       617
       617
       +
       	}

     

       590
       618
        
       	if parentChangeId.Valid {

     

       591
       619
        
       		pull.ParentChangeId = parentChangeId.String

     

       592
       620
        
       	}

+31 -2

appview/pulls/pulls.go

···

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

     

       1694
       1694
        
       	if err != nil {

     

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

     

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

     

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

     

       1697
       1697
        
       		return

     

       1698
       1698
        
       	}

     

       1699
       1699
        
       

     

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

     

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

     

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

     

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

     

       1703
       1704
        
       	for _, p := range origStack {

     

       1704
       1705
        
       		origById[p.ChangeId] = p

     

       1706
       1706
       +
       

     

       1707
       1707
       +
       		// build map from change id to existing at uris

     

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

     

       1709
       1709
       +
       		if err != nil {

     

       1710
       1710
       +
       			log.Println(

     

       1711
       1711
       +
       				"failed to parse string %s into an AT URI while resubmitting stack. this should not be possible",

     

       1712
       1712
       +
       				fmt.Sprintf("at://%s/%s/%s", user.Did, tangled.RepoPullNSID, p.Rkey))

     

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

     

       1714
       1714
       +
       			return

     

       1715
       1715
       +
       		}

     

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

     

       1705
       1717
        
       	}

     

       1706
       1718
        
       	for _, p := range newStack {

     

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

     

       1720
       1720
       +
       		// one made by newStack

     

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

     

       1722
       1722
       +
       			p.ParentAt = ppAt

     

       1723
       1723
       +
       		}

     

       1724
       1724
       +
       

     

       1707
       1725
        
       		newById[p.ChangeId] = p

     

       1708
       1726
        
       	}

     

       1709
       1727
        
       

     
···

       1751
       1769
        
       			// we still need to update the hash in submission.Patch and submission.SourceRev

     

       1752
       1770
        
       			if patchutil.Equal(newFiles, origFiles) &&

     

       1753
       1771
        
       				origHeader.Title == newHeader.Title &&

     

       1754
       1754
       -
       				origHeader.Body == newHeader.Body {

     

       1772
       1772
       +
       				origHeader.Body == newHeader.Body &&

     

       1773
       1773
       +
       				op.ParentChangeId == np.ParentChangeId {

     

       1755
       1774
        
       				unchanged[op.ChangeId] = struct{}{}

     

       1756
       1775
        
       			} else {

     

       1757
       1776
        
       				updated[op.ChangeId] = struct{}{}

     
···

       1825
       1844
        
       

     

       1826
       1845
        
       		record := op.AsRecord()

     

       1827
       1846
        
       		record.Patch = submission.Patch

     

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

     

       1828
       1848
        
       

     

       1829
       1849
        
       		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{

     

       1830
       1850
        
       			RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{

     
···

       2173
       2193
        
       	// the stack is identified by a UUID

     

       2174
       2194
        
       	var stack db.Stack

     

       2175
       2195
        
       	parentChangeId := ""

     

       2196
       2196
       +
       	var parentAt *syntax.ATURI = nil

     

       2176
       2197
        
       	for _, fp := range formatPatches {

     

       2177
       2198
        
       		//  all patches must have a jj change-id

     

       2178
       2199
        
       		changeId, err := fp.ChangeId()

     
···

       2203
       2224
        
       

     

       2204
       2225
        
       			StackId:        stackId,

     

       2205
       2226
        
       			ChangeId:       changeId,

     

       2227
       2227
       +
       			ParentAt:       parentAt,

     

       2206
       2228
        
       			ParentChangeId: parentChangeId,

     

       2207
       2229
        
       		}

     

       2208
       2230
        
       

     

       2209
       2231
        
       		stack = append(stack, &pull)

     

       2210
       2232
        
       

     

       2211
       2233
        
       		parentChangeId = changeId

     

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

     

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

     

       2236
       2236
       +
       		parentAt = &parsedParentAt

     

       2237
       2237
       +
       		if (err != nil) {

     

       2238
       2238
       +
       			return nil, fmt.Errorf("failed to parse string %s into an AT URI. this should not be possible",

     

       2239
       2239
       +
       				fmt.Sprintf("at://%s/%s/%s", user.Did, tangled.RepoPullNSID, pull.Rkey))

     

       2240
       2240
       +
       		}

     

       2212
       2241
        
       	}

     

       2213
       2242
        
       

     

       2214
       2243
        
       	return stack, nil

cmd/gen.go

···

       43
       43
        
       		tangled.RepoIssue{},

     

       44
       44
        
       		tangled.RepoIssueComment{},

     

       45
       45
        
       		tangled.RepoIssueState{},

     

       46
       46
       +
       		tangled.RepoPull_StackInfo{},

     

       46
       47
        
       		tangled.RepoPull_Target{},

     

       47
       48
        
       		tangled.RepoPull{},

     

       48
       49
        
       		tangled.RepoPullComment{},

+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
        
       }