go.dev/cmd/internal/site/site.go - website - Git at Google

 // Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // Package site implements generation of content for serving from go.dev.
 // It is meant to support a transition from being a Hugo-based web site
 // to being a site compatible with x/website.
 package site

 import (
 	"bytes"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"net/http"
 	"os"
 	"path"
 	"path/filepath"
 	"sort"
 	"strings"
 	"time"

 	"golang.org/x/website/go.dev/cmd/internal/html/template"
 	"gopkg.in/yaml.v3"
 )

 // A Site holds metadata about the entire site.
 type Site struct {
 	URL   string
 	Title string

 	pagesByID map[string]*page
 	dir       string
 	base      *template.Template
 }

 // Load loads and returns the site in the directory rooted at dir.
 func Load(dir string) (*Site, error) {
 	dir, err := filepath.Abs(dir)
 	if err != nil {
 		return nil, err
 	}
 	site := &Site{
 		dir:       dir,
 		pagesByID: make(map[string]*page),
 	}
 	if err := site.initTemplate(); err != nil {
 		return nil, err
 	}

 	// Read site config.
 	data, err := ioutil.ReadFile(site.file("_content/site.yaml"))
 	if err != nil {
 		return nil, err
 	}
 	if err := yaml.Unmarshal(data, &site); err != nil {
 		return nil, fmt.Errorf("parsing _content/site.yaml: %v", err)
 	}

 	// Load site pages from md files.
 	err = filepath.Walk(site.file("_content"), func(name string, info os.FileInfo, err error) error {
 		if err != nil {
 			return err
 		}
 		if strings.HasSuffix(name, ".md") {
 			_, err := site.loadPage(name[len(site.file("."))+1:])
 			return err
 		}
 		return nil
 	})
 	if err != nil {
 		return nil, fmt.Errorf("loading pages: %v", err)
 	}

 	// Now that all pages are loaded and set up, can render all.
 	// (Pages can refer to other pages.)
 	for _, p := range site.pagesByID {
 		if err := site.renderHTML(p); err != nil {
 			return nil, err
 		}
 	}

 	return site, nil
 }

 // file returns the full path to the named file within the site.
 func (site *Site) file(name string) string { return filepath.Join(site.dir, name) }

 // newPage returns a new page belonging to site.
 func (site *Site) newPage(short string) *page {
 	p := &page{
 		id:     short,
 		params: make(tPage),
 	}
 	site.pagesByID[p.id] = p
 	return p
 }

 // data parses the named yaml file and returns its structured data.
 func (site *Site) data(name string) (interface{}, error) {
 	data, err := ioutil.ReadFile(site.file("_content/" + name + ".yaml"))
 	if err != nil {
 		return nil, err
 	}
 	var d interface{}
 	if err := yaml.Unmarshal(data, &d); err != nil {
 		return nil, err
 	}
 	return d, nil
 }

 // pageByID returns the page with a given path.
 func (site *Site) pageByPath(path string) (tPage, error) {
 	p := site.pagesByID[strings.Trim(path, "/")]
 	if p == nil {
 		return nil, fmt.Errorf("no such page with path %q", path)
 	}
 	return p.params, nil
 }

 // pagesGlob returns the pages with IDs matching glob.
 func (site *Site) pagesGlob(glob string) ([]tPage, error) {
 	_, err := path.Match(glob, "")
 	if err != nil {
 		return nil, err
 	}
 	glob = strings.Trim(glob, "/")
 	var out []tPage
 	for _, p := range site.pagesByID {
 		if ok, _ := path.Match(glob, p.id); ok {
 			out = append(out, p.params)
 		}
 	}

 	sort.Slice(out, func(i, j int) bool {
 		return out[i]["Path"].(string) < out[j]["Path"].(string)
 	})
 	return out, nil
 }

 // newest returns the pages sorted newest first,
 // breaking ties by .linkTitle or else .title.
 func newest(pages []tPage) []tPage {
 	out := make([]tPage, len(pages))
 	copy(out, pages)

 	sort.Slice(out, func(i, j int) bool {
 		pi := out[i]
 		pj := out[j]
 		di, _ := pi["Date"].(time.Time)
 		dj, _ := pj["Date"].(time.Time)
 		if !di.Equal(dj) {
 			return di.After(dj)
 		}
 		ti, _ := pi["linkTitle"].(string)
 		tj, _ := pj["linkTitle"].(string)
 		if ti != tj {
 			return ti < tj
 		}
 		return false
 	})
 	return out
 }

 // Open returns the content to serve at the given path.
 // This function makes Site an http.FileServer, for easy HTTP serving.
 func (site *Site) Open(name string) (http.File, error) {
 	name = strings.TrimPrefix(name, "/")
 	switch ext := path.Ext(name); ext {
 	case ".css", ".jpeg", ".jpg", ".js", ".png", ".svg", ".txt":
 		if f, err := os.Open(site.file("_content/" + name)); err == nil {
 			return f, nil
 		}

 	case ".html":
 		id := strings.TrimSuffix(name, "/index.html")
 		if name == "index.html" {
 			id = ""
 		}
 		if p := site.pagesByID[id]; p != nil {
 			if redir, ok := p.params["redirect"].(string); ok {
 				s := fmt.Sprintf(redirectFmt, redir)
 				return &httpFile{strings.NewReader(s), int64(len(s))}, nil
 			}
 			return &httpFile{bytes.NewReader(p.html), int64(len(p.html))}, nil
 		}
 	}

 	if !strings.HasSuffix(name, ".html") {
 		if f, err := site.Open(name + "/index.html"); err == nil {
 			size, err := f.Seek(0, io.SeekEnd)
 			f.Close()
 			if err == nil {
 				return &httpDir{httpFileInfo{"index.html", size, false}, 0}, nil
 			}
 		}
 	}

 	return nil, &os.PathError{Op: "open", Path: name, Err: os.ErrNotExist}
 }

 type httpFile struct {
 	io.ReadSeeker
 	size int64
 }

 func (*httpFile) Close() error                 { return nil }
 func (f *httpFile) Stat() (os.FileInfo, error) { return &httpFileInfo{".", f.size, false}, nil }
 func (*httpFile) Readdir(count int) ([]os.FileInfo, error) {
 	return nil, fmt.Errorf("readdir not available")
 }

 const redirectFmt = `<!DOCTYPE html><html><head><title>%s</title><link rel="canonical" href="%[1]s"/><meta name="robots" content="noindex"><meta charset="utf-8" /><meta http-equiv="refresh" content="0; url=%[1]s" /></head></html>`

 type httpDir struct {
 	info httpFileInfo
 	off  int // 0 or 1
 }

 func (*httpDir) Close() error                   { return nil }
 func (*httpDir) Read([]byte) (int, error)       { return 0, fmt.Errorf("read not available") }
 func (*httpDir) Seek(int64, int) (int64, error) { return 0, fmt.Errorf("seek not available") }
 func (*httpDir) Stat() (os.FileInfo, error)     { return &httpFileInfo{".", 0, true}, nil }
 func (d *httpDir) Readdir(count int) ([]os.FileInfo, error) {
 	if count == 0 {
 		return nil, nil
 	}
 	if d.off > 0 {
 		return nil, io.EOF
 	}
 	d.off = 1
 	return []os.FileInfo{&d.info}, nil
 }

 type httpFileInfo struct {
 	name string
 	size int64
 	dir  bool
 }

 func (info *httpFileInfo) Name() string { return info.name }
 func (info *httpFileInfo) Size() int64  { return info.size }
 func (info *httpFileInfo) Mode() os.FileMode {
 	if info.dir {
 		return os.ModeDir | 0555
 	}
 	return 0444
 }
 func (info *httpFileInfo) ModTime() time.Time { return time.Time{} }
 func (info *httpFileInfo) IsDir() bool        { return info.dir }
 func (info *httpFileInfo) Sys() interface{}   { return nil }
	// Copyright 2021 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// Package site implements generation of content for serving from go.dev.
	// It is meant to support a transition from being a Hugo-based web site
	// to being a site compatible with x/website.
	package site

	import (
	"bytes"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	"path"
	"path/filepath"
	"sort"
	"strings"
	"time"

	"golang.org/x/website/go.dev/cmd/internal/html/template"
	"gopkg.in/yaml.v3"
	)

	// A Site holds metadata about the entire site.
	type Site struct {
	URL string
	Title string

	pagesByID map[string]*page
	dir string
	base *template.Template
	}

	// Load loads and returns the site in the directory rooted at dir.
	func Load(dir string) (*Site, error) {
	dir, err := filepath.Abs(dir)
	if err != nil {
	return nil, err
	}
	site := &Site{
	dir: dir,
	pagesByID: make(map[string]*page),
	}
	if err := site.initTemplate(); err != nil {
	return nil, err
	}

	// Read site config.
	data, err := ioutil.ReadFile(site.file("_content/site.yaml"))
	if err != nil {
	return nil, err
	}
	if err := yaml.Unmarshal(data, &site); err != nil {
	return nil, fmt.Errorf("parsing _content/site.yaml: %v", err)
	}

	// Load site pages from md files.
	err = filepath.Walk(site.file("_content"), func(name string, info os.FileInfo, err error) error {
	if err != nil {
	return err
	}
	if strings.HasSuffix(name, ".md") {
	_, err := site.loadPage(name[len(site.file("."))+1:])
	return err
	}
	return nil
	})
	if err != nil {
	return nil, fmt.Errorf("loading pages: %v", err)
	}

	// Now that all pages are loaded and set up, can render all.
	// (Pages can refer to other pages.)
	for _, p := range site.pagesByID {
	if err := site.renderHTML(p); err != nil {
	return nil, err
	}
	}

	return site, nil
	}

	// file returns the full path to the named file within the site.
	func (site *Site) file(name string) string { return filepath.Join(site.dir, name) }

	// newPage returns a new page belonging to site.
	func (site Site) newPage(short string) page {
	p := &page{
	id: short,
	params: make(tPage),
	}
	site.pagesByID[p.id] = p
	return p
	}

	// data parses the named yaml file and returns its structured data.
	func (site *Site) data(name string) (interface{}, error) {
	data, err := ioutil.ReadFile(site.file("_content/" + name + ".yaml"))
	if err != nil {
	return nil, err
	}
	var d interface{}
	if err := yaml.Unmarshal(data, &d); err != nil {
	return nil, err
	}
	return d, nil
	}

	// pageByID returns the page with a given path.
	func (site *Site) pageByPath(path string) (tPage, error) {
	p := site.pagesByID[strings.Trim(path, "/")]
	if p == nil {
	return nil, fmt.Errorf("no such page with path %q", path)
	}
	return p.params, nil
	}

	// pagesGlob returns the pages with IDs matching glob.
	func (site *Site) pagesGlob(glob string) ([]tPage, error) {
	_, err := path.Match(glob, "")
	if err != nil {
	return nil, err
	}
	glob = strings.Trim(glob, "/")
	var out []tPage
	for _, p := range site.pagesByID {
	if ok, _ := path.Match(glob, p.id); ok {
	out = append(out, p.params)
	}
	}

	sort.Slice(out, func(i, j int) bool {
	return out[i]["Path"].(string) < out[j]["Path"].(string)
	})
	return out, nil
	}

	// newest returns the pages sorted newest first,
	// breaking ties by .linkTitle or else .title.
	func newest(pages []tPage) []tPage {
	out := make([]tPage, len(pages))
	copy(out, pages)

	sort.Slice(out, func(i, j int) bool {
	pi := out[i]
	pj := out[j]
	di, _ := pi["Date"].(time.Time)
	dj, _ := pj["Date"].(time.Time)
	if !di.Equal(dj) {
	return di.After(dj)
	}
	ti, _ := pi["linkTitle"].(string)
	tj, _ := pj["linkTitle"].(string)
	if ti != tj {
	return ti < tj
	}
	return false
	})
	return out
	}

	// Open returns the content to serve at the given path.
	// This function makes Site an http.FileServer, for easy HTTP serving.
	func (site *Site) Open(name string) (http.File, error) {
	name = strings.TrimPrefix(name, "/")
	switch ext := path.Ext(name); ext {
	case ".css", ".jpeg", ".jpg", ".js", ".png", ".svg", ".txt":
	if f, err := os.Open(site.file("_content/" + name)); err == nil {
	return f, nil
	}

	case ".html":
	id := strings.TrimSuffix(name, "/index.html")
	if name == "index.html" {
	id = ""
	}
	if p := site.pagesByID[id]; p != nil {
	if redir, ok := p.params["redirect"].(string); ok {
	s := fmt.Sprintf(redirectFmt, redir)
	return &httpFile{strings.NewReader(s), int64(len(s))}, nil
	}
	return &httpFile{bytes.NewReader(p.html), int64(len(p.html))}, nil
	}
	}

	if !strings.HasSuffix(name, ".html") {
	if f, err := site.Open(name + "/index.html"); err == nil {
	size, err := f.Seek(0, io.SeekEnd)
	f.Close()
	if err == nil {
	return &httpDir{httpFileInfo{"index.html", size, false}, 0}, nil
	}
	}
	}

	return nil, &os.PathError{Op: "open", Path: name, Err: os.ErrNotExist}
	}

	type httpFile struct {
	io.ReadSeeker
	size int64
	}

	func (*httpFile) Close() error { return nil }
	func (f *httpFile) Stat() (os.FileInfo, error) { return &httpFileInfo{".", f.size, false}, nil }
	func (*httpFile) Readdir(count int) ([]os.FileInfo, error) {
	return nil, fmt.Errorf("readdir not available")
	}

	const redirectFmt = `<!DOCTYPE html><html><head><title>%s</title><link rel="canonical" href="%[1]s"/><meta name="robots" content="noindex"><meta charset="utf-8" /><meta http-equiv="refresh" content="0; url=%[1]s" /></head></html>`

	type httpDir struct {
	info httpFileInfo
	off int // 0 or 1
	}

	func (*httpDir) Close() error { return nil }
	func (*httpDir) Read([]byte) (int, error) { return 0, fmt.Errorf("read not available") }
	func (*httpDir) Seek(int64, int) (int64, error) { return 0, fmt.Errorf("seek not available") }
	func (*httpDir) Stat() (os.FileInfo, error) { return &httpFileInfo{".", 0, true}, nil }
	func (d *httpDir) Readdir(count int) ([]os.FileInfo, error) {
	if count == 0 {
	return nil, nil
	}
	if d.off > 0 {
	return nil, io.EOF
	}
	d.off = 1
	return []os.FileInfo{&d.info}, nil
	}

	type httpFileInfo struct {
	name string
	size int64
	dir bool
	}

	func (info *httpFileInfo) Name() string { return info.name }
	func (info *httpFileInfo) Size() int64 { return info.size }
	func (info *httpFileInfo) Mode() os.FileMode {
	if info.dir {
	return os.ModeDir \| 0555
	}
	return 0444
	}
	func (info *httpFileInfo) ModTime() time.Time { return time.Time{} }
	func (info *httpFileInfo) IsDir() bool { return info.dir }
	func (info *httpFileInfo) Sys() interface{} { return nil }