Create needed functions for common attributes and their extensions

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

README.md

@@ -1,4 +1,3 @@
-# atom-feed
+# atom
 
 An extensible implementation of an Atom feed that aims to be very close to RFC4287.
-

atom.go

@@ -1,10 +1,12 @@
 package atom
 
 import (
+	"fmt"
 	"mime"
 	"regexp"
 	"strings"
 
+	"github.com/google/uuid"
 	"golang.org/x/text/language"
 )
 
@@ -61,8 +63,17 @@ func isXMLMediaType(mediaType string) bool {
 // isValidMediaType checks whether a string is a valid media type. It returns a
 // bool.
 func isValidMediaType(mediaType string) bool {
-	_, _, err := mime.ParseMediaType(mediaType)
+	mediaType, _, err := mime.ParseMediaType(mediaType)
-	return err == nil
+	if err != nil {
+		return false
+	}
+
+	typeParts := strings.Split(mediaType, "/")
+	if len(typeParts) != 2 || typeParts[0] == "" || typeParts[1] == "" {
+		return false
+	}
+
+	return true
 }
 
 // isValidLanguageTag checks whether a LanguageTag is valid. It returns a bool.
@@ -70,3 +81,8 @@ func isValidLanguageTag(tag LanguageTag) bool {
 	_, err := language.Parse(string(tag))
 	return err == nil
 }
+
+// NewURN generates an new valid IRI based on a UUID. It returns an IRI.
+func NewURN() IRI {
+	return IRI(fmt.Sprint("urn:uuid:", uuid.New()))
+}

category.go

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

commonAttributes.go

@@ -8,6 +8,22 @@ type CommonAttributes struct {
 	UndefinedAttributes []*ExtensionAttribute `xml:",any"`
 }
 
+// NewCommonAttributes creates a new set of CommonAttributes. It returns a
+// *CommonAttributes.
+func NewCommonAttributes() *CommonAttributes {
+	return new(CommonAttributes)
+}
+
+// AddExtensionAttribute adds the ExtensionAttribute to the CommonAttributes.
+func (c *CommonAttributes) AddExtensionAttribute(e *ExtensionAttribute) {
+	if c.UndefinedAttributes == nil {
+		c.UndefinedAttributes = make([]*ExtensionAttribute, 1)
+		c.UndefinedAttributes[0] = e
+	} else {
+		c.UndefinedAttributes = append(c.UndefinedAttributes, e)
+	}
+}
+
 // Check checks the CommonAttributes for incompatibilities with RFC4287. It
 // returns an error.
 func (c *CommonAttributes) Check() error {

date.go

@@ -7,7 +7,7 @@ import (
 
 type Date struct {
 	*CommonAttributes
-	DateTime string
+	DateTime string `xml:",chardata"`
 }
 
 // DateTime formats a time.Time to string formated as defined by RFC3339. It

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"`
+	Authors      []*Person   `xml:"author,omitempty"`
-	Categories   []*Category         `xml:"category,omitempty"`
+	Categories   []*Category `xml:",omitempty"`
-	Content      Content             `xml:"content,omitempty"`
+	Content      Content     `xml:",omitempty"`
-	Contributors []*Person           `xml:"contributors,omitempty"`
+	Contributors []*Person   `xml:"contributors,omitempty"`
-	ID           *ID                 `xml:"id"`
+	ID           *ID
-	Links        []*Link             `xml:"link,omitempty"`
+	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"`
@@ -34,10 +36,15 @@ type Entry struct {
 // the atom:entry contains an atom:source element that contains an atom:author
 // element or, in an Atom Feed Document, the atom:feed element contains an
 // atom:author element itself.
-func (e *Entry) checkAuthors() error {
+func (e *Entry) checkAuthors(authorInFeed bool) error {
 	if e.Authors == nil {
-		if e.Source.Authors == nil {
+		if !authorInFeed {
-			return errors.New("no authors set in entry")
+			if e.Source == nil {
+				return errors.New("no authors set in entry")
+			}
+			if e.Source.Authors == nil {
+				return errors.New("no authors set in entry")
+			}
 		}
 	} else {
 		for i, a := range e.Authors {
@@ -57,13 +64,66 @@ 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(),
+		ID:      id,
 		Title:   text,
 		Updated: NewDate(time.Now()),
 	}, nil
 }
 
+// AddAuthor adds the Person as an author to the Entry.
+func (e *Entry) AddAuthor(p *Person) {
+	if e.Authors == nil {
+		e.Authors = make([]*Person, 1)
+		e.Authors[0] = p
+	} else {
+		e.Authors = append(e.Authors, p)
+	}
+
+	e.Updated.DateTime = DateTime(time.Now())
+}
+
+// AddCategory adds the Category to the Entry.
+func (e *Entry) AddCategory(c *Category) {
+	if e.Categories == nil {
+		e.Categories = make([]*Category, 1)
+		e.Categories[0] = c
+	} else {
+		e.Categories = append(e.Categories, c)
+	}
+
+	e.Updated.DateTime = DateTime(time.Now())
+}
+
+// AddContributor adds the Person as a contributor to the Entry.
+func (e *Entry) AddContributor(c *Person) {
+	if e.Contributors == nil {
+		e.Contributors = make([]*Person, 1)
+		e.Contributors[0] = c
+	} else {
+		e.Contributors = append(e.Contributors, c)
+	}
+
+	e.Updated.DateTime = DateTime(time.Now())
+}
+
+// AddLink adds the Link to the Entry.
+func (e *Entry) AddLink(l *Link) {
+	if e.Links == nil {
+		e.Links = make([]*Link, 1)
+		e.Links[0] = l
+	} else {
+		e.Links = append(e.Links, l)
+	}
+
+	e.Updated.DateTime = DateTime(time.Now())
+}
+
 // AddExtension adds the ExtensionElement to the Entry.
 func (e *Entry) AddExtension(x *ExtensionElement) {
 	if e.Extensions == nil {
@@ -87,7 +147,7 @@ func (e *Entry) Check() error {
 		}
 	}
 
-	if err := e.checkAuthors(); err != nil {
+	if err := e.checkAuthors(true); err != nil {
 		return fmt.Errorf("entry %v: %v", e.ID.URI, err)
 	}
 
@@ -160,7 +220,7 @@ func (e *Entry) Check() error {
 		// is not an XML media type [RFC3023], does not begin with "text/", and
 		// does not end with "/xml" or "+xml".
 		mediaType := e.Content.getType()
-		if !isXMLMediaType(mediaType) && !strings.HasPrefix(mediaType, "text/") {
+		if isValidMediaType(mediaType) && !isXMLMediaType(mediaType) && !strings.HasPrefix(mediaType, "text/") {
 			return fmt.Errorf("no summary element of entry %v but media type not xml", e.ID.URI)
 		}
 	}

extensionAttribute.go

@@ -1,19 +1,24 @@
 package atom
 
 import (
-	"encoding/xml"
 	"errors"
+	"fmt"
 )
 
 type ExtensionAttribute struct {
-	Value   any `xml:",attr"`
+	Attr string `xml:",attr"`
-	XMLName xml.Name
+}
+
+// NewExtensionAttribute creates a new ExtensionAttribute. It returns a
+// *ExtensionAttribute.
+func NewExtensionAttribute(name, value string) *ExtensionAttribute {
+	return &ExtensionAttribute{Attr: fmt.Sprint(name, `="`, value, `"`)}
 }
 
 // Check checks the ExtensionAttribute for incompatibilities with RFC4287. It
 // returns an error.
 func (e *ExtensionAttribute) Check() error {
-	if e.Value == nil {
+	if e.Attr == "" {
 		return errors.New("value element of extension attribute empty")
 	}
 

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"`
+	Authors      []*Person   `xml:"author,omitempty"`
-	Categories   []*Category         `xml:"category,omitempty"`
+	Categories   []*Category `xml:",omitempty"`
-	Contributors []*Person           `xml:"contributor,omitempty"`
+	Contributors []*Person   `xml:"contributor,omitempty"`
-	Generator    *Generator          `xml:"generator,omitempty"`
+	Generator    *Generator  `xml:",omitempty"`
-	Icon         *Icon               `xml:"icon,omitempty"`
+	Icon         *Icon       `xml:",omitempty"`
-	ID           *ID                 `xml:"id"`
+	ID           *ID
-	Links        []*Link             `xml:"link,omitempty"`
+	Links        []*Link             `xml:",omitempty"`
-	Logo         *Logo               `xml:"logo,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(),
+		ID:      id,
 		Title:   text,
 		Updated: NewDate(time.Now()),
 	}, nil
@@ -128,7 +133,7 @@ func (f *Feed) Check() error {
 	// least one atom:author element.
 	if f.Authors == nil {
 		for _, e := range f.Entries {
-			if err := e.checkAuthors(); err != nil {
+			if err := e.checkAuthors(false); err != nil {
 				return fmt.Errorf("no authors set in feed %v: %v", f.ID.URI, err)
 			}
 		}

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.
+// NewIcon creates a new Icon. It returns a *Icon and an error.
-func NewIcon(uri string) *Icon {
+func NewIcon(uri IRI) (*Icon, error) {
-	return &Icon{URI: IRI(uri)}
+	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,20 +1,24 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
-
-	"github.com/google/uuid"
 )
 
 type ID struct {
+	XMLName xml.Name `xml:"id"`
 	*CommonAttributes
-	URI IRI `xml:"uri"`
+	URI IRI `xml:",chardata"`
 }
 
-// NewID creates a new ID. It returns a *ID.
+// NewID creates a new ID. It returns a *ID and an error.
-func NewID() *ID {
+func NewID(uri IRI) (*ID, error) {
-	return &ID{URI: IRI(fmt.Sprint("urn:uuid:", uuid.New()))}
+	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,14 +1,16 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
 	"mime"
 )
 
 type InlineOtherContent struct {
+	XMLName xml.Name `xml:"content"`
 	*CommonAttributes
-	AnyElement any       `xml:"anyelement,omitempty"`
+	AnyElement any       `xml:",chardata"`
 	Type       MediaType `xml:"type,attr,omitempty"`
 }
 

inlineTextContent.go

@@ -1,15 +1,16 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
-	"reflect"
 )
 
 type InlineTextContent struct {
+	XMLName xml.Name `xml:"content"`
 	*CommonAttributes
-	Type  string   `xml:"type,attr,omitempty"` // Must be text or html
+	Type string `xml:"type,attr,omitempty"` // Must be text or html
-	Texts []string `xml:"texts,omitempty"`
+	Text string `xml:",chardata"`
 }
 
 // newInlineTextContent creates a new InlineTextContent. It returns a
@@ -19,23 +20,12 @@ func newInlineTextContent(mediaType string, content any) (*InlineTextContent, er
 		return nil, fmt.Errorf("media type %v incompatible with inline text content", mediaType)
 	}
 
-	texts := make([]string, 0)
+	text, ok := content.(string)
-
+	if !ok {
-	t := reflect.TypeOf(content)
-	switch t.Kind() {
-	case reflect.Slice:
-		if t.Elem().Kind() == reflect.String {
-			for _, t := range content.([]string) {
-				texts = append(texts, t)
-			}
-		}
-	case reflect.String:
-		texts = append(texts, content.(string))
-	default:
 		return nil, fmt.Errorf("content type %T incompatible with inline text content", content)
 	}
 
-	return &InlineTextContent{Type: mediaType, Texts: texts}, nil
+	return &InlineTextContent{Type: mediaType, Text: text}, nil
 }
 
 // isContent checks whether the InlineTextContent is a Content. It returns a

inlineXHTMLContent.go

@@ -1,15 +1,16 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
-	"reflect"
 )
 
 type InlineXHTMLContent struct {
+	XMLName xml.Name `xml:"content"`
 	*CommonAttributes
+	XHTMLDiv *XHTMLDiv
 	Type     string `xml:"type,attr"`
-	XHTMLDiv string `xml:"xhtmldiv"`
 }
 
 // newInlineXHTMLContent creates a new InlineXHTMLContent. It returns a
@@ -19,11 +20,12 @@ func newInlineXHTMLContent(mediaType string, content any) (*InlineXHTMLContent,
 		return nil, fmt.Errorf("media type %v incompatible with inline xhtml content", mediaType)
 	}
 
-	if reflect.TypeOf(content).Kind() != reflect.String {
+	xhtmlDiv, ok := content.(*XHTMLDiv)
+	if !ok {
 		return nil, fmt.Errorf("content type %T incompatible with inline xhtml content", content)
 	}
 
-	return &InlineXHTMLContent{Type: mediaType, XHTMLDiv: content.(string)}, nil
+	return &InlineXHTMLContent{Type: mediaType, XHTMLDiv: xhtmlDiv}, nil
 }
 
 // isContent checks whether the InlineXHTMLContent is a Content. It returns a
@@ -44,8 +46,8 @@ func (i *InlineXHTMLContent) Check() error {
 		return errors.New("type attribute of inline xhtml content must be xhtml")
 	}
 
-	if i.XHTMLDiv == "" {
+	if err := i.XHTMLDiv.Check(); err != nil {
-		return errors.New("xhtmlDiv element of inline xhtml content empty")
+		return fmt.Errorf("xhtml div element %v of inline xhtml content %v: %v", i.XHTMLDiv, i, err)
 	}
 
 	return nil

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  Content     `xml:"content"` // undefinedContent in RFC4287
 	Href     IRI         `xml:"href,attr"`
 	Rel      string      `xml:"rel,attr,omitempty"`
 	Type     MediaType   `xml:"type,attr,omitempty"`
@@ -17,14 +18,9 @@ type Link struct {
 	Length   uint        `xml:"length,attr,omitempty"`
 }
 
-// NewLink creates a new Link. It returns a *Link and an error.
+// NewLink creates a new Link. It returns a *Link.
-func NewLink(href string) (*Link, error) {
+func NewLink(href string) *Link {
-	content, err := NewContent(InlineText, "", "")
+	return &Link{Href: IRI(href)}
-	if err != nil {
-		return nil, fmt.Errorf("error creating content element: %v", err)
-	}
-
-	return &Link{Href: IRI(href), Content: content}, nil
 }
 
 // Check checks the Link for incompatibilities with RFC4287. It returns an
@@ -38,23 +34,21 @@ func (l *Link) Check() error {
 		}
 	}
 
-	if strings.Contains(l.Rel, ":") || !isValidIRI(IRI(l.Rel)) {
+	if l.Rel != "" {
-		return fmt.Errorf("rel attribute %v of link %v not correctly formatted", l.Rel, l.Href)
+		if strings.Contains(l.Rel, ":") && !isValidIRI(IRI(l.Rel)) {
+			return fmt.Errorf("rel attribute %v of link %v not correctly formatted", l.Rel, l.Href)
+		}
 	}
 
-	if !isValidMediaType(string(l.Type)) {
+	if l.Type != "" {
-		return fmt.Errorf("type attribute %v of link %v invalid media type", l.Type, l.Href)
+		if !isValidMediaType(string(l.Type)) {
+			return fmt.Errorf("type attribute %v of link %v invalid media type", l.Type, l.Href)
+		}
 	}
 
-	if !isValidLanguageTag(l.HrefLang) {
+	if l.HrefLang != "" {
-		return fmt.Errorf("hreflang attribute %v of link %v invalid language tag", l.Type, l.HrefLang)
+		if !isValidLanguageTag(l.HrefLang) {
-	}
+			return fmt.Errorf("hreflang attribute %v of link %v invalid language tag", l.Type, l.HrefLang)
-
-	if l.Content == nil {
-		return fmt.Errorf("no content element of link %v", l.Href)
-	} else {
-		if err := l.Content.Check(); err != nil {
-			return fmt.Errorf("content element of link %v: %v", l.Href, err)
 		}
 	}
 

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 {
+func NewLogo(uri IRI) (*Logo, error) {
-	return &Logo{URI: IRI(fmt.Sprint("urn:uuid:", uuid.New()))}
+	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,13 +1,14 @@
 package atom
 
 import (
+	"encoding/xml"
 	"errors"
 	"fmt"
 	"mime"
-	"reflect"
 )
 
 type OutOfLineContent struct {
+	XMLName xml.Name `xml:"content"`
 	*CommonAttributes
 	Type MediaType `xml:"type,attr,omitempty"`
 	SRC  IRI       `xml:"src,attr"`
@@ -20,15 +21,16 @@ func newOutOfLineContent(mediaType string, content any) (*OutOfLineContent, erro
 		return nil, fmt.Errorf("media type %v incompatible with out of line content", mediaType)
 	}
 
-	if reflect.TypeOf(content).Kind() != reflect.String {
+	iri, ok := content.(IRI)
+	if !ok {
 		return nil, fmt.Errorf("content type %T incompatible with out of line content", content)
 	}
 
-	if !isValidIRI(content.(IRI)) {
+	if !isValidIRI(iri) {
 		return nil, errors.New("content not a valid uri")
 	}
 
-	return &OutOfLineContent{Type: MediaType(mediaType), SRC: content.(IRI)}, nil
+	return &OutOfLineContent{Type: MediaType(mediaType), SRC: iri}, nil
 }
 
 // isContent checks whether the OutOfLineContent is a Content. It returns a

plainText.go

@@ -5,7 +5,7 @@ import "errors"
 type PlainText struct {
 	*CommonAttributes
 	Type string `xml:"type,attr,omitempty"` // Must be text or html
-	Text string `xml:"text"`
+	Text string `xml:",chardata"`
 }
 
 // isText checks whether the PlainText is a Text. It returns a bool.

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"`
+	Generator    *Generator          `xml:",omitempty"`
-	Icon         *Icon               `xml:"icon,omitempty"`
+	Icon         *Icon               `xml:",omitempty"`
-	ID           *ID                 `xml:"id,omitempty"`
+	ID           *ID                 `xml:",omitempty"`
-	Links        []*Link             `xml:"link,omitempty"`
+	Links        []*Link             `xml:",omitempty"`
-	Logo         *Logo               `xml:"logo,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,
 			},

xhtmlDiv.go

@@ -0,0 +1,30 @@
+package atom
+
+import (
+	"encoding/xml"
+	"errors"
+)
+
+type XHTMLDiv struct {
+	XMLName xml.Name `xml:"div"`
+	XMLNS   string   `xml:"xmlns,attr"`
+	Content string   `xml:",innerxml"`
+}
+
+// NewXHTMLDiv creates a new XHTMLDiv. It returns a *XHTMLDiv.
+func NewXHTMLDiv(content string) *XHTMLDiv {
+	return &XHTMLDiv{
+		XMLNS:   "http://www.w3.org/1999/xhtml",
+		Content: content,
+	}
+}
+
+// Check checks the XHTMLDiv for incompatibilities with RFC4287. It returns an
+// error.
+func (x *XHTMLDiv) Check() error {
+	if x.XMLNS != "http://www.w3.org/1999/xhtml" {
+		return errors.New("xmlns attribute of xhtml text must be http://www.w3.org/1999/xhtml")
+	}
+
+	return nil
+}

xhtmlText.go

@@ -1,20 +1,14 @@
 package atom
 
 import (
-	"encoding/xml"
 	"errors"
+	"fmt"
 )
 
-type XHTMLDiv struct {
-	XMLName xml.Name `xml:"div"`
-	XMLNS   string   `xml:"xmlns,attr"`
-	Content string   `xml:",innerxml"`
-}
-
 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.
@@ -27,8 +21,8 @@ func (x *XHTMLText) Check() error {
 		return errors.New("type attribute of xhtml text must be xhtml")
 	}
 
-	if x.XHTMLDiv.XMLNS != "http://www.w3.org/1999/xhtml" {
+	if err := x.XHTMLDiv.Check(); err != nil {
-		return errors.New("xmlns attribute of xhtml text must be http://www.w3.org/1999/xhtml")
+		return fmt.Errorf("xhtml div element %v of xhtml text %v: %v", x.XHTMLDiv, x, err)
 	}
 
 	return nil