htmlcheck

htmlcheck

simple, fast and easy HTML validator in Go

About The Project

htmlcheck is a lightweight and efficient Golang package designed to simplify the validation of HTML content in your Go applications. Whether you're working with complete HTML documents or HTML snippets, this package provides a straightforward interface to check the validity of your markup.

You can specify valid HTML tags, their attributes, and permissible attribute values, providing a comprehensive solution for HTML validation.

This package is a clone of htmlcheck package which has not been maintained for a long time

Table of Contents

• Installation
• Usage
• Examples
• Documentation
• Contributing
• License

Installation

go get github.com/anilsenay/htmlcheck

Usage

Explain how users can import and use your package in their Go projects. Include code snippets to demonstrate the basic usage.

package main

import (
	"fmt"
	"github.com/anilsenay/htmlcheck"
)

func main() {
	validator := htmlcheck.Validator{}

	validator.AddValidTag(htmlcheck.ValidTag{
		Name:  "a",
		Attrs: []htmlcheck.Attribute{
			{Name: "id"},
			{Name: "href", Value: &htmlcheck.AttributeValue{
				// valid regex for href attribute value
				Regex: "^(http(s|))://.*"
			}},
			{Name: "target", Value: &htmlcheck.AttributeValue{
				// valid values for target attribute value
				List: []string{"_target", "_blank"}
			}},
		},
		IsSelfClosing: false,
	})

	html := "<a href='http://hello.world'>Hello, World!</a>"
	errors := htmlcheck.Validate(html)
	if len(errors) == 0 {
		fmt.Println("HTML is not valid.")
	} else {
		fmt.Println("HTML is valid!")
	}
}

Examples

package main

import (
	"fmt"
	"github.com/anilsenay/htmlcheck"
)

func main() {
	validator := htmlcheck.Validator{}

	validLink := htmlcheck.ValidTag{
		Name:  "a",
		Attrs: []htmlcheck.Attribute{
			{Name: "id"},
			{Name: "href", Value: &htmlcheck.AttributeValue{Regex: "^(http(s|))://.*"}}, // valid regex for href attribute value
			{Name: "target", Value: &htmlcheck.AttributeValue{List: []string{"_target", "_blank"}}}, // valid values for target attribute value
		},
		IsSelfClosing: false,
	}

	validator.AddValidTag(validLink)

	// first check
	err := validator.ValidateHtmlString("<a href='http://google.com'>m</a>").Join()
	if err == nil {
		fmt.Println("ok")
	} else {
		fmt.Println(err)
	}

	// second check
	// notice the missing / in the second <a>:
	errors := validator.ValidateHtmlString("<a href='http://google.com'>m<a>")
	if len(errors) == 0 {
		fmt.Println("ok")
	} else {
		fmt.Println(errors)
	}
}

output:

ok
tag 'a' is not properly closed

Documentation

Error Handling

Validation function returns a slice of errors ([]error) as type of ValidationErrors.

errors := validator.ValidateHtmlString("<a href='http://google.com'>m<a>")
if len(errors) > 0 {
	fmt.Println("NOT valid")
}

You can join all errors as one by using Join() function:

err := validator.ValidateHtmlString("<a href='http://google.com'>m<a>").Join()
if err != nil {
	fmt.Println("NOT valid")
}

It will return after an error occurs

validator := htmlcheck.Validator{
	StopAfterFirstError: true,
}
errors := validator.ValidateHtmlString("<a href='http://google.com'>m<a>")
if len(errors) > 0 {
	err := errors[0] // its the only error
}

You can check type of errors:

var err error
for _, e := range validationErrors {
  switch v := e.(type) {
  case htmlcheck.ErrInvAttribute:
    err = errors.Join(err, fmt.Errorf("inv attr: '%s'", v.AttributeName))
  case htmlcheck.ErrInvAttributeValue:
    err = errors.Join(err, fmt.Errorf("inv attr val: '%s'", v.AttributeValue))
  case htmlcheck.ErrInvClosedBeforeOpened:
    err = errors.Join(err, fmt.Errorf("closed before opened: '%s'", v.TagName))
  case htmlcheck.ErrInvDuplicatedAttribute:
    err = errors.Join(err, fmt.Errorf("dup attr: '%s'", v.AttributeName))
  case htmlcheck.ErrInvTag:
    err = errors.Join(err, fmt.Errorf("inv tag: '%s'", v.TagName))
  case htmlcheck.ErrInvNotProperlyClosed:
    err = errors.Join(err, fmt.Errorf("not properly closed: '%s'", v.TagName))
  case htmlcheck.ErrInvEOF:
    err = errors.Join(err, fmt.Errorf("EOF"))
  default:
    err = errors.Join(err, fmt.Errorf("Validation error: '%s'", e.Error()))
  }
}

Register Callback

v.RegisterCallback(func(tagName string, attributeName string, value string, reason ErrorReason) error {
	if reason == InvTag || reason == InvAttribute {
		return fmt.Errorf("validation error: tag '%s', attr: %s", tagName, attributeName)
	}
	return nil
})

Validator Functions

validator := htmlcheck.Validator{}
validator.AddValidTag(ValidTag{
	Name:          "b",
	IsSelfClosing: false,
})

validator := htmlcheck.Validator{}
validator.AddValidTags([]*htmlcheck.ValidTag{
	{ Name: "div" },
	{ Name: "p" },
})

You can group attributes to use in valid tags by group name

validator := htmlcheck.Validator{}
// consider it should only accept http/https urls in some attributes in this example
httpRegex := &htmlcheck.AttributeValue{Regex: "^(http(s|))://.*"}
validator.AddGroup(&htmlcheck.TagGroup{
	Name:  "valid-links",
	Attrs: []htmlcheck.Attribute{
		{Name: "href", Value: httpRegex},
		{Name: "src", Value: httpRegex},
	},
})
validator.AddValidTag(htmlcheck.ValidTag{ Name: "a", Groups: []string{"valid-links"} })
validator.AddValidTag(htmlcheck.ValidTag{ Name: "img", Groups: []string{"valid-links"} })

Types

ValidTag

validator.AddValidTags([]*htmlcheck.ValidTag{
  { Name: "div", Attrs: []htmlcheck.Attribute{ {Name: "id"} } },
  { Name: "p", AttrStartsWith: "data-" },
  { Name: "a", AttrRegex: "^(data-).+" },
})

Attribute

validLink := htmlcheck.ValidTag{
  Name:  "a",
  Attrs: []htmlcheck.Attribute{
    {Name: "id"},
    {Name: "href", Value: &htmlcheck.AttributeValue{Regex: "^(http(s|))://.*"}}, // valid regex for href attribute value
    {Name: "target", Value: &htmlcheck.AttributeValue{List: []string{"_target", "_blank"}}}, // valid values for target attribute value
  },
}

AttributeValue

validLink := htmlcheck.ValidTag{
  Name:  "a",
  Attrs: []htmlcheck.Attribute{
    {Name: "id"},
    {Name: "href", Value: &htmlcheck.AttributeValue{Regex: "^(http(s|))://.*"}}, // valid regex for href attribute value
    {Name: "target", Value: &htmlcheck.AttributeValue{List: []string{"_target", "_blank"}}}, // valid values for target attribute value
  },
}

TagGroup

// consider it should only accept http/https urls in some attributes in this example
httpRegex := &htmlcheck.AttributeValue{Regex: "^(http(s|))://.*"}
validator.AddGroup(&htmlcheck.TagGroup{
  Name:  "valid-links",
  Attrs: []htmlcheck.Attribute{
    {Name: "href", Value: httpRegex}, 
    {Name: "src", Value: httpRegex},
  },
})

Error Types

Contributing

Anyone can contribute by opening issue or pull-request

License

Distributed under the GPL License. See LICENSE for more information.