+743 -144

api/tangled/cbor_gen.go

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

+43

api/tangled/labeldefinition.go

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

+3 -1

cmd/gen.go

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

+90

lexicons/label/definition.json

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