go-ap / activitypub / #2

Committed 02 Feb 2026 01:13PM UTC coverage: 43.033% (+1.0%) from 42.028%

Build # #2

Build Type

push

sourcehut

Committed by

mariusor

Commit Message

Adding Stringer methods on the vocabulary types

Run Details

0 of 12 new or added lines in 1 file covered. (0.0%)

1116 existing lines in 23 files now uncovered.

3255 of 7564 relevant lines covered (43.03%)

99.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

18.15

/decoding_gob.go

package activitypub

import (
        "bytes"
        "encoding/gob"
        "errors"
        "time"
)

func GobDecode(data []byte) (Item, error) {
        return gobDecodeItem(data)
}

func gobDecodeUint(i *uint, data []byte) error {
        g := gob.NewDecoder(bytes.NewReader(data))
        return g.Decode(i)
}

func gobDecodeFloat64(f *float64, data []byte) error {
        g := gob.NewDecoder(bytes.NewReader(data))
        return g.Decode(f)
}

func gobDecodeInt64(i *int64, data []byte) error {
        g := gob.NewDecoder(bytes.NewReader(data))
        return g.Decode(i)
}

func gobDecodeBool(b *bool, data []byte) error {
        g := gob.NewDecoder(bytes.NewReader(data))
        return g.Decode(b)
}

func unmapActorProperties(mm map[string][]byte, a *Actor) error {
        err := OnObject(a, func(ob *Object) error {
                return unmapObjectProperties(mm, ob)
        })
        if err != nil {
                return err
        }
        if raw, ok := mm["inbox"]; ok {
                if a.Inbox, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["outbox"]; ok {
                if a.Outbox, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["following"]; ok {
                if a.Following, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["followers"]; ok {
                if a.Followers, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["liked"]; ok {
                if a.Liked, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["preferredUsername"]; ok {
                if a.PreferredUsername, err = gobDecodeNaturalLanguageValues(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["endpoints"]; ok {
                if err = a.Endpoints.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["streams"]; ok {
                if a.Streams, err = gobDecodeItems(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["publicKey"]; ok {
                if err = a.PublicKey.GobDecode(raw); err != nil {
                        return err
                }
        }
        return nil
}

func unmapIntransitiveActivityProperties(mm map[string][]byte, act *IntransitiveActivity) error {
        err := OnObject(act, func(ob *Object) error {
                return unmapObjectProperties(mm, ob)
        })
        if err != nil {
                return err
        }
        if raw, ok := mm["actor"]; ok {
                if act.Actor, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["target"]; ok {
                if act.Target, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["result"]; ok {
                if act.Result, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["origin"]; ok {
                if act.Origin, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["instrument"]; ok {
                if act.Instrument, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        return nil
}

func unmapActivityProperties(mm map[string][]byte, act *Activity) error {
        err := OnIntransitiveActivity(act, func(act *IntransitiveActivity) error {
                return unmapIntransitiveActivityProperties(mm, act)
        })
        if err != nil {
                return err
        }
        if raw, ok := mm["object"]; ok {
                if act.Object, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        return nil
}

func unmapLinkProperties(mm map[string][]byte, l *Link) error {
        if raw, ok := mm["id"]; ok {
                if err := l.ID.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["type"]; ok {
                var err error
                if l.Type, err = gobDecodeTypes(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["mediaType"]; ok {
                if err := l.MediaType.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["href"]; ok {
                if err := l.Href.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["hrefLang"]; ok {
                if err := l.HrefLang.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["name"]; ok {
                if err := l.Name.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["rel"]; ok {
                if err := l.Rel.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["width"]; ok {
                if err := gobDecodeUint(&l.Width, raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["height"]; ok {
                if err := gobDecodeUint(&l.Height, raw); err != nil {
                        return err
                }
        }
        return nil
}

func gobDecodeTypes(data []byte) (Typer, error) {
        items := make(ActivityVocabularyTypes, 0)
        if err := items.GobDecode(data); err != nil {
                return nil, err
        }
        if len(items) == 0 {
                return nil, nil
        }
        if len(items) == 1 {
                return items[0], nil
        }
        return items, nil
}

func unmapObjectProperties(mm map[string][]byte, o *Object) error {
        var err error
        if raw, ok := mm["id"]; ok {
                if err = o.ID.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["type"]; ok {
                if o.Type, err = gobDecodeTypes(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["name"]; ok {
                name := make(NaturalLanguageValues)
                if err = name.GobDecode(raw); err != nil {
                        return err
                }
                o.Name = name
        }
        if raw, ok := mm["attachment"]; ok {
                if o.Attachment, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["attributedTo"]; ok {
                if o.AttributedTo, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["audience"]; ok {
                if o.Audience, err = gobDecodeItems(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["content"]; ok {
                content := make(NaturalLanguageValues)
                if content, err = gobDecodeNaturalLanguageValues(raw); err != nil {
                        return err
                }
                o.Content = content
        }
        if raw, ok := mm["context"]; ok {
                if o.Context, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["mediaType"]; ok {
                if err = o.MediaType.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["endTime"]; ok {
                if err = o.EndTime.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["generator"]; ok {
                if o.Generator, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["icon"]; ok {
                if o.Icon, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["image"]; ok {
                if o.Image, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["inReplyTo"]; ok {
                if o.InReplyTo, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["location"]; ok {
                if o.Location, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["preview"]; ok {
                if o.Preview, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["published"]; ok {
                if err = o.Published.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["replies"]; ok {
                if o.Replies, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["startTime"]; ok {
                if err = o.StartTime.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["summary"]; ok {
                summary := make(NaturalLanguageValues)
                if summary, err = gobDecodeNaturalLanguageValues(raw); err != nil {
                        return err
                }
                o.Summary = summary
        }
        if raw, ok := mm["tag"]; ok {
                if o.Tag, err = gobDecodeItems(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["updated"]; ok {
                if err = o.Updated.GobDecode(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["url"]; ok {
                if o.URL, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["to"]; ok {
                if o.To, err = gobDecodeItems(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["bto"]; ok {
                if o.Bto, err = gobDecodeItems(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["cc"]; ok {
                if o.CC, err = gobDecodeItems(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["bcc"]; ok {
                if o.BCC, err = gobDecodeItems(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["duration"]; ok {
                if o.Duration, err = gobDecodeDuration(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["likes"]; ok {
                if o.Likes, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["shares"]; ok {
                if o.Shares, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["source"]; ok {
                if err := o.Source.GobDecode(raw); err != nil {
                        return err
                }
        }
        return nil
}

func tryDecodeItems(items *ItemCollection, data []byte) error {
        tt := make([][]byte, 0)
        g := gob.NewDecoder(bytes.NewReader(data))
        if err := g.Decode(&tt); err != nil {
                return err
        }
        for _, it := range tt {
                ob, err := gobDecodeItem(it)
                if err != nil {
                        return err
                }
                *items = append(*items, ob)
        }
        return nil
}

func tryDecodeIRIs(iris *IRIs, data []byte) error {
        return iris.GobDecode(data)
}

func tryDecodeIRI(iri *IRI, data []byte) error {
        return iri.GobDecode(data)
}

func gobDecodeDuration(data []byte) (time.Duration, error) {
        var d time.Duration
        err := gob.NewDecoder(bytes.NewReader(data)).Decode(&d)
        return d, err
}

func gobDecodeNaturalLanguageValues(data []byte) (NaturalLanguageValues, error) {
        n := make(NaturalLanguageValues)
        err := n.GobDecode(data)
        return n, err
}

func gobDecodeItems(data []byte) (ItemCollection, error) {
        items := make(ItemCollection, 0)
        if err := tryDecodeItems(&items, data); err != nil {
                return nil, err
        }
        return items, nil
}

func gobDecodeItem(data []byte) (Item, error) {
        items := make(ItemCollection, 0)
        if err := tryDecodeItems(&items, data); err == nil {
                return items, nil
        }
        iris := make(IRIs, 0)
        if err := tryDecodeIRIs(&iris, data); err == nil {
                return iris, nil
        }
        isObject := false
        typ := NilType
        mm, err := gobDecodeObjectAsMap(data)
        if err == nil {
                var sTyp []byte
                sTyp, isObject = mm["type"]
                if isObject {
                        typ = ActivityVocabularyType(sTyp)
                } else {
                        _, isObject = mm["id"]
                }
        }
        if isObject {
                it, err := ItemTyperFunc(typ)
                if err != nil {
                        return nil, err
                }
                switch {
                //case typ.Match(IRIType):
                case ActivityVocabularyTypes{NilType, ObjectType, ArticleType, AudioType, DocumentType, EventType,
                        ImageType, NoteType, PageType, VideoType}.Match(typ):
                        err = OnObject(it, func(ob *Object) error {
                                return unmapObjectProperties(mm, ob)
                        })
                case ActivityVocabularyTypes{LinkType, MentionType}.Match(typ):
                        err = OnLink(it, func(l *Link) error {
                                return unmapLinkProperties(mm, l)
                        })
                case ActivityVocabularyTypes{ActivityType, AcceptType, AddType, AnnounceType, BlockType, CreateType, DeleteType, DislikeType,
                        FlagType, FollowType, IgnoreType, InviteType, JoinType, LeaveType, LikeType, ListenType, MoveType, OfferType,
                        RejectType, ReadType, RemoveType, TentativeRejectType, TentativeAcceptType, UndoType, UpdateType, ViewType}.Match(typ):
                        err = OnActivity(it, func(act *Activity) error {
                                return unmapActivityProperties(mm, act)
                        })
                case ActivityVocabularyTypes{IntransitiveActivityType, ArriveType, TravelType}.Match(typ):
                        err = OnIntransitiveActivity(it, func(act *IntransitiveActivity) error {
                                return unmapIntransitiveActivityProperties(mm, act)
                        })
                case ActivityVocabularyTypes{ActorType, ApplicationType, GroupType, OrganizationType, PersonType, ServiceType}.Match(typ):
                        err = OnActor(it, func(a *Actor) error {
                                return unmapActorProperties(mm, a)
                        })
                }
                return it, err
        }
        iri := IRI("")
        if err := tryDecodeIRI(&iri, data); err == nil {
                return iri, err
        }

        return nil, errors.New("unable to gob decode to any known ActivityPub types")
}

func gobDecodeObjectAsMap(data []byte) (map[string][]byte, error) {
        mm := make(map[string][]byte)
        g := gob.NewDecoder(bytes.NewReader(data))
        if err := g.Decode(&mm); err != nil {
                return nil, err
        }
        return mm, nil
}

func unmapIncompleteCollectionProperties(mm map[string][]byte, c *Collection) error {
        err := OnObject(c, func(ob *Object) error {
                return unmapObjectProperties(mm, ob)
        })
        if err != nil {
                return err
        }
        if raw, ok := mm["current"]; ok {
                if c.Current, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["first"]; ok {
                if c.First, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["last"]; ok {
                if c.Last, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["totalItems"]; ok {
                if err = gobDecodeUint(&c.TotalItems, raw); err != nil {
                        return err
                }
        }
        return nil
}

func unmapCollectionProperties(mm map[string][]byte, c *Collection) error {
        err := unmapIncompleteCollectionProperties(mm, c)
        if err != nil {
                return err
        }
        if raw, ok := mm["items"]; ok {
                if c.Items, err = gobDecodeItems(raw); err != nil {
                        return err
                }
        }
        return err
}

func unmapCollectionPageProperties(mm map[string][]byte, c *CollectionPage) error {
        err := OnCollection(c, func(c *Collection) error {
                return unmapCollectionProperties(mm, c)
        })
        if err != nil {
                return err
        }
        if raw, ok := mm["partOf"]; ok {
                if c.PartOf, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["next"]; ok {
                if c.Next, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["prev"]; ok {
                if c.Prev, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        return err
}

func unmapOrderedCollectionProperties(mm map[string][]byte, o *OrderedCollection) error {
        err := OnCollection(o, func(c *Collection) error {
                return unmapIncompleteCollectionProperties(mm, c)
        })
        if err != nil {
                return err
        }
        if raw, ok := mm["orderedItems"]; ok {
                if o.OrderedItems, err = gobDecodeItems(raw); err != nil {
                        return err
                }
        }
        return err
}

func unmapOrderedCollectionPageProperties(mm map[string][]byte, c *OrderedCollectionPage) error {
        err := OnOrderedCollection(c, func(c *OrderedCollection) error {
                return unmapOrderedCollectionProperties(mm, c)
        })
        if err != nil {
                return err
        }
        if raw, ok := mm["partOf"]; ok {
                if c.PartOf, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["next"]; ok {
                if c.Next, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["prev"]; ok {
                if c.Prev, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        return err
}

func unmapPlaceProperties(mm map[string][]byte, p *Place) error {
        err := OnObject(p, func(ob *Object) error {
                return unmapObjectProperties(mm, ob)
        })
        if err != nil {
                return err
        }
        if raw, ok := mm["accuracy"]; ok {
                if err = gobDecodeFloat64(&p.Accuracy, raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["altitude"]; ok {
                if err = gobDecodeFloat64(&p.Altitude, raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["latitude"]; ok {
                if err = gobDecodeFloat64(&p.Latitude, raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["radius"]; ok {
                if err = gobDecodeInt64(&p.Radius, raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["units"]; ok {
                p.Units = string(raw)
        }
        return nil
}

func unmapProfileProperties(mm map[string][]byte, p *Profile) error {
        err := OnObject(p, func(ob *Object) error {
                return unmapObjectProperties(mm, ob)
        })
        if err != nil {
                return err
        }
        if raw, ok := mm["Describes"]; ok {
                if p.Describes, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        return nil
}

func unmapRelationshipProperties(mm map[string][]byte, r *Relationship) error {
        err := OnObject(r, func(ob *Object) error {
                return unmapObjectProperties(mm, ob)
        })
        if err != nil {
                return err
        }
        if raw, ok := mm["subject"]; ok {
                if r.Subject, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["object"]; ok {
                if r.Object, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["relationship"]; ok {
                if r.Relationship, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        return nil
}

func unmapTombstoneProperties(mm map[string][]byte, t *Tombstone) error {
        err := OnObject(t, func(ob *Object) error {
                return unmapObjectProperties(mm, ob)
        })
        if err != nil {
                return err
        }
        if raw, ok := mm["formerType"]; ok {
                if t.FormerType, err = gobDecodeTypes(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["deleted"]; ok {
                if err = t.Deleted.GobDecode(raw); err != nil {
                        return err
                }
        }
        return nil
}

func unmapQuestionProperties(mm map[string][]byte, q *Question) error {
        err := OnIntransitiveActivity(q, func(act *IntransitiveActivity) error {
                return unmapIntransitiveActivityProperties(mm, act)
        })
        if err != nil {
                return err
        }
        if raw, ok := mm["oneOf"]; ok {
                if q.OneOf, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["anyOf"]; ok {
                if q.AnyOf, err = gobDecodeItem(raw); err != nil {
                        return err
                }
        }
        if raw, ok := mm["closed"]; ok {
                if err = gobDecodeBool(&q.Closed, raw); err != nil {
                        return err
                }
        }
        return nil
}

1	package activitypub
2
3	import (
4	"bytes"
5	"encoding/gob"
6	"errors"
7	"time"
8	)
9
10	func GobDecode(data []byte) (Item, error) {	×
11	return gobDecodeItem(data)	×
12	}	×
13
14	func gobDecodeUint(i *uint, data []byte) error {	×
15	g := gob.NewDecoder(bytes.NewReader(data))	×
16	return g.Decode(i)	×
17	}	×
18
19	func gobDecodeFloat64(f *float64, data []byte) error {	×
20	g := gob.NewDecoder(bytes.NewReader(data))	×
21	return g.Decode(f)	×
22	}	×
23
24	func gobDecodeInt64(i *int64, data []byte) error {	×
25	g := gob.NewDecoder(bytes.NewReader(data))	×
26	return g.Decode(i)	×
27	}	×
28
29	func gobDecodeBool(b *bool, data []byte) error {	×
30	g := gob.NewDecoder(bytes.NewReader(data))	×
31	return g.Decode(b)	×
32	}	×
33
34	func unmapActorProperties(mm map[string][]byte, a *Actor) error {	×
35	err := OnObject(a, func(ob *Object) error {	×
36	return unmapObjectProperties(mm, ob)	×
37	})	×
38	if err != nil {	×
39	return err	×
40	}	×
41	if raw, ok := mm["inbox"]; ok {	×
42	if a.Inbox, err = gobDecodeItem(raw); err != nil {	×
43	return err	×
44	}	×
45	}
46	if raw, ok := mm["outbox"]; ok {	×
47	if a.Outbox, err = gobDecodeItem(raw); err != nil {	×
48	return err	×
49	}	×
50	}
51	if raw, ok := mm["following"]; ok {	×
52	if a.Following, err = gobDecodeItem(raw); err != nil {	×
53	return err	×
54	}	×
55	}
56	if raw, ok := mm["followers"]; ok {	×
57	if a.Followers, err = gobDecodeItem(raw); err != nil {	×
58	return err	×
59	}	×
60	}
61	if raw, ok := mm["liked"]; ok {	×
62	if a.Liked, err = gobDecodeItem(raw); err != nil {	×
63	return err	×
64	}	×
65	}
66	if raw, ok := mm["preferredUsername"]; ok {	×
67	if a.PreferredUsername, err = gobDecodeNaturalLanguageValues(raw); err != nil {	×
68	return err	×
69	}	×
70	}
71	if raw, ok := mm["endpoints"]; ok {	×
72	if err = a.Endpoints.GobDecode(raw); err != nil {	×
73	return err	×
74	}	×
75	}
76	if raw, ok := mm["streams"]; ok {	×
77	if a.Streams, err = gobDecodeItems(raw); err != nil {	×
78	return err	×
79	}	×
80	}
81	if raw, ok := mm["publicKey"]; ok {	×
82	if err = a.PublicKey.GobDecode(raw); err != nil {	×
83	return err	×
84	}	×
85	}
86	return nil	×
87	}
88
89	func unmapIntransitiveActivityProperties(mm map[string][]byte, act *IntransitiveActivity) error {	×
90	err := OnObject(act, func(ob *Object) error {	×
91	return unmapObjectProperties(mm, ob)	×
92	})	×
93	if err != nil {	×
94	return err	×
95	}	×
96	if raw, ok := mm["actor"]; ok {	×
97	if act.Actor, err = gobDecodeItem(raw); err != nil {	×
98	return err	×
99	}	×
100	}
101	if raw, ok := mm["target"]; ok {	×
102	if act.Target, err = gobDecodeItem(raw); err != nil {	×
103	return err	×
104	}	×
105	}
106	if raw, ok := mm["result"]; ok {	×
107	if act.Result, err = gobDecodeItem(raw); err != nil {	×
108	return err	×
109	}	×
110	}
111	if raw, ok := mm["origin"]; ok {	×
112	if act.Origin, err = gobDecodeItem(raw); err != nil {	×
113	return err	×
114	}	×
115	}
116	if raw, ok := mm["instrument"]; ok {	×
117	if act.Instrument, err = gobDecodeItem(raw); err != nil {	×
118	return err	×
119	}	×
120	}
121	return nil	×
122	}
123
124	func unmapActivityProperties(mm map[string][]byte, act *Activity) error {	×
125	err := OnIntransitiveActivity(act, func(act *IntransitiveActivity) error {	×
126	return unmapIntransitiveActivityProperties(mm, act)	×
127	})	×
128	if err != nil {	×
129	return err	×
130	}	×
131	if raw, ok := mm["object"]; ok {	×
132	if act.Object, err = gobDecodeItem(raw); err != nil {	×
133	return err	×
134	}	×
135	}
136	return nil	×
137	}
138
139	func unmapLinkProperties(mm map[string][]byte, l *Link) error {	×
140	if raw, ok := mm["id"]; ok {	×
141	if err := l.ID.GobDecode(raw); err != nil {	×
142	return err	×
143	}	×
144	}
145	if raw, ok := mm["type"]; ok {	×
146	var err error	×
147	if l.Type, err = gobDecodeTypes(raw); err != nil {	×
148	return err	×
UNCOV 149	}	×
150	}
151	if raw, ok := mm["mediaType"]; ok {	×
152	if err := l.MediaType.GobDecode(raw); err != nil {	×
153	return err	×
UNCOV 154	}	×
155	}
156	if raw, ok := mm["href"]; ok {	×
157	if err := l.Href.GobDecode(raw); err != nil {	×
158	return err	×
UNCOV 159	}	×
160	}
161	if raw, ok := mm["hrefLang"]; ok {	×
162	if err := l.HrefLang.GobDecode(raw); err != nil {	×
163	return err	×
UNCOV 164	}	×
165	}
166	if raw, ok := mm["name"]; ok {	×
167	if err := l.Name.GobDecode(raw); err != nil {	×
168	return err	×
UNCOV 169	}	×
170	}
171	if raw, ok := mm["rel"]; ok {	×
172	if err := l.Rel.GobDecode(raw); err != nil {	×
173	return err	×
UNCOV 174	}	×
175	}
176	if raw, ok := mm["width"]; ok {	×
177	if err := gobDecodeUint(&l.Width, raw); err != nil {	×
178	return err	×
UNCOV 179	}	×
180	}
181	if raw, ok := mm["height"]; ok {	×
182	if err := gobDecodeUint(&l.Height, raw); err != nil {	×
183	return err	×
UNCOV 184	}	×
185	}
UNCOV 186	return nil	×
187	}
188
189	func gobDecodeTypes(data []byte) (Typer, error) {	4✔
190	items := make(ActivityVocabularyTypes, 0)	4✔
191	if err := items.GobDecode(data); err != nil {	4✔
192	return nil, err	×
193	}	×
194	if len(items) == 0 {	4✔
UNCOV 195	return nil, nil	×
UNCOV 196	}	×
197	if len(items) == 1 {	8✔
198	return items[0], nil	4✔
199	}	4✔
UNCOV 200	return items, nil	×
201	}
202
203	func unmapObjectProperties(mm map[string][]byte, o *Object) error {	16✔
204	var err error	16✔
205	if raw, ok := mm["id"]; ok {	24✔
206	if err = o.ID.GobDecode(raw); err != nil {	8✔
UNCOV 207	return err	×
208	}	×
209	}
210	if raw, ok := mm["type"]; ok {	20✔
211	if o.Type, err = gobDecodeTypes(raw); err != nil {	4✔
UNCOV 212	return err	×
UNCOV 213	}	×
214	}
215	if raw, ok := mm["name"]; ok {	18✔
216	name := make(NaturalLanguageValues)	2✔
217	if err = name.GobDecode(raw); err != nil {	2✔
218	return err	×
219	}	×
220	o.Name = name	2✔
221	}
222	if raw, ok := mm["attachment"]; ok {	16✔
223	if o.Attachment, err = gobDecodeItem(raw); err != nil {	×
224	return err	×
225	}	×
226	}
227	if raw, ok := mm["attributedTo"]; ok {	22✔
228	if o.AttributedTo, err = gobDecodeItem(raw); err != nil {	6✔
UNCOV 229	return err	×
230	}	×
231	}
232	if raw, ok := mm["audience"]; ok {	16✔
UNCOV 233	if o.Audience, err = gobDecodeItems(raw); err != nil {	×
UNCOV 234	return err	×
235	}	×
236	}
237	if raw, ok := mm["content"]; ok {	16✔
UNCOV 238	content := make(NaturalLanguageValues)	×
UNCOV 239	if content, err = gobDecodeNaturalLanguageValues(raw); err != nil {	×
240	return err	×
241	}	×
242	o.Content = content	×
243	}
244	if raw, ok := mm["context"]; ok {	16✔
245	if o.Context, err = gobDecodeItem(raw); err != nil {	×
246	return err	×
247	}	×
248	}
249	if raw, ok := mm["mediaType"]; ok {	16✔
250	if err = o.MediaType.GobDecode(raw); err != nil {	×
251	return err	×
252	}	×
253	}
254	if raw, ok := mm["endTime"]; ok {	16✔
255	if err = o.EndTime.GobDecode(raw); err != nil {	×
256	return err	×
257	}	×
258	}
259	if raw, ok := mm["generator"]; ok {	16✔
260	if o.Generator, err = gobDecodeItem(raw); err != nil {	×
261	return err	×
262	}	×
263	}
264	if raw, ok := mm["icon"]; ok {	16✔
265	if o.Icon, err = gobDecodeItem(raw); err != nil {	×
266	return err	×
267	}	×
268	}
269	if raw, ok := mm["image"]; ok {	16✔
270	if o.Image, err = gobDecodeItem(raw); err != nil {	×
271	return err	×
272	}	×
273	}
274	if raw, ok := mm["inReplyTo"]; ok {	16✔
275	if o.InReplyTo, err = gobDecodeItem(raw); err != nil {	×
276	return err	×
277	}	×
278	}
279	if raw, ok := mm["location"]; ok {	16✔
280	if o.Location, err = gobDecodeItem(raw); err != nil {	×
281	return err	×
282	}	×
283	}
284	if raw, ok := mm["preview"]; ok {	16✔
285	if o.Preview, err = gobDecodeItem(raw); err != nil {	×
286	return err	×
287	}	×
288	}
289	if raw, ok := mm["published"]; ok {	16✔
290	if err = o.Published.GobDecode(raw); err != nil {	×
291	return err	×
292	}	×
293	}
294	if raw, ok := mm["replies"]; ok {	16✔
UNCOV 295	if o.Replies, err = gobDecodeItem(raw); err != nil {	×
UNCOV 296	return err	×
297	}	×
298	}
299	if raw, ok := mm["startTime"]; ok {	16✔
UNCOV 300	if err = o.StartTime.GobDecode(raw); err != nil {	×
UNCOV 301	return err	×
302	}	×
303	}
304	if raw, ok := mm["summary"]; ok {	16✔
UNCOV 305	summary := make(NaturalLanguageValues)	×
UNCOV 306	if summary, err = gobDecodeNaturalLanguageValues(raw); err != nil {	×
307	return err	×
308	}	×
309	o.Summary = summary	×
310	}
311	if raw, ok := mm["tag"]; ok {	16✔
312	if o.Tag, err = gobDecodeItems(raw); err != nil {	×
313	return err	×
314	}	×
315	}
316	if raw, ok := mm["updated"]; ok {	16✔
317	if err = o.Updated.GobDecode(raw); err != nil {	×
318	return err	×
319	}	×
320	}
321	if raw, ok := mm["url"]; ok {	16✔
322	if o.URL, err = gobDecodeItem(raw); err != nil {	×
323	return err	×
324	}	×
325	}
326	if raw, ok := mm["to"]; ok {	16✔
327	if o.To, err = gobDecodeItems(raw); err != nil {	×
328	return err	×
329	}	×
330	}
331	if raw, ok := mm["bto"]; ok {	16✔
332	if o.Bto, err = gobDecodeItems(raw); err != nil {	×
333	return err	×
334	}	×
335	}
336	if raw, ok := mm["cc"]; ok {	16✔
337	if o.CC, err = gobDecodeItems(raw); err != nil {	×
338	return err	×
339	}	×
340	}
341	if raw, ok := mm["bcc"]; ok {	16✔
342	if o.BCC, err = gobDecodeItems(raw); err != nil {	×
343	return err	×
344	}	×
345	}
346	if raw, ok := mm["duration"]; ok {	16✔
UNCOV 347	if o.Duration, err = gobDecodeDuration(raw); err != nil {	×
348	return err	×
349	}	×
350	}
351	if raw, ok := mm["likes"]; ok {	16✔
UNCOV 352	if o.Likes, err = gobDecodeItem(raw); err != nil {	×
UNCOV 353	return err	×
UNCOV 354	}	×
355	}
356	if raw, ok := mm["shares"]; ok {	16✔
UNCOV 357	if o.Shares, err = gobDecodeItem(raw); err != nil {	×
UNCOV 358	return err	×
UNCOV 359	}	×
360	}
361	if raw, ok := mm["source"]; ok {	18✔
362	if err := o.Source.GobDecode(raw); err != nil {	2✔
363	return err	×
364	}	×
365	}
366	return nil	16✔
367	}
368
369	func tryDecodeItems(items *ItemCollection, data []byte) error {	10✔
370	tt := make([][]byte, 0)	10✔
371	g := gob.NewDecoder(bytes.NewReader(data))	10✔
372	if err := g.Decode(&tt); err != nil {	18✔
373	return err	8✔
374	}	8✔
375	for _, it := range tt {	6✔
376	ob, err := gobDecodeItem(it)	4✔
377	if err != nil {	4✔
378	return err	×
379	}	×
380	items = append(items, ob)	4✔
381	}
382	return nil	2✔
383	}
384
385	func tryDecodeIRIs(iris *IRIs, data []byte) error {	8✔
386	return iris.GobDecode(data)	8✔
387	}	8✔
388
389	func tryDecodeIRI(iri *IRI, data []byte) error {	6✔
390	return iri.GobDecode(data)	6✔
391	}	6✔
392
393	func gobDecodeDuration(data []byte) (time.Duration, error) {	×
394	var d time.Duration	×
395	err := gob.NewDecoder(bytes.NewReader(data)).Decode(&d)	×
UNCOV 396	return d, err	×
UNCOV 397	}	×
398
UNCOV 399	func gobDecodeNaturalLanguageValues(data []byte) (NaturalLanguageValues, error) {	×
UNCOV 400	n := make(NaturalLanguageValues)	×
UNCOV 401	err := n.GobDecode(data)	×
UNCOV 402	return n, err	×
UNCOV 403	}	×
404
405	func gobDecodeItems(data []byte) (ItemCollection, error) {	×
406	items := make(ItemCollection, 0)	×
UNCOV 407	if err := tryDecodeItems(&items, data); err != nil {	×
UNCOV 408	return nil, err	×
UNCOV 409	}	×
UNCOV 410	return items, nil	×
411	}
412
413	func gobDecodeItem(data []byte) (Item, error) {	10✔
414	items := make(ItemCollection, 0)	10✔
415	if err := tryDecodeItems(&items, data); err == nil {	12✔
416	return items, nil	2✔
417	}	2✔
418	iris := make(IRIs, 0)	8✔
419	if err := tryDecodeIRIs(&iris, data); err == nil {	8✔
UNCOV 420	return iris, nil	×
UNCOV 421	}	×
422	isObject := false	8✔
423	typ := NilType	8✔
424	mm, err := gobDecodeObjectAsMap(data)	8✔
425	if err == nil {	10✔
426	var sTyp []byte	2✔
427	sTyp, isObject = mm["type"]	2✔
428	if isObject {	2✔
UNCOV 429	typ = ActivityVocabularyType(sTyp)	×
430	} else {	2✔
431	_, isObject = mm["id"]	2✔
432	}	2✔
433	}
434	if isObject {	10✔
435	it, err := ItemTyperFunc(typ)	2✔
436	if err != nil {	2✔
437	return nil, err	×
438	}	×
439	switch {	2✔
440	//case typ.Match(IRIType):
441	case ActivityVocabularyTypes{NilType, ObjectType, ArticleType, AudioType, DocumentType, EventType,
442	ImageType, NoteType, PageType, VideoType}.Match(typ):	2✔
443	err = OnObject(it, func(ob *Object) error {	4✔
444	return unmapObjectProperties(mm, ob)	2✔
445	})	2✔
446	case ActivityVocabularyTypes{LinkType, MentionType}.Match(typ):	×
447	err = OnLink(it, func(l *Link) error {	×
448	return unmapLinkProperties(mm, l)	×
449	})	×
450	case ActivityVocabularyTypes{ActivityType, AcceptType, AddType, AnnounceType, BlockType, CreateType, DeleteType, DislikeType,
451	FlagType, FollowType, IgnoreType, InviteType, JoinType, LeaveType, LikeType, ListenType, MoveType, OfferType,
452	RejectType, ReadType, RemoveType, TentativeRejectType, TentativeAcceptType, UndoType, UpdateType, ViewType}.Match(typ):	×
453	err = OnActivity(it, func(act *Activity) error {	×
454	return unmapActivityProperties(mm, act)	×
455	})	×
456	case ActivityVocabularyTypes{IntransitiveActivityType, ArriveType, TravelType}.Match(typ):	×
457	err = OnIntransitiveActivity(it, func(act *IntransitiveActivity) error {	×
458	return unmapIntransitiveActivityProperties(mm, act)	×
459	})	×
460	case ActivityVocabularyTypes{ActorType, ApplicationType, GroupType, OrganizationType, PersonType, ServiceType}.Match(typ):	×
461	err = OnActor(it, func(a *Actor) error {	×
462	return unmapActorProperties(mm, a)	×
463	})	×
464	}
465	return it, err	2✔
466	}
467	iri := IRI("")	6✔
468	if err := tryDecodeIRI(&iri, data); err == nil {	12✔
469	return iri, err	6✔
470	}	6✔
471
472	return nil, errors.New("unable to gob decode to any known ActivityPub types")	×
473	}
474
475	func gobDecodeObjectAsMap(data []byte) (map[string][]byte, error) {	22✔
476	mm := make(map[string][]byte)	22✔
477	g := gob.NewDecoder(bytes.NewReader(data))	22✔
478	if err := g.Decode(&mm); err != nil {	28✔
479	return nil, err	6✔
480	}	6✔
481	return mm, nil	16✔
482	}
483
UNCOV 484	func unmapIncompleteCollectionProperties(mm map[string][]byte, c *Collection) error {	×
UNCOV 485	err := OnObject(c, func(ob *Object) error {	×
UNCOV 486	return unmapObjectProperties(mm, ob)	×
UNCOV 487	})	×
UNCOV 488	if err != nil {	×
UNCOV 489	return err	×
UNCOV 490	}	×
UNCOV 491	if raw, ok := mm["current"]; ok {	×
492	if c.Current, err = gobDecodeItem(raw); err != nil {	×
UNCOV 493	return err	×
UNCOV 494	}	×
495	}
UNCOV 496	if raw, ok := mm["first"]; ok {	×
UNCOV 497	if c.First, err = gobDecodeItem(raw); err != nil {	×
UNCOV 498	return err	×
UNCOV 499	}	×
500	}
UNCOV 501	if raw, ok := mm["last"]; ok {	×
UNCOV 502	if c.Last, err = gobDecodeItem(raw); err != nil {	×
UNCOV 503	return err	×
504	}	×
505	}
506	if raw, ok := mm["totalItems"]; ok {	×
507	if err = gobDecodeUint(&c.TotalItems, raw); err != nil {	×
508	return err	×
509	}	×
510	}
511	return nil	×
512	}
513
514	func unmapCollectionProperties(mm map[string][]byte, c *Collection) error {	×
UNCOV 515	err := unmapIncompleteCollectionProperties(mm, c)	×
516	if err != nil {	×
517	return err	×
518	}	×
519	if raw, ok := mm["items"]; ok {	×
UNCOV 520	if c.Items, err = gobDecodeItems(raw); err != nil {	×
521	return err	×
522	}	×
523	}
524	return err	×
525	}
526
527	func unmapCollectionPageProperties(mm map[string][]byte, c *CollectionPage) error {	×
528	err := OnCollection(c, func(c *Collection) error {	×
529	return unmapCollectionProperties(mm, c)	×
UNCOV 530	})	×
531	if err != nil {	×
UNCOV 532	return err	×
UNCOV 533	}	×
534	if raw, ok := mm["partOf"]; ok {	×
535	if c.PartOf, err = gobDecodeItem(raw); err != nil {	×
536	return err	×
537	}	×
538	}
539	if raw, ok := mm["next"]; ok {	×
540	if c.Next, err = gobDecodeItem(raw); err != nil {	×
541	return err	×
542	}	×
543	}
544	if raw, ok := mm["prev"]; ok {	×
UNCOV 545	if c.Prev, err = gobDecodeItem(raw); err != nil {	×
UNCOV 546	return err	×
547	}	×
548	}
549	return err	×
550	}
551
552	func unmapOrderedCollectionProperties(mm map[string][]byte, o *OrderedCollection) error {	×
553	err := OnCollection(o, func(c *Collection) error {	×
554	return unmapIncompleteCollectionProperties(mm, c)	×
555	})	×
556	if err != nil {	×
557	return err	×
UNCOV 558	}	×
559	if raw, ok := mm["orderedItems"]; ok {	×
560	if o.OrderedItems, err = gobDecodeItems(raw); err != nil {	×
561	return err	×
562	}	×
563	}
564	return err	×
565	}
566
567	func unmapOrderedCollectionPageProperties(mm map[string][]byte, c *OrderedCollectionPage) error {	×
UNCOV 568	err := OnOrderedCollection(c, func(c *OrderedCollection) error {	×
569	return unmapOrderedCollectionProperties(mm, c)	×
UNCOV 570	})	×
UNCOV 571	if err != nil {	×
572	return err	×
573	}	×
574	if raw, ok := mm["partOf"]; ok {	×
575	if c.PartOf, err = gobDecodeItem(raw); err != nil {	×
576	return err	×
577	}	×
578	}
579	if raw, ok := mm["next"]; ok {	×
580	if c.Next, err = gobDecodeItem(raw); err != nil {	×
581	return err	×
582	}	×
583	}
584	if raw, ok := mm["prev"]; ok {	×
UNCOV 585	if c.Prev, err = gobDecodeItem(raw); err != nil {	×
UNCOV 586	return err	×
587	}	×
588	}
589	return err	×
590	}
591
592	func unmapPlaceProperties(mm map[string][]byte, p *Place) error {	×
593	err := OnObject(p, func(ob *Object) error {	×
594	return unmapObjectProperties(mm, ob)	×
595	})	×
596	if err != nil {	×
597	return err	×
UNCOV 598	}	×
599	if raw, ok := mm["accuracy"]; ok {	×
600	if err = gobDecodeFloat64(&p.Accuracy, raw); err != nil {	×
601	return err	×
602	}	×
603	}
604	if raw, ok := mm["altitude"]; ok {	×
605	if err = gobDecodeFloat64(&p.Altitude, raw); err != nil {	×
606	return err	×
607	}	×
608	}
609	if raw, ok := mm["latitude"]; ok {	×
UNCOV 610	if err = gobDecodeFloat64(&p.Latitude, raw); err != nil {	×
UNCOV 611	return err	×
612	}	×
613	}
614	if raw, ok := mm["radius"]; ok {	×
615	if err = gobDecodeInt64(&p.Radius, raw); err != nil {	×
616	return err	×
617	}	×
618	}
619	if raw, ok := mm["units"]; ok {	×
620	p.Units = string(raw)	×
621	}	×
622	return nil	×
623	}
624
625	func unmapProfileProperties(mm map[string][]byte, p *Profile) error {	×
626	err := OnObject(p, func(ob *Object) error {	×
627	return unmapObjectProperties(mm, ob)	×
UNCOV 628	})	×
629	if err != nil {	×
630	return err	×
631	}	×
632	if raw, ok := mm["Describes"]; ok {	×
UNCOV 633	if p.Describes, err = gobDecodeItem(raw); err != nil {	×
634	return err	×
635	}	×
636	}
637	return nil	×
638	}
639
640	func unmapRelationshipProperties(mm map[string][]byte, r *Relationship) error {	×
641	err := OnObject(r, func(ob *Object) error {	×
642	return unmapObjectProperties(mm, ob)	×
UNCOV 643	})	×
UNCOV 644	if err != nil {	×
645	return err	×
646	}	×
647	if raw, ok := mm["subject"]; ok {	×
648	if r.Subject, err = gobDecodeItem(raw); err != nil {	×
649	return err	×
650	}	×
651	}
652	if raw, ok := mm["object"]; ok {	×
653	if r.Object, err = gobDecodeItem(raw); err != nil {	×
654	return err	×
655	}	×
656	}
657	if raw, ok := mm["relationship"]; ok {	×
UNCOV 658	if r.Relationship, err = gobDecodeItem(raw); err != nil {	×
UNCOV 659	return err	×
660	}	×
661	}
662	return nil	×
663	}
664
665	func unmapTombstoneProperties(mm map[string][]byte, t *Tombstone) error {	×
666	err := OnObject(t, func(ob *Object) error {	×
667	return unmapObjectProperties(mm, ob)	×
668	})	×
669	if err != nil {	×
670	return err	×
UNCOV 671	}	×
672	if raw, ok := mm["formerType"]; ok {	×
673	if t.FormerType, err = gobDecodeTypes(raw); err != nil {	×
674	return err	×
675	}	×
676	}
677	if raw, ok := mm["deleted"]; ok {	×
678	if err = t.Deleted.GobDecode(raw); err != nil {	×
679	return err	×
680	}	×
681	}
682	return nil	×
683	}
684
685	func unmapQuestionProperties(mm map[string][]byte, q *Question) error {	×
686	err := OnIntransitiveActivity(q, func(act *IntransitiveActivity) error {	×
687	return unmapIntransitiveActivityProperties(mm, act)	×
688	})	×
689	if err != nil {	×
690	return err	×
691	}	×
692	if raw, ok := mm["oneOf"]; ok {	×
693	if q.OneOf, err = gobDecodeItem(raw); err != nil {	×
694	return err	×
695	}	×
696	}
697	if raw, ok := mm["anyOf"]; ok {	×
698	if q.AnyOf, err = gobDecodeItem(raw); err != nil {	×
699	return err	×
700	}	×
701	}
702	if raw, ok := mm["closed"]; ok {	×
UNCOV 703	if err = gobDecodeBool(&q.Closed, raw); err != nil {	×
UNCOV 704	return err	×
705	}	×
706	}
707	return nil	×
708	}

go-ap / activitypub / #2

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous