And implement the new keys

nsActivitystreams.go

@@ -327,7 +327,7 @@ func ParseASFollowersData(raw map[string]any, next BaseApChain) (BaseApChain, er
 	if err != nil {
 		return nil, err
 	}
-	return &ASAttributedToData{FullIdType: *id}, nil
+	return &ASFollowersData{FullIdType: *id}, nil
 }
 
 type ASFollowingData struct {
@@ -347,7 +347,7 @@ func ParseASFollowingData(raw map[string]any, next BaseApChain) (BaseApChain, er
 	if err != nil {
 		return nil, err
 	}
-	return &ASAttributedToData{FullIdType: *id}, nil
+	return &ASFollowingData{FullIdType: *id}, nil
 }
 
 type ASHrefData struct {
@@ -367,7 +367,7 @@ func ParseASHrefData(raw map[string]any, next BaseApChain) (BaseApChain, error)
 	if err != nil {
 		return nil, err
 	}
-	return &ASAttributedToData{FullIdType: *id}, nil
+	return &ASHrefData{FullIdType: *id}, nil
 }
 
 type ASIconData struct {
@@ -503,7 +503,7 @@ func (attributedtodata *ASOutboxData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (attributedtodata *ASOutboxData) MarshalToMap() map[string]any {
-	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_HREF)
+	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_OUTBOX)
 }
 
 func ParseASOutboxData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
@@ -807,7 +807,7 @@ func (object *ASUrlData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (object *ASUrlData) MarshalToMap() map[string]any {
-	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_SHAREDINBOX)
+	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_URL)
 }
 
 func ParseASUrlData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
@@ -864,3 +864,148 @@ func ParseASUpdatedData(raw map[string]any, next BaseApChain) (BaseApChain, erro
 		Timestamp: t,
 	}, nil
 }
+
+type ASFirstData struct {
+	Next BaseApChain
+	// Technically the object is decodable into BaseApChain as well
+	// but Go doesn't like the potential recursive call
+	// So uhh, you have to do it yourself
+	Objects map[string]any
+}
+
+func (a *ASFirstData) GetSelfOrBase() (BaseApChain, bool) {
+	return a.Next, true
+}
+
+func (a *ASFirstData) MarshalToMap() map[string]any {
+	return appendWithKey(
+		a.Next.MarshalToMap(),
+		KEY_ACTIVITYSTREAMS_FIRST,
+		[]map[string]any{a.Objects},
+	)
+}
+
+func ParseASFirstData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData, ok := raw[KEY_ACTIVITYSTREAMS_FIRST]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_FIRST}
+	}
+	data, ok := rawData.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{KEY_ACTIVITYSTREAMS_FIRST, rawData, data}
+	}
+	if len(data) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_FIRST, 1, len(data)}
+	}
+	delete(raw, KEY_ACTIVITYSTREAMS_FIRST)
+	return &ASFirstData{
+		Next:    next,
+		Objects: data[0],
+	}, nil
+}
+
+type ASItemsData struct {
+	Next BaseApChain
+	// Items are all AP objects, but can't preparse since Go doesn't like the potential recursion
+	Items []map[string]any
+}
+
+func (a *ASItemsData) GetSelfOrBase() (BaseApChain, bool) {
+	return a.Next, true
+}
+
+func (a *ASItemsData) MarshalToMap() map[string]any {
+	return appendWithKey(a.Next.MarshalToMap(), KEY_ACTIVITYSTREAMS_ITEMS, a.Items)
+}
+
+func ParseASItemsData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData, ok := raw[KEY_ACTIVITYSTREAMS_ITEMS]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_ITEMS}
+	}
+	data, ok := rawData.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{KEY_ACTIVITYSTREAMS_ITEMS, rawData, data}
+	}
+	return &ASItemsData{Next: next, Items: data}, nil
+}
+
+type ASNextData struct {
+	FullIdType
+}
+
+func (object *ASNextData) GetSelfOrBase() (BaseApChain, bool) {
+	return object.FullIdType.Next, true
+}
+
+func (object *ASNextData) MarshalToMap() map[string]any {
+	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_NEXT)
+}
+
+func ParseASNextData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_NEXT)
+	if err != nil {
+		return nil, err
+	}
+	return &ASNextData{FullIdType: *id}, nil
+}
+
+type ASPartOfData struct {
+	FullIdType
+}
+
+func (object *ASPartOfData) GetSelfOrBase() (BaseApChain, bool) {
+	return object.FullIdType.Next, true
+}
+
+func (object *ASPartOfData) MarshalToMap() map[string]any {
+	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_PARTOF)
+}
+
+func ParseASPartOfData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_PARTOF)
+	if err != nil {
+		return nil, err
+	}
+	return &ASPartOfData{FullIdType: *id}, nil
+}
+
+type ASInReplyTo struct {
+	FullIdType
+}
+
+func (a *ASInReplyTo) GetSelfOrBase() (BaseApChain, bool) {
+	return a.Next, true
+}
+
+func (a *ASInReplyTo) MarshalToMap() map[string]any {
+	return a.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_INREPLYTO)
+}
+
+func ParseASInReplyToData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_INREPLYTO)
+	if err != nil {
+		return nil, err
+	}
+	return &ASInReplyTo{*id}, nil
+}
+
+type ASQuoteUrlData struct {
+	FullValueType[string]
+}
+
+func (namedata *ASQuoteUrlData) GetSelfOrBase() (BaseApChain, bool) {
+	return namedata.Next, true
+}
+
+func (namedata *ASQuoteUrlData) MarshalToMap() map[string]any {
+	return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_QUOTEURL)
+}
+
+func ParseASQuoteUrlData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_QUOTEURL)
+	if err != nil {
+		return nil, err
+	}
+	return &ASQuoteUrlData{*tmp}, nil
+}

nsFedibird.go

@@ -0,0 +1,21 @@
+package goap
+
+type FedibirdQuoteUriData struct {
+	FullValueType[string]
+}
+
+func (f *FedibirdQuoteUriData) GetSelfOrBase() (BaseApChain, bool) {
+	return f.Next, true
+}
+
+func (f *FedibirdQuoteUriData) MarshalToMap() map[string]any {
+	return f.MarshalToMapWithName(KEY_FEDIBIRD_QUOTEURI)
+}
+
+func ParseFedibirdQuoteUriData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	v, err := ParseValueTypeWithName[string](raw, next, KEY_FEDIBIRD_QUOTEURI)
+	if err != nil {
+		return nil, err
+	}
+	return &FedibirdQuoteUriData{*v}, nil
+}

nsMisskey.go

@@ -61,3 +61,23 @@ func ParseFFSpeakAsCatData(raw map[string]any, next BaseApChain) (BaseApChain, e
 	}
 	return &FFSpeakAsCatData{*tmp}, nil
 }
+
+type MKQuoteData struct {
+	FullValueType[string]
+}
+
+func (misskeysummarydata *MKQuoteData) GetSelfOrBase() (BaseApChain, bool) {
+	return misskeysummarydata.Next, true
+}
+
+func (misskeysummarydata *MKQuoteData) MarshalToMap() map[string]any {
+	return misskeysummarydata.MarshalToMapWithName(KEY_MISSKEY_MKQUOTE)
+}
+
+func ParseMKQuoteData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_MISSKEY_MKQUOTE)
+	if err != nil {
+		return nil, err
+	}
+	return &MKQuoteData{*tmp}, nil
+}

nsOstatus.go

@@ -1,8 +1,7 @@
 package goap
 
 type OstatusAtomUriData struct {
-	Next BaseApChain
+	FullValueType[string]
-	Uri  ValueValue[string]
 }
 
 func (atomurivalue *OstatusAtomUriData) GetSelfOrBase() (BaseApChain, bool) {
@@ -10,43 +9,19 @@ func (atomurivalue *OstatusAtomUriData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (atomurivalue *OstatusAtomUriData) MarshalToMap() map[string]any {
-	return appendWithKey(
+	return atomurivalue.MarshalToMapWithName(KEY_OSTATUS_ATOMURI)
-		atomurivalue.Next.MarshalToMap(),
-		KEY_OSTATUS_ATOMURI,
-		[]map[string]any{atomurivalue.Uri.Marshal()},
-	)
 }
 
 func ParseOstatusAtomUriData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
-	rawData1, ok := raw[KEY_OSTATUS_ATOMURI]
+	v, err := ParseValueTypeWithName[string](raw, next, KEY_OSTATUS_ATOMURI)
-	if !ok {
-		return nil, NoRequiredFieldError{KEY_OSTATUS_ATOMURI}
-	}
-	data1, ok := rawData1.([]map[string]any)
-	if !ok {
-		return nil, BadFieldValueError[[]map[string]any]{
-			KEY_OSTATUS_ATOMURI,
-			rawData1,
-			data1,
-		}
-	}
-	if len(data1) != 1 {
-		return nil, BadFieldArrayLengthError{KEY_OSTATUS_ATOMURI, 1, len(data1)}
-	}
-	tmp, err := ParseValueValue[string](data1[0])
 	if err != nil {
 		return nil, err
 	}
-	delete(raw, KEY_OSTATUS_ATOMURI)
+	return &OstatusAtomUriData{*v}, nil
-	return &OstatusAtomUriData{
-		Next: next,
-		Uri:  *tmp,
-	}, nil
 }
 
 type OstatusConversationData struct {
-	Next BaseApChain
+	FullValueType[string]
-	Uri  ValueValue[string]
 }
 
 func (atomurivalue *OstatusConversationData) GetSelfOrBase() (BaseApChain, bool) {
@@ -54,36 +29,33 @@ func (atomurivalue *OstatusConversationData) GetSelfOrBase() (BaseApChain, bool)
 }
 
 func (atomurivalue *OstatusConversationData) MarshalToMap() map[string]any {
-	return appendWithKey(
+	return atomurivalue.MarshalToMapWithName(KEY_OSTATUS_CONVERSATION)
-		atomurivalue.Next.MarshalToMap(),
-		KEY_OSTATUS_CONVERSATION,
-		[]map[string]any{atomurivalue.Uri.Marshal()},
-	)
 }
 
 func ParseOstatusConversationData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
-	rawData1, ok := raw[KEY_OSTATUS_CONVERSATION]
+	v, err := ParseValueTypeWithName[string](raw, next, KEY_OSTATUS_CONVERSATION)
-	if !ok {
-		return nil, NoRequiredFieldError{KEY_OSTATUS_CONVERSATION}
-	}
-	data1, ok := rawData1.([]map[string]any)
-	if !ok {
-		return nil, BadFieldValueError[[]map[string]any]{
-			KEY_OSTATUS_CONVERSATION,
-			rawData1,
-			data1,
-		}
-	}
-	if len(data1) != 1 {
-		return nil, BadFieldArrayLengthError{KEY_OSTATUS_CONVERSATION, 1, len(data1)}
-	}
-	tmp, err := ParseValueValue[string](data1[0])
 	if err != nil {
 		return nil, err
 	}
-	delete(raw, KEY_OSTATUS_CONVERSATION)
+	return &OstatusConversationData{*v}, nil
-	return &OstatusConversationData{
+}
-		Next: next,
+
-		Uri:  *tmp,
+type OstatusReplyToAtomUriData struct {
-	}, nil
+	FullValueType[string]
+}
+
+func (a *OstatusReplyToAtomUriData) GetSelfOrBase() (BaseApChain, bool) {
+	return a.Next, true
+}
+
+func (a *OstatusReplyToAtomUriData) MarshalToMap() map[string]any {
+	return a.MarshalToMapWithName(KEY_OSTATUS_INREPLYTOATOMURI)
+}
+
+func ParseOstatusInReplyToAtomUriData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	v, err := ParseValueTypeWithName[string](raw, next, KEY_OSTATUS_INREPLYTOATOMURI)
+	if err != nil {
+		return nil, err
+	}
+	return &OstatusReplyToAtomUriData{*v}, nil
 }

parser.go

@@ -38,9 +38,16 @@ var allInternalParsersExceptBase []UnmarshalFunc = []UnmarshalFunc{
 	ParseASToData,
 	ParseASUrlData,
 	ParseASUpdatedData,
+	ParseASFirstData,
+	ParseASNextData,
+	ParseASItemsData,
+	ParseASPartOfData,
+	ParseASInReplyToData,
+	ParseASQuoteUrlData,
 
 	ParseOstatusAtomUriData,
 	ParseOstatusConversationData,
+	ParseOstatusInReplyToAtomUriData,
 
 	ParseW3InboxData,
 
@@ -62,8 +69,11 @@ var allInternalParsersExceptBase []UnmarshalFunc = []UnmarshalFunc{
 
 	ParseMKIsCatData,
 	ParseMKSummaryData,
+	ParseMKQuoteData,
 
 	ParseFFSpeakAsCatData,
+
+	ParseFedibirdQuoteUriData,
 }
 
 func chainParse(