+752 -144

api/tangled/cbor_gen.go

View file Reviewed

··· 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) (slice) 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) > 8192 { 2580 2580 + return xerrors.Errorf("Slice value in field t.Scope was too long") 2581 2581 + } 2582 2582 + 2583 2583 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Scope))); err != nil { 2584 2584 + return err 2585 2585 + } 2586 2586 + for _, v := range t.Scope { 2587 2587 + if len(v) > 1000000 { 2588 2588 + return xerrors.Errorf("Value in field v was too long") 2589 2589 + } 2590 2590 + 2591 2591 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 2592 2592 + return err 2593 2593 + } 2594 2594 + if _, err := cw.WriteString(string(v)); err != nil { 2595 2595 + return err 2596 2596 + } 2597 2597 + 2598 2598 + } 2599 2599 + 2600 2600 + // t.Multiple (bool) (bool) 2601 2601 + if t.Multiple != nil { 2602 2602 + 2603 2603 + if len("multiple") > 1000000 { 2604 2604 + return xerrors.Errorf("Value in field \"multiple\" was too long") 2605 2605 + } 2606 2606 + 2607 2607 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("multiple"))); err != nil { 2608 2608 + return err 2609 2609 + } 2610 2610 + if _, err := cw.WriteString(string("multiple")); err != nil { 2611 2611 + return err 2612 2612 + } 2613 2613 + 2614 2614 + if t.Multiple == nil { 2615 2615 + if _, err := cw.Write(cbg.CborNull); err != nil { 2616 2616 + return err 2617 2617 + } 2618 2618 + } else { 2619 2619 + if err := cbg.WriteBool(w, *t.Multiple); err != nil { 2620 2620 + return err 2621 2621 + } 2622 2622 + } 2623 2623 + } 2624 2624 + 2625 2625 + // t.CreatedAt (string) (string) 2626 2626 + if len("createdAt") > 1000000 { 2627 2627 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 2628 2628 + } 2629 2629 + 2630 2630 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 2631 2631 + return err 2632 2632 + } 2633 2633 + if _, err := cw.WriteString(string("createdAt")); err != nil { 2634 2634 + return err 2635 2635 + } 2636 2636 + 2637 2637 + if len(t.CreatedAt) > 1000000 { 2638 2638 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 2639 2639 + } 2640 2640 + 2641 2641 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 2642 2642 + return err 2643 2643 + } 2644 2644 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 2645 2645 + return err 2646 2646 + } 2647 2647 + 2648 2648 + // t.ValueType (tangled.LabelDefinition_ValueType) (struct) 2649 2649 + if len("valueType") > 1000000 { 2650 2650 + return xerrors.Errorf("Value in field \"valueType\" was too long") 2651 2651 + } 2652 2652 + 2653 2653 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("valueType"))); err != nil { 2654 2654 + return err 2655 2655 + } 2656 2656 + if _, err := cw.WriteString(string("valueType")); err != nil { 2657 2657 + return err 2658 2658 + } 2659 2659 + 2660 2660 + if err := t.ValueType.MarshalCBOR(cw); err != nil { 2661 2661 + return err 2662 2662 + } 2663 2663 + return nil 2664 2664 + } 2665 2665 + 2666 2666 + func (t *LabelDefinition) UnmarshalCBOR(r io.Reader) (err error) { 2667 2667 + *t = LabelDefinition{} 2668 2668 + 2669 2669 + cr := cbg.NewCborReader(r) 2670 2670 + 2671 2671 + maj, extra, err := cr.ReadHeader() 2672 2672 + if err != nil { 2673 2673 + return err 2674 2674 + } 2675 2675 + defer func() { 2676 2676 + if err == io.EOF { 2677 2677 + err = io.ErrUnexpectedEOF 2678 2678 + } 2679 2679 + }() 2680 2680 + 2681 2681 + if maj != cbg.MajMap { 2682 2682 + return fmt.Errorf("cbor input should be of type map") 2683 2683 + } 2684 2684 + 2685 2685 + if extra > cbg.MaxLength { 2686 2686 + return fmt.Errorf("LabelDefinition: map struct too large (%d)", extra) 2687 2687 + } 2688 2688 + 2689 2689 + n := extra 2690 2690 + 2691 2691 + nameBuf := make([]byte, 9) 2692 2692 + for i := uint64(0); i < n; i++ { 2693 2693 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2694 2694 + if err != nil { 2695 2695 + return err 2696 2696 + } 2697 2697 + 2698 2698 + if !ok { 2699 2699 + // Field doesn't exist on this type, so ignore it 2700 2700 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2701 2701 + return err 2702 2702 + } 2703 2703 + continue 2704 2704 + } 2705 2705 + 2706 2706 + switch string(nameBuf[:nameLen]) { 2707 2707 + // t.Name (string) (string) 2708 2708 + case "name": 2709 2709 + 2710 2710 + { 2711 2711 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2712 2712 + if err != nil { 2713 2713 + return err 2714 2714 + } 2715 2715 + 2716 2716 + t.Name = string(sval) 2717 2717 + } 2718 2718 + // t.LexiconTypeID (string) (string) 2719 2719 + case "$type": 2720 2720 + 2721 2721 + { 2722 2722 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2723 2723 + if err != nil { 2724 2724 + return err 2725 2725 + } 2726 2726 + 2727 2727 + t.LexiconTypeID = string(sval) 2728 2728 + } 2729 2729 + // t.Color (string) (string) 2730 2730 + case "color": 2731 2731 + 2732 2732 + { 2733 2733 + b, err := cr.ReadByte() 2734 2734 + if err != nil { 2735 2735 + return err 2736 2736 + } 2737 2737 + if b != cbg.CborNull[0] { 2738 2738 + if err := cr.UnreadByte(); err != nil { 2739 2739 + return err 2740 2740 + } 2741 2741 + 2742 2742 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2743 2743 + if err != nil { 2744 2744 + return err 2745 2745 + } 2746 2746 + 2747 2747 + t.Color = (*string)(&sval) 2748 2748 + } 2749 2749 + } 2750 2750 + // t.Scope ([]string) (slice) 2751 2751 + case "scope": 2752 2752 + 2753 2753 + maj, extra, err = cr.ReadHeader() 2754 2754 + if err != nil { 2755 2755 + return err 2756 2756 + } 2757 2757 + 2758 2758 + if extra > 8192 { 2759 2759 + return fmt.Errorf("t.Scope: array too large (%d)", extra) 2760 2760 + } 2761 2761 + 2762 2762 + if maj != cbg.MajArray { 2763 2763 + return fmt.Errorf("expected cbor array") 2764 2764 + } 2765 2765 + 2766 2766 + if extra > 0 { 2767 2767 + t.Scope = make([]string, extra) 2768 2768 + } 2769 2769 + 2770 2770 + for i := 0; i < int(extra); i++ { 2771 2771 + { 2772 2772 + var maj byte 2773 2773 + var extra uint64 2774 2774 + var err error 2775 2775 + _ = maj 2776 2776 + _ = extra 2777 2777 + _ = err 2778 2778 + 2779 2779 + { 2780 2780 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2781 2781 + if err != nil { 2782 2782 + return err 2783 2783 + } 2784 2784 + 2785 2785 + t.Scope[i] = string(sval) 2786 2786 + } 2787 2787 + 2788 2788 + } 2789 2789 + } 2790 2790 + // t.Multiple (bool) (bool) 2791 2791 + case "multiple": 2792 2792 + 2793 2793 + { 2794 2794 + b, err := cr.ReadByte() 2795 2795 + if err != nil { 2796 2796 + return err 2797 2797 + } 2798 2798 + if b != cbg.CborNull[0] { 2799 2799 + if err := cr.UnreadByte(); err != nil { 2800 2800 + return err 2801 2801 + } 2802 2802 + 2803 2803 + maj, extra, err = cr.ReadHeader() 2804 2804 + if err != nil { 2805 2805 + return err 2806 2806 + } 2807 2807 + if maj != cbg.MajOther { 2808 2808 + return fmt.Errorf("booleans must be major type 7") 2809 2809 + } 2810 2810 + 2811 2811 + var val bool 2812 2812 + switch extra { 2813 2813 + case 20: 2814 2814 + val = false 2815 2815 + case 21: 2816 2816 + val = true 2817 2817 + default: 2818 2818 + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) 2819 2819 + } 2820 2820 + t.Multiple = &val 2821 2821 + } 2822 2822 + } 2823 2823 + // t.CreatedAt (string) (string) 2824 2824 + case "createdAt": 2825 2825 + 2826 2826 + { 2827 2827 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2828 2828 + if err != nil { 2829 2829 + return err 2830 2830 + } 2831 2831 + 2832 2832 + t.CreatedAt = string(sval) 2833 2833 + } 2834 2834 + // t.ValueType (tangled.LabelDefinition_ValueType) (struct) 2835 2835 + case "valueType": 2836 2836 + 2837 2837 + { 2838 2838 + 2839 2839 + b, err := cr.ReadByte() 2840 2840 + if err != nil { 2841 2841 + return err 2842 2842 + } 2843 2843 + if b != cbg.CborNull[0] { 2844 2844 + if err := cr.UnreadByte(); err != nil { 2845 2845 + return err 2846 2846 + } 2847 2847 + t.ValueType = new(LabelDefinition_ValueType) 2848 2848 + if err := t.ValueType.UnmarshalCBOR(cr); err != nil { 2849 2849 + return xerrors.Errorf("unmarshaling t.ValueType pointer: %w", err) 2850 2850 + } 2851 2851 + } 2852 2852 + 2853 2853 + } 2854 2854 + 2855 2855 + default: 2856 2856 + // Field doesn't exist on this type, so ignore it 2857 2857 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2858 2858 + return err 2859 2859 + } 2860 2860 + } 2861 2861 + } 2862 2862 + 2863 2863 + return nil 2864 2864 + } 2865 2865 + func (t *LabelDefinition_ValueType) MarshalCBOR(w io.Writer) error { 2866 2866 + if t == nil { 2867 2867 + _, err := w.Write(cbg.CborNull) 2868 2868 + return err 2869 2869 + } 2870 2870 + 2871 2871 + cw := cbg.NewCborWriter(w) 2872 2872 + fieldCount := 3 2873 2873 + 2874 2874 + if t.Enum == nil { 2875 2875 + fieldCount-- 2876 2876 + } 2877 2877 + 2878 2878 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 2879 2879 + return err 2880 2880 + } 2881 2881 + 2882 2882 + // t.Enum ([]string) (slice) 2883 2883 + if t.Enum != nil { 2884 2884 + 2885 2885 + if len("enum") > 1000000 { 2886 2886 + return xerrors.Errorf("Value in field \"enum\" was too long") 2887 2887 + } 2888 2888 + 2889 2889 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("enum"))); err != nil { 2890 2890 + return err 2891 2891 + } 2892 2892 + if _, err := cw.WriteString(string("enum")); err != nil { 2893 2893 + return err 2894 2894 + } 2895 2895 + 2896 2896 + if len(t.Enum) > 8192 { 2897 2897 + return xerrors.Errorf("Slice value in field t.Enum was too long") 2898 2898 + } 2899 2899 + 2900 2900 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Enum))); err != nil { 2901 2901 + return err 2902 2902 + } 2903 2903 + for _, v := range t.Enum { 2904 2904 + if len(v) > 1000000 { 2905 2905 + return xerrors.Errorf("Value in field v was too long") 2906 2906 + } 2907 2907 + 2908 2908 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 2909 2909 + return err 2910 2910 + } 2911 2911 + if _, err := cw.WriteString(string(v)); err != nil { 2912 2912 + return err 2913 2913 + } 2914 2914 + 2915 2915 + } 2916 2916 + } 2917 2917 + 2918 2918 + // t.Type (string) (string) 2919 2919 + if len("type") > 1000000 { 2920 2920 + return xerrors.Errorf("Value in field \"type\" was too long") 2921 2921 + } 2922 2922 + 2923 2923 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil { 2924 2924 + return err 2925 2925 + } 2926 2926 + if _, err := cw.WriteString(string("type")); err != nil { 2927 2927 + return err 2928 2928 + } 2929 2929 + 2930 2930 + if len(t.Type) > 1000000 { 2931 2931 + return xerrors.Errorf("Value in field t.Type was too long") 2932 2932 + } 2933 2933 + 2934 2934 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil { 2935 2935 + return err 2936 2936 + } 2937 2937 + if _, err := cw.WriteString(string(t.Type)); err != nil { 2938 2938 + return err 2939 2939 + } 2940 2940 + 2941 2941 + // t.Format (string) (string) 2942 2942 + if len("format") > 1000000 { 2943 2943 + return xerrors.Errorf("Value in field \"format\" was too long") 2944 2944 + } 2945 2945 + 2946 2946 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("format"))); err != nil { 2947 2947 + return err 2948 2948 + } 2949 2949 + if _, err := cw.WriteString(string("format")); err != nil { 2950 2950 + return err 2951 2951 + } 2952 2952 + 2953 2953 + if len(t.Format) > 1000000 { 2954 2954 + return xerrors.Errorf("Value in field t.Format was too long") 2955 2955 + } 2956 2956 + 2957 2957 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Format))); err != nil { 2958 2958 + return err 2959 2959 + } 2960 2960 + if _, err := cw.WriteString(string(t.Format)); err != nil { 2961 2961 + return err 2962 2962 + } 2963 2963 + return nil 2964 2964 + } 2965 2965 + 2966 2966 + func (t *LabelDefinition_ValueType) UnmarshalCBOR(r io.Reader) (err error) { 2967 2967 + *t = LabelDefinition_ValueType{} 2968 2968 + 2969 2969 + cr := cbg.NewCborReader(r) 2970 2970 + 2971 2971 + maj, extra, err := cr.ReadHeader() 2972 2972 + if err != nil { 2973 2973 + return err 2974 2974 + } 2975 2975 + defer func() { 2976 2976 + if err == io.EOF { 2977 2977 + err = io.ErrUnexpectedEOF 2978 2978 + } 2979 2979 + }() 2980 2980 + 2981 2981 + if maj != cbg.MajMap { 2982 2982 + return fmt.Errorf("cbor input should be of type map") 2983 2983 + } 2984 2984 + 2985 2985 + if extra > cbg.MaxLength { 2986 2986 + return fmt.Errorf("LabelDefinition_ValueType: map struct too large (%d)", extra) 2987 2987 + } 2988 2988 + 2989 2989 + n := extra 2990 2990 + 2991 2991 + nameBuf := make([]byte, 6) 2992 2992 + for i := uint64(0); i < n; i++ { 2993 2993 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2994 2994 + if err != nil { 2995 2995 + return err 2996 2996 + } 2997 2997 + 2998 2998 + if !ok { 2999 2999 + // Field doesn't exist on this type, so ignore it 3000 3000 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3001 3001 + return err 3002 3002 + } 3003 3003 + continue 3004 3004 + } 3005 3005 + 3006 3006 + switch string(nameBuf[:nameLen]) { 3007 3007 + // t.Enum ([]string) (slice) 3008 3008 + case "enum": 3009 3009 + 3010 3010 + maj, extra, err = cr.ReadHeader() 3011 3011 + if err != nil { 3012 3012 + return err 3013 3013 + } 3014 3014 + 3015 3015 + if extra > 8192 { 3016 3016 + return fmt.Errorf("t.Enum: array too large (%d)", extra) 3017 3017 + } 3018 3018 + 3019 3019 + if maj != cbg.MajArray { 3020 3020 + return fmt.Errorf("expected cbor array") 3021 3021 + } 3022 3022 + 3023 3023 + if extra > 0 { 3024 3024 + t.Enum = make([]string, extra) 3025 3025 + } 3026 3026 + 3027 3027 + for i := 0; i < int(extra); i++ { 3028 3028 + { 3029 3029 + var maj byte 3030 3030 + var extra uint64 3031 3031 + var err error 3032 3032 + _ = maj 3033 3033 + _ = extra 3034 3034 + _ = err 3035 3035 + 3036 3036 + { 3037 3037 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3038 3038 + if err != nil { 3039 3039 + return err 3040 3040 + } 3041 3041 + 3042 3042 + t.Enum[i] = string(sval) 3043 3043 + } 3044 3044 + 3045 3045 + } 3046 3046 + } 3047 3047 + // t.Type (string) (string) 3048 3048 + case "type": 3049 3049 + 3050 3050 + { 3051 3051 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3052 3052 + if err != nil { 3053 3053 + return err 3054 3054 + } 3055 3055 + 3056 3056 + t.Type = string(sval) 3057 3057 + } 3058 3058 + // t.Format (string) (string) 3059 3059 + case "format": 3060 3060 + 3061 3061 + { 3062 3062 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3063 3063 + if err != nil { 3064 3064 + return err 3065 3065 + } 3066 3066 + 3067 3067 + t.Format = string(sval) 2460 3068 } 2461 3069 2462 3070 default:

+42

api/tangled/labeldefinition.go

View file Reviewed

··· 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 areas 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 + // LabelDefinition_ValueType is a "valueType" in the sh.tangled.label.definition schema. 35 35 + type LabelDefinition_ValueType struct { 36 36 + // enum: Closed set of values that this label can take. 37 37 + Enum []string `json:"enum,omitempty" cborgen:"enum,omitempty"` 38 38 + // format: An optional constraint that can be applied on string concrete types. 39 39 + Format string `json:"format" cborgen:"format"` 40 40 + // type: The concrete type of this label's value. 41 41 + Type string `json:"type" cborgen:"type"` 42 42 + }

+3 -1

cmd/gen.go

View file Reviewed

··· 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{},

+89

lexicons/label/definition.json

View file Reviewed

··· 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": "array", 32 32 + "description": "The areas of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this.", 33 33 + "items": { 34 34 + "type": "string", 35 35 + "format": "nsid" 36 36 + } 37 37 + }, 38 38 + "color": { 39 39 + "type": "string", 40 40 + "description": "The hex value for the background color for the label. Appviews may choose to respect this." 41 41 + }, 42 42 + "createdAt": { 43 43 + "type": "string", 44 44 + "format": "datetime" 45 45 + }, 46 46 + "multiple": { 47 47 + "type": "boolean", 48 48 + "description": "Whether this label can be repeated for a given entity, eg.: [reviewer:foo, reviewer:bar]" 49 49 + } 50 50 + } 51 51 + } 52 52 + }, 53 53 + "valueType": { 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 + }