Use built-in xml attributes

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)
-	return err == nil
+	mediaType, _, err := mime.ParseMediaType(mediaType)
+	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,14 @@ func isValidLanguageTag(tag LanguageTag) bool {
 	_, err := language.Parse(string(tag))
 	return err == nil
 }
+
+// isValidAttribute checks whether an Attribute is valid. It returns a bool.
+func isValidAttribute(attribute string) bool {
+	regex := regexp.MustCompile(`^[a-zA-Z0-9_]+="[^"]*"$`)
+	return regex.MatchString(attribute)
+}
+
+// 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"`
-	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 string) (*Category, error) {
-	content, err := NewContent(InlineText, "", "")
-	if err != nil {
-		return nil, fmt.Errorf("error creating content element: %v", err)
-	}
-
-	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.
@@ -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

@@ -1,21 +1,27 @@
 package atom
 
-import "fmt"
+import (
+	"encoding/xml"
+)
 
 type CommonAttributes struct {
-	Base                IRI                   `xml:"base,attr,omitempty"`
-	Lang                LanguageTag           `xml:"lang,attr,omitempty"`
-	UndefinedAttributes []*ExtensionAttribute `xml:",any"`
+	Base                IRI         `xml:"base,attr,omitempty"`
+	Lang                LanguageTag `xml:"lang,attr,omitempty"`
+	UndefinedAttributes []*xml.Attr `xml:",attr,omitempty"`
 }
 
-// Check checks the CommonAttributes for incompatibilities with RFC4287. It
-// returns an error.
-func (c *CommonAttributes) Check() error {
-	for i, e := range c.UndefinedAttributes {
-		if err := e.Check(); err != nil {
-			return fmt.Errorf("extension attribute %v of common attributes: %v", i, err)
-		}
+// 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(name, value string) {
+	if c.UndefinedAttributes == nil {
+		c.UndefinedAttributes = make([]*xml.Attr, 1)
+		c.UndefinedAttributes[0] = &xml.Attr{Name: xml.Name{Local: name}, Value: value}
+	} else {
+		c.UndefinedAttributes = append(c.UndefinedAttributes, &xml.Attr{Name: xml.Name{Local: name}, Value: value})
 	}
-
-	return nil
 }

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"`
-	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"`
@@ -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 {
-			return errors.New("no authors set in entry")
+		if !authorInFeed {
+			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,21 +0,0 @@
-package atom
-
-import (
-	"encoding/xml"
-	"errors"
-)
-
-type ExtensionAttribute struct {
-	Value   any `xml:",attr"`
-	XMLName xml.Name
-}
-
-// Check checks the ExtensionAttribute for incompatibilities with RFC4287. It
-// returns an error.
-func (e *ExtensionAttribute) Check() error {
-	if e.Value == nil {
-		return errors.New("value element of extension attribute empty")
-	}
-
-	return nil
-}

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(),
+		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.
-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,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.
-func NewID() *ID {
-	return &ID{URI: IRI(fmt.Sprint("urn:uuid:", uuid.New()))}
+// 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,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
-	Texts []string `xml:"texts,omitempty"`
+	Type string `xml:"type,attr,omitempty"` // Must be text or html
+	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)
-
-	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:
+	text, ok := content.(string)
+	if !ok {
 		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 == "" {
-		return errors.New("xhtmlDiv element of inline xhtml content empty")
+	if err := i.XHTMLDiv.Check(); err != nil {
+		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.
-func NewLink(href string) (*Link, error) {
-	content, err := NewContent(InlineText, "", "")
-	if err != nil {
-		return nil, fmt.Errorf("error creating content element: %v", err)
-	}
-
-	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
@@ -38,23 +34,21 @@ func (l *Link) Check() error {
 		}
 	}
 
-	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 l.Rel != "" {
+		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)) {
-		return fmt.Errorf("type attribute %v of link %v invalid media type", l.Type, l.Href)
+	if l.Type != "" {
+		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) {
-		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)
+	if l.HrefLang != "" {
+		if !isValidLanguageTag(l.HrefLang) {
+			return fmt.Errorf("hreflang attribute %v of link %v invalid language tag", l.Type, l.HrefLang)
 		}
 	}
 

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,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"`
-	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,
 			},

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" {
-		return errors.New("xmlns attribute of xhtml text must be http://www.w3.org/1999/xhtml")
+	if err := x.XHTMLDiv.Check(); err != nil {
+		return fmt.Errorf("xhtml div element %v of xhtml text %v: %v", x.XHTMLDiv, x, err)
 	}
 
 	return nil