look for href and src attributes in a and img tags

Signed-off-by: Adrien Duermael <adrien@duermael.com>

tests/src/validator/html_test.go

@@ -0,0 +1,130 @@
+package main
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "golang.org/x/net/html"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+)
+
+var countLinks = 0
+var countImages = 0
+
+// TestURLs tests if we're not using absolute paths for URLs
+// when pointing to local pages.
+func TestURLs(t *testing.T) {
+ count := 0
+
+ filepath.Walk("/usr/src/app/allvbuild", func(path string, info os.FileInfo, err error) error {
+
+ relPath := strings.TrimPrefix(path, "/usr/src/app/allvbuild")
+
+ if err != nil {
+ t.Error(err.Error(), "-", relPath)
+ }
+ b, htmlBytes, err := isHTML(path)
+ if err != nil {
+ t.Error(err.Error(), "-", relPath)
+ }
+ // don't check non-html files
+ if b == false {
+ return nil
+ }
+
+ count++
+
+ err = testURLs(htmlBytes)
+ if err != nil {
+ t.Error(err.Error(), "-", relPath)
+ }
+ return nil
+ })
+
+ fmt.Println("found", count, "html files")
+ fmt.Println("found", countLinks, "links")
+ fmt.Println("found", countImages, "images")
+}
+
+// testURLs tests if we're not using absolute paths for URLs
+// when pointing to local pages.
+func testURLs(htmlBytes []byte) error {
+
+ reader := bytes.NewReader(htmlBytes)
+
+ z := html.NewTokenizer(reader)
+
+ for {
+ tt := z.Next()
+
+ switch tt {
+ case html.ErrorToken:
+ // End of the document, we're done
+ return nil
+ case html.StartTagToken:
+ t := z.Token()
+ // check tag types
+ switch t.Data {
+ case "a":
+ countLinks++
+ ok, _ := getHref(t)
+ // skip, it may just be an anchor
+ if !ok {
+ break
+ }
+
+ case "img":
+ countImages++
+ ok, _ := getSrc(t)
+ if !ok {
+ return errors.New("img with no src: " + t.String())
+ }
+ }
+ }
+ }
+
+ // _, md, err := frontparser.ParseFrontmatterAndContent(mdBytes)
+ // if err != nil {
+ // return err
+ // }
+
+ // regularExpression, err := regexp.Compile(`\[[^\]]+\]\(([^\)]+)\)`)
+ // if err != nil {
+ // return err
+ // }
+
+ // submatches := regularExpression.FindAllStringSubmatch(string(md), -1)
+
+ // for _, submatch := range submatches {
+ // if strings.Contains(submatch[1], "docs.docker.com") {
+ // return errors.New("found absolute link (" + strings.TrimSpace(submatch[1]) + ")")
+ // }
+ // }
+
+ return nil
+}
+
+// helpers
+
+func getHref(t html.Token) (ok bool, href string) {
+ for _, a := range t.Attr {
+ if a.Key == "href" {
+ href = a.Val
+ ok = true
+ }
+ }
+ return
+}
+
+func getSrc(t html.Token) (ok bool, src string) {
+ for _, a := range t.Attr {
+ if a.Key == "src" {
+ src = a.Val
+ ok = true
+ }
+ }
+ return
+}

tests/src/validator/markdown_test.go

@@ -3,11 +3,8 @@ package main
 import (
  "errors"
  "github.com/gdevillele/frontparser"
- "io/ioutil"
  "os"
  "path/filepath"
- "regexp"
- "strings"
  "testing"
 )
 
@@ -89,83 +86,3 @@ func testFrontMatterKeywords(mdBytes []byte) error {
 
  return nil
 }
-
-// TestURLs tests if we're not using absolute paths for URLs
-// when pointing to local pages.
-func TestURLs(t *testing.T) {
- filepath.Walk("/docs", func(path string, info os.FileInfo, err error) error {
- if err != nil {
- t.Error(err.Error(), "-", path)
- }
- published, mdBytes, err := isPublishedMarkdown(path)
- if err != nil {
- t.Error(err.Error(), "-", path)
- }
- if published == false {
- return nil
- }
- err = testURLs(mdBytes)
- if err != nil {
- t.Error(err.Error(), "-", path)
- }
- return nil
- })
-}
-
-// testURLs tests if we're not using absolute paths for URLs
-// when pointing to local pages.
-func testURLs(mdBytes []byte) error {
- _, md, err := frontparser.ParseFrontmatterAndContent(mdBytes)
- if err != nil {
- return err
- }
-
- regularExpression, err := regexp.Compile(`\[[^\]]+\]\(([^\)]+)\)`)
- if err != nil {
- return err
- }
-
- submatches := regularExpression.FindAllStringSubmatch(string(md), -1)
-
- for _, submatch := range submatches {
- if strings.Contains(submatch[1], "docs.docker.com") {
- return errors.New("found absolute link (" + strings.TrimSpace(submatch[1]) + ")")
- }
- }
-
- return nil
-}
-
-//-----------------
-// utils
-//-----------------
-
-// isPublishedMarkdown returns wether a file is a published markdown or not
-// as a convenience it also returns the markdown bytes to avoid reading files twice
-func isPublishedMarkdown(path string) (bool, []byte, error) {
- if strings.HasSuffix(path, ".md") {
- fileBytes, err := ioutil.ReadFile(path)
- if err != nil {
- return false, nil, err
- }
- if frontparser.HasFrontmatterHeader(fileBytes) {
- fm, _, err := frontparser.ParseFrontmatterAndContent(fileBytes)
- if err != nil {
- return false, nil, err
- }
- // skip markdowns that are not published
- if published, exists := fm["published"]; exists {
- if publishedBool, ok := published.(bool); ok {
- if publishedBool {
- // file is markdown, has frontmatter and is published
- return true, fileBytes, nil
- }
- }
- } else {
- // if "published" field is missing, it means published == true
- return true, fileBytes, nil
- }
- }
- }
- return false, nil, nil
-}

tests/src/validator/utils.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+ "github.com/gdevillele/frontparser"
+ "io/ioutil"
+ "os"
+ "strings"
+)
+
+// isPublishedMarkdown returns wether a file is a published markdown or not
+// as a convenience it also returns the markdown bytes to avoid reading files twice
+func isPublishedMarkdown(path string) (bool, []byte, error) {
+ if strings.HasSuffix(path, ".md") {
+ fileBytes, err := ioutil.ReadFile(path)
+ if err != nil {
+ return false, nil, err
+ }
+ if frontparser.HasFrontmatterHeader(fileBytes) {
+ fm, _, err := frontparser.ParseFrontmatterAndContent(fileBytes)
+ if err != nil {
+ return false, nil, err
+ }
+ // skip markdowns that are not published
+ if published, exists := fm["published"]; exists {
+ if publishedBool, ok := published.(bool); ok {
+ if publishedBool {
+ // file is markdown, has frontmatter and is published
+ return true, fileBytes, nil
+ }
+ }
+ } else {
+ // if "published" field is missing, it means published == true
+ return true, fileBytes, nil
+ }
+ }
+ }
+ return false, nil, nil
+}
+
+// isHTML returns wether a file is an html file or not
+// as a convenience it also returns the markdown bytes to avoid reading files twice
+func isHTML(path string) (bool, []byte, error) {
+ if strings.HasSuffix(path, ".html") {
+ fileBytes, err := ioutil.ReadFile(path)
+ if err != nil {
+ return false, nil, err
+ }
+ return true, fileBytes, nil
+ }
+ return false, nil, nil
+}
+
+// fileExists returns true if the given file exists
+func fileExists(name string) bool {
+ _, err := os.Stat(name)
+ return err == nil
+}