jason/atom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 14 Wiki Activity

Get rid of checks when creating constructs. Check should handle this.

Browse Source
This commit is contained in:
Jason Streifling 2024-10-19 14:12:51 +02:00
parent 960889f9e7
commit 57db4178d0
21 changed files with 143 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
atom.go
View File

@ -2,6 +2,7 @@ package atom
import (
"fmt"
"html"
"mime"
"regexp"
"strings"
@ -10,6 +11,10 @@ import (
"golang.org/x/text/language"
)
func Unescape(s string) string {
return html.UnescapeString(s)
}
// isValidIRI checks whether an IRI is valid or not. It returns a bool.
// https://www.w3.org/2011/04/XMLSchema/TypeLibrary-IRI-RFC3987.xsd
func isValidIRI(iri string) bool {
@ -17,6 +22,15 @@ func isValidIRI(iri string) bool {
return regexp.MustCompile(pattern).MatchString(iri)
}
// NewIRI creates a new IRI. It returns a string and an error.
func NewIRI(iri string) (string, error) {
if !isValidIRI(iri) {
return "", fmt.Errorf("iri %v not correctly formatted", iri)
}
return iri, nil
}
// isCorrectlyEscaped checks whether a string is correctly escaped as per
// RFC4287. It returns a bool.
func isCorrectlyEscaped(text string) bool {
@ -69,12 +83,31 @@ func isValidMediaType(m string) bool {
return true
}
// NewMediaType creates a new MediaType. It returns a string and an error.
func NewMediaType(m string) (string, error) {
if !isValidMediaType(m) {
return "", fmt.Errorf("media type %v invalid", m)
}
mediaType, _, _ := mime.ParseMediaType(m)
return mediaType, nil
}
// isValidLanguageTag checks whether a LanguageTag is valid. It returns a bool.
func isValidLanguageTag(languageTag string) bool {
_, err := language.Parse(languageTag)
return err == nil
}
// NewLanguageTag creates a new LanguageTag. It returns a string and an error.
func NewLanguageTag(l string) (string, error) {
if !isValidLanguageTag(l) {
return "", fmt.Errorf("language tag %v invalid", l)
}
return l, nil
}
// isValidAttribute checks whether an Attribute is valid. It returns a bool.
func isValidAttribute(attribute string) bool {
regex := regexp.MustCompile(`^[a-zA-Z0-9_]+="[^"]*"$`)

43
category.go
View File

@ -2,9 +2,7 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
"html"
)
type Category struct {
@ -15,43 +13,14 @@ type Category struct {
Label string `xml:"label,attr,omitempty"`
}
// NewCategory creates a new Category. It returns a *Category and an error.
func NewCategory(term string) (*Category, error) {
if term == "" {
return nil, errors.New("error creating new category: term string empty")
}
return &Category{Term: term}, nil
// NewCategory creates a new Category. It returns a *Category.
func NewCategory(term string) *Category {
return &Category{Term: term}
}
// SetTerm sets the Term attribute of the Category. It returns an error.
func (c *Category) SetTerm(t string) error {
if t == "" {
return errors.New("error setting term of category: t string empty")
}
c.Term = t
return nil
}
// SetScheme sets the Scheme attribute of the Category. It returns an error.
func (c *Category) SetScheme(s string) error {
if !isValidIRI(s) {
return fmt.Errorf("scheme %v not correctly formatted", s)
}
c.Scheme = s
return nil
}
// SetLabel sets the Label attribute of the Category. It returns an error.
func (c *Category) SetLabel(label string) error {
if label == "" {
return errors.New("error setting label of category: label string empty")
}
c.Label = html.UnescapeString(label)
return nil
// SetLabel sets the Label attribute of the Category.
func (c *Category) SetLabel(label string) {
c.Label = Unescape(label)
}
// Check checks the Category for incompatibilities with RFC4287. It returns an

26
commonAttributes.go
View File

@ -2,7 +2,7 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
)
type CommonAttributes struct {
@ -17,21 +17,27 @@ func NewCommonAttributes() *CommonAttributes {
return new(CommonAttributes)
}
// AddAttribute adds the Attribute to the CommonAttributes. It returns an error.
func (c *CommonAttributes) AddAttribute(name, value string) error {
if name == "" {
return errors.New("error adding attribute: name string empty")
}
if value == "" {
return errors.New("error adding attribute: value string empty")
}
// AddAttribute adds the Attribute to the CommonAttributes.
func (c *CommonAttributes) AddAttribute(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})
}
}
// Check checks the CommonAttributes for incompatibilities with RFC4287. It
// returns an error.
func (c *CommonAttributes) Check() error {
for i, u := range c.UndefinedAttributes {
if u.Name.Local == "" {
return fmt.Errorf("xml name of undefined attribute %v empty", i)
}
if u.Value == "" {
return fmt.Errorf("value of undefined attribute %v empty", i)
}
}
return nil
}

12
content.go
View File

@ -1,7 +1,5 @@
package atom
import "fmt"
const (
InlineText = iota
InlineXHTML
@ -17,17 +15,17 @@ type Content interface {
}
// NewContent creates a new Content. It returns a Content and an error.
func NewContent(contentType int, mediaType string, content any) (Content, error) {
func NewContent(contentType int, mediaType string, content any) Content {
switch contentType {
case 0:
return newInlineTextContent(mediaType, content)
return newInlineTextContent(mediaType, content.(string))
case 1:
return newInlineXHTMLContent(mediaType, content)
return newInlineXHTMLContent(mediaType, content.(*XHTMLDiv))
case 2:
return newInlineOtherContent(mediaType, content)
case 3:
return newOutOfLineContent(mediaType, content)
return newOutOfLineContent(mediaType, content.(string))
default:
return nil, fmt.Errorf("error creating new content: %v is not a valid text type", contentType)
return nil
}
}

67
entry.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
"strings"
"time"
@ -57,31 +56,17 @@ func (e *Entry) checkAuthors(authorInFeed bool) error {
return nil
}
// NewEntry creates a new Entry. It returns a *Entry and an error.
func NewEntry(title string) (*Entry, error) {
text, err := NewText("text", title)
if err != nil {
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)
}
// NewEntry creates a new Entry. It returns a *Entry.
func NewEntry(title string) *Entry {
return &Entry{
ID: id,
Title: text,
ID: NewID(NewURN()),
Title: NewText("text", title),
Updated: NewDate(time.Now()),
}, nil
}
}
// AddAuthor adds the Person as an author to the Entry. It returns an error.
func (e *Entry) AddAuthor(p *Person) error {
if p == nil {
return errors.New("error adding author element to entry: *Person is 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
@ -90,15 +75,10 @@ func (e *Entry) AddAuthor(p *Person) error {
}
e.Updated.DateTime = DateTime(time.Now())
return nil
}
// AddCategory adds the Category to the Entry. It returns an error.
func (e *Entry) AddCategory(c *Category) error {
if c == nil {
return errors.New("error adding category element to entry: *Category is nil")
}
// 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
@ -107,16 +87,10 @@ func (e *Entry) AddCategory(c *Category) error {
}
e.Updated.DateTime = DateTime(time.Now())
return nil
}
// AddContributor adds the Person as a contributor to the Entry. It returns an
// error.
func (e *Entry) AddContributor(c *Person) error {
if c == nil {
return errors.New("error adding contributor element to entry: *Person is nil")
}
// 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
@ -125,15 +99,10 @@ func (e *Entry) AddContributor(c *Person) error {
}
e.Updated.DateTime = DateTime(time.Now())
return nil
}
// AddLink adds the Link to the Entry. It returns an error.
func (e *Entry) AddLink(l *Link) error {
if l == nil {
return errors.New("error adding link element to entry: *Link is nil")
}
// 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
@ -142,15 +111,10 @@ func (e *Entry) AddLink(l *Link) error {
}
e.Updated.DateTime = DateTime(time.Now())
return nil
}
// AddExtension adds the ExtensionElement to the Entry. It returns an error.
func (e *Entry) AddExtension(x *ExtensionElement) error {
if x == nil {
return errors.New("error adding extension element to entry: *ExtensionElement is nil")
}
// AddExtension adds the ExtensionElement to the Entry.
func (e *Entry) AddExtension(x *ExtensionElement) {
if e.Extensions == nil {
e.Extensions = make([]*ExtensionElement, 1)
e.Extensions[0] = x
@ -159,7 +123,6 @@ func (e *Entry) AddExtension(x *ExtensionElement) error {
}
e.Updated.DateTime = DateTime(time.Now())
return nil
}
// Check checks the Entry for incompatibilities with RFC4287. It returns an

19
extensionElement.go
View File

@ -2,7 +2,7 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
)
type ExtensionElement struct {
@ -11,27 +11,20 @@ type ExtensionElement struct {
}
// NewExtensionElement creates a new ExtensionElement. It returns a
// *ExtensionElement and an error.
func NewExtensionElement(name string, value any) (*ExtensionElement, error) {
if name == "" {
return nil, errors.New("error adding extension attribute: name string empty")
}
if value == "" {
return nil, errors.New("error adding extension attribute: value string empty")
}
return &ExtensionElement{XMLName: xml.Name{Local: name}, Value: value}, nil
// *ExtensionElement.
func NewExtensionElement(name string, value any) *ExtensionElement {
return &ExtensionElement{XMLName: xml.Name{Local: name}, Value: value}
}
// Check checks the ExtensionElement for incompatibilities with RFC4287. It
// returns an error.
func (e *ExtensionElement) Check() error {
if e.XMLName.Local == "" {
return errors.New("xml name of extension empty")
return fmt.Errorf("xml name of extension %v empty", e)
}
if e.Value == nil {
return errors.New("value element of extension empty")
return fmt.Errorf("value of extension %v empty", e)
}
return nil

77
feed.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
"time"
)
@ -26,31 +25,17 @@ type Feed struct {
Entries []*Entry `xml:",omitempty"`
}
// NewFeed creates a new Feed. It returns a *Feed and an error.
func NewFeed(title string) (*Feed, error) {
text, err := NewText("text", title)
if err != nil {
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)
}
// NewFeed creates a new Feed. It returns a *Feed.
func NewFeed(title string) *Feed {
return &Feed{
ID: id,
Title: text,
ID: NewID(NewURN()),
Title: NewText("text", title),
Updated: NewDate(time.Now()),
}, nil
}
}
// AddAuthor adds the Person as an author to the Feed. It returns an error.
func (f *Feed) AddAuthor(p *Person) error {
if p == nil {
return errors.New("error adding author element to feed: *Person is nil")
}
// AddAuthor adds the Person as an author to the Feed.
func (f *Feed) AddAuthor(p *Person) {
if f.Authors == nil {
f.Authors = make([]*Person, 1)
f.Authors[0] = p
@ -59,15 +44,10 @@ func (f *Feed) AddAuthor(p *Person) error {
}
f.Updated.DateTime = DateTime(time.Now())
return nil
}
// AddCategory adds the Category to the Feed. It returns an error.
func (f *Feed) AddCategory(c *Category) error {
if c == nil {
return errors.New("error adding category element to feed: *Category is nil")
}
// AddCategory adds the Category to the Feed.
func (f *Feed) AddCategory(c *Category) {
if f.Categories == nil {
f.Categories = make([]*Category, 1)
f.Categories[0] = c
@ -76,16 +56,10 @@ func (f *Feed) AddCategory(c *Category) error {
}
f.Updated.DateTime = DateTime(time.Now())
return nil
}
// AddContributor adds the Person as a contributor to the Feed. It returns an
// error.
func (f *Feed) AddContributor(c *Person) error {
if c == nil {
return errors.New("error adding contributor element to feed: *Person is nil")
}
// AddContributor adds the Person as a contributor to the Feed.
func (f *Feed) AddContributor(c *Person) {
if f.Contributors == nil {
f.Contributors = make([]*Person, 1)
f.Contributors[0] = c
@ -94,16 +68,10 @@ func (f *Feed) AddContributor(c *Person) error {
}
f.Updated.DateTime = DateTime(time.Now())
return nil
}
// AddLink adds the Link to the Feed. It returns an error. There should be one
// Link with Rel "self".
func (f *Feed) AddLink(l *Link) error {
if l == nil {
return errors.New("error adding link element to feed: *Link is nil")
}
// AddLink adds the Link to the Feed. There should be one Link with Rel "self".
func (f *Feed) AddLink(l *Link) {
if f.Links == nil {
f.Links = make([]*Link, 1)
f.Links[0] = l
@ -112,15 +80,10 @@ func (f *Feed) AddLink(l *Link) error {
}
f.Updated.DateTime = DateTime(time.Now())
return nil
}
// AddExtension adds the Extension to the Feed. It returns an error.
func (f *Feed) AddExtension(e *ExtensionElement) error {
if e == nil {
return errors.New("error adding extension element to feed: *ExtensionElement is nil")
}
// AddExtension adds the Extension to the Feed.
func (f *Feed) AddExtension(e *ExtensionElement) {
if f.Extensions == nil {
f.Extensions = make([]*ExtensionElement, 1)
f.Extensions[0] = e
@ -129,15 +92,10 @@ func (f *Feed) AddExtension(e *ExtensionElement) error {
}
f.Updated.DateTime = DateTime(time.Now())
return nil
}
// AddEntry adds the Entry to the Feed. It returns an error.
func (f *Feed) AddEntry(e *Entry) error {
if e == nil {
return errors.New("error adding entry element to feed: *Entry is nil")
}
// AddEntry adds the Entry to the Feed.
func (f *Feed) AddEntry(e *Entry) {
if f.Entries == nil {
f.Entries = make([]*Entry, 1)
f.Entries[0] = e
@ -146,7 +104,6 @@ func (f *Feed) AddEntry(e *Entry) error {
}
f.Updated.DateTime = DateTime(time.Now())
return nil
}
// Check checks the Feed for incompatibilities with RFC4287. It returns an

20
generator.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
"html"
)
@ -15,22 +14,9 @@ type Generator struct {
Text string `xml:",chardata"`
}
// NewGenerator creates a new Generator. It returns a *Generator and an error.
func NewGenerator(text string) (*Generator, error) {
if text == "" {
return nil, errors.New("error creating new generator: text string empty")
}
return &Generator{Text: html.UnescapeString(text)}, nil
}
// SetURI sets the URI attribute of the Generator. It returns an error.
func (g *Generator) SetURI(uri string) error {
if !isValidIRI(uri) {
return fmt.Errorf("uri %v not correctly formatted", g)
}
return nil
// NewGenerator creates a new Generator. It returns a *Generator.
func NewGenerator(text string) *Generator {
return &Generator{Text: html.UnescapeString(text)}
}
// Check checks the Generator for incompatibilities with RFC4287. It returns an

10
icon.go
View File

@ -12,13 +12,9 @@ type Icon struct {
URI string `xml:",chardata"` // IRI
}
// NewIcon creates a new Icon. It returns a *Icon and an error.
func NewIcon(uri string) (*Icon, error) {
if !isValidIRI(uri) {
return nil, fmt.Errorf("uri %v not correctly formatted", uri)
}
return &Icon{URI: uri}, nil
// NewIcon creates a new Icon. It returns a *Icon.
func NewIcon(uri string) *Icon {
return &Icon{URI: uri}
}
// Check checks the Icon for incompatibilities with RFC4287. It returns an

10
id.go
View File

@ -12,13 +12,9 @@ type ID struct {
URI string `xml:",chardata"` // IRI
}
// NewID creates a new ID. It returns a *ID and an error.
func NewID(uri string) (*ID, error) {
if !isValidIRI(uri) {
return nil, fmt.Errorf("uri %v not correctly formatted", uri)
}
return &ID{URI: uri}, nil
// NewID creates a new ID. It returns a *ID.
func NewID(uri string) *ID {
return &ID{URI: uri}
}
// Check checks the ID for incompatibilities with RFC4287. It returns an error.

8
inlineOtherContent.go
View File

@ -15,13 +15,9 @@ type InlineOtherContent struct {
// newInlineOtherContent creates a new InlineOtherContent. It returns a
// *InlineOtherContent and an error.
func newInlineOtherContent(mediaType string, content any) (*InlineOtherContent, error) {
if !isValidMediaType(mediaType) {
return nil, fmt.Errorf("error creating new inline other content: media type %v invalid", mediaType)
}
func newInlineOtherContent(mediaType string, content any) *InlineOtherContent {
mediaType, _, _ = mime.ParseMediaType(mediaType)
return &InlineOtherContent{Type: mediaType, AnyElement: content}, nil
return &InlineOtherContent{Type: mediaType, AnyElement: content}
}
// isContent checks whether the InlineOtherContent is a Content. It returns a

15
inlineTextContent.go
View File

@ -13,18 +13,9 @@ type InlineTextContent struct {
}
// newInlineTextContent creates a new InlineTextContent. It returns a
// *InlineTextContent and an error.
func newInlineTextContent(mediaType string, content any) (*InlineTextContent, error) {
if mediaType != "text" && mediaType != "html" && mediaType != "" {
return nil, fmt.Errorf("media type %v incompatible with inline text content", mediaType)
}
text, ok := content.(string)
if !ok {
return nil, fmt.Errorf("content type %T incompatible with inline text content", content)
}
return &InlineTextContent{Type: mediaType, Text: text}, nil
// *InlineTextContent.
func newInlineTextContent(mediaType, text string) *InlineTextContent {
return &InlineTextContent{Type: mediaType, Text: text}
}
// isContent checks whether the InlineTextContent is a Content. It returns a

15
inlineXHTMLContent.go
View File

@ -13,18 +13,9 @@ type InlineXHTMLContent struct {
}
// newInlineXHTMLContent creates a new InlineXHTMLContent. It returns a
// *InlineXHTMLContent and an error.
func newInlineXHTMLContent(mediaType string, content any) (*InlineXHTMLContent, error) {
if mediaType != "xhtml" {
return nil, fmt.Errorf("media type %v incompatible with inline xhtml content", mediaType)
}
xhtmlDiv, ok := content.(*XHTMLDiv)
if !ok {
return nil, fmt.Errorf("content type %T incompatible with inline xhtml content", content)
}
return &InlineXHTMLContent{Type: mediaType, XHTMLDiv: xhtmlDiv}, nil
// *InlineXHTMLContent.
func newInlineXHTMLContent(mediaType string, div *XHTMLDiv) *InlineXHTMLContent {
return &InlineXHTMLContent{Type: mediaType, XHTMLDiv: div}
}
// isContent checks whether the InlineXHTMLContent is a Content. It returns a

28
link.go
View File

@ -17,31 +17,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) {
if !isValidIRI(href) {
return nil, fmt.Errorf("href %v not correctly formatted", href)
}
return &Link{Href: href}, nil
}
// SetType sets the Type attribute of the Link. It returns an error.
func (l *Link) SetType(t string) error {
if !isValidMediaType(t) {
return fmt.Errorf("type %v invalid media type", t)
}
return nil
}
// SetHrefLang sets the HrefLang attribute of the Link. It returns an error.
func (l *Link) SetHrefLang(h string) error {
if !isValidLanguageTag(h) {
return fmt.Errorf("hreflang %v invalid language tag", h)
}
return nil
// NewLink creates a new Link. It returns a *Link.
func NewLink(href string) *Link {
return &Link{Href: href}
}
// Check checks the Link for incompatibilities with RFC4287. It returns an

10
logo.go
View File

@ -11,13 +11,9 @@ type Logo struct {
URI string `xml:",chardata"` // IRI
}
// NewLogo creates a new Logo. It returns a *Logo and an error.
func NewLogo(uri string) (*Logo, error) {
if !isValidIRI(uri) {
return nil, fmt.Errorf("uri %v not correctly formatted", uri)
}
return &Logo{URI: uri}, nil
// NewLogo creates a new Logo. It returns a *Logo.
func NewLogo(uri string) *Logo {
return &Logo{URI: uri}
}
// Check checks the Logo for incompatibilities with RFC4287. It returns an

19
outOfLineContent.go
View File

@ -14,23 +14,10 @@ type OutOfLineContent struct {
}
// newOutOfLineContent creates a new OutOfLineContent. It returns a
// *OutOfLineContent and an error.
func newOutOfLineContent(mediaType string, content any) (*OutOfLineContent, error) {
if !isValidMediaType(mediaType) {
return nil, fmt.Errorf("error creating new out of line content: media type %v invalid", mediaType)
}
// *OutOfLineContent.
func newOutOfLineContent(mediaType, src string) *OutOfLineContent {
mediaType, _, _ = mime.ParseMediaType(mediaType)
iri, ok := content.(string)
if !ok {
return nil, fmt.Errorf("content type %T incompatible with out of line content", content)
}
if !isValidIRI(iri) {
return nil, fmt.Errorf("content %v not a valid uri", iri)
}
return &OutOfLineContent{Type: mediaType, SRC: iri}, nil
return &OutOfLineContent{Type: mediaType, SRC: src}
}
// isContent checks whether the OutOfLineContent is a Content. It returns a

30
person.go
View File

@ -1,7 +1,6 @@
package atom
import (
"errors"
"fmt"
"net/mail"
)
@ -14,38 +13,19 @@ type Person struct {
Extensions []*ExtensionElement `xml:",any,omitempty"`
}
// NewPerson creates a new Person. It returns a *Person and an error.
func NewPerson(name string) (*Person, error) {
if name == "" {
return nil, errors.New("error creating new person: name string empty")
}
return &Person{Name: name}, nil
// NewPerson creates a new Person. It returns a *Person.
func NewPerson(name string) *Person {
return &Person{Name: name}
}
// SetURI sets the URI element of the Person. It returns an error.
func (l *Link) SetURI(uri string) error {
if !isValidIRI(uri) {
return fmt.Errorf("uri %v not correctly formatted", uri)
}
return nil
}
// AddExtension adds the Extension to the Person. It returns an error.
func (p *Person) AddExtension(e *ExtensionElement) error {
if e == nil {
return errors.New("error adding extension element to person: *ExtensionElement is nil")
}
// AddExtension adds the Extension to the Person.
func (p *Person) AddExtension(e *ExtensionElement) {
if p.Extensions == nil {
p.Extensions = make([]*ExtensionElement, 1)
p.Extensions[0] = e
} else {
p.Extensions = append(p.Extensions, e)
}
return nil
}
// Check checks the Person for incompatibilities with RFC4287. It returns an

11
plainText.go
View File

@ -1,7 +1,6 @@
package atom
import (
"errors"
"fmt"
)
@ -14,13 +13,9 @@ type PlainText struct {
// isText checks whether the PlainText is a Text. It returns a bool.
func (p *PlainText) isText() bool { return true }
// newPlainText creates a new PlainText. It returns a *PlainText and an error.
func newPlainText(textType, content string) (*PlainText, error) {
if content == "" {
return nil, errors.New("error creating new plain text: content string empty")
}
return &PlainText{Type: textType, Text: content}, nil
// newPlainText creates a new PlainText. It returns a *PlainText.
func newPlainText(textType, content string) *PlainText {
return &PlainText{Type: textType, Text: content}
}
// Check checks the PlainText for incompatibilities with RFC4287. It returns an

11
text.go
View File

@ -1,17 +1,14 @@
package atom
import (
"fmt"
"html"
)
import "html"
type Text interface {
isText() bool
Check() error
}
// NewText creates a new Text. It returns a Text and an error.
func NewText(textType, content string) (Text, error) {
// NewText creates a new Text. It returns a Text.
func NewText(textType, content string) Text {
switch textType {
case "text", "":
return newPlainText(textType, content)
@ -20,6 +17,6 @@ func NewText(textType, content string) (Text, error) {
case "xhtml":
return newXHTMLText(textType, content)
default:
return nil, fmt.Errorf("%v is not a valid text type", textType)
return nil
}
}

11
xhtmlDiv.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
)
@ -12,16 +11,12 @@ type XHTMLDiv struct {
Content string `xml:",innerxml"`
}
// NewXHTMLDiv creates a new XHTMLDiv. It returns a *XHTMLDiv and an error.
func NewXHTMLDiv(content string) (*XHTMLDiv, error) {
if content == "" {
return nil, errors.New("error creating new xhtml div: content string empty")
}
// 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,
}, nil
}
}
// Check checks the XHTMLDiv for incompatibilities with RFC4287. It returns an

13
xhtmlText.go
View File

@ -13,17 +13,12 @@ type XHTMLText struct {
// isText checks whether the XHTMLText is a Text. It returns a bool.
func (x *XHTMLText) isText() bool { return true }
// newPlainText creates a new PlainText. It returns a *PlainText and an error.
func newXHTMLText(textType, content string) (*XHTMLText, error) {
xhtmlDiv, err := NewXHTMLDiv(content)
if err != nil {
return nil, fmt.Errorf("error creating new xhtml text: %v", err)
}
// newPlainText creates a new PlainText. It returns a *PlainText.
func newXHTMLText(textType, content string) *XHTMLText {
return &XHTMLText{
Type: textType,
XHTMLDiv: xhtmlDiv,
}, nil
XHTMLDiv: NewXHTMLDiv(content),
}
}
// Check checks the XHTMLText for incompatibilities with RFC4287. It returns an