lexicons: pulls: put target repo and branch together in their own object #404

+166 -64

api/tangled/cbor_gen.go

··· 6392 6392 6393 6393 return nil 6394 6394 } 6395 6395 + func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error { 6396 6396 + if t == nil { 6397 6397 + _, err := w.Write(cbg.CborNull) 6398 6398 + return err 6399 6399 + } 6400 6400 + 6401 6401 + cw := cbg.NewCborWriter(w) 6402 6402 + 6403 6403 + if _, err := cw.Write([]byte{162}); err != nil { 6404 6404 + return err 6405 6405 + } 6406 6406 + 6407 6407 + // t.Repo (string) (string) 6408 6408 + if len("repo") > 1000000 { 6409 6409 + return xerrors.Errorf("Value in field \"repo\" was too long") 6410 6410 + } 6411 6411 + 6412 6412 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6413 6413 + return err 6414 6414 + } 6415 6415 + if _, err := cw.WriteString(string("repo")); err != nil { 6416 6416 + return err 6417 6417 + } 6418 6418 + 6419 6419 + if len(t.Repo) > 1000000 { 6420 6420 + return xerrors.Errorf("Value in field t.Repo was too long") 6421 6421 + } 6422 6422 + 6423 6423 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 6424 6424 + return err 6425 6425 + } 6426 6426 + if _, err := cw.WriteString(string(t.Repo)); err != nil { 6427 6427 + return err 6428 6428 + } 6429 6429 + 6430 6430 + // t.Branch (string) (string) 6431 6431 + if len("branch") > 1000000 { 6432 6432 + return xerrors.Errorf("Value in field \"branch\" was too long") 6433 6433 + } 6434 6434 + 6435 6435 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("branch"))); err != nil { 6436 6436 + return err 6437 6437 + } 6438 6438 + if _, err := cw.WriteString(string("branch")); err != nil { 6439 6439 + return err 6440 6440 + } 6441 6441 + 6442 6442 + if len(t.Branch) > 1000000 { 6443 6443 + return xerrors.Errorf("Value in field t.Branch was too long") 6444 6444 + } 6445 6445 + 6446 6446 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Branch))); err != nil { 6447 6447 + return err 6448 6448 + } 6449 6449 + if _, err := cw.WriteString(string(t.Branch)); err != nil { 6450 6450 + return err 6451 6451 + } 6452 6452 + return nil 6453 6453 + } 6454 6454 + 6455 6455 + func (t *RepoPull_Target) UnmarshalCBOR(r io.Reader) (err error) { 6456 6456 + *t = RepoPull_Target{} 6457 6457 + 6458 6458 + cr := cbg.NewCborReader(r) 6459 6459 + 6460 6460 + maj, extra, err := cr.ReadHeader() 6461 6461 + if err != nil { 6462 6462 + return err 6463 6463 + } 6464 6464 + defer func() { 6465 6465 + if err == io.EOF { 6466 6466 + err = io.ErrUnexpectedEOF 6467 6467 + } 6468 6468 + }() 6469 6469 + 6470 6470 + if maj != cbg.MajMap { 6471 6471 + return fmt.Errorf("cbor input should be of type map") 6472 6472 + } 6473 6473 + 6474 6474 + if extra > cbg.MaxLength { 6475 6475 + return fmt.Errorf("RepoPull_Target: map struct too large (%d)", extra) 6476 6476 + } 6477 6477 + 6478 6478 + n := extra 6479 6479 + 6480 6480 + nameBuf := make([]byte, 6) 6481 6481 + for i := uint64(0); i < n; i++ { 6482 6482 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6483 6483 + if err != nil { 6484 6484 + return err 6485 6485 + } 6486 6486 + 6487 6487 + if !ok { 6488 6488 + // Field doesn't exist on this type, so ignore it 6489 6489 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6490 6490 + return err 6491 6491 + } 6492 6492 + continue 6493 6493 + } 6494 6494 + 6495 6495 + switch string(nameBuf[:nameLen]) { 6496 6496 + // t.Repo (string) (string) 6497 6497 + case "repo": 6498 6498 + 6499 6499 + { 6500 6500 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6501 6501 + if err != nil { 6502 6502 + return err 6503 6503 + } 6504 6504 + 6505 6505 + t.Repo = string(sval) 6506 6506 + } 6507 6507 + // t.Branch (string) (string) 6508 6508 + case "branch": 6509 6509 + 6510 6510 + { 6511 6511 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6512 6512 + if err != nil { 6513 6513 + return err 6514 6514 + } 6515 6515 + 6516 6516 + t.Branch = string(sval) 6517 6517 + } 6518 6518 + 6519 6519 + default: 6520 6520 + // Field doesn't exist on this type, so ignore it 6521 6521 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6522 6522 + return err 6523 6523 + } 6524 6524 + } 6525 6525 + } 6526 6526 + 6527 6527 + return nil 6528 6528 + } 6395 6529 func (t *RepoPull) MarshalCBOR(w io.Writer) error { 6396 6530 if t == nil { 6397 6531 _, err := w.Write(cbg.CborNull) ··· 6399 6533 } 6400 6534 6401 6535 cw := cbg.NewCborWriter(w) 6402 6402 - fieldCount := 8 6536 6536 + fieldCount := 7 6403 6537 6404 6538 if t.Body == nil { 6405 6539 fieldCount-- ··· 6529 6663 } 6530 6664 } 6531 6665 6532 6532 - // t.CreatedAt (string) (string) 6533 6533 - if len("createdAt") > 1000000 { 6534 6534 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 6666 6666 + // t.Target (tangled.RepoPull_Target) (struct) 6667 6667 + if len("target") > 1000000 { 6668 6668 + return xerrors.Errorf("Value in field \"target\" was too long") 6535 6669 } 6536 6670 6537 6537 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 6671 6671 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("target"))); err != nil { 6538 6672 return err 6539 6673 } 6540 6540 - if _, err := cw.WriteString(string("createdAt")); err != nil { 6674 6674 + if _, err := cw.WriteString(string("target")); err != nil { 6541 6675 return err 6542 6676 } 6543 6677 6544 6544 - if len(t.CreatedAt) > 1000000 { 6545 6545 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 6546 6546 - } 6547 6547 - 6548 6548 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 6549 6549 - return err 6550 6550 - } 6551 6551 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 6552 6552 - return err 6553 6553 - } 6554 6554 - 6555 6555 - // t.TargetRepo (string) (string) 6556 6556 - if len("targetRepo") > 1000000 { 6557 6557 - return xerrors.Errorf("Value in field \"targetRepo\" was too long") 6558 6558 - } 6559 6559 - 6560 6560 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetRepo"))); err != nil { 6561 6561 - return err 6562 6562 - } 6563 6563 - if _, err := cw.WriteString(string("targetRepo")); err != nil { 6678 6678 + if err := t.Target.MarshalCBOR(cw); err != nil { 6564 6679 return err 6565 6680 } 6566 6681 6567 6567 - if len(t.TargetRepo) > 1000000 { 6568 6568 - return xerrors.Errorf("Value in field t.TargetRepo was too long") 6569 6569 - } 6570 6570 - 6571 6571 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetRepo))); err != nil { 6572 6572 - return err 6573 6573 - } 6574 6574 - if _, err := cw.WriteString(string(t.TargetRepo)); err != nil { 6575 6575 - return err 6576 6576 - } 6577 6577 - 6578 6578 - // t.TargetBranch (string) (string) 6579 6579 - if len("targetBranch") > 1000000 { 6580 6580 - return xerrors.Errorf("Value in field \"targetBranch\" was too long") 6682 6682 + // t.CreatedAt (string) (string) 6683 6683 + if len("createdAt") > 1000000 { 6684 6684 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 6581 6685 } 6582 6686 6583 6583 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("targetBranch"))); err != nil { 6687 6687 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 6584 6688 return err 6585 6689 } 6586 6586 - if _, err := cw.WriteString(string("targetBranch")); err != nil { 6690 6690 + if _, err := cw.WriteString(string("createdAt")); err != nil { 6587 6691 return err 6588 6692 } 6589 6693 6590 6590 - if len(t.TargetBranch) > 1000000 { 6591 6591 - return xerrors.Errorf("Value in field t.TargetBranch was too long") 6694 6694 + if len(t.CreatedAt) > 1000000 { 6695 6695 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 6592 6696 } 6593 6697 6594 6594 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.TargetBranch))); err != nil { 6698 6698 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 6595 6699 return err 6596 6700 } 6597 6597 - if _, err := cw.WriteString(string(t.TargetBranch)); err != nil { 6701 6701 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 6598 6702 return err 6599 6703 } 6600 6704 return nil ··· 6625 6729 6626 6730 n := extra 6627 6731 6628 6628 - nameBuf := make([]byte, 12) 6732 6732 + nameBuf := make([]byte, 9) 6629 6733 for i := uint64(0); i < n; i++ { 6630 6734 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6631 6735 if err != nil { ··· 6715 6819 } 6716 6820 6717 6821 } 6718 6718 - // t.CreatedAt (string) (string) 6719 6719 - case "createdAt": 6822 6822 + // t.Target (tangled.RepoPull_Target) (struct) 6823 6823 + case "target": 6720 6824 6721 6825 { 6722 6722 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6723 6723 - if err != nil { 6724 6724 - return err 6725 6725 - } 6726 6826 6727 6727 - t.CreatedAt = string(sval) 6728 6728 - } 6729 6729 - // t.TargetRepo (string) (string) 6730 6730 - case "targetRepo": 6731 6731 - 6732 6732 - { 6733 6733 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6827 6827 + b, err := cr.ReadByte() 6734 6828 if err != nil { 6735 6829 return err 6736 6830 } 6831 6831 + if b != cbg.CborNull[0] { 6832 6832 + if err := cr.UnreadByte(); err != nil { 6833 6833 + return err 6834 6834 + } 6835 6835 + t.Target = new(RepoPull_Target) 6836 6836 + if err := t.Target.UnmarshalCBOR(cr); err != nil { 6837 6837 + return xerrors.Errorf("unmarshaling t.Target pointer: %w", err) 6838 6838 + } 6839 6839 + } 6737 6840 6738 6738 - t.TargetRepo = string(sval) 6739 6841 } 6740 6740 - // t.TargetBranch (string) (string) 6741 6741 - case "targetBranch": 6842 6842 + // t.CreatedAt (string) (string) 6843 6843 + case "createdAt": 6742 6844 6743 6845 { 6744 6846 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 6746 6848 return err 6747 6849 } 6748 6850 6749 6749 - t.TargetBranch = string(sval) 6851 6851 + t.CreatedAt = string(sval) 6750 6852 } 6751 6853 6752 6854 default:

+7 -2

api/tangled/repopull.go

··· 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 - TargetBranch string `json:"targetBranch" cborgen:"targetBranch"` 26 26 - TargetRepo string `json:"targetRepo" cborgen:"targetRepo"` 25 25 + Target *RepoPull_Target `json:"target" cborgen:"target"` 27 26 Title string `json:"title" cborgen:"title"` 28 27 } 29 28 ··· 33 32 Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 34 33 Sha string `json:"sha" cborgen:"sha"` 35 34 } 35 35 + 36 36 + // RepoPull_Target is a "target" in the sh.tangled.repo.pull schema. 37 37 + type RepoPull_Target struct { 38 38 + Branch string `json:"branch" cborgen:"branch"` 39 39 + Repo string `json:"repo" cborgen:"repo"` 40 40 + }

+4 -2

appview/db/pulls.go

··· 94 94 Title: p.Title, 95 95 Body: &p.Body, 96 96 CreatedAt: p.Created.Format(time.RFC3339), 97 97 - TargetRepo: p.RepoAt.String(), 98 98 - TargetBranch: p.TargetBranch, 97 97 + Target: &tangled.RepoPull_Target{ 98 98 + Repo: p.RepoAt.String(), 99 99 + Branch: p.TargetBranch, 100 100 + }, 99 101 Patch: p.LatestPatch(), 100 102 Source: source, 101 103 }

+8 -4

appview/pulls/pulls.go

··· 1031 1031 Record: &lexutil.LexiconTypeDecoder{ 1032 1032 Val: &tangled.RepoPull{ 1033 1033 Title: title, 1034 1034 - TargetRepo: string(f.RepoAt()), 1035 1035 - TargetBranch: targetBranch, 1034 1034 + Target: &tangled.RepoPull_Target{ 1035 1035 + Repo: string(f.RepoAt()), 1036 1036 + Branch: targetBranch, 1037 1037 + }, 1036 1038 Patch: patch, 1037 1039 Source: recordPullSource, 1038 1040 }, ··· 1592 1594 Record: &lexutil.LexiconTypeDecoder{ 1593 1595 Val: &tangled.RepoPull{ 1594 1596 Title: pull.Title, 1595 1595 - TargetRepo: string(f.RepoAt()), 1596 1596 - TargetBranch: pull.TargetBranch, 1597 1597 + Target: &tangled.RepoPull_Target{ 1598 1598 + Repo: string(f.RepoAt()), 1599 1599 + Branch: pull.TargetBranch, 1600 1600 + }, 1597 1601 Patch: patch, // new patch 1598 1602 Source: recordPullSource, 1599 1603 },

+1

cmd/gen.go

··· 45 45 tangled.RepoPull{}, 46 46 tangled.RepoPullComment{}, 47 47 tangled.RepoPull_Source{}, 48 48 + tangled.RepoPull_Target{}, 48 49 tangled.RepoPullStatus{}, 49 50 tangled.Spindle{}, 50 51 tangled.SpindleMember{},

+20 -8

lexicons/pulls/pull.json

··· 10 10 "record": { 11 11 "type": "object", 12 12 "required": [ 13 13 - "targetRepo", 14 14 - "targetBranch", 13 13 + "target", 15 14 "title", 16 15 "patch", 17 16 "createdAt" 18 17 ], 19 18 "properties": { 20 20 - "targetRepo": { 21 21 - "type": "string", 22 22 - "format": "at-uri" 23 23 - }, 24 24 - "targetBranch": { 25 25 - "type": "string" 19 19 + "target": { 20 20 + "type": "ref", 21 21 + "ref": "#target" 26 22 }, 27 23 "title": { 28 24 "type": "string" ··· 44 40 } 45 41 } 46 42 }, 43 43 + "target": { 44 44 + "type": "object", 45 45 + "required": [ 46 46 + "repo", 47 47 + "branch" 48 48 + ], 49 49 + "properties": { 50 50 + "repo": { 51 51 + "type": "string", 52 52 + "format": "at-uri" 53 53 + }, 54 54 + "branch": { 55 55 + "type": "string" 56 56 + } 57 57 + } 58 58 + }, 47 59 "source": { 48 60 "type": "object", 49 61 "required": [