+743 -144

api/tangled/cbor_gen.go

··· 1499 1500 return nil 1501 } 1502 - func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error { 1503 if t == nil { 1504 _, err := w.Write(cbg.CborNull) 1505 return err 1506 } 1507 1508 cw := cbg.NewCborWriter(w) 1509 - fieldCount := 1 1510 1511 - if t.Inputs == nil { 1512 - fieldCount-- 1513 } 1514 1515 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 0 0 0 0 0 0 0 0 1516 return err 1517 } 1518 1519 - // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice) 1520 - if t.Inputs != nil { 0 1521 1522 - if len("inputs") > 1000000 { 1523 - return xerrors.Errorf("Value in field \"inputs\" was too long") 1524 - } 0 0 0 1525 1526 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil { 1527 - return err 1528 - } 1529 - if _, err := cw.WriteString(string("inputs")); err != nil { 1530 - return err 1531 - } 1532 1533 - if len(t.Inputs) > 8192 { 1534 - return xerrors.Errorf("Slice value in field t.Inputs was too long") 1535 - } 0 0 0 1536 1537 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil { 0 1538 return err 1539 } 1540 - for _, v := range t.Inputs { 1541 - if err := v.MarshalCBOR(cw); err != nil { 1542 - return err 1543 - } 1544 - 1545 } 1546 } 0 1547 return nil 1548 } 1549 1550 - func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) { 1551 - *t = GitRefUpdate_LangBreakdown{} 1552 1553 cr := cbg.NewCborReader(r) 1554 ··· 1567 } 1568 1569 if extra > cbg.MaxLength { 1570 - return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra) 1571 } 1572 1573 n := extra 1574 1575 - nameBuf := make([]byte, 6) 1576 for i := uint64(0); i < n; i++ { 1577 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1578 if err != nil { ··· 1588 } 1589 1590 switch string(nameBuf[:nameLen]) { 1591 - // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice) 1592 - case "inputs": 1593 - 1594 - maj, extra, err = cr.ReadHeader() 1595 - if err != nil { 1596 - return err 1597 - } 1598 - 1599 - if extra > 8192 { 1600 - return fmt.Errorf("t.Inputs: array too large (%d)", extra) 1601 - } 1602 1603 - if maj != cbg.MajArray { 1604 - return fmt.Errorf("expected cbor array") 1605 - } 0 0 1606 1607 - if extra > 0 { 1608 - t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra) 1609 } 1610 - 1611 - for i := 0; i < int(extra); i++ { 1612 - { 1613 - var maj byte 1614 - var extra uint64 1615 - var err error 1616 - _ = maj 1617 - _ = extra 1618 - _ = err 1619 - 1620 - { 1621 - 1622 - b, err := cr.ReadByte() 1623 - if err != nil { 1624 - return err 1625 - } 1626 - if b != cbg.CborNull[0] { 1627 - if err := cr.UnreadByte(); err != nil { 1628 - return err 1629 - } 1630 - t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize) 1631 - if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil { 1632 - return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err) 1633 - } 1634 - } 1635 - 1636 } 1637 - 0 0 0 0 0 0 0 1638 } 0 0 1639 } 1640 1641 default: ··· 1648 1649 return nil 1650 } 1651 - func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error { 1652 if t == nil { 1653 _, err := w.Write(cbg.CborNull) 1654 return err 1655 } 1656 1657 cw := cbg.NewCborWriter(w) 0 1658 1659 - if _, err := cw.Write([]byte{162}); err != nil { 1660 - return err 1661 - } 1662 - 1663 - // t.Lang (string) (string) 1664 - if len("lang") > 1000000 { 1665 - return xerrors.Errorf("Value in field \"lang\" was too long") 1666 } 1667 1668 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil { 1669 - return err 1670 - } 1671 - if _, err := cw.WriteString(string("lang")); err != nil { 1672 return err 1673 } 1674 1675 - if len(t.Lang) > 1000000 { 1676 - return xerrors.Errorf("Value in field t.Lang was too long") 1677 - } 1678 1679 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil { 1680 - return err 1681 - } 1682 - if _, err := cw.WriteString(string(t.Lang)); err != nil { 1683 - return err 1684 - } 1685 1686 - // t.Size (int64) (int64) 1687 - if len("size") > 1000000 { 1688 - return xerrors.Errorf("Value in field \"size\" was too long") 1689 - } 0 0 1690 1691 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil { 1692 - return err 1693 - } 1694 - if _, err := cw.WriteString(string("size")); err != nil { 1695 - return err 1696 - } 1697 1698 - if t.Size >= 0 { 1699 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil { 1700 return err 1701 } 1702 - } else { 1703 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil { 1704 - return err 0 0 1705 } 1706 } 1707 - 1708 return nil 1709 } 1710 1711 - func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) { 1712 - *t = GitRefUpdate_IndividualLanguageSize{} 1713 1714 cr := cbg.NewCborReader(r) 1715 ··· 1728 } 1729 1730 if extra > cbg.MaxLength { 1731 - return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra) 1732 } 1733 1734 n := extra 1735 1736 - nameBuf := make([]byte, 4) 1737 for i := uint64(0); i < n; i++ { 1738 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1739 if err != nil { ··· 1749 } 1750 1751 switch string(nameBuf[:nameLen]) { 1752 - // t.Lang (string) (string) 1753 - case "lang": 1754 1755 - { 1756 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1757 - if err != nil { 1758 - return err 1759 - } 1760 1761 - t.Lang = string(sval) 0 1762 } 1763 - // t.Size (int64) (int64) 1764 - case "size": 1765 - { 1766 - maj, extra, err := cr.ReadHeader() 1767 - if err != nil { 1768 - return err 1769 - } 1770 - var extraI int64 1771 - switch maj { 1772 - case cbg.MajUnsignedInt: 1773 - extraI = int64(extra) 1774 - if extraI < 0 { 1775 - return fmt.Errorf("int64 positive overflow") 1776 - } 1777 - case cbg.MajNegativeInt: 1778 - extraI = int64(extra) 1779 - if extraI < 0 { 1780 - return fmt.Errorf("int64 negative overflow") 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1781 } 1782 - extraI = -1 - extraI 1783 - default: 1784 - return fmt.Errorf("wrong type for int64 field: %d", maj) 1785 } 1786 - 1787 - t.Size = int64(extraI) 1788 } 1789 1790 default: ··· 2457 } 2458 2459 t.CreatedAt = string(sval) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2460 } 2461 2462 default:

··· 1499 1500 return nil 1501 } 1502 + func (t *GitRefUpdate_IndividualLanguageSize) MarshalCBOR(w io.Writer) error { 1503 if t == nil { 1504 _, err := w.Write(cbg.CborNull) 1505 return err 1506 } 1507 1508 cw := cbg.NewCborWriter(w) 0 1509 1510 + if _, err := cw.Write([]byte{162}); err != nil { 1511 + return err 1512 } 1513 1514 + // t.Lang (string) (string) 1515 + if len("lang") > 1000000 { 1516 + return xerrors.Errorf("Value in field \"lang\" was too long") 1517 + } 1518 + 1519 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil { 1520 + return err 1521 + } 1522 + if _, err := cw.WriteString(string("lang")); err != nil { 1523 return err 1524 } 1525 1526 + if len(t.Lang) > 1000000 { 1527 + return xerrors.Errorf("Value in field t.Lang was too long") 1528 + } 1529 1530 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil { 1531 + return err 1532 + } 1533 + if _, err := cw.WriteString(string(t.Lang)); err != nil { 1534 + return err 1535 + } 1536 1537 + // t.Size (int64) (int64) 1538 + if len("size") > 1000000 { 1539 + return xerrors.Errorf("Value in field \"size\" was too long") 1540 + } 0 0 1541 1542 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("size"))); err != nil { 1543 + return err 1544 + } 1545 + if _, err := cw.WriteString(string("size")); err != nil { 1546 + return err 1547 + } 1548 1549 + if t.Size >= 0 { 1550 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil { 1551 return err 1552 } 1553 + } else { 1554 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Size-1)); err != nil { 1555 + return err 0 0 1556 } 1557 } 1558 + 1559 return nil 1560 } 1561 1562 + func (t *GitRefUpdate_IndividualLanguageSize) UnmarshalCBOR(r io.Reader) (err error) { 1563 + *t = GitRefUpdate_IndividualLanguageSize{} 1564 1565 cr := cbg.NewCborReader(r) 1566 ··· 1579 } 1580 1581 if extra > cbg.MaxLength { 1582 + return fmt.Errorf("GitRefUpdate_IndividualLanguageSize: map struct too large (%d)", extra) 1583 } 1584 1585 n := extra 1586 1587 + nameBuf := make([]byte, 4) 1588 for i := uint64(0); i < n; i++ { 1589 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1590 if err != nil { ··· 1600 } 1601 1602 switch string(nameBuf[:nameLen]) { 1603 + // t.Lang (string) (string) 1604 + case "lang": 0 0 0 0 0 0 0 0 0 1605 1606 + { 1607 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1608 + if err != nil { 1609 + return err 1610 + } 1611 1612 + t.Lang = string(sval) 0 1613 } 1614 + // t.Size (int64) (int64) 1615 + case "size": 1616 + { 1617 + maj, extra, err := cr.ReadHeader() 1618 + if err != nil { 1619 + return err 1620 + } 1621 + var extraI int64 1622 + switch maj { 1623 + case cbg.MajUnsignedInt: 1624 + extraI = int64(extra) 1625 + if extraI < 0 { 1626 + return fmt.Errorf("int64 positive overflow") 0 0 0 0 0 0 0 0 0 0 0 0 0 1627 } 1628 + case cbg.MajNegativeInt: 1629 + extraI = int64(extra) 1630 + if extraI < 0 { 1631 + return fmt.Errorf("int64 negative overflow") 1632 + } 1633 + extraI = -1 - extraI 1634 + default: 1635 + return fmt.Errorf("wrong type for int64 field: %d", maj) 1636 } 1637 + 1638 + t.Size = int64(extraI) 1639 } 1640 1641 default: ··· 1648 1649 return nil 1650 } 1651 + func (t *GitRefUpdate_LangBreakdown) MarshalCBOR(w io.Writer) error { 1652 if t == nil { 1653 _, err := w.Write(cbg.CborNull) 1654 return err 1655 } 1656 1657 cw := cbg.NewCborWriter(w) 1658 + fieldCount := 1 1659 1660 + if t.Inputs == nil { 1661 + fieldCount-- 0 0 0 0 0 1662 } 1663 1664 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 0 0 0 1665 return err 1666 } 1667 1668 + // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice) 1669 + if t.Inputs != nil { 0 1670 1671 + if len("inputs") > 1000000 { 1672 + return xerrors.Errorf("Value in field \"inputs\" was too long") 1673 + } 0 0 0 1674 1675 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("inputs"))); err != nil { 1676 + return err 1677 + } 1678 + if _, err := cw.WriteString(string("inputs")); err != nil { 1679 + return err 1680 + } 1681 1682 + if len(t.Inputs) > 8192 { 1683 + return xerrors.Errorf("Slice value in field t.Inputs was too long") 1684 + } 0 0 0 1685 1686 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Inputs))); err != nil { 0 1687 return err 1688 } 1689 + for _, v := range t.Inputs { 1690 + if err := v.MarshalCBOR(cw); err != nil { 1691 + return err 1692 + } 1693 + 1694 } 1695 } 0 1696 return nil 1697 } 1698 1699 + func (t *GitRefUpdate_LangBreakdown) UnmarshalCBOR(r io.Reader) (err error) { 1700 + *t = GitRefUpdate_LangBreakdown{} 1701 1702 cr := cbg.NewCborReader(r) 1703 ··· 1716 } 1717 1718 if extra > cbg.MaxLength { 1719 + return fmt.Errorf("GitRefUpdate_LangBreakdown: map struct too large (%d)", extra) 1720 } 1721 1722 n := extra 1723 1724 + nameBuf := make([]byte, 6) 1725 for i := uint64(0); i < n; i++ { 1726 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1727 if err != nil { ··· 1737 } 1738 1739 switch string(nameBuf[:nameLen]) { 1740 + // t.Inputs ([]*tangled.GitRefUpdate_IndividualLanguageSize) (slice) 1741 + case "inputs": 1742 1743 + maj, extra, err = cr.ReadHeader() 1744 + if err != nil { 1745 + return err 1746 + } 0 1747 1748 + if extra > 8192 { 1749 + return fmt.Errorf("t.Inputs: array too large (%d)", extra) 1750 } 1751 + 1752 + if maj != cbg.MajArray { 1753 + return fmt.Errorf("expected cbor array") 1754 + } 1755 + 1756 + if extra > 0 { 1757 + t.Inputs = make([]*GitRefUpdate_IndividualLanguageSize, extra) 1758 + } 1759 + 1760 + for i := 0; i < int(extra); i++ { 1761 + { 1762 + var maj byte 1763 + var extra uint64 1764 + var err error 1765 + _ = maj 1766 + _ = extra 1767 + _ = err 1768 + 1769 + { 1770 + 1771 + b, err := cr.ReadByte() 1772 + if err != nil { 1773 + return err 1774 + } 1775 + if b != cbg.CborNull[0] { 1776 + if err := cr.UnreadByte(); err != nil { 1777 + return err 1778 + } 1779 + t.Inputs[i] = new(GitRefUpdate_IndividualLanguageSize) 1780 + if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil { 1781 + return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err) 1782 + } 1783 + } 1784 + 1785 } 1786 + 0 0 1787 } 0 0 1788 } 1789 1790 default: ··· 2457 } 2458 2459 t.CreatedAt = string(sval) 2460 + } 2461 + 2462 + default: 2463 + // Field doesn't exist on this type, so ignore it 2464 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2465 + return err 2466 + } 2467 + } 2468 + } 2469 + 2470 + return nil 2471 + } 2472 + func (t *LabelDefinition) MarshalCBOR(w io.Writer) error { 2473 + if t == nil { 2474 + _, err := w.Write(cbg.CborNull) 2475 + return err 2476 + } 2477 + 2478 + cw := cbg.NewCborWriter(w) 2479 + fieldCount := 7 2480 + 2481 + if t.Color == nil { 2482 + fieldCount-- 2483 + } 2484 + 2485 + if t.Multiple == nil { 2486 + fieldCount-- 2487 + } 2488 + 2489 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 2490 + return err 2491 + } 2492 + 2493 + // t.Name (string) (string) 2494 + if len("name") > 1000000 { 2495 + return xerrors.Errorf("Value in field \"name\" was too long") 2496 + } 2497 + 2498 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 2499 + return err 2500 + } 2501 + if _, err := cw.WriteString(string("name")); err != nil { 2502 + return err 2503 + } 2504 + 2505 + if len(t.Name) > 1000000 { 2506 + return xerrors.Errorf("Value in field t.Name was too long") 2507 + } 2508 + 2509 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 2510 + return err 2511 + } 2512 + if _, err := cw.WriteString(string(t.Name)); err != nil { 2513 + return err 2514 + } 2515 + 2516 + // t.LexiconTypeID (string) (string) 2517 + if len("$type") > 1000000 { 2518 + return xerrors.Errorf("Value in field \"$type\" was too long") 2519 + } 2520 + 2521 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 2522 + return err 2523 + } 2524 + if _, err := cw.WriteString(string("$type")); err != nil { 2525 + return err 2526 + } 2527 + 2528 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil { 2529 + return err 2530 + } 2531 + if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil { 2532 + return err 2533 + } 2534 + 2535 + // t.Color (string) (string) 2536 + if t.Color != nil { 2537 + 2538 + if len("color") > 1000000 { 2539 + return xerrors.Errorf("Value in field \"color\" was too long") 2540 + } 2541 + 2542 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("color"))); err != nil { 2543 + return err 2544 + } 2545 + if _, err := cw.WriteString(string("color")); err != nil { 2546 + return err 2547 + } 2548 + 2549 + if t.Color == nil { 2550 + if _, err := cw.Write(cbg.CborNull); err != nil { 2551 + return err 2552 + } 2553 + } else { 2554 + if len(*t.Color) > 1000000 { 2555 + return xerrors.Errorf("Value in field t.Color was too long") 2556 + } 2557 + 2558 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Color))); err != nil { 2559 + return err 2560 + } 2561 + if _, err := cw.WriteString(string(*t.Color)); err != nil { 2562 + return err 2563 + } 2564 + } 2565 + } 2566 + 2567 + // t.Scope (string) (string) 2568 + if len("scope") > 1000000 { 2569 + return xerrors.Errorf("Value in field \"scope\" was too long") 2570 + } 2571 + 2572 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("scope"))); err != nil { 2573 + return err 2574 + } 2575 + if _, err := cw.WriteString(string("scope")); err != nil { 2576 + return err 2577 + } 2578 + 2579 + if len(t.Scope) > 1000000 { 2580 + return xerrors.Errorf("Value in field t.Scope was too long") 2581 + } 2582 + 2583 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Scope))); err != nil { 2584 + return err 2585 + } 2586 + if _, err := cw.WriteString(string(t.Scope)); err != nil { 2587 + return err 2588 + } 2589 + 2590 + // t.Multiple (bool) (bool) 2591 + if t.Multiple != nil { 2592 + 2593 + if len("multiple") > 1000000 { 2594 + return xerrors.Errorf("Value in field \"multiple\" was too long") 2595 + } 2596 + 2597 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("multiple"))); err != nil { 2598 + return err 2599 + } 2600 + if _, err := cw.WriteString(string("multiple")); err != nil { 2601 + return err 2602 + } 2603 + 2604 + if t.Multiple == nil { 2605 + if _, err := cw.Write(cbg.CborNull); err != nil { 2606 + return err 2607 + } 2608 + } else { 2609 + if err := cbg.WriteBool(w, *t.Multiple); err != nil { 2610 + return err 2611 + } 2612 + } 2613 + } 2614 + 2615 + // t.CreatedAt (string) (string) 2616 + if len("createdAt") > 1000000 { 2617 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 2618 + } 2619 + 2620 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 2621 + return err 2622 + } 2623 + if _, err := cw.WriteString(string("createdAt")); err != nil { 2624 + return err 2625 + } 2626 + 2627 + if len(t.CreatedAt) > 1000000 { 2628 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 2629 + } 2630 + 2631 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 2632 + return err 2633 + } 2634 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 2635 + return err 2636 + } 2637 + 2638 + // t.ValueType (tangled.LabelDefinition_ValueType) (struct) 2639 + if len("valueType") > 1000000 { 2640 + return xerrors.Errorf("Value in field \"valueType\" was too long") 2641 + } 2642 + 2643 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("valueType"))); err != nil { 2644 + return err 2645 + } 2646 + if _, err := cw.WriteString(string("valueType")); err != nil { 2647 + return err 2648 + } 2649 + 2650 + if err := t.ValueType.MarshalCBOR(cw); err != nil { 2651 + return err 2652 + } 2653 + return nil 2654 + } 2655 + 2656 + func (t *LabelDefinition) UnmarshalCBOR(r io.Reader) (err error) { 2657 + *t = LabelDefinition{} 2658 + 2659 + cr := cbg.NewCborReader(r) 2660 + 2661 + maj, extra, err := cr.ReadHeader() 2662 + if err != nil { 2663 + return err 2664 + } 2665 + defer func() { 2666 + if err == io.EOF { 2667 + err = io.ErrUnexpectedEOF 2668 + } 2669 + }() 2670 + 2671 + if maj != cbg.MajMap { 2672 + return fmt.Errorf("cbor input should be of type map") 2673 + } 2674 + 2675 + if extra > cbg.MaxLength { 2676 + return fmt.Errorf("LabelDefinition: map struct too large (%d)", extra) 2677 + } 2678 + 2679 + n := extra 2680 + 2681 + nameBuf := make([]byte, 9) 2682 + for i := uint64(0); i < n; i++ { 2683 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2684 + if err != nil { 2685 + return err 2686 + } 2687 + 2688 + if !ok { 2689 + // Field doesn't exist on this type, so ignore it 2690 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2691 + return err 2692 + } 2693 + continue 2694 + } 2695 + 2696 + switch string(nameBuf[:nameLen]) { 2697 + // t.Name (string) (string) 2698 + case "name": 2699 + 2700 + { 2701 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2702 + if err != nil { 2703 + return err 2704 + } 2705 + 2706 + t.Name = string(sval) 2707 + } 2708 + // t.LexiconTypeID (string) (string) 2709 + case "$type": 2710 + 2711 + { 2712 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2713 + if err != nil { 2714 + return err 2715 + } 2716 + 2717 + t.LexiconTypeID = string(sval) 2718 + } 2719 + // t.Color (string) (string) 2720 + case "color": 2721 + 2722 + { 2723 + b, err := cr.ReadByte() 2724 + if err != nil { 2725 + return err 2726 + } 2727 + if b != cbg.CborNull[0] { 2728 + if err := cr.UnreadByte(); err != nil { 2729 + return err 2730 + } 2731 + 2732 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2733 + if err != nil { 2734 + return err 2735 + } 2736 + 2737 + t.Color = (*string)(&sval) 2738 + } 2739 + } 2740 + // t.Scope (string) (string) 2741 + case "scope": 2742 + 2743 + { 2744 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2745 + if err != nil { 2746 + return err 2747 + } 2748 + 2749 + t.Scope = string(sval) 2750 + } 2751 + // t.Multiple (bool) (bool) 2752 + case "multiple": 2753 + 2754 + { 2755 + b, err := cr.ReadByte() 2756 + if err != nil { 2757 + return err 2758 + } 2759 + if b != cbg.CborNull[0] { 2760 + if err := cr.UnreadByte(); err != nil { 2761 + return err 2762 + } 2763 + 2764 + maj, extra, err = cr.ReadHeader() 2765 + if err != nil { 2766 + return err 2767 + } 2768 + if maj != cbg.MajOther { 2769 + return fmt.Errorf("booleans must be major type 7") 2770 + } 2771 + 2772 + var val bool 2773 + switch extra { 2774 + case 20: 2775 + val = false 2776 + case 21: 2777 + val = true 2778 + default: 2779 + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) 2780 + } 2781 + t.Multiple = &val 2782 + } 2783 + } 2784 + // t.CreatedAt (string) (string) 2785 + case "createdAt": 2786 + 2787 + { 2788 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2789 + if err != nil { 2790 + return err 2791 + } 2792 + 2793 + t.CreatedAt = string(sval) 2794 + } 2795 + // t.ValueType (tangled.LabelDefinition_ValueType) (struct) 2796 + case "valueType": 2797 + 2798 + { 2799 + 2800 + b, err := cr.ReadByte() 2801 + if err != nil { 2802 + return err 2803 + } 2804 + if b != cbg.CborNull[0] { 2805 + if err := cr.UnreadByte(); err != nil { 2806 + return err 2807 + } 2808 + t.ValueType = new(LabelDefinition_ValueType) 2809 + if err := t.ValueType.UnmarshalCBOR(cr); err != nil { 2810 + return xerrors.Errorf("unmarshaling t.ValueType pointer: %w", err) 2811 + } 2812 + } 2813 + 2814 + } 2815 + 2816 + default: 2817 + // Field doesn't exist on this type, so ignore it 2818 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2819 + return err 2820 + } 2821 + } 2822 + } 2823 + 2824 + return nil 2825 + } 2826 + func (t *LabelDefinition_ValueType) MarshalCBOR(w io.Writer) error { 2827 + if t == nil { 2828 + _, err := w.Write(cbg.CborNull) 2829 + return err 2830 + } 2831 + 2832 + cw := cbg.NewCborWriter(w) 2833 + fieldCount := 4 2834 + 2835 + if t.Enum == nil { 2836 + fieldCount-- 2837 + } 2838 + 2839 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 2840 + return err 2841 + } 2842 + 2843 + // t.Enum ([]string) (slice) 2844 + if t.Enum != nil { 2845 + 2846 + if len("enum") > 1000000 { 2847 + return xerrors.Errorf("Value in field \"enum\" was too long") 2848 + } 2849 + 2850 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("enum"))); err != nil { 2851 + return err 2852 + } 2853 + if _, err := cw.WriteString(string("enum")); err != nil { 2854 + return err 2855 + } 2856 + 2857 + if len(t.Enum) > 8192 { 2858 + return xerrors.Errorf("Slice value in field t.Enum was too long") 2859 + } 2860 + 2861 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Enum))); err != nil { 2862 + return err 2863 + } 2864 + for _, v := range t.Enum { 2865 + if len(v) > 1000000 { 2866 + return xerrors.Errorf("Value in field v was too long") 2867 + } 2868 + 2869 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 2870 + return err 2871 + } 2872 + if _, err := cw.WriteString(string(v)); err != nil { 2873 + return err 2874 + } 2875 + 2876 + } 2877 + } 2878 + 2879 + // t.Type (string) (string) 2880 + if len("type") > 1000000 { 2881 + return xerrors.Errorf("Value in field \"type\" was too long") 2882 + } 2883 + 2884 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil { 2885 + return err 2886 + } 2887 + if _, err := cw.WriteString(string("type")); err != nil { 2888 + return err 2889 + } 2890 + 2891 + if len(t.Type) > 1000000 { 2892 + return xerrors.Errorf("Value in field t.Type was too long") 2893 + } 2894 + 2895 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil { 2896 + return err 2897 + } 2898 + if _, err := cw.WriteString(string(t.Type)); err != nil { 2899 + return err 2900 + } 2901 + 2902 + // t.LexiconTypeID (string) (string) 2903 + if len("$type") > 1000000 { 2904 + return xerrors.Errorf("Value in field \"$type\" was too long") 2905 + } 2906 + 2907 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 2908 + return err 2909 + } 2910 + if _, err := cw.WriteString(string("$type")); err != nil { 2911 + return err 2912 + } 2913 + 2914 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.label.definition"))); err != nil { 2915 + return err 2916 + } 2917 + if _, err := cw.WriteString(string("sh.tangled.label.definition")); err != nil { 2918 + return err 2919 + } 2920 + 2921 + // t.Format (string) (string) 2922 + if len("format") > 1000000 { 2923 + return xerrors.Errorf("Value in field \"format\" was too long") 2924 + } 2925 + 2926 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("format"))); err != nil { 2927 + return err 2928 + } 2929 + if _, err := cw.WriteString(string("format")); err != nil { 2930 + return err 2931 + } 2932 + 2933 + if len(t.Format) > 1000000 { 2934 + return xerrors.Errorf("Value in field t.Format was too long") 2935 + } 2936 + 2937 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Format))); err != nil { 2938 + return err 2939 + } 2940 + if _, err := cw.WriteString(string(t.Format)); err != nil { 2941 + return err 2942 + } 2943 + return nil 2944 + } 2945 + 2946 + func (t *LabelDefinition_ValueType) UnmarshalCBOR(r io.Reader) (err error) { 2947 + *t = LabelDefinition_ValueType{} 2948 + 2949 + cr := cbg.NewCborReader(r) 2950 + 2951 + maj, extra, err := cr.ReadHeader() 2952 + if err != nil { 2953 + return err 2954 + } 2955 + defer func() { 2956 + if err == io.EOF { 2957 + err = io.ErrUnexpectedEOF 2958 + } 2959 + }() 2960 + 2961 + if maj != cbg.MajMap { 2962 + return fmt.Errorf("cbor input should be of type map") 2963 + } 2964 + 2965 + if extra > cbg.MaxLength { 2966 + return fmt.Errorf("LabelDefinition_ValueType: map struct too large (%d)", extra) 2967 + } 2968 + 2969 + n := extra 2970 + 2971 + nameBuf := make([]byte, 6) 2972 + for i := uint64(0); i < n; i++ { 2973 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2974 + if err != nil { 2975 + return err 2976 + } 2977 + 2978 + if !ok { 2979 + // Field doesn't exist on this type, so ignore it 2980 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2981 + return err 2982 + } 2983 + continue 2984 + } 2985 + 2986 + switch string(nameBuf[:nameLen]) { 2987 + // t.Enum ([]string) (slice) 2988 + case "enum": 2989 + 2990 + maj, extra, err = cr.ReadHeader() 2991 + if err != nil { 2992 + return err 2993 + } 2994 + 2995 + if extra > 8192 { 2996 + return fmt.Errorf("t.Enum: array too large (%d)", extra) 2997 + } 2998 + 2999 + if maj != cbg.MajArray { 3000 + return fmt.Errorf("expected cbor array") 3001 + } 3002 + 3003 + if extra > 0 { 3004 + t.Enum = make([]string, extra) 3005 + } 3006 + 3007 + for i := 0; i < int(extra); i++ { 3008 + { 3009 + var maj byte 3010 + var extra uint64 3011 + var err error 3012 + _ = maj 3013 + _ = extra 3014 + _ = err 3015 + 3016 + { 3017 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3018 + if err != nil { 3019 + return err 3020 + } 3021 + 3022 + t.Enum[i] = string(sval) 3023 + } 3024 + 3025 + } 3026 + } 3027 + // t.Type (string) (string) 3028 + case "type": 3029 + 3030 + { 3031 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3032 + if err != nil { 3033 + return err 3034 + } 3035 + 3036 + t.Type = string(sval) 3037 + } 3038 + // t.LexiconTypeID (string) (string) 3039 + case "$type": 3040 + 3041 + { 3042 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3043 + if err != nil { 3044 + return err 3045 + } 3046 + 3047 + t.LexiconTypeID = string(sval) 3048 + } 3049 + // t.Format (string) (string) 3050 + case "format": 3051 + 3052 + { 3053 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3054 + if err != nil { 3055 + return err 3056 + } 3057 + 3058 + t.Format = string(sval) 3059 } 3060 3061 default:

+43

api/tangled/labeldefinition.go

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 + 3 + package tangled 4 + 5 + // schema: sh.tangled.label.definition 6 + 7 + import ( 8 + "github.com/bluesky-social/indigo/lex/util" 9 + ) 10 + 11 + const ( 12 + LabelDefinitionNSID = "sh.tangled.label.definition" 13 + ) 14 + 15 + func init() { 16 + util.RegisterType("sh.tangled.label.definition", &LabelDefinition{}) 17 + } // 18 + // RECORDTYPE: LabelDefinition 19 + type LabelDefinition struct { 20 + LexiconTypeID string `json:"$type,const=sh.tangled.label.definition" cborgen:"$type,const=sh.tangled.label.definition"` 21 + // color: The hex value for the background color for the label. Appviews may choose to respect this. 22 + Color *string `json:"color,omitempty" cborgen:"color,omitempty"` 23 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 24 + // multiple: Whether this label can be repeated for a given entity, eg.: [reviewer:foo, reviewer:bar] 25 + Multiple *bool `json:"multiple,omitempty" cborgen:"multiple,omitempty"` 26 + // name: The display name of this label. 27 + Name string `json:"name" cborgen:"name"` 28 + // scope: The area of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this. 29 + Scope string `json:"scope" cborgen:"scope"` 30 + // valueType: The type definition of this label. Appviews may allow sorting for certain types. 31 + ValueType *LabelDefinition_ValueType `json:"valueType" cborgen:"valueType"` 32 + } 33 + 34 + // RECORDTYPE: LabelDefinition_ValueType 35 + type LabelDefinition_ValueType struct { 36 + LexiconTypeID string `json:"$type,const=sh.tangled.label.definition" cborgen:"$type,const=sh.tangled.label.definition"` 37 + // enum: Closed set of values that this label can take. 38 + Enum []string `json:"enum,omitempty" cborgen:"enum,omitempty"` 39 + // format: An optional constraint that can be applied on string concrete types. 40 + Format string `json:"format" cborgen:"format"` 41 + // type: The concrete type of this label's value. 42 + Type string `json:"type" cborgen:"type"` 43 + }

+3 -1

cmd/gen.go

··· 20 tangled.GitRefUpdate{}, 21 tangled.GitRefUpdate_CommitCountBreakdown{}, 22 tangled.GitRefUpdate_IndividualEmailCommitCount{}, 23 - tangled.GitRefUpdate_LangBreakdown{}, 24 tangled.GitRefUpdate_IndividualLanguageSize{}, 0 25 tangled.GitRefUpdate_Meta{}, 26 tangled.GraphFollow{}, 27 tangled.Knot{}, 28 tangled.KnotMember{}, 0 0 29 tangled.Pipeline{}, 30 tangled.Pipeline_CloneOpts{}, 31 tangled.Pipeline_ManualTriggerData{},

··· 20 tangled.GitRefUpdate{}, 21 tangled.GitRefUpdate_CommitCountBreakdown{}, 22 tangled.GitRefUpdate_IndividualEmailCommitCount{}, 0 23 tangled.GitRefUpdate_IndividualLanguageSize{}, 24 + tangled.GitRefUpdate_LangBreakdown{}, 25 tangled.GitRefUpdate_Meta{}, 26 tangled.GraphFollow{}, 27 tangled.Knot{}, 28 tangled.KnotMember{}, 29 + tangled.LabelDefinition{}, 30 + tangled.LabelDefinition_ValueType{}, 31 tangled.Pipeline{}, 32 tangled.Pipeline_CloneOpts{}, 33 tangled.Pipeline_ManualTriggerData{},

+90

lexicons/label/definition.json

··· 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

··· 1 + { 2 + "lexicon": 1, 3 + "id": "sh.tangled.label.definition", 4 + "needsCbor": true, 5 + "needsType": true, 6 + "defs": { 7 + "main": { 8 + "type": "record", 9 + "key": "any", 10 + "record": { 11 + "type": "object", 12 + "required": [ 13 + "name", 14 + "valueType", 15 + "scope", 16 + "createdAt" 17 + ], 18 + "properties": { 19 + "name": { 20 + "type": "string", 21 + "description": "The display name of this label.", 22 + "minGraphemes": 1, 23 + "maxGraphemes": 40 24 + }, 25 + "valueType": { 26 + "type": "ref", 27 + "ref": "#valueType", 28 + "description": "The type definition of this label. Appviews may allow sorting for certain types." 29 + }, 30 + "scope": { 31 + "type": "string", 32 + "format": "nsid", 33 + "description": "The area of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this." 34 + }, 35 + "color": { 36 + "type": "string", 37 + "description": "The hex value for the background color for the label. Appviews may choose to respect this." 38 + }, 39 + "createdAt": { 40 + "type": "string", 41 + "format": "datetime" 42 + }, 43 + "multiple": { 44 + "type": "boolean", 45 + "description": "Whether this label can be repeated for a given entity, eg.: [reviewer:foo, reviewer:bar]" 46 + } 47 + } 48 + } 49 + }, 50 + "valueType": { 51 + "type": "record", 52 + "key": "any", 53 + "record": { 54 + "type": "object", 55 + "required": [ 56 + "type", 57 + "format" 58 + ], 59 + "properties": { 60 + "type": { 61 + "type": "string", 62 + "enum": [ 63 + "null", 64 + "boolean", 65 + "integer", 66 + "string" 67 + ], 68 + "description": "The concrete type of this label's value." 69 + }, 70 + "format": { 71 + "type": "string", 72 + "enum": [ 73 + "any", 74 + "did", 75 + "nsid" 76 + ], 77 + "description": "An optional constraint that can be applied on string concrete types." 78 + }, 79 + "enum": { 80 + "type": "array", 81 + "description": "Closed set of values that this label can take.", 82 + "items": { 83 + "type": "string" 84 + } 85 + } 86 + } 87 + } 88 + } 89 + } 90 + }