Properly use xml names

It seems that undefined content is only mentioned in RFC4287 because
link and category are elements and those usually need some content.

category.go

@@ -1,22 +1,23 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
 	"html"
 )
 
 type Category struct {
+	XMLName xml.Name `xml:"category"`
 	*CommonAttributes
-	Content string `xml:",chardata"` // undefinedContent in RFC4287
-	Term    string `xml:"term,attr"`
-	Scheme  IRI    `xml:"scheme,attr,omitempty"`
-	Label   string `xml:"label,attr,omitempty"`
+	Term   string `xml:"term,attr"`
+	Scheme IRI    `xml:"scheme,attr,omitempty"`
+	Label  string `xml:"label,attr,omitempty"`
 }
 
-// NewCategory creates a new Category. It returns a *Category and an error.
-func NewCategory(term, content string) (*Category, error) {
-	return &Category{Term: term, Content: content}, nil
+// NewCategory creates a new Category. It returns a *Category.
+func NewCategory(term string) *Category {
+	return &Category{Term: term}
 }
 
 // SetLabel sets the label of the Category.
@@ -41,9 +42,5 @@ func (c *Category) Check() error {
 		return fmt.Errorf("label attribute %v of category not correctly escaped", c.Label)
 	}
 
-	if c.Content == "" {
-		return errors.New("content element of category empty")
-	}
-
 	return nil
 }

entry.go

@@ -1,6 +1,7 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
 	"strings"
@@ -12,16 +13,17 @@ import (
 // a non-empty atom:summary element when the entry contains no atom:content
 // element.
 type Entry struct {
+	XMLName xml.Name `xml:"entry"`
 	*CommonAttributes
-	Authors      []*Person           `xml:"author,omitempty"`
-	Categories   []*Category         `xml:"category,omitempty"`
-	Content      Content             `xml:"content,omitempty"`
-	Contributors []*Person           `xml:"contributors,omitempty"`
-	ID           *ID                 `xml:"id"`
-	Links        []*Link             `xml:"link,omitempty"`
+	Authors      []*Person   `xml:"author,omitempty"`
+	Categories   []*Category `xml:",omitempty"`
+	Content      Content     `xml:",omitempty"`
+	Contributors []*Person   `xml:"contributors,omitempty"`
+	ID           *ID
+	Links        []*Link             `xml:",omitempty"`
 	Published    *Date               `xml:"published,omitempty"`
 	Rights       Text                `xml:"rights,omitempty"`
-	Source       *Source             `xml:"source,omitempty"`
+	Source       *Source             `xml:",omitempty"`
 	Summary      Text                `xml:"summary,omitempty"`
 	Title        Text                `xml:"title"`
 	Updated      *Date               `xml:"updated"`
@@ -62,8 +64,13 @@ func NewEntry(title string) (*Entry, error) {
 		return nil, fmt.Errorf("error creating new entry: %v", err)
 	}
 
+	id, err := NewID(NewURN())
+	if err != nil {
+		return nil, fmt.Errorf("error creating new entry: %v", err)
+	}
+
 	return &Entry{
-		ID:      NewID(NewURN()),
+		ID:      id,
 		Title:   text,
 		Updated: NewDate(time.Now()),
 	}, nil

extensionAttribute.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 )
 
+// TODO: Is this really correct?
 type ExtensionAttribute struct {
 	Value   any `xml:",attr"`
 	XMLName xml.Name

extensionElement.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 )
 
+// TODO: Is this really correct?
 type ExtensionElement struct {
 	Value   any `xml:",innerxml"`
 	XMLName xml.Name

feed.go

@@ -10,20 +10,20 @@ import (
 type Feed struct {
 	XMLName xml.Name `xml:"http://www.w3.org/2005/Atom feed"`
 	*CommonAttributes
-	Authors      []*Person           `xml:"author,omitempty"`
-	Categories   []*Category         `xml:"category,omitempty"`
-	Contributors []*Person           `xml:"contributor,omitempty"`
-	Generator    *Generator          `xml:"generator,omitempty"`
-	Icon         *Icon               `xml:"icon,omitempty"`
-	ID           *ID                 `xml:"id"`
-	Links        []*Link             `xml:"link,omitempty"`
-	Logo         *Logo               `xml:"logo,omitempty"`
+	Authors      []*Person   `xml:"author,omitempty"`
+	Categories   []*Category `xml:",omitempty"`
+	Contributors []*Person   `xml:"contributor,omitempty"`
+	Generator    *Generator  `xml:",omitempty"`
+	Icon         *Icon       `xml:",omitempty"`
+	ID           *ID
+	Links        []*Link             `xml:",omitempty"`
+	Logo         *Logo               `xml:",omitempty"`
 	Rights       Text                `xml:"rights,omitempty"`
 	Subtitle     Text                `xml:"subtitle,omitempty"`
 	Title        Text                `xml:"title"`
 	Updated      *Date               `xml:"updated"`
 	Extensions   []*ExtensionElement `xml:",any,omitempty"`
-	Entries      []*Entry            `xml:"entry,omitempty"`
+	Entries      []*Entry            `xml:",omitempty"`
 }
 
 // NewFeed creates a new Feed. It returns a *Feed and an error.
@@ -33,8 +33,13 @@ func NewFeed(title string) (*Feed, error) {
 		return nil, fmt.Errorf("error creating new feed: %v", err)
 	}
 
+	id, err := NewID(NewURN())
+	if err != nil {
+		return nil, fmt.Errorf("error creating new feed: %v", err)
+	}
+
 	return &Feed{
-		ID:      NewID(NewURN()),
+		ID:      id,
 		Title:   text,
 		Updated: NewDate(time.Now()),
 	}, nil

generator.go

@@ -1,16 +1,18 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
 	"html"
 )
 
 type Generator struct {
+	XMLName xml.Name `xml:"generator"`
 	*CommonAttributes
 	URI     IRI    `xml:"uri,attr,omitempty"`
 	Version string `xml:"version,attr,omitempty"`
-	Text    string `xml:"text"`
+	Text    string `xml:",chardata"`
 }
 
 // NewGenerator creates a new Generator. It returns a *Generator.

icon.go

@@ -1,18 +1,24 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
 )
 
 type Icon struct {
+	XMLName xml.Name `xml:"icon"`
 	*CommonAttributes
-	URI IRI `xml:"uri"`
+	URI IRI `xml:",chardata"`
 }
 
-// NewIcon creates a new Icon. It returns a *Icon.
-func NewIcon(uri string) *Icon {
-	return &Icon{URI: IRI(uri)}
+// NewIcon creates a new Icon. It returns a *Icon and an error.
+func NewIcon(uri IRI) (*Icon, error) {
+	if !isValidIRI(uri) {
+		return nil, fmt.Errorf("uri %v not correctly formatted", uri)
+	}
+
+	return &Icon{URI: uri}, nil
 }
 
 // Check checks the Icon for incompatibilities with RFC4287. It returns an

id.go

@@ -1,18 +1,24 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
 )
 
 type ID struct {
+	XMLName xml.Name `xml:"id"`
 	*CommonAttributes
 	URI IRI `xml:",chardata"`
 }
 
-// NewID creates a new ID. It returns a *ID.
-func NewID(id IRI) *ID {
-	return &ID{URI: IRI(id)}
+// NewID creates a new ID. It returns a *ID and an error.
+func NewID(uri IRI) (*ID, error) {
+	if !isValidIRI(uri) {
+		return nil, fmt.Errorf("uri %v not correctly formatted", uri)
+	}
+
+	return &ID{URI: IRI(uri)}, nil
 }
 
 // Check checks the ID for incompatibilities with RFC4287. It returns an error.

inlineOtherContent.go

@@ -1,12 +1,14 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
 	"mime"
 )
 
 type InlineOtherContent struct {
+	XMLName xml.Name `xml:"content"`
 	*CommonAttributes
 	AnyElement any       `xml:",chardata"`
 	Type       MediaType `xml:"type,attr,omitempty"`

inlineTextContent.go

@@ -1,11 +1,13 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
 )
 
 type InlineTextContent struct {
+	XMLName xml.Name `xml:"content"`
 	*CommonAttributes
 	Type string `xml:"type,attr,omitempty"` // Must be text or html
 	Text string `xml:",chardata"`

inlineXHTMLContent.go

@@ -1,14 +1,16 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
 )
 
 type InlineXHTMLContent struct {
+	XMLName xml.Name `xml:"content"`
 	*CommonAttributes
+	XHTMLDiv *XHTMLDiv
 	Type     string `xml:"type,attr"`
-	XHTMLDiv XHTMLDiv
 }
 
 // newInlineXHTMLContent creates a new InlineXHTMLContent. It returns a
@@ -18,7 +20,7 @@ func newInlineXHTMLContent(mediaType string, content any) (*InlineXHTMLContent,
 		return nil, fmt.Errorf("media type %v incompatible with inline xhtml content", mediaType)
 	}
 
-	xhtmlDiv, ok := content.(XHTMLDiv)
+	xhtmlDiv, ok := content.(*XHTMLDiv)
 	if !ok {
 		return nil, fmt.Errorf("content type %T incompatible with inline xhtml content", content)
 	}

link.go

@@ -1,15 +1,16 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
 	"strings"
 )
 
 type Link struct {
+	XMLName xml.Name `xml:"link"`
 	*CommonAttributes
 	Title    string      `xml:"title,attr,omitempty"`
-	Content  string      `xml:",chardata"` // undefinedContent in RFC4287
 	Href     IRI         `xml:"href,attr"`
 	Rel      string      `xml:"rel,attr,omitempty"`
 	Type     MediaType   `xml:"type,attr,omitempty"`
@@ -17,9 +18,9 @@ type Link struct {
 	Length   uint        `xml:"length,attr,omitempty"`
 }
 
-// NewLink creates a new Link. It returns a *Link and an error.
-func NewLink(href, content string) (*Link, error) {
-	return &Link{Href: IRI(href), Content: content}, nil
+// NewLink creates a new Link. It returns a *Link.
+func NewLink(href string) *Link {
+	return &Link{Href: IRI(href)}
 }
 
 // Check checks the Link for incompatibilities with RFC4287. It returns an
@@ -51,10 +52,6 @@ func (l *Link) Check() error {
 		}
 	}
 
-	if l.Content == "" {
-		return errors.New("content element of link empty")
-	}
-
 	return nil
 }
 

logo.go

@@ -1,20 +1,24 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
-
-	"github.com/google/uuid"
 )
 
 type Logo struct {
+	XMLName xml.Name `xml:"logo"`
 	*CommonAttributes
-	URI IRI `xml:"uri"`
+	URI IRI `xml:",chardata"`
 }
 
 // NewLogo creates a new Logo. It returns a *Logo.
-func NewLogo() *Logo {
-	return &Logo{URI: IRI(fmt.Sprint("urn:uuid:", uuid.New()))}
+func NewLogo(uri IRI) (*Logo, error) {
+	if !isValidIRI(uri) {
+		return nil, fmt.Errorf("uri %v not correctly formatted", uri)
+	}
+
+	return &Logo{URI: uri}, nil
 }
 
 // Check checks the Logo for incompatibilities with RFC4287. It returns an

outOfLineContent.go

@@ -1,12 +1,14 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
 	"mime"
 )
 
 type OutOfLineContent struct {
+	XMLName xml.Name `xml:"content"`
 	*CommonAttributes
 	Type MediaType `xml:"type,attr,omitempty"`
 	SRC  IRI       `xml:"src,attr"`

source.go

@@ -1,17 +1,21 @@
 package atom
 
-import "fmt"
+import (
+	"encoding/xml"
+	"fmt"
+)
 
 type Source struct {
+	XMLName xml.Name `xml:"source"`
 	*CommonAttributes
 	Authors      []*Person           `xml:"author,omitempty"`
-	Categories   []*Category         `xml:"category,omitempty"`
+	Categories   []*Category         `xml:",omitempty"`
 	Contributors []*Person           `xml:"contributor,omitempty"`
-	Generator    *Generator          `xml:"generator,omitempty"`
-	Icon         *Icon               `xml:"icon,omitempty"`
-	ID           *ID                 `xml:"id,omitempty"`
-	Links        []*Link             `xml:"link,omitempty"`
-	Logo         *Logo               `xml:"logo,omitempty"`
+	Generator    *Generator          `xml:",omitempty"`
+	Icon         *Icon               `xml:",omitempty"`
+	ID           *ID                 `xml:",omitempty"`
+	Links        []*Link             `xml:",omitempty"`
+	Logo         *Logo               `xml:",omitempty"`
 	Rights       Text                `xml:"rights,omitempty"`
 	Subtitle     Text                `xml:"subtitle,omitempty"`
 	Title        Text                `xml:"title,omitempty"`

text.go

@@ -20,7 +20,7 @@ func NewText(textType, content string) (Text, error) {
 	case "xhtml":
 		return &XHTMLText{
 			Type: textType,
-			XHTMLDiv: XHTMLDiv{
+			XHTMLDiv: &XHTMLDiv{
 				XMLNS:   "http://www.w3.org/1999/xhtml",
 				Content: content,
 			},

xhtmlText.go

@@ -7,8 +7,8 @@ import (
 
 type XHTMLText struct {
 	*CommonAttributes
+	XHTMLDiv *XHTMLDiv
 	Type     string `xml:"type,attr"` // Must be xhtml
-	XHTMLDiv XHTMLDiv
 }
 
 // isText checks whether the XHTMLText is a Text. It returns a bool.