Updated parser to return similar named errors as in

https://url.spec.whatwg.org/commit-snapshots/eee49fdf4f99d59f717cbeb0bce29fda930196d4/#writing

canonicalizer/canonicalizer.go

@@ -49,7 +49,7 @@ type profile struct {
 func (p *profile) Parse(rawUrl string) (*url.Url, error) {
  u, err := p.Parser.Parse(rawUrl)
  if err != nil {
- if errors.Code(err) == errors.FailRelativeUrlWithNoBase && p.defaultScheme != "" {
+ if errors.Type(err) == errors.MissingSchemeNonRelativeURL && p.defaultScheme != "" {
  rawUrl = p.defaultScheme + "://" + rawUrl
  u, err = p.Parser.Parse(rawUrl)
  }
@@ -64,7 +64,7 @@ func (p *profile) Parse(rawUrl string) (*url.Url, error) {
 func (p *profile) ParseRef(rawUrl, ref string) (*url.Url, error) {
  b, err := p.Parser.Parse(rawUrl)
  if err != nil {
- if errors.Code(err) == errors.FailRelativeUrlWithNoBase && p.defaultScheme != "" {
+ if errors.Type(err) == errors.MissingSchemeNonRelativeURL && p.defaultScheme != "" {
  rawUrl = p.defaultScheme + "://" + rawUrl
  b, err = p.Parser.Parse(rawUrl)
  }

errors/codes.go

@@ -16,65 +16,45 @@
 
 package errors
 
-import (
- "fmt"
-)
-
-// ErrorCode is data type of error codes for different kind of errors
-type ErrorCode int32
+type ErrorType string
 
-// Validation errors
+// IDNA errors
 const (
- IllegalCodePoint ErrorCode = iota + 100
- InvalidPercentEncoding
- IllegalLeadingOrTrailingChar
- IllegalTabOrNewline
- AtInAuthority
- IllegalSlashes
- IllegalLocalFileAndHostCombo
- BadWindowsDriveLetter
- IllegalIPv4Address
- IllegalIPv6Address
- CouldNotDecodeHost
+ DomainToASCII ErrorType = "Unicode ToASCII records an error or returns the empty string"
+ DomainToUnicode ErrorType = "Unicode ToUnicode records an error"
 )
 
-// Validation failures
+// Host parsing errors
 const (
- FailIllegalCodePoint ErrorCode = iota + 500
- FailIllegalScheme
- FailRelativeUrlWithNoBase
- FailMissingHost
- FailIllegalHost
- FailIllegalPort
+ DomainInvalidCodePoint ErrorType = "The host contains a forbidden domain code point"
+ HostInvalidCodePoint ErrorType = "An opaque host (in a URL that is not special) contains a forbidden host code point"
+ IPv4EmptyPart ErrorType = "An IPv4 address ends with a U+002E (.)"
+ IPv4TooManyParts ErrorType = "An IPv4 address has more than four parts"
+ IPv4NonNumericPart ErrorType = "An IPv4 address contains a non-numeric part"
+ IPv4NonDecimalPart ErrorType = "The IPv4 address contains numbers expressed using hexadecimal or octal digits"
+ IPv4OutOfRangePart ErrorType = "An IPv4 address contains a part that is greater than 255"
+ IPv6Unclosed ErrorType = "An IPv6 address is missing the closing U+005D (])"
+ IPv6InvalidCompression ErrorType = "An IPv6 address begins with improper compression"
+ IPv6TooManyPieces ErrorType = "An IPv6 address has more than eight pieces"
+ IPv6MultipleCompression ErrorType = "An IPv6 address contains multiple instances of '::'"
+ IPv6InvalidCodePoint ErrorType = "An IPv6 address contains a code point that is neither an ASCII hex digit nor a U+003A (:). Or it unexpectedly ends"
+ IPv6TooFewPieces ErrorType = "An uncompressed IPv6 address contains fewer than 8 pieces"
+ IPv4InIPv6TooManyPieces ErrorType = "An IPv4 address is found in an IPv6 address, but the IPv6 address has more than 6 pieces"
+ IPv4InIPv6InvalidCodePoint ErrorType = "An IPv4 address is found in an IPv6 address and one of the following is true: 1. An IPv4 part is empty or contains a non-ASCII digit. 2. An IPv4 part contains a leading 0. 3. There are too many IPv4 parts"
+ IPv4InIPv6OutOfRangePart ErrorType = "An IPv4 address is found in an IPv6 address and one of the IPv4 parts is greater than 255"
+ IPv4InIPv6TooFewParts ErrorType = "An IPv4 address is found in an IPv6 address and there are too few IPv4 parts"
 )
 
-func (e ErrorCode) String() string {
- return fmt.Sprintf("%d: %s", e, messages[e])
-}
-
-func (e ErrorCode) Int32() int32 {
- return int32(e)
-}
-
-var messages = map[ErrorCode]string{
- // Validation errors
- IllegalCodePoint: "illegal code point",
- InvalidPercentEncoding: "invalid percent encoding",
- IllegalLeadingOrTrailingChar: "illegal leading or trailing character",
- IllegalTabOrNewline: "illegal tab or newline",
- AtInAuthority: "'@' in authority",
- IllegalSlashes: "illegal combination of slashes",
- IllegalLocalFileAndHostCombo: "illegal combination of host and local file reference",
- BadWindowsDriveLetter: "badly formatted windows drive letter",
- IllegalIPv4Address: "illegal IPv4 address",
- IllegalIPv6Address: "illegal IPv6 address",
- CouldNotDecodeHost: "could not decode host",
-
- // Validation failures
- FailIllegalCodePoint: "illegal code point",
- FailIllegalScheme: "illegal scheme",
- FailRelativeUrlWithNoBase: "relative url with missing or invalid base url",
- FailMissingHost: "missing host",
- FailIllegalHost: "illegal host",
- FailIllegalPort: "illegal port",
-}
+// URL parsing errors
+const (
+ InvalidURLUnit ErrorType = "A code point is found that is not a URL unit"
+ SpecialSchemeMissingFollowingSolidus ErrorType = "The input’s scheme is not followed by '//'"
+ MissingSchemeNonRelativeURL ErrorType = "The input is missing a scheme, because it does not begin with an ASCII alpha, and either no base URL was provided or the base URL cannot be used as a base URL because it has an opaque path"
+ InvalidReverseSolidus ErrorType = "The URL has a special scheme and it uses U+005C (\\) instead of U+002F (/)"
+ InvalidCredentials ErrorType = "The input includes credentials"
+ HostMissing ErrorType = "The input has a special scheme, but does not contain a host"
+ PortOutOfRange ErrorType = "The input's port is outside the range [0-65535]"
+ PortInvalid ErrorType = "The input's port is not a number"
+ FileInvalidWindowsDriveLetter ErrorType = "The input is a relative-URL string that starts with a Windows drive letter and the base URL’s scheme is 'file'"
+ FileInvalidWindowsDriveLetterHost ErrorType = "A file: URL’s host is a Windows drive letter"
+)

errors/errors.go

@@ -20,21 +20,22 @@ import (
  "fmt"
 )
 
-// UrlError is the struct of url error
-type UrlError struct {
- code ErrorCode
- descr string
- url string
- cause error // the root cause for this error
+// ValidationError indicates that the url is not valid
+type ValidationError struct {
+ errorType ErrorType
+ cause error // the root cause for this error
+ descr string // description of the error
+ failure bool // true if the error is a failure, false if it is a warning
+ url string
 }
 
-func (e *UrlError) Error() string {
- errMsg := fmt.Sprintf("Error: %s", e.code)
+func (e *ValidationError) Error() string {
+ errMsg := fmt.Sprintf("Error: %s", e.errorType)
  if e.descr != "" {
- errMsg += fmt.Sprintf(" '%s'", e.descr)
+ errMsg += fmt.Sprintf(": '%s'", e.descr)
  }
  if e.url != "" {
- errMsg += fmt.Sprintf(", Url: %s", e.url)
+ errMsg += fmt.Sprintf(". Url: '%s'", e.url)
  }
  if nil == e.cause {
  return errMsg
@@ -43,29 +44,42 @@ func (e *UrlError) Error() string {
  return errMsg + ", Cause: " + e.cause.Error()
 }
 
-func (e *UrlError) Unwrap() error {
+// Unwrap returns the root cause for this error
+func (e *ValidationError) Unwrap() error {
  return e.cause
 }
 
-func (e *UrlError) Code() ErrorCode {
- return e.code
+// Type returns the error type
+func (e *ValidationError) Type() ErrorType {
+ return e.errorType
 }
 
-func (e *UrlError) Url() string {
+// Url returns the url causing the error
+func (e *ValidationError) Url() string {
  return e.url
 }
 
-// Code returns the error code
-func Code(err error) ErrorCode {
- type coder interface {
- Code() ErrorCode
+// Failure returns true if the error is a failure, false if it is a warning
+func (e *ValidationError) Failure() bool {
+ return e.failure
+}
+
+// Description returns the error description
+func (e *ValidationError) Description() string {
+ return e.descr
+}
+
+// Type returns the error type
+func Type(err error) ErrorType {
+ type typer interface {
+ Type() ErrorType
  }
 
- cd, ok := err.(coder)
+ cd, ok := err.(typer)
  if !ok {
- return 0
+ return ""
  }
- return cd.Code()
+ return cd.Type()
 }
 
 // Description returns the error description
@@ -94,38 +108,56 @@ func Url(err error) string {
  return m.Url()
 }
 
+// Failure returns true if the error is a failure, false if it is a warning.
+// If the error does not implement the Failure() method, true is returned
+func Failure(err error) bool {
+ type failure interface {
+ Failure() bool
+ }
+
+ m, ok := err.(failure)
+ if !ok {
+ return true
+ }
+ return m.Failure()
+}
+
 // Error constructs a new error
-func Error(code ErrorCode, url string) error {
- return &UrlError{
- code: code,
- url: url,
+func Error(errorType ErrorType, url string, failure bool) error {
+ return &ValidationError{
+ errorType: errorType,
+ url: url,
+ failure: failure,
  }
 }
 
 // ErrorWithDescr constructs a new error
-func ErrorWithDescr(code ErrorCode, descr string, url string) error {
- return &UrlError{
- code: code,
- descr: descr,
- url: url,
+func ErrorWithDescr(errorType ErrorType, descr string, url string, failure bool) error {
+ return &ValidationError{
+ errorType: errorType,
+ descr: descr,
+ url: url,
+ failure: failure,
  }
 }
 
 // Wrap wraps an error with an error code and url
-func Wrap(err error, code ErrorCode, url string) error {
- return &UrlError{
- code: code,
- url: url,
- cause: err,
+func Wrap(err error, errorType ErrorType, url string, failure bool) error {
+ return &ValidationError{
+ errorType: errorType,
+ url: url,
+ cause: err,
+ failure: failure,
  }
 }
 
 // WrapWithDescr wraps an error with an error code, url and a description
-func WrapWithDescr(err error, code ErrorCode, descr string, url string) error {
- return &UrlError{
- code: code,
- descr: descr,
- url: url,
- cause: err,
+func WrapWithDescr(err error, errorType ErrorType, descr string, url string, failure bool) error {
+ return &ValidationError{
+ errorType: errorType,
+ descr: descr,
+ url: url,
+ cause: err,
+ failure: failure,
  }
 }

errors/errors_test.go

@@ -22,22 +22,19 @@ import (
 )
 
 func TestError(t *testing.T) {
- type args struct {
- code ErrorCode
- url string
- }
  tests := []struct {
- name string
- code ErrorCode
- url string
+ name string
+ errorType ErrorType
+ url string
+ failure bool
  }{
- {"1", IllegalLeadingOrTrailingChar, "http://example.com\t"},
+ {"1", HostInvalidCodePoint, "http://example.com\t", false},
  }
  for _, tt := range tests {
  t.Run(tt.name, func(t *testing.T) {
- err := Error(tt.code, tt.url)
+ err := Error(tt.errorType, tt.url, false)
  fmt.Printf("Error: %s\n", err)
- fmt.Printf("Code: %s\n", Code(err))
+ fmt.Printf("Type: %s\n", Type(err))
  fmt.Printf("Url: %s\n", Url(err))
  //if err := Error(tt.args.code, tt.args.url); (err != nil) != tt.wantErr {
  // t.Errorf("Error() error = %v, wantErr %v", err, tt.wantErr)

url/errorhandler.go

@@ -20,16 +20,50 @@ import (
  "github.com/nlnwa/whatwg-url/errors"
 )
 
-func (p *parser) handleError(u *Url, code errors.ErrorCode) error {
+// handleError handles an error according to the options set for the parser
+func (p *parser) handleError(u *Url, errorType errors.ErrorType, failure bool) error {
+ e := errors.Error(errorType, u.inputUrl, failure)
  if p.opts.reportValidationErrors {
- u.validationErrors = append(u.validationErrors, errors.Error(code, u.inputUrl))
+ u.validationErrors = append(u.validationErrors, e)
  }
- if p.opts.failOnValidationError {
- return errors.Error(code, u.inputUrl)
+ if failure || p.opts.failOnValidationError {
+ return e
  }
  return nil
 }
 
-func (p *parser) handleFailure(u *Url, code errors.ErrorCode, err error) (*Url, error) {
- return nil, errors.Wrap(err, code, u.inputUrl)
+// handleErrorWithDescription handles an error according to the options set for the parser
+func (p *parser) handleErrorWithDescription(u *Url, errorType errors.ErrorType, failure bool, descr string) error {
+ e := errors.ErrorWithDescr(errorType, descr, u.inputUrl, failure)
+ if p.opts.reportValidationErrors {
+ u.validationErrors = append(u.validationErrors, e)
+ }
+ if failure || p.opts.failOnValidationError {
+ return e
+ }
+ return nil
+}
+
+// handleWrappedError handles an error according to the options set for the parser
+func (p *parser) handleWrappedError(u *Url, errorType errors.ErrorType, failure bool, cause error) error {
+ e := errors.Wrap(cause, errorType, u.inputUrl, failure)
+ if p.opts.reportValidationErrors {
+ u.validationErrors = append(u.validationErrors, e)
+ }
+ if failure || p.opts.failOnValidationError {
+ return e
+ }
+ return nil
+}
+
+// handleWrappedErrorWithDescription handles an error according to the options set for the parser
+func (p *parser) handleWrappedErrorWithDescription(u *Url, errorType errors.ErrorType, failure bool, cause error, descr string) error {
+ e := errors.WrapWithDescr(cause, errorType, descr, u.inputUrl, failure)
+ if p.opts.reportValidationErrors {
+ u.validationErrors = append(u.validationErrors, e)
+ }
+ if failure || p.opts.failOnValidationError {
+ return e
+ }
+ return nil
 }