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

Unify error messages

Browse Source
This commit is contained in:
Jason Streifling 2024-10-18 19:04:08 +02:00
parent 411cd89b7c
commit d4e7bce5e2
20 changed files with 92 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
category.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
"html"
)
@ -29,17 +28,17 @@ func (c *Category) SetLabel(label string) {
// error.
func (c *Category) Check() error {
if c.Term == "" {
return errors.New("term attribute of category empty")
return fmt.Errorf("term attribute of category %v empty", c)
}
if c.Scheme != "" {
if !isValidIRI(c.Scheme) {
return fmt.Errorf("scheme attribute %v of category not correctly formatted", c.Scheme)
return fmt.Errorf("scheme attribute of category %v not correctly formatted", c)
}
}
if !isCorrectlyEscaped(c.Label) {
return fmt.Errorf("label attribute %v of category not correctly escaped", c.Label)
return fmt.Errorf("label attribute of category %v not correctly escaped", c)
}
return nil

4
commonAttributes.go
View File

@ -1,8 +1,6 @@
package atom
import (
"encoding/xml"
)
import "encoding/xml"
type CommonAttributes struct {
Base IRI `xml:"base,attr,omitempty"`

4
content.go
View File

@ -1,8 +1,6 @@
package atom
import (
"fmt"
)
import "fmt"
const (
InlineText = iota

47
entry.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
"strings"
"time"
@ -40,16 +39,16 @@ func (e *Entry) checkAuthors(authorInFeed bool) error {
if e.Authors == nil {
if !authorInFeed {
if e.Source == nil {
return errors.New("no authors set in entry")
return fmt.Errorf("no authors set in entry %v", e)
}
if e.Source.Authors == nil {
return errors.New("no authors set in entry")
return fmt.Errorf("no authors set in entry %v", e)
}
}
} else {
for i, a := range e.Authors {
if err := a.Check(); err != nil {
return fmt.Errorf("author element %v of entry: %v", i, err)
return fmt.Errorf("author element %v of entry %v: %v", i, e, err)
}
}
}
@ -140,72 +139,72 @@ func (e *Entry) AddExtension(x *ExtensionElement) {
// error.
func (e *Entry) Check() error {
if e.ID == nil {
return errors.New("no id element of entry")
return fmt.Errorf("no id element of entry %v", e)
} else {
if err := e.ID.Check(); err != nil {
return fmt.Errorf("id element of entry: %v", err)
return fmt.Errorf("id element of entry %v: %v", e, err)
}
}
if err := e.checkAuthors(true); err != nil {
return fmt.Errorf("entry %v: %v", e.ID.URI, err)
return fmt.Errorf("entry %v: %v", e, err)
}
for i, c := range e.Categories {
if err := c.Check(); err != nil {
return fmt.Errorf("category element %v of entry %v: %v", i, e.ID.URI, err)
return fmt.Errorf("category element %v of entry %v: %v", i, e, err)
}
}
if e.Content != nil {
if err := e.Content.Check(); err != nil {
return fmt.Errorf("content element of entry %v: %v", e.ID.URI, err)
return fmt.Errorf("content element of entry %v: %v", e, err)
}
} else {
// atom:entry elements that contain no child atom:content element MUST
// contain at least one atom:link element with a rel attribute value of
// "alternate".
if !alternateRelExists(e.Links) {
return errors.New("no content element of entry %v and no link element with rel \"alternate\"")
return fmt.Errorf("no content element of entry %v and no link element with rel \"alternate\"", e)
}
}
for i, c := range e.Contributors {
if err := c.Check(); err != nil {
return fmt.Errorf("contributor element %v of entry %v: %v", i, e.ID.URI, err)
return fmt.Errorf("contributor element %v of entry %v: %v", i, e, err)
}
}
for i, l := range e.Links {
if err := l.Check(); err != nil {
return fmt.Errorf("link element %v of entry %v: %v", i, e.ID.URI, err)
return fmt.Errorf("link element %v of entry %v: %v", i, e, err)
}
}
if hasAlternateDuplicateLinks(e.Links) {
return fmt.Errorf("links with with a rel attribute value of \"alternate\" and duplicate type and hreflang attribute values found in entry %v", e.ID.URI)
return fmt.Errorf("links with a rel attribute value of \"alternate\" and duplicate type and hreflang attribute values found in entry %v", e)
}
if e.Published != nil {
if err := e.Published.Check(); err != nil {
return fmt.Errorf("published element of entry %v: %v", e.ID.URI, err)
return fmt.Errorf("published element of entry %v: %v", e, err)
}
}
if e.Rights != nil {
if err := e.Rights.Check(); err != nil {
return fmt.Errorf("rights element of entry %v: %v", e.ID.URI, err)
return fmt.Errorf("rights element of entry %v: %v", e, err)
}
}
if e.Source != nil {
if err := e.Source.Check(); err != nil {
return fmt.Errorf("source element of entry %v: %v", e.ID.URI, err)
return fmt.Errorf("source element of entry %v: %v", e, err)
}
}
if e.Summary != nil {
if err := e.Summary.Check(); err != nil {
return fmt.Errorf("summary element of entry %v: %v", e.ID.URI, err)
return fmt.Errorf("summary element of entry %v: %v", e, err)
}
} else {
// atom:entry elements MUST contain an atom:summary element in either
@ -213,7 +212,7 @@ func (e *Entry) Check() error {
// the atom:entry contains an atom:content that has a "src" attribute
// (and is thus empty).
if e.Content.hasSRC() {
return fmt.Errorf("no summary element of entry %v but content of type out of line content", e.ID.URI)
return fmt.Errorf("no summary element of entry %v but content of type out of line content", e)
}
// the atom:entry contains content that is encoded in Base64; i.e., the
// "type" attribute of atom:content is a MIME media type [MIMEREG], but
@ -221,29 +220,29 @@ func (e *Entry) Check() error {
// does not end with "/xml" or "+xml".
mediaType := e.Content.getType()
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)
return fmt.Errorf("no summary element of entry %v but media type not xml", e)
}
}
if e.Title == nil {
return fmt.Errorf("no title element of entry %v", e.ID.URI)
return fmt.Errorf("no title element of entry %v", e)
} else {
if err := e.Title.Check(); err != nil {
return fmt.Errorf("title element of entry %v: %v", e.ID.URI, err)
return fmt.Errorf("title element of entry %v: %v", e, err)
}
}
if e.Updated == nil {
return fmt.Errorf("no updated element of entry %v", e.ID.URI)
return fmt.Errorf("no updated element of entry %v", e)
} else {
if err := e.Updated.Check(); err != nil {
return fmt.Errorf("updated element of entry %v: %v", e.ID.URI, err)
return fmt.Errorf("updated element of entry %v: %v", e, err)
}
}
for i, x := range e.Extensions {
if err := x.Check(); err != nil {
return fmt.Errorf("extension element %v of entry %v: %v", i, e.ID.URI, err)
return fmt.Errorf("extension element %v of entry %v: %v", i, e, err)
}
}

2
extensionElement.go
View File

@ -20,7 +20,7 @@ func NewExtensionElement(name string, value any) *ExtensionElement {
// returns an error.
func (e *ExtensionElement) Check() error {
if e.Value == nil {
return errors.New("value element of extension element empty")
return errors.New("value element of extension empty")
}
return nil

39
feed.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
"time"
)
@ -121,10 +120,10 @@ func (f *Feed) AddEntry(e *Entry) {
// error.
func (f *Feed) Check() error {
if f.ID == nil {
return errors.New("no id element of feed")
return fmt.Errorf("no id element of feed %v", f)
} else {
if err := f.ID.Check(); err != nil {
return fmt.Errorf("id element of feed: %v", err)
return fmt.Errorf("id element of feed %v: %v", f, err)
}
}
@ -134,93 +133,93 @@ func (f *Feed) Check() error {
if f.Authors == nil {
for _, e := range f.Entries {
if err := e.checkAuthors(false); err != nil {
return fmt.Errorf("no authors set in feed %v: %v", f.ID.URI, err)
return fmt.Errorf("no authors set in feed %v: %v", f, err)
}
}
} else {
for i, a := range f.Authors {
if err := a.Check(); err != nil {
return fmt.Errorf("author element %v of feed %v: %v", i, f.ID.URI, err)
return fmt.Errorf("author element %v of feed %v: %v", i, f, err)
}
}
}
for i, c := range f.Categories {
if err := c.Check(); err != nil {
return fmt.Errorf("category element %v of feed %v: %v", i, f.ID.URI, err)
return fmt.Errorf("category element %v of feed %v: %v", i, f, err)
}
}
for i, c := range f.Contributors {
if err := c.Check(); err != nil {
return fmt.Errorf("contributor element %v of feed %v: %v", i, f.ID.URI, err)
return fmt.Errorf("contributor element %v of feed %v: %v", i, f, err)
}
}
if f.Generator != nil {
if err := f.Generator.Check(); err != nil {
return fmt.Errorf("generator element of feed %v: %v", f.ID.URI, err)
return fmt.Errorf("generator element of feed %v: %v", f, err)
}
}
if f.Icon != nil {
if err := f.Icon.Check(); err != nil {
return fmt.Errorf("icon element of feed %v: %v", f.ID.URI, err)
return fmt.Errorf("icon element of feed %v: %v", f, err)
}
}
for i, l := range f.Links {
if err := l.Check(); err != nil {
return fmt.Errorf("link element %v of feed %v: %v", i, f.ID.URI, err)
return fmt.Errorf("link element %v of feed %v: %v", i, f, err)
}
}
if hasAlternateDuplicateLinks(f.Links) {
return fmt.Errorf("links with with a rel attribute value of \"alternate\" and duplicate type and hreflang attribute values found in feed %v", f.ID.URI)
return fmt.Errorf("links with a rel attribute value of \"alternate\" and duplicate type and hreflang attribute values found in feed %v", f)
}
if f.Logo != nil {
if err := f.Logo.Check(); err != nil {
return fmt.Errorf("logo element of feed %v: %v", f.ID.URI, err)
return fmt.Errorf("logo element of feed %v: %v", f, err)
}
}
if f.Rights != nil {
if err := f.Rights.Check(); err != nil {
return fmt.Errorf("rights element of feed %v: %v", f.ID.URI, err)
return fmt.Errorf("rights element of feed %v: %v", f, err)
}
}
if f.Subtitle != nil {
if err := f.Subtitle.Check(); err != nil {
return fmt.Errorf("subtitle element of feed %v: %v", f.ID.URI, err)
return fmt.Errorf("subtitle element of feed %v: %v", f, err)
}
}
if f.Title == nil {
return fmt.Errorf("no title element of feed %v", f.ID.URI)
return fmt.Errorf("no title element of feed %v", f)
} else {
if err := f.Title.Check(); err != nil {
return fmt.Errorf("title element of feed %v: %v", f.ID.URI, err)
return fmt.Errorf("title element of feed %v: %v", f, err)
}
}
if f.Updated == nil {
return fmt.Errorf("no updated element of feed %v", f.ID)
return fmt.Errorf("no updated element of feed %v", f)
} else {
if err := f.Updated.Check(); err != nil {
return fmt.Errorf("updated element of feed %v: %v", f.ID.URI, err)
return fmt.Errorf("updated element of feed %v: %v", f, err)
}
}
for i, x := range f.Extensions {
if err := x.Check(); err != nil {
return fmt.Errorf("extension element %v of feed %v: %v", i, f.ID.URI, err)
return fmt.Errorf("extension element %v of feed %v: %v", i, f, err)
}
}
for i, n := range f.Entries {
if err := n.Check(); err != nil {
return fmt.Errorf("entry element %v of feed %v: %v", i, f.ID.URI, err)
return fmt.Errorf("entry element %v of feed %v: %v", i, f, err)
}
}

7
generator.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
"html"
)
@ -25,16 +24,16 @@ func NewGenerator(text string) *Generator {
func (g *Generator) Check() error {
if g.URI != "" {
if !isValidIRI(g.URI) {
return fmt.Errorf("uri attribute %v of generator not correctly formatted", g.URI)
return fmt.Errorf("uri attribute of generator %v not correctly formatted", g)
}
}
if g.Text == "" {
return errors.New("text element of generator empty")
return fmt.Errorf("text element of generator %v empty", g)
}
if !isCorrectlyEscaped(g.Text) {
return fmt.Errorf("text element %v of generator not correctly escaped", g.Text)
return fmt.Errorf("text element of generator %v not correctly escaped", g)
}
return nil

2
icon.go
View File

@ -28,7 +28,7 @@ func (i *Icon) Check() error {
return errors.New("uri element of icon empty")
} else {
if !isValidIRI(i.URI) {
return fmt.Errorf("uri attribute %v of icon not correctly formatted", i.URI)
return fmt.Errorf("uri attribute of icon %v not correctly formatted", i)
}
}

2
id.go
View File

@ -27,7 +27,7 @@ func (i *ID) Check() error {
return errors.New("uri element of id empty")
} else {
if !isValidIRI(i.URI) {
return fmt.Errorf("uri element %v of id not correctly formatted", i.URI)
return fmt.Errorf("uri element of id %v not correctly formatted", i)
}
}

3
inlineOtherContent.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
"mime"
)
@ -45,7 +44,7 @@ func (i *InlineOtherContent) Check() error {
}
if isCompositeMediaType(mediaType) {
return errors.New("type attribute of inline other content must not be a composite type")
return fmt.Errorf("type attribute of inline other content %v must not be a composite type", i)
}
return nil

3
inlineTextContent.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
)
@ -43,7 +42,7 @@ func (i *InlineTextContent) getType() string { return i.Type }
// returns an error.
func (i *InlineTextContent) Check() error {
if i.Type != "" && i.Type != "text" && i.Type != "html" {
return errors.New("type attribute of inline text content must be text or html if not omitted")
return fmt.Errorf("type attribute of inline text content %v must be text or html if not omitted", i)
}
return nil

5
inlineXHTMLContent.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
)
@ -43,11 +42,11 @@ func (i *InlineXHTMLContent) getType() string { return i.Type }
// returns an error.
func (i *InlineXHTMLContent) Check() error {
if i.Type != "xhtml" {
return errors.New("type attribute of inline xhtml content must be xhtml")
return fmt.Errorf("type attribute of inline xhtml content %v must be xhtml", i)
}
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 fmt.Errorf("xhtml div element of inline xhtml content %v: %v", i, err)
}
return nil

11
link.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
"strings"
)
@ -27,28 +26,28 @@ func NewLink(href string) *Link {
// error.
func (l *Link) Check() error {
if l.Href == "" {
return errors.New("href attribute of link empty")
return fmt.Errorf("href attribute of link %v empty", l)
} else {
if !isValidIRI(l.Href) {
return fmt.Errorf("href attribute %v of link not correctly formatted", l.Href)
return fmt.Errorf("href attribute of link %v not correctly formatted", l)
}
}
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)
return fmt.Errorf("rel attribute of link %v not correctly formatted", l)
}
}
if l.Type != "" {
if !isValidMediaType(string(l.Type)) {
return fmt.Errorf("type attribute %v of link %v invalid media type", l.Type, l.Href)
return fmt.Errorf("type attribute of link %v invalid media type", l)
}
}
if l.HrefLang != "" {
if !isValidLanguageTag(l.HrefLang) {
return fmt.Errorf("hreflang attribute %v of link %v invalid language tag", l.Type, l.HrefLang)
return fmt.Errorf("hreflang attribute of link %v invalid language tag", l)
}
}

5
logo.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
)
@ -25,10 +24,10 @@ func NewLogo(uri IRI) (*Logo, error) {
// error.
func (l *Logo) Check() error {
if l.URI == "" {
return errors.New("uri element of logo empty")
return fmt.Errorf("uri element of logo %v empty", l)
} else {
if !isValidIRI(l.URI) {
return fmt.Errorf("uri element %v of logo not correctly formatted", l.URI)
return fmt.Errorf("uri element of logo %v not correctly formatted", l)
}
}

7
outOfLineContent.go
View File

@ -2,7 +2,6 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
"mime"
)
@ -27,7 +26,7 @@ func newOutOfLineContent(mediaType string, content any) (*OutOfLineContent, erro
}
if !isValidIRI(iri) {
return nil, errors.New("content not a valid uri")
return nil, fmt.Errorf("content %v not a valid uri", iri)
}
return &OutOfLineContent{Type: MediaType(mediaType), SRC: iri}, nil
@ -54,11 +53,11 @@ func (o *OutOfLineContent) Check() error {
}
if isCompositeMediaType(mediaType) {
return errors.New("type attribute of out of line content must not be a composite type")
return fmt.Errorf("type attribute of out of line content %v must not be a composite type", o)
}
if o.SRC == "" {
return errors.New("src attribute of out of line content empty")
return fmt.Errorf("src attribute of out of line content %v empty", o)
}
return nil

9
person.go
View File

@ -1,7 +1,6 @@
package atom
import (
"errors"
"fmt"
"net/mail"
)
@ -33,25 +32,25 @@ func (p *Person) AddExtension(e *ExtensionElement) {
// error.
func (p *Person) Check() error {
if p.Name == "" {
return errors.New("name element of person element empty")
return fmt.Errorf("name element of person %v empty", p)
}
if p.URI != "" {
if !isValidIRI(p.URI) {
return fmt.Errorf("uri element of person %v not correctly formatted", p.Name)
return fmt.Errorf("uri element of person %v not correctly formatted", p)
}
}
if p.Email != "" {
if _, err := mail.ParseAddress(string(p.Email)); err != nil {
return fmt.Errorf("email element of person %v not correctly formatted", p.Name)
return fmt.Errorf("email element of person %v not correctly formatted", p)
}
}
if p.Extensions != nil {
for i, e := range p.Extensions {
if err := e.Check(); err != nil {
return fmt.Errorf("extension element %v of person %v: %v", i, p.Name, err)
return fmt.Errorf("extension element %v of person %v: %v", i, p, err)
}
}
}

8
plainText.go
View File

@ -1,6 +1,6 @@
package atom
import "errors"
import "fmt"
type PlainText struct {
*CommonAttributes
@ -15,15 +15,15 @@ func (p *PlainText) isText() bool { return true }
// error.
func (p *PlainText) Check() error {
if p.Type != "" && p.Type != "text" && p.Type != "html" {
return errors.New("type attribute of plain text must be text or html if not omitted")
return fmt.Errorf("type attribute of plain text %v must be text or html if not omitted", p)
}
if p.Type == "html" && !isCorrectlyEscaped(p.Text) {
return errors.New("text element of plain text not correctly escaped")
return fmt.Errorf("text element of plain text %v not correctly escaped", p)
}
if p.Text == "" {
return errors.New("text element of plain text empty")
return fmt.Errorf("text element of plain text %v empty", p)
}
return nil

26
source.go
View File

@ -28,79 +28,79 @@ type Source struct {
func (s *Source) Check() error {
for i, a := range s.Authors {
if err := a.Check(); err != nil {
return fmt.Errorf("author element %v of source %v: %v", i, s.ID.URI, err)
return fmt.Errorf("author element %v of source %v: %v", i, s, err)
}
}
for i, c := range s.Categories {
if err := c.Check(); err != nil {
return fmt.Errorf("category element %v of source %v: %v", i, s.ID.URI, err)
return fmt.Errorf("category element %v of source %v: %v", i, s, err)
}
}
for i, c := range s.Contributors {
if err := c.Check(); err != nil {
return fmt.Errorf("contributor element %v of source %v: %v", i, s.ID.URI, err)
return fmt.Errorf("contributor element %v of source %v: %v", i, s, err)
}
}
if s.Generator != nil {
if err := s.Generator.Check(); err != nil {
return fmt.Errorf("generator element of source %v: %v", s.ID.URI, err)
return fmt.Errorf("generator element of source %v: %v", s, err)
}
}
if s.Icon != nil {
if err := s.Icon.Check(); err != nil {
return fmt.Errorf("icon element of source %v: %v", s.ID.URI, err)
return fmt.Errorf("icon element of source %v: %v", s, err)
}
}
if s.ID != nil {
if err := s.ID.Check(); err != nil {
return fmt.Errorf("id element of source %v: %v", s.ID.URI, err)
return fmt.Errorf("id element of source %v: %v", s, err)
}
}
for i, l := range s.Links {
if err := l.Check(); err != nil {
return fmt.Errorf("link element %v of source %v: %v", i, s.ID.URI, err)
return fmt.Errorf("link element %v of source %v: %v", i, s, err)
}
}
if s.Logo != nil {
if err := s.Logo.Check(); err != nil {
return fmt.Errorf("logo element of source %v: %v", s.ID.URI, err)
return fmt.Errorf("logo element of source %v: %v", s, err)
}
}
if s.Rights != nil {
if err := s.Rights.Check(); err != nil {
return fmt.Errorf("rights element of source %v: %v", s.ID.URI, err)
return fmt.Errorf("rights element of source %v: %v", s, err)
}
}
if s.Subtitle != nil {
if err := s.Subtitle.Check(); err != nil {
return fmt.Errorf("subtitle element of source %v: %v", s.ID.URI, err)
return fmt.Errorf("subtitle element of source %v: %v", s, err)
}
}
if s.Title != nil {
if err := s.Title.Check(); err != nil {
return fmt.Errorf("title element of source %v: %v", s.ID.URI, err)
return fmt.Errorf("title element of source %v: %v", s, err)
}
}
if s.Updated != nil {
if err := s.Updated.Check(); err != nil {
return fmt.Errorf("updated element of source %v: %v", s.ID.URI, err)
return fmt.Errorf("updated element of source %v: %v", s, err)
}
}
for i, e := range s.Extensions {
if err := e.Check(); err != nil {
return fmt.Errorf("extension element %v of source %v: %v", i, s.ID.URI, err)
return fmt.Errorf("extension element %v of source %v: %v", i, s, err)
}
}

4
xhtmlDiv.go
View File

@ -2,7 +2,7 @@ package atom
import (
"encoding/xml"
"errors"
"fmt"
)
type XHTMLDiv struct {
@ -23,7 +23,7 @@ func NewXHTMLDiv(content string) *XHTMLDiv {
// 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 fmt.Errorf("xmlns attribute of xhtml text %v must be http://www.w3.org/1999/xhtml", x)
}
return nil

7
xhtmlText.go
View File

@ -1,9 +1,6 @@
package atom
import (
"errors"
"fmt"
)
import "fmt"
type XHTMLText struct {
*CommonAttributes
@ -18,7 +15,7 @@ func (x *XHTMLText) isText() bool { return true }
// error.
func (x *XHTMLText) Check() error {
if x.Type != "xhtml" {
return errors.New("type attribute of xhtml text must be xhtml")
return fmt.Errorf("type attribute of xhtml text %v must be xhtml", x)
}
if err := x.XHTMLDiv.Check(); err != nil {