├── go.mod
├── testdata
    ├── error.tmpl
    ├── error.ts
    ├── site.tmpl
    ├── example.js
    └── example.ts
├── README.md
├── go.sum
├── LICENSE
├── istext.go
├── site_test.go
├── tmpl.go
├── pkg.go
├── page.go
├── code.go
├── render.go
├── internal
    └── texthtml
    │   ├── ast.go
    │   └── texthtml.go
└── site.go


/go.mod:
--------------------------------------------------------------------------------
 1 | module rsc.io/web
 2 | 
 3 | go 1.18
 4 | 
 5 | require (
 6 | 	github.com/yuin/goldmark v1.4.7
 7 | 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
 8 | 	rsc.io/tmplfunc v0.0.3
 9 | )
10 | 


--------------------------------------------------------------------------------
/testdata/error.tmpl:
--------------------------------------------------------------------------------
1 | <!--
2 | 	Copyright 2021 The Go Authors. All rights reserved.
3 | 	Use of this source code is governed by a BSD-style
4 | 	license that can be found in the LICENSE file.
5 | -->
6 | 
7 | {{define "layout"}}{{.error}}{{end}}
8 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | [![Documentation](https://pkg.go.dev/badge/rsc.io/web.svg)](https://pkg.go.dev/rsc.io/web)
2 | 
3 | Package web implements a basic web site serving framework.
4 | 
5 | See the [package documentation](https://pkg.go.dev/rsc.io/web) for details.
6 | 


--------------------------------------------------------------------------------
/testdata/error.ts:
--------------------------------------------------------------------------------
1 | /**
2 |  * @license
3 |  * Copyright 2021 The Go Authors. All rights reserved.
4 |  * Use of this source code is governed by a BSD-style
5 |  * license that can be found in the LICENSE file.
6 |  */
7 | 
8 | const function = () => {};
9 | 


--------------------------------------------------------------------------------
/testdata/site.tmpl:
--------------------------------------------------------------------------------
1 | <!--
2 | 	Copyright 2021 The Go Authors. All rights reserved.
3 | 	Use of this source code is governed by a BSD-style
4 | 	license that can be found in the LICENSE file.
5 | -->
6 | 
7 | {{block "entirepage" .}}{{block "layout" .}}{{.Content}}{{end}}{{end}}
8 | 


--------------------------------------------------------------------------------
/testdata/example.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @license
 3 |  * Copyright 2021 The Go Authors. All rights reserved.
 4 |  * Use of this source code is governed by a BSD-style
 5 |  * license that can be found in the LICENSE file.
 6 |  */
 7 | function sayHello(to) {
 8 |   console.log("Hello, " + to + "!");
 9 | }
10 | const world = {
11 |   name: "World",
12 |   toString() {
13 |     return this.name;
14 |   }
15 | };
16 | sayHello(world);
17 | 


--------------------------------------------------------------------------------
/testdata/example.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @license
 3 |  * Copyright 2021 The Go Authors. All rights reserved.
 4 |  * Use of this source code is governed by a BSD-style
 5 |  * license that can be found in the LICENSE file.
 6 |  */
 7 | 
 8 | interface Target {
 9 |   toString(): string;
10 | }
11 | 
12 | function sayHello(to: Target): void {
13 |   console.log('Hello, ' + to + '!');
14 | }
15 | 
16 | const world = {
17 |   name: 'World',
18 |   toString(): string {
19 |     return this.name;
20 |   },
21 | };
22 | 
23 | sayHello(world);
24 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
1 | github.com/yuin/goldmark v1.4.7 h1:KHHlQL4EKBZ43vpA1KBEQHfodk4JeIgeb0xJLg7rvDI=
2 | github.com/yuin/goldmark v1.4.7/go.mod h1:rmuwmfZ0+bvzB24eSC//bk1R1Zp3hM0OXYv/G2LIilg=
3 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
4 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
5 | gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
6 | gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
7 | rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU=
8 | rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA=
9 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2009 The Go Authors. All rights reserved.
 2 | 
 3 | Redistribution and use in source and binary forms, with or without
 4 | modification, are permitted provided that the following conditions are
 5 | met:
 6 | 
 7 |    * Redistributions of source code must retain the above copyright
 8 | notice, this list of conditions and the following disclaimer.
 9 |    * Redistributions in binary form must reproduce the above
10 | copyright notice, this list of conditions and the following disclaimer
11 | in the documentation and/or other materials provided with the
12 | distribution.
13 |    * Neither the name of Google Inc. nor the names of its
14 | contributors may be used to endorse or promote products derived from
15 | this software without specific prior written permission.
16 | 
17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 | 


--------------------------------------------------------------------------------
/istext.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2013 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package web
 6 | 
 7 | import (
 8 | 	"io/fs"
 9 | 	"path"
10 | 	"strings"
11 | 	"unicode/utf8"
12 | )
13 | 
14 | // isText reports whether a significant prefix of s looks like correct UTF-8;
15 | // that is, if it is likely that s is human-readable text.
16 | func isText(s []byte) bool {
17 | 	const max = 1024 // at least utf8.UTFMax
18 | 	if len(s) > max {
19 | 		s = s[0:max]
20 | 	}
21 | 	for i, c := range string(s) {
22 | 		if i+utf8.UTFMax > len(s) {
23 | 			// last char may be incomplete - ignore
24 | 			break
25 | 		}
26 | 		if c == 0xFFFD || c < ' ' && c != '\n' && c != '\t' && c != '\f' {
27 | 			// decoding error or control character - not a text file
28 | 			return false
29 | 		}
30 | 	}
31 | 	return true
32 | }
33 | 
34 | // isTextFile reports whether the file has a known extension indicating
35 | // a text file, or if a significant chunk of the specified file looks like
36 | // correct UTF-8; that is, if it is likely that the file contains human-
37 | // readable text.
38 | func isTextFile(fsys fs.FS, filename string) bool {
39 | 	// Various special cases must be served raw, not converted to nice HTML.
40 | 	if filename == "robots.txt" || strings.HasPrefix(filename, "doc/play/") {
41 | 		return false
42 | 	}
43 | 	switch path.Ext(filename) {
44 | 	case ".css", ".js", ".svg", ".ts":
45 | 		return false
46 | 	}
47 | 
48 | 	// the extension is not known; read an initial chunk
49 | 	// of the file and check if it looks like text
50 | 	f, err := fsys.Open(filename)
51 | 	if err != nil {
52 | 		return false
53 | 	}
54 | 	defer f.Close()
55 | 
56 | 	var buf [1024]byte
57 | 	n, err := f.Read(buf[0:])
58 | 	if err != nil {
59 | 		return false
60 | 	}
61 | 
62 | 	return isText(buf[0:n])
63 | }
64 | 


--------------------------------------------------------------------------------
/site_test.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package web
 6 | 
 7 | import (
 8 | 	"net/http"
 9 | 	"net/http/httptest"
10 | 	"net/url"
11 | 	"strings"
12 | 	"testing"
13 | 	"testing/fstest"
14 | )
15 | 
16 | func testServeBody(t *testing.T, p *Site, path, body string) {
17 | 	t.Helper()
18 | 	r := &http.Request{URL: &url.URL{Path: path}}
19 | 	rw := httptest.NewRecorder()
20 | 	p.ServeHTTP(rw, r)
21 | 	if rw.Code != 200 || !strings.Contains(rw.Body.String(), body) {
22 | 		t.Fatalf("GET %s: expected 200 w/ %q: got %d w/ body:\n%s",
23 | 			path, body, rw.Code, rw.Body)
24 | 	}
25 | }
26 | 
27 | func TestRedirectAndMetadata(t *testing.T) {
28 | 	fsys := fstest.MapFS{
29 | 		"site.tmpl":           {Data: []byte(`{{.Content}}`)},
30 | 		"doc/x/index.html":    {Data: []byte("Hello, x.")},
31 | 		"lib/godoc/site.html": {Data: []byte(`{{.Data}}`)},
32 | 	}
33 | 	site := NewSite(fsys)
34 | 
35 | 	// Test that redirect is sent back correctly.
36 | 	// Used to panic. See golang.org/issue/40665.
37 | 	dir := "/doc/x/"
38 | 
39 | 	r := &http.Request{URL: &url.URL{Path: dir + "index.html"}}
40 | 	rw := httptest.NewRecorder()
41 | 	site.ServeHTTP(rw, r)
42 | 	loc := rw.Result().Header.Get("Location")
43 | 	if rw.Code != 301 || loc != dir {
44 | 		t.Errorf("GET %s: expected 301 -> %q, got %d -> %q", r.URL.Path, dir, rw.Code, loc)
45 | 	}
46 | 
47 | 	testServeBody(t, site, dir, "Hello, x")
48 | }
49 | 
50 | func TestMarkdown(t *testing.T) {
51 | 	site := NewSite(fstest.MapFS{
52 | 		"site.tmpl":           {Data: []byte(`{{.Content}}`)},
53 | 		"doc/test.md":         {Data: []byte("**bold**")},
54 | 		"doc/test2.md":        {Data: []byte(`{{"*template*"}}`)},
55 | 		"lib/godoc/site.html": {Data: []byte(`{{.Data}}`)},
56 | 	})
57 | 
58 | 	testServeBody(t, site, "/doc/test", "<strong>bold</strong>")
59 | 	testServeBody(t, site, "/doc/test2", "<em>template</em>")
60 | }
61 | 


--------------------------------------------------------------------------------
/tmpl.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2021 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | package web
  6 | 
  7 | import (
  8 | 	"fmt"
  9 | 	"html/template"
 10 | 	"io/fs"
 11 | 	"path"
 12 | 	"reflect"
 13 | 	"sort"
 14 | 	"strings"
 15 | 
 16 | 	"gopkg.in/yaml.v3"
 17 | )
 18 | 
 19 | // A siteDir is a site extended with a known directory for interpreting relative paths.
 20 | type siteDir struct {
 21 | 	*Site
 22 | 	dir string
 23 | }
 24 | 
 25 | func toString(x interface{}) string {
 26 | 	switch x := x.(type) {
 27 | 	case string:
 28 | 		return x
 29 | 	case template.HTML:
 30 | 		return string(x)
 31 | 	case nil:
 32 | 		return ""
 33 | 	default:
 34 | 		panic(fmt.Sprintf("cannot toString %T", x))
 35 | 	}
 36 | }
 37 | 
 38 | // data parses the named yaml file (relative to dir) and returns its structured data.
 39 | func (site *siteDir) data(name string) (interface{}, error) {
 40 | 	data, err := site.readFile(site.dir, name)
 41 | 	if err != nil {
 42 | 		return nil, err
 43 | 	}
 44 | 	var d interface{}
 45 | 	if err := yaml.Unmarshal(data, &d); err != nil {
 46 | 		return nil, err
 47 | 	}
 48 | 	return d, nil
 49 | }
 50 | 
 51 | func first(n int, list reflect.Value) reflect.Value {
 52 | 	if !list.IsValid() {
 53 | 		return list
 54 | 	}
 55 | 	if list.Kind() == reflect.Interface {
 56 | 		if list.IsNil() {
 57 | 			return list
 58 | 		}
 59 | 		list = list.Elem()
 60 | 	}
 61 | 
 62 | 	if list.Len() < n {
 63 | 		return list
 64 | 	}
 65 | 	return list.Slice(0, n)
 66 | }
 67 | 
 68 | // markdown is the function provided to templates.
 69 | func markdown(data interface{}) (template.HTML, error) {
 70 | 	h, err := markdownToHTML(toString(data))
 71 | 	if err != nil {
 72 | 		return "", err
 73 | 	}
 74 | 	s := strings.TrimSpace(string(h))
 75 | 	if strings.HasPrefix(s, "<p>") && strings.HasSuffix(s, "</p>") && strings.Count(s, "<p>") == 1 {
 76 | 		h = template.HTML(strings.TrimSpace(s[len("<p>") : len(s)-len("</p>")]))
 77 | 	}
 78 | 	return h, nil
 79 | }
 80 | 
 81 | func (site *siteDir) readfile(name string) (string, error) {
 82 | 	data, err := site.readFile(site.dir, name)
 83 | 	return string(data), err
 84 | }
 85 | 
 86 | // page returns the page params for the page with a given url u.
 87 | // The url may or may not have its leading slash.
 88 | func (site *siteDir) page(u string) (Page, error) {
 89 | 	if !path.IsAbs(u) {
 90 | 		u = path.Join(site.dir, u)
 91 | 	}
 92 | 	p, err := site.openPage(strings.Trim(u, "/"))
 93 | 	if err != nil {
 94 | 		return nil, err
 95 | 	}
 96 | 	return p.page, nil
 97 | }
 98 | 
 99 | // Pages returns the pages found in files matching glob.
100 | func (site *Site) Pages(glob string) ([]Page, error) {
101 | 	return (&siteDir{site, "."}).pages(glob)
102 | }
103 | 
104 | // pages returns the page params for pages with urls matching glob.
105 | func (site *siteDir) pages(glob string) ([]Page, error) {
106 | 	if !path.IsAbs(glob) {
107 | 		glob = path.Join(site.dir, glob)
108 | 	}
109 | 	// TODO(rsc): Add a cache?
110 | 	_, err := path.Match(glob, "")
111 | 	if err != nil {
112 | 		return nil, err
113 | 	}
114 | 	glob = strings.Trim(glob, "/")
115 | 	if glob == "" {
116 | 		glob = "."
117 | 	}
118 | 	matches, err := fs.Glob(site.fs, glob)
119 | 	if err != nil {
120 | 		return nil, err
121 | 	}
122 | 	var out []Page
123 | 	for _, file := range matches {
124 | 		if !strings.HasSuffix(file, ".md") && !strings.HasSuffix(file, ".html") {
125 | 			f := path.Join(file, "index.md")
126 | 			if _, err := fs.Stat(site.fs, f); err != nil {
127 | 				f = path.Join(file, "index.html")
128 | 				if _, err = fs.Stat(site.fs, f); err != nil {
129 | 					continue
130 | 				}
131 | 			}
132 | 			file = f
133 | 		}
134 | 		p, err := site.openPage(file)
135 | 		if err != nil {
136 | 			return nil, fmt.Errorf("%s: %v", file, err)
137 | 		}
138 | 		out = append(out, p.page)
139 | 	}
140 | 
141 | 	sort.Slice(out, func(i, j int) bool {
142 | 		return out[i]["URL"].(string) < out[j]["URL"].(string)
143 | 	})
144 | 	return out, nil
145 | }
146 | 
147 | // file parses the named file (relative to dir) and returns its content as a string.
148 | func (site *siteDir) file(name string) (string, error) {
149 | 	data, err := site.readFile(site.dir, name)
150 | 	if err != nil {
151 | 		return "", err
152 | 	}
153 | 	return string(data), nil
154 | }
155 | 
156 | func raw(s interface{}) template.HTML {
157 | 	return template.HTML(toString(s))
158 | }
159 | 
160 | func yamlFn(s string) (interface{}, error) {
161 | 	var d interface{}
162 | 	if err := yaml.Unmarshal([]byte(s), &d); err != nil {
163 | 		return nil, err
164 | 	}
165 | 	return d, nil
166 | }
167 | 


--------------------------------------------------------------------------------
/pkg.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2021 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package web
 6 | 
 7 | import (
 8 | 	"path"
 9 | 	"strings"
10 | 	"unicode"
11 | )
12 | 
13 | type pkgPath struct{}
14 | 
15 | func (pkgPath) Base(a string) string            { return path.Base(a) }
16 | func (pkgPath) Clean(a string) string           { return path.Clean(a) }
17 | func (pkgPath) Dir(a string) string             { return path.Dir(a) }
18 | func (pkgPath) Ext(a string) string             { return path.Ext(a) }
19 | func (pkgPath) IsAbs(a string) bool             { return path.IsAbs(a) }
20 | func (pkgPath) Join(a ...string) string         { return path.Join(a...) }
21 | func (pkgPath) Match(a, b string) (bool, error) { return path.Match(a, b) }
22 | func (pkgPath) Split(a string) (string, string) { return path.Split(a) }
23 | 
24 | type pkgStrings struct{}
25 | 
26 | func (pkgStrings) Compare(a, b string) int                         { return strings.Compare(a, b) }
27 | func (pkgStrings) Contains(a, b string) bool                       { return strings.Contains(a, b) }
28 | func (pkgStrings) ContainsAny(a, b string) bool                    { return strings.ContainsAny(a, b) }
29 | func (pkgStrings) ContainsRune(a string, b rune) bool              { return strings.ContainsRune(a, b) }
30 | func (pkgStrings) Count(a, b string) int                           { return strings.Count(a, b) }
31 | func (pkgStrings) EqualFold(a, b string) bool                      { return strings.EqualFold(a, b) }
32 | func (pkgStrings) Fields(a string) []string                        { return strings.Fields(a) }
33 | func (pkgStrings) FieldsFunc(a string, b func(rune) bool) []string { return strings.FieldsFunc(a, b) }
34 | func (pkgStrings) HasPrefix(a, b string) bool                      { return strings.HasPrefix(a, b) }
35 | func (pkgStrings) HasSuffix(a, b string) bool                      { return strings.HasSuffix(a, b) }
36 | func (pkgStrings) Index(a, b string) int                           { return strings.Index(a, b) }
37 | func (pkgStrings) IndexAny(a, b string) int                        { return strings.IndexAny(a, b) }
38 | func (pkgStrings) IndexByte(a string, b byte) int                  { return strings.IndexByte(a, b) }
39 | func (pkgStrings) IndexFunc(a string, b func(rune) bool) int       { return strings.IndexFunc(a, b) }
40 | func (pkgStrings) IndexRune(a string, b rune) int                  { return strings.IndexRune(a, b) }
41 | func (pkgStrings) Join(a []string, b string) string                { return strings.Join(a, b) }
42 | func (pkgStrings) LastIndex(a, b string) int                       { return strings.LastIndex(a, b) }
43 | func (pkgStrings) LastIndexAny(a, b string) int                    { return strings.LastIndexAny(a, b) }
44 | func (pkgStrings) LastIndexByte(a string, b byte) int              { return strings.LastIndexByte(a, b) }
45 | func (pkgStrings) LastIndexFunc(a string, b func(rune) bool) int {
46 | 	return strings.LastIndexFunc(a, b)
47 | }
48 | func (pkgStrings) Map(a func(rune) rune, b string) string    { return strings.Map(a, b) }
49 | func (pkgStrings) NewReader(a string) *strings.Reader        { return strings.NewReader(a) }
50 | func (pkgStrings) NewReplacer(a ...string) *strings.Replacer { return strings.NewReplacer(a...) }
51 | func (pkgStrings) Repeat(a string, b int) string             { return strings.Repeat(a, b) }
52 | func (pkgStrings) Replace(a, b, c string, d int) string      { return strings.Replace(a, b, c, d) }
53 | func (pkgStrings) ReplaceAll(a, b, c string) string          { return strings.ReplaceAll(a, b, c) }
54 | func (pkgStrings) Split(a, b string) []string                { return strings.Split(a, b) }
55 | func (pkgStrings) SplitAfter(a, b string) []string           { return strings.SplitAfter(a, b) }
56 | func (pkgStrings) SplitAfterN(a, b string, c int) []string   { return strings.SplitAfterN(a, b, c) }
57 | func (pkgStrings) SplitN(a, b string, c int) []string        { return strings.SplitN(a, b, c) }
58 | func (pkgStrings) Title(a string) string                     { return strings.Title(a) }
59 | func (pkgStrings) ToLower(a string) string                   { return strings.ToLower(a) }
60 | func (pkgStrings) ToLowerSpecial(a unicode.SpecialCase, b string) string {
61 | 	return strings.ToLowerSpecial(a, b)
62 | }
63 | func (pkgStrings) ToTitle(a string) string { return strings.ToTitle(a) }
64 | func (pkgStrings) ToTitleSpecial(a unicode.SpecialCase, b string) string {
65 | 	return strings.ToTitleSpecial(a, b)
66 | }
67 | func (pkgStrings) ToUpper(a string) string { return strings.ToUpper(a) }
68 | func (pkgStrings) ToUpperSpecial(a unicode.SpecialCase, b string) string {
69 | 	return strings.ToUpperSpecial(a, b)
70 | }
71 | func (pkgStrings) ToValidUTF8(a, b string) string                  { return strings.ToValidUTF8(a, b) }
72 | func (pkgStrings) Trim(a, b string) string                         { return strings.Trim(a, b) }
73 | func (pkgStrings) TrimFunc(a string, b func(rune) bool) string     { return strings.TrimFunc(a, b) }
74 | func (pkgStrings) TrimLeft(a, b string) string                     { return strings.TrimLeft(a, b) }
75 | func (pkgStrings) TrimLeftFunc(a string, b func(rune) bool) string { return strings.TrimLeftFunc(a, b) }
76 | func (pkgStrings) TrimPrefix(a, b string) string                   { return strings.TrimPrefix(a, b) }
77 | func (pkgStrings) TrimRight(a, b string) string                    { return strings.TrimRight(a, b) }
78 | func (pkgStrings) TrimRightFunc(a string, b func(rune) bool) string {
79 | 	return strings.TrimRightFunc(a, b)
80 | }
81 | func (pkgStrings) TrimSpace(a string) string     { return strings.TrimSpace(a) }
82 | func (pkgStrings) TrimSuffix(a, b string) string { return strings.TrimSuffix(a, b) }
83 | 


--------------------------------------------------------------------------------
/page.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2021 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | package web
  6 | 
  7 | import (
  8 | 	"bytes"
  9 | 	"encoding/json"
 10 | 	"io/fs"
 11 | 	"path"
 12 | 	"strings"
 13 | 	"sync/atomic"
 14 | 	"time"
 15 | 
 16 | 	"gopkg.in/yaml.v3"
 17 | )
 18 | 
 19 | // A pageFile is a Page loaded from a file.
 20 | // It corresponds to some .md or .html file in the content tree.
 21 | type pageFile struct {
 22 | 	file string      // .md file for page
 23 | 	stat fs.FileInfo // stat for file when page was loaded
 24 | 	url  string      // url excluding site.BaseURL; always begins with slash
 25 | 	data []byte      // page data (markdown)
 26 | 	page Page        // parameters passed to templates
 27 | 
 28 | 	checked int64 // unix nano, atomically updated
 29 | }
 30 | 
 31 | // A Page is the data for a web page.
 32 | // See the package doc comment for details.
 33 | type Page map[string]interface{}
 34 | 
 35 | func (site *Site) openPage(file string) (*pageFile, error) {
 36 | 	// Strip trailing .html or .md or /; it all names the same page.
 37 | 	if strings.HasSuffix(file, "/index.md") {
 38 | 		file = strings.TrimSuffix(file, "/index.md")
 39 | 	} else if strings.HasSuffix(file, "/index.html") {
 40 | 		file = strings.TrimSuffix(file, "/index.html")
 41 | 	} else if file == "index.md" || file == "index.html" {
 42 | 		file = "."
 43 | 	} else if strings.HasSuffix(file, "/") {
 44 | 		file = strings.TrimSuffix(file, "/")
 45 | 	} else if strings.HasSuffix(file, ".html") {
 46 | 		file = strings.TrimSuffix(file, ".html")
 47 | 	} else {
 48 | 		file = strings.TrimSuffix(file, ".md")
 49 | 	}
 50 | 
 51 | 	now := time.Now().UnixNano()
 52 | 	if cp, ok := site.cache.Load(file); ok {
 53 | 		// Have cache entry; only use if the underlying file hasn't changed.
 54 | 		// To avoid continuous stats, only check it has been 3s since the last one.
 55 | 		// TODO(rsc): Move caching into a more general layer and cache templates.
 56 | 		p := cp.(*pageFile)
 57 | 		if now-atomic.LoadInt64(&p.checked) >= 3e9 {
 58 | 			info, err := fs.Stat(site.fs, p.file)
 59 | 			if err == nil && info.ModTime().Equal(p.stat.ModTime()) && info.Size() == p.stat.Size() {
 60 | 				atomic.StoreInt64(&p.checked, now)
 61 | 				return p, nil
 62 | 			}
 63 | 		}
 64 | 	}
 65 | 
 66 | 	// Check md before html to work correctly when x/website is layered atop Go 1.15 goroot during Go 1.15 tests.
 67 | 	// Want to find x/website's debugging_with_gdb.md not Go 1.15's debuging_with_gdb.html.
 68 | 	files := []string{file + ".md", file + ".html", path.Join(file, "index.md"), path.Join(file, "index.html")}
 69 | 	var filePath string
 70 | 	var b []byte
 71 | 	var err error
 72 | 	var stat fs.FileInfo
 73 | 	for _, filePath = range files {
 74 | 		stat, err = fs.Stat(site.fs, filePath)
 75 | 		if err == nil {
 76 | 			b, err = site.readFile(".", filePath)
 77 | 			if err == nil {
 78 | 				break
 79 | 			}
 80 | 		}
 81 | 	}
 82 | 	if err != nil {
 83 | 		return nil, err
 84 | 	}
 85 | 
 86 | 	// If we read an index.md or index.html, the canonical relpath is without the index.md/index.html suffix.
 87 | 	url := path.Join("/", file)
 88 | 	if name := path.Base(filePath); name == "index.html" || name == "index.md" {
 89 | 		url, _ = path.Split(path.Join("/", filePath))
 90 | 	}
 91 | 
 92 | 	params, body, err := parseMeta(b)
 93 | 	if err != nil {
 94 | 		return nil, err
 95 | 	}
 96 | 
 97 | 	p := &pageFile{
 98 | 		file:    filePath,
 99 | 		stat:    stat,
100 | 		url:     url,
101 | 		data:    body,
102 | 		page:    params,
103 | 		checked: now,
104 | 	}
105 | 
106 | 	// File, FileData, URL
107 | 	p.page["File"] = filePath
108 | 	p.page["FileData"] = string(body)
109 | 	p.page["URL"] = p.url
110 | 
111 | 	// User-specified redirect: overrides url but not URL.
112 | 	if redir, _ := p.page["redirect"].(string); redir != "" {
113 | 		p.url = redir
114 | 	}
115 | 
116 | 	site.cache.Store(file, p)
117 | 
118 | 	return p, nil
119 | }
120 | 
121 | var (
122 | 	jsonStart = []byte("<!--{")
123 | 	jsonEnd   = []byte("}-->")
124 | 
125 | 	yamlStart = []byte("---\n")
126 | 	yamlEnd   = []byte("\n---\n")
127 | )
128 | 
129 | // parseMeta extracts top-of-file metadata from the file contents b.
130 | // If there is no metadata, parseMeta returns Page{}, b, nil.
131 | // Otherwise, the metdata is extracted, and parseMeta returns
132 | // the metadata and the remainder of the file.
133 | // The end of the metadata is overwritten in b to preserve
134 | // the correct number of newlines so that the line numbers in tail
135 | // match the line numbers in b.
136 | //
137 | // A JSON metadata object is bracketed by <!--{...}-->.
138 | // A YAML metadata object is bracketed by "---\n" above and below the YAML.
139 | //
140 | // JSON is typically used in HTML; YAML is typically used in Markdown.
141 | func parseMeta(b []byte) (meta Page, tail []byte, err error) {
142 | 	tail = b
143 | 	meta = make(Page)
144 | 	var end int
145 | 	if bytes.HasPrefix(b, jsonStart) {
146 | 		end = bytes.Index(b, jsonEnd)
147 | 		if end < 0 {
148 | 			return
149 | 		}
150 | 		b = b[len(jsonStart)-1 : end+1] // drop leading <!-- and include trailing }
151 | 		if err = json.Unmarshal(b, &meta); err != nil {
152 | 			return
153 | 		}
154 | 		end += len(jsonEnd)
155 | 		for k, v := range meta {
156 | 			delete(meta, k)
157 | 			meta[strings.ToLower(k)] = v
158 | 		}
159 | 	} else if bytes.HasPrefix(b, yamlStart) {
160 | 		end = bytes.Index(b, yamlEnd)
161 | 		if end < 0 {
162 | 			return
163 | 		}
164 | 		b = b[len(yamlStart) : end+1] // drop ---\n but include final \n
165 | 		if err = yaml.Unmarshal(b, &meta); err != nil {
166 | 			return
167 | 		}
168 | 		end += len(yamlEnd)
169 | 	}
170 | 
171 | 	// Put the right number of \n at the start of tail to preserve line numbers.
172 | 	nl := bytes.Count(tail[:end], []byte("\n"))
173 | 	for i := 0; i < nl; i++ {
174 | 		end--
175 | 		tail[end] = '\n'
176 | 	}
177 | 	tail = tail[end:]
178 | 	return
179 | }
180 | 


--------------------------------------------------------------------------------
/code.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2013 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | package web
  6 | 
  7 | import (
  8 | 	"bytes"
  9 | 	"fmt"
 10 | 	"html"
 11 | 	"html/template"
 12 | 	"log"
 13 | 	"regexp"
 14 | 	"strings"
 15 | 
 16 | 	"rsc.io/web/internal/texthtml"
 17 | )
 18 | 
 19 | func (s *siteDir) code(file string, arg ...interface{}) (_ template.HTML, err error) {
 20 | 	defer func() {
 21 | 		if r := recover(); r != nil {
 22 | 			err = fmt.Errorf("%v", r)
 23 | 		}
 24 | 	}()
 25 | 
 26 | 	_, text, _, cfg, err := s.locate("code", file, arg...)
 27 | 	if err != nil {
 28 | 		return "", err
 29 | 	}
 30 | 	cfg.GoComments = true
 31 | 	if cfg.HL == "" {
 32 | 		cfg.HL = "HL"
 33 | 	}
 34 | 
 35 | 	var buf bytes.Buffer
 36 | 	fmt.Fprintf(&buf, "<div class=\"code\">\n\n")
 37 | 	fmt.Fprintf(&buf, "<pre>")
 38 | 	// HTML-escape text and syntax-color comments like elsewhere.
 39 | 	buf.Write(texthtml.Format([]byte(text), cfg))
 40 | 	fmt.Fprintf(&buf, "</pre>\n")
 41 | 	fmt.Fprintf(&buf, "</div>\n\n")
 42 | 	return template.HTML(buf.String()), nil
 43 | }
 44 | 
 45 | func (s *siteDir) play(file string, arg ...interface{}) (_ template.HTML, err error) {
 46 | 	defer func() {
 47 | 		if r := recover(); r != nil {
 48 | 			err = fmt.Errorf("%v", r)
 49 | 		}
 50 | 	}()
 51 | 
 52 | 	before, text, after, cfg, err := s.locate("play", file, arg...)
 53 | 	if err != nil {
 54 | 		return "", err
 55 | 	}
 56 | 	cfg.Playground = true
 57 | 
 58 | 	var buf bytes.Buffer
 59 | 	fmt.Fprintf(&buf, "<div class=\"playground\">\n\n")
 60 | 	if before != "" {
 61 | 		fmt.Fprintf(&buf, "<pre style=\"display: none\"><span>%s</span>\n</pre>\n", html.EscapeString(before))
 62 | 	}
 63 | 	// HTML-escape text and syntax-color comments like elsewhere.
 64 | 	fmt.Fprintf(&buf, "<pre contenteditable=\"true\" spellcheck=\"false\">")
 65 | 	buf.Write(texthtml.Format([]byte(text), cfg))
 66 | 	fmt.Fprintf(&buf, "</pre>\n")
 67 | 	if after != "" {
 68 | 		fmt.Fprintf(&buf, "<pre style=\"display: none\"><span>%s</span>\n</pre>\n", html.EscapeString(after))
 69 | 	}
 70 | 	fmt.Fprintf(&buf, "</div>\n\n")
 71 | 
 72 | 	return template.HTML(buf.String()), nil
 73 | }
 74 | 
 75 | func (s *siteDir) locate(verb, file string, arg ...interface{}) (before, text, after string, cfg texthtml.Config, err error) {
 76 | 	btext, err := s.readFile(s.dir, file)
 77 | 	if err != nil {
 78 | 		return
 79 | 	}
 80 | 	text = string(btext)
 81 | 	if len(arg) > 0 {
 82 | 		if s, ok := arg[len(arg)-1].(string); ok && strings.HasPrefix(s, "HL") {
 83 | 			cfg.HL = s
 84 | 			arg = arg[:len(arg)-1]
 85 | 		}
 86 | 	}
 87 | 	if len(arg) > 0 {
 88 | 		if n, ok := arg[len(arg)-1].(int); ok {
 89 | 			if n == 0 {
 90 | 				n = -1
 91 | 			}
 92 | 			cfg.Line = n
 93 | 			arg = arg[:len(arg)-1]
 94 | 		}
 95 | 	}
 96 | 	switch len(arg) {
 97 | 	case 0:
 98 | 		// text is already whole file.
 99 | 		if cfg.Line == -1 {
100 | 			cfg.Line = 1
101 | 		}
102 | 	case 1:
103 | 		var n int
104 | 		before, text, after, n = s.oneLine(file, text, arg[0])
105 | 		if cfg.Line == -1 {
106 | 			cfg.Line = n
107 | 		}
108 | 	case 2:
109 | 		var n int
110 | 		before, text, after, n = s.multipleLines(file, text, arg[0], arg[1])
111 | 		if cfg.Line == -1 {
112 | 			cfg.Line = n
113 | 		}
114 | 	default:
115 | 		err = fmt.Errorf("incorrect code invocation: %s %q [%v, ...] (%d arguments)", verb, file, arg[0], len(arg))
116 | 		return
117 | 	}
118 | 
119 | 	// Trim leading and trailing blank lines from output.
120 | 	text = strings.Trim(text, "\n")
121 | 	if text != "" {
122 | 		text += "\n"
123 | 	}
124 | 	// Replace tabs by spaces, which work better in HTML.
125 | 	text = strings.Replace(text, "\t", "    ", -1)
126 | 
127 | 	return
128 | }
129 | 
130 | // Functions in this file panic on error, but the panic is recovered
131 | // to an error by 'code'.
132 | 
133 | // stringFor returns a textual representation of the arg, formatted according to its nature.
134 | func stringFor(arg interface{}) string {
135 | 	switch arg := arg.(type) {
136 | 	case int:
137 | 		return fmt.Sprintf("%d", arg)
138 | 	case string:
139 | 		if len(arg) > 2 && arg[0] == '/' && arg[len(arg)-1] == '/' {
140 | 			return fmt.Sprintf("%#q", arg)
141 | 		}
142 | 		return fmt.Sprintf("%q", arg)
143 | 	default:
144 | 		log.Panicf("unrecognized argument: %v type %T", arg, arg)
145 | 	}
146 | 	return ""
147 | }
148 | 
149 | // oneLine returns the single line generated by a two-argument code invocation.
150 | func (s *Site) oneLine(file, body string, arg interface{}) (before, text, after string, num int) {
151 | 	lines := strings.SplitAfter(body, "\n")
152 | 	line, pattern, isInt := parseArg(arg, file, len(lines))
153 | 	if !isInt {
154 | 		line = match(file, 0, lines, pattern)
155 | 	}
156 | 	line--
157 | 	return strings.Join(lines[:line], ""), lines[line], strings.Join(lines[line+1:], ""), line
158 | }
159 | 
160 | // multipleLines returns the text generated by a three-argument code invocation.
161 | func (s *Site) multipleLines(file, body string, arg1, arg2 interface{}) (before, text, after string, num int) {
162 | 	lines := strings.SplitAfter(body, "\n")
163 | 	line1, pattern1, isInt1 := parseArg(arg1, file, len(lines))
164 | 	line2, pattern2, isInt2 := parseArg(arg2, file, len(lines))
165 | 	if !isInt1 {
166 | 		line1 = match(file, 0, lines, pattern1)
167 | 	}
168 | 	if !isInt2 {
169 | 		line2 = match(file, line1, lines, pattern2)
170 | 	} else if line2 < line1 {
171 | 		log.Panicf("lines out of order for %q: %d %d", file, line1, line2)
172 | 	}
173 | 	for k := line1 - 1; k < line2; k++ {
174 | 		if strings.HasSuffix(lines[k], "OMIT\n") {
175 | 			lines[k] = ""
176 | 		}
177 | 	}
178 | 	line1--
179 | 	return strings.Join(lines[:line1], ""),
180 | 		strings.Join(lines[line1:line2], ""),
181 | 		strings.Join(lines[line2:], ""), line1
182 | }
183 | 
184 | // parseArg returns the integer or string value of the argument and tells which it is.
185 | func parseArg(arg interface{}, file string, max int) (ival int, sval string, isInt bool) {
186 | 	switch n := arg.(type) {
187 | 	case int:
188 | 		if n <= 0 || n > max {
189 | 			log.Panicf("%q:%d is out of range", file, n)
190 | 		}
191 | 		return n, "", true
192 | 	case string:
193 | 		return 0, n, false
194 | 	}
195 | 	log.Panicf("unrecognized argument %v type %T", arg, arg)
196 | 	return
197 | }
198 | 
199 | // match identifies the input line that matches the pattern in a code invocation.
200 | // If start>0, match lines starting there rather than at the beginning.
201 | // The return value is 1-indexed.
202 | func match(file string, start int, lines []string, pattern string) int {
203 | 	// $ matches the end of the file.
204 | 	if pattern == "$" {
205 | 		if len(lines) == 0 {
206 | 			log.Panicf("%q: empty file", file)
207 | 		}
208 | 		return len(lines)
209 | 	}
210 | 	// /regexp/ matches the line that matches the regexp.
211 | 	if len(pattern) > 2 && pattern[0] == '/' && pattern[len(pattern)-1] == '/' {
212 | 		re, err := regexp.Compile("(?m)" + pattern[1:len(pattern)-1])
213 | 		if err != nil {
214 | 			log.Panic(err)
215 | 		}
216 | 		for i := start; i < len(lines); i++ {
217 | 			if re.MatchString(lines[i]) {
218 | 				return i + 1
219 | 			}
220 | 		}
221 | 		log.Panicf("%s: no match for %#q", file, pattern)
222 | 	}
223 | 	log.Panicf("unrecognized pattern: %q", pattern)
224 | 	return 0
225 | }
226 | 


--------------------------------------------------------------------------------
/render.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2020 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | package web
  6 | 
  7 | import (
  8 | 	"bytes"
  9 | 	"fmt"
 10 | 	"io/fs"
 11 | 	"net/http"
 12 | 	"net/url"
 13 | 	"path"
 14 | 	"regexp"
 15 | 	"strings"
 16 | 	"unicode/utf8"
 17 | 
 18 | 	"html/template"
 19 | 
 20 | 	"github.com/yuin/goldmark"
 21 | 	"github.com/yuin/goldmark/ast"
 22 | 	"github.com/yuin/goldmark/extension"
 23 | 	"github.com/yuin/goldmark/parser"
 24 | 	"github.com/yuin/goldmark/renderer/html"
 25 | 	"github.com/yuin/goldmark/text"
 26 | 	"github.com/yuin/goldmark/util"
 27 | 	"rsc.io/tmplfunc"
 28 | )
 29 | 
 30 | // RenderContent returns the HTML rendering for the page using the named base template
 31 | // (the standard base template is "site.tmpl").
 32 | func (site *Site) RenderContent(p Page, tmpl string) (template.HTML, error) {
 33 | 	html, err := site.renderHTML(p, tmpl, &http.Request{URL: &url.URL{Path: "/missingurl"}})
 34 | 	if err != nil {
 35 | 		return "", err
 36 | 	}
 37 | 	return template.HTML(html), nil
 38 | }
 39 | 
 40 | // renderHTML renders and returns the Content and framed HTML for the page.
 41 | func (site *Site) renderHTML(p Page, tmpl string, r *http.Request) ([]byte, error) {
 42 | 	// Clone p, because we are going to set its Content key-value pair.
 43 | 	p2 := make(Page)
 44 | 	for k, v := range p {
 45 | 		p2[k] = v
 46 | 	}
 47 | 	p = p2
 48 | 
 49 | 	url, ok := p["URL"].(string)
 50 | 	if !ok {
 51 | 		// Set URL - caller did not.
 52 | 		p["URL"] = r.URL.Path
 53 | 	}
 54 | 	file, _ := p["File"].(string)
 55 | 	data, _ := p["FileData"].(string)
 56 | 
 57 | 	// Load base template.
 58 | 	base, err := site.readFile(".", tmpl)
 59 | 	if err != nil {
 60 | 		return nil, err
 61 | 	}
 62 | 
 63 | 	dir := strings.Trim(path.Dir(url), "/")
 64 | 	if dir == "" {
 65 | 		dir = "."
 66 | 	}
 67 | 	sd := &siteDir{site, dir}
 68 | 
 69 | 	t := template.New("site.tmpl").Funcs(template.FuncMap{
 70 | 		"add":      func(a, b int) int { return a + b },
 71 | 		"sub":      func(a, b int) int { return a - b },
 72 | 		"mul":      func(a, b int) int { return a * b },
 73 | 		"div":      func(a, b int) int { return a / b },
 74 | 		"code":     sd.code,
 75 | 		"data":     sd.data,
 76 | 		"page":     sd.page,
 77 | 		"pages":    sd.pages,
 78 | 		"play":     sd.play,
 79 | 		"request":  func() *http.Request { return r },
 80 | 		"path":     func() pkgPath { return pkgPath{} },
 81 | 		"strings":  func() pkgStrings { return pkgStrings{} },
 82 | 		"file":     sd.file,
 83 | 		"first":    first,
 84 | 		"markdown": markdown,
 85 | 		"raw":      raw,
 86 | 		"yaml":     yamlFn,
 87 | 	})
 88 | 	t.Funcs(site.funcs)
 89 | 
 90 | 	if err := tmplfunc.Parse(t, string(base)); err != nil {
 91 | 		return nil, err
 92 | 	}
 93 | 
 94 | 	// Load page-specific layout template.
 95 | 	layout, _ := p["layout"].(string)
 96 | 	if layout == "" {
 97 | 		l, ok := site.findLayout(dir, "default")
 98 | 		if ok {
 99 | 			layout = l
100 | 		} else {
101 | 			layout = "none"
102 | 		}
103 | 	} else if path.IsAbs(layout) {
104 | 		layout = strings.TrimLeft(path.Clean(layout+".tmpl"), "/")
105 | 	} else if strings.Contains(layout, "/") {
106 | 		layout = path.Join(dir, layout+".tmpl")
107 | 	} else if layout != "none" {
108 | 		l, ok := site.findLayout(dir, layout)
109 | 		if !ok {
110 | 			return nil, fmt.Errorf("cannot find layout %q", layout)
111 | 		}
112 | 		layout = l
113 | 	}
114 | 
115 | 	if layout != "none" {
116 | 		ldata, err := site.readFile(".", layout)
117 | 		if err != nil {
118 | 			return nil, err
119 | 		}
120 | 		if err := tmplfunc.Parse(t.New(layout), string(ldata)); err != nil {
121 | 			return nil, err
122 | 		}
123 | 	}
124 | 
125 | 	var buf bytes.Buffer
126 | 	if _, ok := p["Content"]; !ok && data != "" {
127 | 		// Load actual Markdown content (also a template).
128 | 		tf := t.New(file)
129 | 		if err := tmplfunc.Parse(tf, data); err != nil {
130 | 			return nil, err
131 | 		}
132 | 		if err := tf.Execute(&buf, p); err != nil {
133 | 			return nil, err
134 | 		}
135 | 		if strings.HasSuffix(file, ".md") {
136 | 			html, err := markdownToHTML(buf.String())
137 | 			if err != nil {
138 | 				return nil, err
139 | 			}
140 | 			p["Content"] = html
141 | 		} else {
142 | 			p["Content"] = template.HTML(buf.String())
143 | 		}
144 | 		buf.Reset()
145 | 	}
146 | 
147 | 	if err := t.Execute(&buf, p); err != nil {
148 | 		return nil, err
149 | 	}
150 | 	return buf.Bytes(), nil
151 | }
152 | 
153 | // findLayout searches the start directory and parent directories for a template with the given base name.
154 | func (site *Site) findLayout(dir, name string) (string, bool) {
155 | 	name += ".tmpl"
156 | 	for {
157 | 		abs := path.Join(dir, name)
158 | 		if _, err := fs.Stat(site.fs, abs); err == nil {
159 | 			return abs, true
160 | 		}
161 | 		if dir == "." {
162 | 			return "", false
163 | 		}
164 | 		dir = path.Dir(dir)
165 | 	}
166 | }
167 | 
168 | // markdownToHTML converts Markdown to HTML.
169 | // The Markdown source may contain raw HTML,
170 | // but Go templates have already been processed.
171 | func markdownToHTML(markdown string) (template.HTML, error) {
172 | 	// parser.WithHeadingAttribute allows custom ids on headings.
173 | 	// html.WithUnsafe allows use of raw HTML, which we need for tables.
174 | 	md := goldmark.New(
175 | 		goldmark.WithParserOptions(
176 | 			parser.WithHeadingAttribute(),
177 | 			parser.WithAutoHeadingID(),
178 | 			parser.WithASTTransformers(util.Prioritized(mdTransformFunc(mdLink), 1)),
179 | 		),
180 | 		goldmark.WithRendererOptions(html.WithUnsafe()),
181 | 		goldmark.WithExtensions(
182 | 			extension.NewTypographer(),
183 | 			extension.NewLinkify(
184 | 				extension.WithLinkifyAllowedProtocols([][]byte{[]byte("http"), []byte("https")}),
185 | 				extension.WithLinkifyEmailRegexp(regexp.MustCompile(`[^\x00-\x{10FFFF}]`)), // impossible
186 | 			),
187 | 			extension.DefinitionList,
188 | 		),
189 | 	)
190 | 	var buf bytes.Buffer
191 | 	if err := md.Convert(replaceTabs([]byte(markdown)), &buf); err != nil {
192 | 		return "", err
193 | 	}
194 | 	return template.HTML(buf.Bytes()), nil
195 | }
196 | 
197 | // mdTransformFunc is a func implementing parser.ASTTransformer.
198 | type mdTransformFunc func(*ast.Document, text.Reader, parser.Context)
199 | 
200 | func (f mdTransformFunc) Transform(node *ast.Document, reader text.Reader, pc parser.Context) {
201 | 	f(node, reader, pc)
202 | }
203 | 
204 | // mdLink walks doc, adding rel=noreferrer target=_blank to non-relative links.
205 | func mdLink(doc *ast.Document, _ text.Reader, _ parser.Context) {
206 | 	mdLinkWalk(doc)
207 | }
208 | 
209 | func mdLinkWalk(n ast.Node) {
210 | 	switch n := n.(type) {
211 | 	case *ast.Link:
212 | 		dest := string(n.Destination)
213 | 		if strings.HasPrefix(dest, "https://") || strings.HasPrefix(dest, "http://") {
214 | 			n.SetAttributeString("rel", []byte("noreferrer"))
215 | 			n.SetAttributeString("target", []byte("_blank"))
216 | 		}
217 | 		return
218 | 	case *ast.AutoLink:
219 | 		// All autolinks are non-relative.
220 | 		n.SetAttributeString("rel", []byte("noreferrer"))
221 | 		n.SetAttributeString("target", []byte("_blank"))
222 | 		return
223 | 	}
224 | 
225 | 	for child := n.FirstChild(); child != nil; child = child.NextSibling() {
226 | 		mdLinkWalk(child)
227 | 	}
228 | }
229 | 
230 | // replaceTabs replaces all tabs in text with spaces up to a 4-space tab stop.
231 | //
232 | // In Markdown, tabs used for indentation are required to be interpreted as
233 | // 4-space tab stops. See https://spec.commonmark.org/0.30/#tabs.
234 | // Go also renders nicely and more compactly on the screen with 4-space
235 | // tab stops, while browsers often use 8-space.
236 | // And Goldmark crashes in some inputs that mix spaces and tabs.
237 | // Fix the crashes and make the Go code consistently compact across browsers,
238 | // all while staying Markdown-compatible, by expanding to 4-space tab stops.
239 | //
240 | // This function does not handle multi-codepoint Unicode sequences correctly.
241 | func replaceTabs(text []byte) []byte {
242 | 	var buf bytes.Buffer
243 | 	col := 0
244 | 	for len(text) > 0 {
245 | 		r, size := utf8.DecodeRune(text)
246 | 		text = text[size:]
247 | 
248 | 		switch r {
249 | 		case '\n':
250 | 			buf.WriteByte('\n')
251 | 			col = 0
252 | 
253 | 		case '\t':
254 | 			buf.WriteByte(' ')
255 | 			col++
256 | 			for col%4 != 0 {
257 | 				buf.WriteByte(' ')
258 | 				col++
259 | 			}
260 | 
261 | 		default:
262 | 			buf.WriteRune(r)
263 | 			col++
264 | 		}
265 | 	}
266 | 	return buf.Bytes()
267 | }
268 | 


--------------------------------------------------------------------------------
/internal/texthtml/ast.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2011 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | package texthtml
  6 | 
  7 | import (
  8 | 	"bytes"
  9 | 	"fmt"
 10 | 	"go/ast"
 11 | 	"go/doc"
 12 | 	"go/token"
 13 | 	"strconv"
 14 | 	"unicode"
 15 | 	"unicode/utf8"
 16 | )
 17 | 
 18 | // A goLink describes the (HTML) link information for a Go identifier.
 19 | // The zero value of a link represents "no link".
 20 | type goLink struct {
 21 | 	path, name string // package path, identifier name
 22 | 	isVal      bool   // identifier is defined in a const or var declaration
 23 | 	oldDocs    bool   // link to ?m=old docs
 24 | }
 25 | 
 26 | func (l *goLink) tags() (start, end string) {
 27 | 	switch {
 28 | 	case l.path != "" && l.name == "":
 29 | 		// package path
 30 | 		return `<a href="/pkg/` + l.path + `/` + l.docSuffix() + `">`, `</a>`
 31 | 	case l.path != "" && l.name != "":
 32 | 		// qualified identifier
 33 | 		return `<a href="/pkg/` + l.path + `/` + l.docSuffix() + `#` + l.name + `">`, `</a>`
 34 | 	case l.path == "" && l.name != "":
 35 | 		// local identifier
 36 | 		if l.isVal {
 37 | 			return `<span id="` + l.name + `">`, `</span>`
 38 | 		}
 39 | 		if ast.IsExported(l.name) {
 40 | 			return `<a href="#` + l.name + `">`, `</a>`
 41 | 		}
 42 | 	}
 43 | 	return "", ""
 44 | }
 45 | 
 46 | func (l *goLink) docSuffix() string {
 47 | 	if l.oldDocs {
 48 | 		return "?m=old"
 49 | 	}
 50 | 	return ""
 51 | }
 52 | 
 53 | // goLinksFor returns the list of links for the identifiers used
 54 | // by node in the same order as they appear in the source.
 55 | func goLinksFor(node ast.Node) (links []goLink) {
 56 | 	// linkMap tracks link information for each ast.Ident node. Entries may
 57 | 	// be created out of source order (for example, when we visit a parent
 58 | 	// definition node). These links are appended to the returned slice when
 59 | 	// their ast.Ident nodes are visited.
 60 | 	linkMap := make(map[*ast.Ident]goLink)
 61 | 
 62 | 	ast.Inspect(node, func(node ast.Node) bool {
 63 | 		switch n := node.(type) {
 64 | 		case *ast.Field:
 65 | 			for _, n := range n.Names {
 66 | 				linkMap[n] = goLink{}
 67 | 			}
 68 | 		case *ast.ImportSpec:
 69 | 			if name := n.Name; name != nil {
 70 | 				linkMap[name] = goLink{}
 71 | 			}
 72 | 		case *ast.ValueSpec:
 73 | 			for _, n := range n.Names {
 74 | 				linkMap[n] = goLink{name: n.Name, isVal: true}
 75 | 			}
 76 | 		case *ast.FuncDecl:
 77 | 			linkMap[n.Name] = goLink{}
 78 | 		case *ast.TypeSpec:
 79 | 			linkMap[n.Name] = goLink{}
 80 | 		case *ast.AssignStmt:
 81 | 			// Short variable declarations only show up if we apply
 82 | 			// this code to all source code (as opposed to exported
 83 | 			// declarations only).
 84 | 			if n.Tok == token.DEFINE {
 85 | 				// Some of the lhs variables may be re-declared,
 86 | 				// so technically they are not defs. We don't
 87 | 				// care for now.
 88 | 				for _, x := range n.Lhs {
 89 | 					// Each lhs expression should be an
 90 | 					// ident, but we are conservative and check.
 91 | 					if n, _ := x.(*ast.Ident); n != nil {
 92 | 						linkMap[n] = goLink{isVal: true}
 93 | 					}
 94 | 				}
 95 | 			}
 96 | 		case *ast.SelectorExpr:
 97 | 			// Detect qualified identifiers of the form pkg.ident.
 98 | 			// If anything fails we return true and collect individual
 99 | 			// identifiers instead.
100 | 			if x, _ := n.X.(*ast.Ident); x != nil {
101 | 				// Create links only if x is a qualified identifier.
102 | 				if obj := x.Obj; obj != nil && obj.Kind == ast.Pkg {
103 | 					if spec, _ := obj.Decl.(*ast.ImportSpec); spec != nil {
104 | 						// spec.Path.Value is the import path
105 | 						if path, err := strconv.Unquote(spec.Path.Value); err == nil {
106 | 							// Register two links, one for the package
107 | 							// and one for the qualified identifier.
108 | 							linkMap[x] = goLink{path: path}
109 | 							linkMap[n.Sel] = goLink{path: path, name: n.Sel.Name}
110 | 						}
111 | 					}
112 | 				}
113 | 			}
114 | 		case *ast.CompositeLit:
115 | 			// Detect field names within composite literals. These links should
116 | 			// be prefixed by the type name.
117 | 			fieldPath := ""
118 | 			prefix := ""
119 | 			switch typ := n.Type.(type) {
120 | 			case *ast.Ident:
121 | 				prefix = typ.Name + "."
122 | 			case *ast.SelectorExpr:
123 | 				if x, _ := typ.X.(*ast.Ident); x != nil {
124 | 					// Create links only if x is a qualified identifier.
125 | 					if obj := x.Obj; obj != nil && obj.Kind == ast.Pkg {
126 | 						if spec, _ := obj.Decl.(*ast.ImportSpec); spec != nil {
127 | 							// spec.Path.Value is the import path
128 | 							if path, err := strconv.Unquote(spec.Path.Value); err == nil {
129 | 								// Register two links, one for the package
130 | 								// and one for the qualified identifier.
131 | 								linkMap[x] = goLink{path: path}
132 | 								linkMap[typ.Sel] = goLink{path: path, name: typ.Sel.Name}
133 | 								fieldPath = path
134 | 								prefix = typ.Sel.Name + "."
135 | 							}
136 | 						}
137 | 					}
138 | 				}
139 | 			}
140 | 			for _, e := range n.Elts {
141 | 				if kv, ok := e.(*ast.KeyValueExpr); ok {
142 | 					if k, ok := kv.Key.(*ast.Ident); ok {
143 | 						// Note: there is some syntactic ambiguity here. We cannot determine
144 | 						// if this is a struct literal or a map literal without type
145 | 						// information. We assume struct literal.
146 | 						name := prefix + k.Name
147 | 						linkMap[k] = goLink{path: fieldPath, name: name}
148 | 					}
149 | 				}
150 | 			}
151 | 		case *ast.Ident:
152 | 			if l, ok := linkMap[n]; ok {
153 | 				links = append(links, l)
154 | 			} else {
155 | 				l := goLink{name: n.Name}
156 | 				if n.Obj == nil && doc.IsPredeclared(n.Name) {
157 | 					l.path = "builtin"
158 | 				}
159 | 				links = append(links, l)
160 | 			}
161 | 		}
162 | 		return true
163 | 	})
164 | 	return
165 | }
166 | 
167 | // postFormatAST makes any appropriate changes to the formatting of node in buf.
168 | // Specifically, it adds span links to each struct field, so they can be linked properly.
169 | // TODO(rsc): Why not do this as part of the linking above?
170 | func postFormatAST(buf *bytes.Buffer, node ast.Node) {
171 | 	if st, name := isStructTypeDecl(node); st != nil {
172 | 		addStructFieldIDAttributes(buf, name, st)
173 | 	}
174 | }
175 | 
176 | // isStructTypeDecl checks whether n is a struct declaration.
177 | // It either returns a non-nil StructType and its name, or zero values.
178 | func isStructTypeDecl(n ast.Node) (st *ast.StructType, name string) {
179 | 	gd, ok := n.(*ast.GenDecl)
180 | 	if !ok || gd.Tok != token.TYPE {
181 | 		return nil, ""
182 | 	}
183 | 	if gd.Lparen > 0 {
184 | 		// Parenthesized type. Who does that, anyway?
185 | 		// TODO: Reportedly gri does. Fix this to handle that too.
186 | 		return nil, ""
187 | 	}
188 | 	if len(gd.Specs) != 1 {
189 | 		return nil, ""
190 | 	}
191 | 	ts, ok := gd.Specs[0].(*ast.TypeSpec)
192 | 	if !ok {
193 | 		return nil, ""
194 | 	}
195 | 	st, ok = ts.Type.(*ast.StructType)
196 | 	if !ok {
197 | 		return nil, ""
198 | 	}
199 | 	return st, ts.Name.Name
200 | }
201 | 
202 | // addStructFieldIDAttributes modifies the contents of buf such that
203 | // all struct fields of the named struct have <span id='name.Field'>
204 | // in them, so people can link to /#Struct.Field.
205 | func addStructFieldIDAttributes(buf *bytes.Buffer, name string, st *ast.StructType) {
206 | 	if st.Fields == nil {
207 | 		return
208 | 	}
209 | 	// needsLink is a set of identifiers that still need to be
210 | 	// linked, where value == key, to avoid an allocation in func
211 | 	// linkedField.
212 | 	needsLink := make(map[string]string)
213 | 
214 | 	for _, f := range st.Fields.List {
215 | 		if len(f.Names) == 0 {
216 | 			continue
217 | 		}
218 | 		fieldName := f.Names[0].Name
219 | 		needsLink[fieldName] = fieldName
220 | 	}
221 | 	var newBuf bytes.Buffer
222 | 	foreachLine(buf.Bytes(), func(line []byte) {
223 | 		if fieldName := linkedField(line, needsLink); fieldName != "" {
224 | 			fmt.Fprintf(&newBuf, `<span id="%s.%s"></span>`, name, fieldName)
225 | 			delete(needsLink, fieldName)
226 | 		}
227 | 		newBuf.Write(line)
228 | 	})
229 | 	buf.Reset()
230 | 	buf.Write(newBuf.Bytes())
231 | }
232 | 
233 | // foreachLine calls fn for each line of in, where a line includes
234 | // the trailing "\n", except on the last line, if it doesn't exist.
235 | func foreachLine(in []byte, fn func(line []byte)) {
236 | 	for len(in) > 0 {
237 | 		nl := bytes.IndexByte(in, '\n')
238 | 		if nl == -1 {
239 | 			fn(in)
240 | 			return
241 | 		}
242 | 		fn(in[:nl+1])
243 | 		in = in[nl+1:]
244 | 	}
245 | }
246 | 
247 | // commentPrefix is the line prefix for comments after they've been HTMLified.
248 | var commentPrefix = []byte(`<span class="comment">// `)
249 | 
250 | // linkedField determines whether the given line starts with an
251 | // identifier in the provided ids map (mapping from identifier to the
252 | // same identifier). The line can start with either an identifier or
253 | // an identifier in a comment. If one matches, it returns the
254 | // identifier that matched. Otherwise it returns the empty string.
255 | func linkedField(line []byte, ids map[string]string) string {
256 | 	line = bytes.TrimSpace(line)
257 | 
258 | 	// For fields with a doc string of the
259 | 	// conventional form, we put the new span into
260 | 	// the comment instead of the field.
261 | 	// The "conventional" form is a complete sentence
262 | 	// per https://golang.org/s/style#comment-sentences like:
263 | 	//
264 | 	//    // Foo is an optional Fooer to foo the foos.
265 | 	//    Foo Fooer
266 | 	//
267 | 	// In this case, we want the #StructName.Foo
268 | 	// link to make the browser go to the comment
269 | 	// line "Foo is an optional Fooer" instead of
270 | 	// the "Foo Fooer" line, which could otherwise
271 | 	// obscure the docs above the browser's "fold".
272 | 	//
273 | 	// TODO: do this better, so it works for all
274 | 	// comments, including unconventional ones.
275 | 	line = bytes.TrimPrefix(line, commentPrefix)
276 | 	id := scanIdentifier(line)
277 | 	if len(id) == 0 {
278 | 		// No leading identifier. Avoid map lookup for
279 | 		// somewhat common case.
280 | 		return ""
281 | 	}
282 | 	return ids[string(id)]
283 | }
284 | 
285 | // scanIdentifier scans a valid Go identifier off the front of v and
286 | // either returns a subslice of v if there's a valid identifier, or
287 | // returns a zero-length slice.
288 | func scanIdentifier(v []byte) []byte {
289 | 	var n int // number of leading bytes of v belonging to an identifier
290 | 	for {
291 | 		r, width := utf8.DecodeRune(v[n:])
292 | 		if !(isLetter(r) || n > 0 && isDigit(r)) {
293 | 			break
294 | 		}
295 | 		n += width
296 | 	}
297 | 	return v[:n]
298 | }
299 | 
300 | func isLetter(ch rune) bool {
301 | 	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= utf8.RuneSelf && unicode.IsLetter(ch)
302 | }
303 | 
304 | func isDigit(ch rune) bool {
305 | 	return '0' <= ch && ch <= '9' || ch >= utf8.RuneSelf && unicode.IsDigit(ch)
306 | }
307 | 


--------------------------------------------------------------------------------
/internal/texthtml/texthtml.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2011 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | // Package texthtml formats text files to HTML.
  6 | package texthtml
  7 | 
  8 | import (
  9 | 	"bytes"
 10 | 	"fmt"
 11 | 	"go/ast"
 12 | 	"go/scanner"
 13 | 	"go/token"
 14 | 	"io"
 15 | 	"regexp"
 16 | 	"text/template"
 17 | )
 18 | 
 19 | // A Span describes a text span [start, end).
 20 | // The zero value of a Span is an empty span.
 21 | type Span struct {
 22 | 	Start, End int
 23 | }
 24 | 
 25 | func (s *Span) isEmpty() bool { return s.Start >= s.End }
 26 | 
 27 | // A Selection is an "iterator" function returning a text span.
 28 | // Repeated calls to a selection return consecutive, non-overlapping,
 29 | // non-empty spans, followed by an infinite sequence of empty
 30 | // spans. The first empty span marks the end of the selection.
 31 | type Selection func() Span
 32 | 
 33 | // A Config configures how to format text as HTML.
 34 | type Config struct {
 35 | 	Line       int       // if >= 1, number lines beginning with number Line, with <span class="ln">
 36 | 	GoComments bool      // mark comments in Go text with <span class="comment">
 37 | 	Playground bool      // format for playground sample
 38 | 	Highlight  string    // highlight matches for this regexp with <span class="highlight">
 39 | 	HL         string    // highlight lines that end with // HL (x/tools/present convention)
 40 | 	Selection  Selection // mark selected spans with <span class="selection">
 41 | 	AST        ast.Node  // link uses to declarations, assuming text is formatting of AST
 42 | 	OldDocs    bool      // emit links to ?m=old docs
 43 | }
 44 | 
 45 | // Format formats text to HTML according to the configuration cfg.
 46 | func Format(text []byte, cfg Config) (html []byte) {
 47 | 	var comments, highlights Selection
 48 | 	if cfg.GoComments {
 49 | 		comments = tokenSelection(text, token.COMMENT)
 50 | 	}
 51 | 	if cfg.Highlight != "" {
 52 | 		highlights = regexpSelection(text, cfg.Highlight)
 53 | 	}
 54 | 	if cfg.HL != "" {
 55 | 		highlights = hlSelection(text, cfg.HL)
 56 | 	}
 57 | 
 58 | 	var buf bytes.Buffer
 59 | 	var idents Selection = Spans()
 60 | 	var goLinks []goLink
 61 | 	if cfg.AST != nil {
 62 | 		idents = tokenSelection(text, token.IDENT)
 63 | 		goLinks = goLinksFor(cfg.AST)
 64 | 		if cfg.OldDocs {
 65 | 			for i := range goLinks {
 66 | 				goLinks[i].oldDocs = true
 67 | 			}
 68 | 		}
 69 | 	}
 70 | 
 71 | 	formatSelections(&buf, text, goLinks, comments, highlights, cfg.Selection, idents)
 72 | 
 73 | 	if cfg.AST != nil {
 74 | 		postFormatAST(&buf, cfg.AST)
 75 | 	}
 76 | 
 77 | 	trimSpaces(&buf)
 78 | 
 79 | 	if cfg.Line > 0 {
 80 | 		// Add line numbers in a separate pass.
 81 | 		old := buf.Bytes()
 82 | 		buf = bytes.Buffer{}
 83 | 		n := cfg.Line
 84 | 		for _, line := range bytes.Split(old, []byte("\n")) {
 85 | 			// The line numbers are inserted into the document via a CSS ::before
 86 | 			// pseudo-element. This prevents them from being copied when users
 87 | 			// highlight and copy text.
 88 | 			// ::before is supported in 98% of browsers: https://caniuse.com/#feat=css-gencontent
 89 | 			// This is also the trick Github uses to hide line numbers.
 90 | 			//
 91 | 			// The first tab for the code snippet needs to start in column 9, so
 92 | 			// it indents a full 8 spaces, hence the two nbsp's. Otherwise the tab
 93 | 			// character only indents a short amount.
 94 | 			//
 95 | 			// Due to rounding and font width Firefox might not treat 8 rendered
 96 | 			// characters as 8 characters wide, and subsequently may treat the tab
 97 | 			// character in the 9th position as moving the width from (7.5 or so) up
 98 | 			// to 8. See
 99 | 			// https://github.com/webcompat/web-bugs/issues/17530#issuecomment-402675091
100 | 			// for a fuller explanation. The solution is to add a CSS class to
101 | 			// explicitly declare the width to be 8 characters.
102 | 			if cfg.Playground {
103 | 				fmt.Fprintf(&buf, `<span class="number">%2d&nbsp;&nbsp;</span>`, n)
104 | 			} else {
105 | 				fmt.Fprintf(&buf, `<span id="L%d" class="ln">%6d&nbsp;&nbsp;</span>`, n, n)
106 | 			}
107 | 			n++
108 | 			buf.Write(line)
109 | 			buf.WriteByte('\n')
110 | 		}
111 | 	}
112 | 	return buf.Bytes()
113 | }
114 | 
115 | // formatSelections takes a text and writes it to w using link and span
116 | // writers lw and sw as follows: lw is invoked for consecutive span starts
117 | // and ends as specified through the links selection, and sw is invoked for
118 | // consecutive spans of text overlapped by the same selections as specified
119 | // by selections.
120 | func formatSelections(w io.Writer, text []byte, goLinks []goLink, selections ...Selection) {
121 | 	// compute the sequence of consecutive span changes
122 | 	changes := newMerger(selections)
123 | 
124 | 	// The i'th bit in bitset indicates that the text
125 | 	// at the current offset is covered by selections[i].
126 | 	bitset := 0
127 | 	lastOffs := 0
128 | 
129 | 	// Text spans are written in a delayed fashion
130 | 	// such that consecutive spans belonging to the
131 | 	// same selection can be combined (peephole optimization).
132 | 	// last describes the last span which has not yet been written.
133 | 	var last struct {
134 | 		begin, end int // valid if begin < end
135 | 		bitset     int
136 | 	}
137 | 
138 | 	// flush writes the last delayed text span
139 | 	flush := func() {
140 | 		if last.begin < last.end {
141 | 			selectionTag(w, text[last.begin:last.end], last.bitset)
142 | 		}
143 | 		last.begin = last.end // invalidate last
144 | 	}
145 | 
146 | 	// span runs the span [lastOffs, end) with the selection
147 | 	// indicated by bitset through the span peephole optimizer.
148 | 	span := func(end int) {
149 | 		if lastOffs < end { // ignore empty spans
150 | 			if last.end != lastOffs || last.bitset != bitset {
151 | 				// the last span is not adjacent to or
152 | 				// differs from the new one
153 | 				flush()
154 | 				// start a new span
155 | 				last.begin = lastOffs
156 | 			}
157 | 			last.end = end
158 | 			last.bitset = bitset
159 | 		}
160 | 	}
161 | 
162 | 	linkEnd := ""
163 | 	for {
164 | 		// get the next span change
165 | 		index, offs, start := changes.next()
166 | 		if index < 0 || offs > len(text) {
167 | 			// no more span changes or the next change
168 | 			// is past the end of the text - we're done
169 | 			break
170 | 		}
171 | 
172 | 		// format the previous selection span, determine
173 | 		// the new selection bitset and start a new span
174 | 		span(offs)
175 | 		if index == 3 { // Go link
176 | 			flush()
177 | 			if start {
178 | 				if len(goLinks) > 0 {
179 | 					start, end := goLinks[0].tags()
180 | 					io.WriteString(w, start)
181 | 					linkEnd = end
182 | 					goLinks = goLinks[1:]
183 | 				}
184 | 			} else {
185 | 				if linkEnd != "" {
186 | 					io.WriteString(w, linkEnd)
187 | 					linkEnd = ""
188 | 				}
189 | 			}
190 | 		} else {
191 | 			mask := 1 << uint(index)
192 | 			if start {
193 | 				bitset |= mask
194 | 			} else {
195 | 				bitset &^= mask
196 | 			}
197 | 		}
198 | 		lastOffs = offs
199 | 	}
200 | 	span(len(text))
201 | 	flush()
202 | }
203 | 
204 | // A merger merges a slice of Selections and produces a sequence of
205 | // consecutive span change events through repeated next() calls.
206 | type merger struct {
207 | 	selections []Selection
208 | 	spans      []Span // spans[i] is the next span of selections[i]
209 | }
210 | 
211 | const infinity int = 2e9
212 | 
213 | func newMerger(selections []Selection) *merger {
214 | 	spans := make([]Span, len(selections))
215 | 	for i, sel := range selections {
216 | 		spans[i] = Span{infinity, infinity}
217 | 		if sel != nil {
218 | 			if seg := sel(); !seg.isEmpty() {
219 | 				spans[i] = seg
220 | 			}
221 | 		}
222 | 	}
223 | 	return &merger{selections, spans}
224 | }
225 | 
226 | // next returns the next span change: index specifies the Selection
227 | // to which the span belongs, offs is the span start or end offset
228 | // as determined by the start value. If there are no more span changes,
229 | // next returns an index value < 0.
230 | func (m *merger) next() (index, offs int, start bool) {
231 | 	// find the next smallest offset where a span starts or ends
232 | 	offs = infinity
233 | 	index = -1
234 | 	for i, seg := range m.spans {
235 | 		switch {
236 | 		case seg.Start < offs:
237 | 			offs = seg.Start
238 | 			index = i
239 | 			start = true
240 | 		case seg.End < offs:
241 | 			offs = seg.End
242 | 			index = i
243 | 			start = false
244 | 		}
245 | 	}
246 | 	if index < 0 {
247 | 		// no offset found => all selections merged
248 | 		return
249 | 	}
250 | 	// offset found - it's either the start or end offset but
251 | 	// either way it is ok to consume the start offset: set it
252 | 	// to infinity so it won't be considered in the following
253 | 	// next call
254 | 	m.spans[index].Start = infinity
255 | 	if start {
256 | 		return
257 | 	}
258 | 	// end offset found - consume it
259 | 	m.spans[index].End = infinity
260 | 	// advance to the next span for that selection
261 | 	seg := m.selections[index]()
262 | 	if !seg.isEmpty() {
263 | 		m.spans[index] = seg
264 | 	}
265 | 	return
266 | }
267 | 
268 | // lineSelection returns the line spans for text as a Selection.
269 | func lineSelection(text []byte) Selection {
270 | 	i, j := 0, 0
271 | 	return func() (seg Span) {
272 | 		// find next newline, if any
273 | 		for j < len(text) {
274 | 			j++
275 | 			if text[j-1] == '\n' {
276 | 				break
277 | 			}
278 | 		}
279 | 		if i < j {
280 | 			// text[i:j] constitutes a line
281 | 			seg = Span{i, j}
282 | 			i = j
283 | 		}
284 | 		return
285 | 	}
286 | }
287 | 
288 | // tokenSelection returns, as a selection, the sequence of
289 | // consecutive occurrences of token sel in the Go src text.
290 | func tokenSelection(src []byte, sel token.Token) Selection {
291 | 	var s scanner.Scanner
292 | 	fset := token.NewFileSet()
293 | 	file := fset.AddFile("", fset.Base(), len(src))
294 | 	s.Init(file, src, nil, scanner.ScanComments)
295 | 	return func() (seg Span) {
296 | 		for {
297 | 			pos, tok, lit := s.Scan()
298 | 			if tok == token.EOF {
299 | 				break
300 | 			}
301 | 			offs := file.Offset(pos)
302 | 			if tok == sel {
303 | 				seg = Span{offs, offs + len(lit)}
304 | 				break
305 | 			}
306 | 		}
307 | 		return
308 | 	}
309 | }
310 | 
311 | // Spans is a helper function to make a Selection from a slice of spans.
312 | // Empty spans are discarded.
313 | func Spans(spans ...Span) Selection {
314 | 	i := 0
315 | 	return func() Span {
316 | 		for i < len(spans) {
317 | 			s := spans[i]
318 | 			i++
319 | 			if s.Start < s.End {
320 | 				// non-empty
321 | 				return s
322 | 			}
323 | 		}
324 | 		return Span{}
325 | 	}
326 | }
327 | 
328 | var hlRE = regexp.MustCompile(`(?m)\s*(.+)(\s+// (HL[a-zA-Z0-9_]*))$`)
329 | 
330 | // hlSelection returns the Selection for lines ending in // hl in text,
331 | // also removing any // HLxxx from the text (overwriting with spaces)
332 | func hlSelection(text []byte, hl string) Selection {
333 | 	lines := bytes.SplitAfter(text, []byte("\n"))
334 | 	off := 0
335 | 	var spans []Span
336 | 	for _, line := range lines {
337 | 		if m := hlRE.FindSubmatchIndex(line); m != nil {
338 | 			if string(line[m[6]:m[7]]) == hl {
339 | 				spans = append(spans, Span{off + m[2], off + m[3]})
340 | 			}
341 | 			for i := m[4]; i < m[5]; i++ {
342 | 				line[i] = ' '
343 | 			}
344 | 		}
345 | 		off += len(line)
346 | 	}
347 | 	return Spans(spans...)
348 | }
349 | 
350 | // regexpSelection computes the Selection for the regular expression expr in text.
351 | func regexpSelection(text []byte, expr string) Selection {
352 | 	var matches [][]int
353 | 	if rx, err := regexp.Compile(expr); err == nil {
354 | 		matches = rx.FindAllIndex(text, -1)
355 | 	}
356 | 	var spans []Span
357 | 	for _, m := range matches {
358 | 		spans = append(spans, Span{m[0], m[1]})
359 | 	}
360 | 	return Spans(spans...)
361 | }
362 | 
363 | // Span tags for all the possible selection combinations that may
364 | // be generated by FormatText. Selections are indicated by a bitset,
365 | // and the value of the bitset specifies the tag to be used.
366 | //
367 | // bit 0: comments
368 | // bit 1: highlights
369 | // bit 2: selections
370 | //
371 | var startTags = [][]byte{
372 | 	/* 000 */ []byte(``),
373 | 	/* 001 */ []byte(`<span class="comment">`),
374 | 	/* 010 */ []byte(`<span class="highlight">`),
375 | 	/* 011 */ []byte(`<span class="highlight-comment">`),
376 | 	/* 100 */ []byte(`<span class="selection">`),
377 | 	/* 101 */ []byte(`<span class="selection-comment">`),
378 | 	/* 110 */ []byte(`<span class="selection-highlight">`),
379 | 	/* 111 */ []byte(`<span class="selection-highlight-comment">`),
380 | }
381 | 
382 | var endTag = []byte(`</span>`)
383 | 
384 | func selectionTag(w io.Writer, text []byte, selections int) {
385 | 	if selections < len(startTags) {
386 | 		if tag := startTags[selections]; len(tag) > 0 {
387 | 			w.Write(tag)
388 | 			template.HTMLEscape(w, text)
389 | 			w.Write(endTag)
390 | 			return
391 | 		}
392 | 	}
393 | 	template.HTMLEscape(w, text)
394 | }
395 | 
396 | // trimSpaces removes trailing spaces at the end of each line in buf.
397 | func trimSpaces(buf *bytes.Buffer) {
398 | 	data := buf.Bytes()
399 | 	out := data[:0]
400 | 	for len(data) > 0 {
401 | 		j := bytes.IndexByte(data, '\n')
402 | 		if j < 0 {
403 | 			j = len(data)
404 | 		}
405 | 		var line []byte
406 | 		line, data = data[:j], data[j:]
407 | 		for len(line) > 0 && (line[len(line)-1] == ' ' || line[len(line)-1] == '\t') {
408 | 			line = line[:len(line)-1]
409 | 		}
410 | 		out = append(out, line...)
411 | 		if len(data) > 0 {
412 | 			out = append(out, '\n')
413 | 			data = data[1:]
414 | 		}
415 | 	}
416 | 	buf.Truncate(len(out))
417 | }
418 | 


--------------------------------------------------------------------------------
/site.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2013 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | // Package web implements a basic web site serving framework.
  6 | // The two fundamental types in this package are Site and Page.
  7 | //
  8 | // Sites
  9 | //
 10 | // A Site is an http.Handler that serves requests from a file system.
 11 | // Use NewSite(fsys) to create a new Site.
 12 | //
 13 | // The Site is defined primarily by the content of its file system fsys,
 14 | // which holds files to be served as well as templates for
 15 | // converting Markdown or HTML fragments into full HTML pages.
 16 | //
 17 | // Pages
 18 | //
 19 | // A Page, which is a map[string]interface{}, is the raw data that a Site renders into a web page.
 20 | // Typically a Page is loaded from a *.html or *.md file in the file system fsys, although
 21 | // dynamic pages can be computed and passed to ServePage as well,
 22 | // as described in “Serving Dynamic Pages” below.
 23 | //
 24 | // For a Page loaded from the file system, the key-value pairs in the map
 25 | // are initialized from the YAML or JSON metadata block at the top of a Markdown or HTML file,
 26 | // which looks like (YAML):
 27 | //
 28 | //	---
 29 | //	key: value
 30 | //	...
 31 | //	---
 32 | //
 33 | // or (JSON):
 34 | //
 35 | //	<!--{
 36 | //		"Key": "value",
 37 | //		...
 38 | //	}-->
 39 | //
 40 | // By convention, key-value pairs loaded from a metadata block use lower-case keys.
 41 | // For historical reasons, keys in JSON metadata are converted to lower-case when read,
 42 | // so that the two headers above both refer to a key with a lower-case k.
 43 | //
 44 | // A few keys have special meanings:
 45 | //
 46 | // The key-value pair “status: n” sets the HTTP response status to the integer code n.
 47 | //
 48 | // The key-value pair “redirect: url” causes requests for this page redirect to the given
 49 | // relative or absolute URL.
 50 | //
 51 | // The key-value pair “layout: name” selects the page layout template with the given name.
 52 | // See the next section, “Page Rendering”, for details about layout and rendering.
 53 | //
 54 | // In addition to these explicit key-value pairs, pages loaded from the file system
 55 | // have a few implicit key-value pairs added by the page loading process:
 56 | //
 57 | //	- File: the path in fsys to the file containing the page
 58 | //	- FileData: the file body, with the key-value metadata stripped
 59 | //	- URL: this page's URL path (/x/y/z for x/y/z.md, /x/y/ for x/y/index.md)
 60 | //
 61 | // The key “Content” is added during during the rendering process.
 62 | // See “Page Rendering” for details.
 63 | //
 64 | // Page Rendering
 65 | //
 66 | // A Page's content is rendered in two steps: conversion to content, and framing of content.
 67 | //
 68 | // To convert a page to content, the page's file body (its FileData key, a []byte) is parsed
 69 | // and executed as an HTML template, with the page itself passed as the template input data.
 70 | // The template output is then interpreted as Markdown (perhaps with embedded HTML),
 71 | // and converted to HTML. The result is stored in the page under the key “Content”,
 72 | // with type template.HTML.
 73 | //
 74 | // A page's conversion to content can be skipped entirely in dynamically-generated pages
 75 | // by setting the “Content” key before passing the page to ServePage.
 76 | //
 77 | // The second step is framing the content in the overall site HTML, which is done by
 78 | // executing the site template, again using the Page itself as the template input data.
 79 | //
 80 | // The site template is constructed from two files in the file system.
 81 | // The first file is the fsys's “site.tmpl”, which provides the overall HTML frame for the site.
 82 | // The second file is a layout-specific template file, selected by the Page's
 83 | // “layout: name” key-value pair.
 84 | // The renderer searches for “name.tmpl” in the directory containing the page's file,
 85 | // then in the parent of that directory, and so on up to the root.
 86 | // If no such template is found, the rendering fails and reports that error.
 87 | // As a special case, “layout: none” skips the second file entirely.
 88 | //
 89 | // If there is no “layout: name” key-value pair, then the renderer tries using an
 90 | // implicit “layout: default”, but if no such “default.tmpl” template file can be found,
 91 | // the renderer uses an implicit “layout: none” instead.
 92 | //
 93 | // By convention, the site template and the layout-specific template are connected as follows.
 94 | // The site template, at the point where the content should be rendered, executes:
 95 | //
 96 | //	{{block "layout" .}}{{.Content}}{{end}}
 97 | //
 98 | // The layout-specific template overrides this block by defining its own template named “layout”.
 99 | // For example:
100 | //
101 | //	{{define "layout"}}
102 | //	Here's some <blink>great</blink> content: {{.Content}}
103 | //	{{end}}
104 | //
105 | // The use of the “block” template construct ensures that
106 | // if there is no layout-specific template,
107 | // the content will still be rendered.
108 | //
109 | // Page Template Functions
110 | //
111 | // In this web server, templates can themselves be invoked as functions.
112 | // See https://pkg.go.dev/rsc.io/tmplfunc for more details about that feature.
113 | //
114 | // During page rendering, both when rendering a page to content and when framing the content,
115 | // the following template functions are available (in addition to those provided by the
116 | // template package itself and the per-template functions just mentioned).
117 | //
118 | // In all functions taking a file path f, if the path begins with a slash,
119 | // it is interpreted relative to the fsys root.
120 | // Otherwise, it is interpreted relative to the directory of the current page's URL.
121 | //
122 | // The “{{add x y}}”, “{{sub x y}}”, “{{mul x y}}”, and “{{div x y}}” functions
123 | // provide basic math on arguments of type int.
124 | //
125 | // The “{{code f [start [end]]}}” function returns a template.HTML of a formatted display
126 | // of code lines from the file f.
127 | // If both start and end are omitted, then the display shows the entire file.
128 | // If only the start line is specified, then the display shows that single line.
129 | // If both start and end are specified, then the display shows a range of lines
130 | // starting at start up to and including end.
131 | // The arguments start and end can take two forms: a number indicates a specific line number,
132 | // and a string is taken to be a regular expresion indicating the earliest matching line
133 | // in the file (or, for end, the earliest matching line after the start line).
134 | // Any lines ending in “OMIT” are elided from the display.
135 | //
136 | // For example:
137 | //
138 | //	{{code "hello.go" `^func main` `^}`}}
139 | //
140 | // The “{{data f}}” function reads the file f,
141 | // decodes it as YAML, and then returns the resulting data,
142 | // typically a map[string]interface{}.
143 | // It is effectively shorthand for “{{yaml (file f)}}”.
144 | //
145 | // The “{{file f}}” function reads the file f and returns its content as a string.
146 | //
147 | // The “{{first n slice}}” function returns a slice of the first n elements of slice,
148 | // or else slice itself when slice has fewer than n elements.
149 | //
150 | // The “{{markdown text}}” function interprets text (a string) as Markdown
151 | // and returns the equivalent HTML as a template.HTML.
152 | //
153 | // The “{{page f}}” function returns the page data (a Page)
154 | // for the static page contained in the file f.
155 | // The lookup ignores trailing slashes in f as well as the presence or absence
156 | // of extensions like .md, .html, /index.md, and /index.html,
157 | // making it possible for f to be a relative or absolute URL path instead of a file path.
158 | //
159 | // The “{{pages glob}}” function returns a slice of page data (a []Page)
160 | // for all pages loaded from files or directories
161 | // in fsys matching the given glob (a string),
162 | // according to the usual file path rules (if the glob starts with slash,
163 | // it is interpreted relative to the fsys root, and otherwise
164 | // relative to the directory of the page's URL).
165 | // If the glob pattern matches a directory,
166 | // the page for the directory's index.md or index.html is used.
167 | //
168 | // For example:
169 | //
170 | //	Here are all the articles:
171 | //	{{range (pages "/articles/*")}}
172 | //	- [{{.title}}]({{.URL}})
173 | //	{{end}}
174 | //
175 | // The “{{raw s}}” function converts s (a string) to type template.HTML without any escaping,
176 | // to allow using s as raw Markdown or HTML in the final output.
177 | //
178 | // The “{{yaml s}}” function decodes s (a string) as YAML and returns the resulting data.
179 | // It is most useful for defining templates that accept YAML-structured data as a literal argument.
180 | // For example:
181 | //
182 | //	{{define "quote info"}}
183 | //	{{with (yaml .info)}}
184 | //	.text
185 | //	— .name{{if .title}}, .title{{end}}
186 | //	{{end}}
187 | //
188 | //	{{quote `
189 | //	  text: If a program is too slow, it must have a loop.
190 | //	  name: Ken Thompson
191 | //	`}}
192 | //
193 | // The “path” and “strings” functions return package objects with methods for every top-level
194 | // function in these packages (except path.Split, which has more than one non-error result
195 | // and would not be invokable). For example, “{{strings.ToUpper "abc"}}”.
196 | //
197 | // Serving Requests
198 | //
199 | // A Site is an http.Handler that serves requests by consulting the underlying
200 | // file system and constructing and rendering pages, as well as serving binary
201 | // and text files.
202 | //
203 | // To serve a request for URL path /p, if fsys has a file
204 | // p/index.md, p/index.html, p.md, or p.html
205 | // (in that order of preference), then the Site opens that file,
206 | // parses it into a Page, renders the page as described
207 | // in the “Page Rendering” section above,
208 | // and responds to the request with the generated HTML.
209 | // If the request URL does not match the parsed page's URL,
210 | // then the Site responds with a redirect to the canonical URL.
211 | //
212 | // Otherwise, if fsys has a directory p and the Site
213 | // can find a template “dir.tmpl” in that directory or a parent,
214 | // then the Site responds with the rendering of
215 | //
216 | //	Page{
217 | //		"URL": "/p/",
218 | //		"File": "p",
219 | //		"layout": "dir",
220 | //		"dir": []fs.FileInfo(dir),
221 | //	}
222 | //
223 | // where dir is the directory contents.
224 | //
225 | // Otherwise, if fsys has a file p containing valid UTF-8 text
226 | // (at least up to the first kilobyte of the file) and the Site
227 | // can find a template “text.tmpl” in that file's directory or a parent,
228 | // and the file is not named robots.txt,
229 | // and the file does not have a .css, .js, .svg, or .ts extension,
230 | // then the Site responds with the rendering of
231 | //
232 | //	Page{
233 | //		"URL": "/p",
234 | //		"File": "p",
235 | //		"layout": "texthtml",
236 | //		"texthtml": template.HTML(texthtml),
237 | //	}
238 | //
239 | // where texthtml is the text file as rendered by the
240 | // golang.org/x/website/internal/texthtml package.
241 | // In the texthtml.Config, GoComments is set to true for
242 | // file names ending in .go;
243 | // the h URL query parameter, if present, is passed as Highlight,
244 | // and the s URL query parameter, if set to lo:hi, is passed as a
245 | // single-range Selection.
246 | //
247 | // If the request has the URL query parameter m=text,
248 | // then the text file content is not rendered or framed and is instead
249 | // served directly as a plain text response.
250 | //
251 | // If the request is for a file with a .ts extension the file contents
252 | // are transformed from TypeScript to JavaScript and then served with
253 | // a Content-Type=text/javascript header.
254 | //
255 | // Otherwise, if none of those cases apply but the request path p
256 | // does exist in the file system, then the Site passes the
257 | // request to an http.FileServer serving from fsys.
258 | // This last case handles binary static content as well as
259 | // textual static content excluded from the text file case above.
260 | //
261 | // Otherwise, the Site responds with the rendering of
262 | //
263 | //	Page{
264 | //		"URL": r.URL.Path,
265 | //		"status": 404,
266 | //		"layout": "error",
267 | //		"error": err,
268 | //	}
269 | //
270 | // where err is the “not exist” error returned by fs.Stat(fsys, p).
271 | // (See also the “Serving Errors” section below.)
272 | //
273 | // Serving Dynamic Requests
274 | //
275 | // Of course, a web site may wish to serve more than static content.
276 | // To allow dynamically generated web pages to make use of page
277 | // rendering and site templates, the Site.ServePage method can be
278 | // called with a dynamically generated Page value, which will then
279 | // be rendered and served as the result of the request.
280 | //
281 | // Serving Errors
282 | //
283 | // If an error occurs while serving a request r,
284 | // the Site responds with the rendering of
285 | //
286 | //	Page{
287 | //		"URL": r.URL.Path,
288 | //		"status": 500,
289 | //		"layout": "error",
290 | //		"error": err,
291 | //	}
292 | //
293 | // If that rendering itself fails, the Site responds with status 500
294 | // and the cryptic page text “error rendering error”.
295 | //
296 | // The Site.ServeError and Site.ServeErrorStatus methods provide a way
297 | // for dynamic servers to generate similar responses.
298 | //
299 | package web
300 | 
301 | import (
302 | 	"bytes"
303 | 	"errors"
304 | 	"fmt"
305 | 	"html"
306 | 	"html/template"
307 | 	"io/fs"
308 | 	"log"
309 | 	"net/http"
310 | 	"path"
311 | 	"regexp"
312 | 	"strconv"
313 | 	"strings"
314 | 	"sync"
315 | 
316 | 	"rsc.io/web/internal/texthtml"
317 | )
318 | 
319 | // A Site is an http.Handler that serves requests from a file system.
320 | // See the package doc comment for details.
321 | type Site struct {
322 | 	fs         fs.FS            // from NewSite
323 | 	fileServer http.Handler     // http.FileServer(http.FS(fs))
324 | 	funcs      template.FuncMap // accumulated from s.Funcs
325 | 	cache      sync.Map         // canonical file path -> *pageFile, for site.openPage
326 | }
327 | 
328 | // NewSite returns a new Site for serving pages from the file system fsys.
329 | func NewSite(fsys fs.FS) *Site {
330 | 	return &Site{
331 | 		fs:         fsys,
332 | 		fileServer: http.FileServer(http.FS(fsys)),
333 | 	}
334 | }
335 | 
336 | // Funcs adds the functions in m to the set of functions available to templates.
337 | // Funcs must not be called concurrently with any page rendering.
338 | func (s *Site) Funcs(m template.FuncMap) {
339 | 	if s.funcs == nil {
340 | 		s.funcs = make(template.FuncMap)
341 | 	}
342 | 	for k, v := range m {
343 | 		s.funcs[k] = v
344 | 	}
345 | }
346 | 
347 | // readFile returns the content of the named file in the site's file system.
348 | // If file begins with a slash, it is interpreted relative to the root of the file system.
349 | // Otherwise, it is interpreted relative to dir.
350 | func (site *Site) readFile(dir, file string) ([]byte, error) {
351 | 	if strings.HasPrefix(file, "/") {
352 | 		file = path.Clean(file)
353 | 	} else {
354 | 		file = path.Join(dir, file)
355 | 	}
356 | 	file = strings.Trim(file, "/")
357 | 	if file == "" {
358 | 		file = "."
359 | 	}
360 | 	return fs.ReadFile(site.fs, file)
361 | }
362 | 
363 | // ServeError is ServeErrorStatus with HTTP status code 500 (internal server error).
364 | func (s *Site) ServeError(w http.ResponseWriter, r *http.Request, err error) {
365 | 	s.ServeErrorStatus(w, r, err, http.StatusInternalServerError)
366 | }
367 | 
368 | // ServeErrorStatus responds to the request
369 | // with the given error and HTTP status.
370 | // It is equivalent to calling ServePage(w, r, p) where p is:
371 | //
372 | //	Page{
373 | //		"URL": r.URL.Path,
374 | //		"status": status,
375 | //		"layout": error,
376 | //		"error": err,
377 | //	}
378 | //
379 | func (s *Site) ServeErrorStatus(w http.ResponseWriter, r *http.Request, err error, status int) {
380 | 	s.serveErrorStatus(w, r, err, status, false)
381 | }
382 | 
383 | func (s *Site) serveErrorStatus(w http.ResponseWriter, r *http.Request, err error, status int, renderingError bool) {
384 | 
385 | 	if renderingError {
386 | 		log.Printf("error rendering error: %v", err)
387 | 		w.WriteHeader(status)
388 | 		w.Write([]byte("error rendering error"))
389 | 		return
390 | 	}
391 | 
392 | 	p := Page{
393 | 		"URL":    r.URL.Path,
394 | 		"status": status,
395 | 		"layout": "error",
396 | 		"error":  err,
397 | 	}
398 | 	s.servePage(w, r, p, true)
399 | }
400 | 
401 | // ServePage renders the page p to HTML and writes that HTML to w.
402 | // See the package doc comment for details about page rendering.
403 | //
404 | // So that all templates can assume the presence of p["URL"],
405 | // if p["URL"] is unset or does not have type string, then ServePage
406 | // sets p["URL"] to r.URL.Path in a clone of p before rendering the page.
407 | func (s *Site) ServePage(w http.ResponseWriter, r *http.Request, p Page) {
408 | 	s.servePage(w, r, p, false)
409 | }
410 | 
411 | func (s *Site) servePage(w http.ResponseWriter, r *http.Request, p Page, renderingError bool) {
412 | 	html, err := s.renderHTML(p, "site.tmpl", r)
413 | 	if err != nil {
414 | 		s.serveErrorStatus(w, r, fmt.Errorf("template execution: %v", err), http.StatusInternalServerError, renderingError)
415 | 		return
416 | 	}
417 | 	if code, ok := p["status"].(int); ok {
418 | 		w.WriteHeader(code)
419 | 	}
420 | 	w.Write(html)
421 | }
422 | 
423 | // ServeHTTP implements http.Handler, serving from a file in the site.
424 | // See the Site type documentation for details about how requests are handled.
425 | func (s *Site) ServeHTTP(w http.ResponseWriter, r *http.Request) {
426 | 	abspath := r.URL.Path
427 | 	relpath := path.Clean(strings.TrimPrefix(abspath, "/"))
428 | 
429 | 	// Is it a page we can generate?
430 | 	if p, err := s.openPage(relpath); err == nil {
431 | 		if p.url != abspath {
432 | 			// Redirect to canonical path.
433 | 			status := http.StatusMovedPermanently
434 | 			if i, ok := p.page["status"].(int); ok {
435 | 				status = i
436 | 			}
437 | 			http.Redirect(w, r, p.url, status)
438 | 			return
439 | 		}
440 | 		// Serve from the actual filesystem path.
441 | 		s.serveHTML(w, r, p)
442 | 		return
443 | 	}
444 | 
445 | 	// Is it a directory or file we can serve?
446 | 	info, err := fs.Stat(s.fs, relpath)
447 | 	if err != nil {
448 | 		status := http.StatusInternalServerError
449 | 		if errors.Is(err, fs.ErrNotExist) {
450 | 			status = http.StatusNotFound
451 | 		}
452 | 		s.ServeErrorStatus(w, r, err, status)
453 | 		return
454 | 	}
455 | 
456 | 	// Serve directory.
457 | 	if info != nil && info.IsDir() {
458 | 		if _, ok := s.findLayout(relpath, "dir"); ok {
459 | 			if !maybeRedirect(w, r) {
460 | 				s.serveDir(w, r, relpath)
461 | 			}
462 | 			return
463 | 		}
464 | 	}
465 | 
466 | 	// Serve text file.
467 | 	if isTextFile(s.fs, relpath) {
468 | 		if _, ok := s.findLayout(path.Dir(relpath), "texthtml"); ok {
469 | 			if !maybeRedirectFile(w, r) {
470 | 				s.serveText(w, r, relpath)
471 | 			}
472 | 			return
473 | 		}
474 | 	}
475 | 
476 | 	// Serve raw bytes.
477 | 	s.fileServer.ServeHTTP(w, r)
478 | }
479 | 
480 | func maybeRedirect(w http.ResponseWriter, r *http.Request) (redirected bool) {
481 | 	canonical := path.Clean(r.URL.Path)
482 | 	if !strings.HasSuffix(canonical, "/") {
483 | 		canonical += "/"
484 | 	}
485 | 	if r.URL.Path != canonical {
486 | 		url := *r.URL
487 | 		url.Path = canonical
488 | 		http.Redirect(w, r, url.String(), http.StatusMovedPermanently)
489 | 		redirected = true
490 | 	}
491 | 	return
492 | }
493 | 
494 | func maybeRedirectFile(w http.ResponseWriter, r *http.Request) (redirected bool) {
495 | 	c := path.Clean(r.URL.Path)
496 | 	c = strings.TrimRight(c, "/")
497 | 	if r.URL.Path != c {
498 | 		url := *r.URL
499 | 		url.Path = c
500 | 		http.Redirect(w, r, url.String(), http.StatusMovedPermanently)
501 | 		redirected = true
502 | 	}
503 | 	return
504 | }
505 | 
506 | func (s *Site) serveHTML(w http.ResponseWriter, r *http.Request, p *pageFile) {
507 | 	src, _ := p.page["FileData"].(string)
508 | 	filePath, _ := p.page["File"].(string)
509 | 	isMarkdown := strings.HasSuffix(filePath, ".md")
510 | 
511 | 	// if it begins with "<!DOCTYPE " assume it is standalone
512 | 	// html that doesn't need the template wrapping.
513 | 	if strings.HasPrefix(src, "<!DOCTYPE ") {
514 | 		w.Write([]byte(src))
515 | 		return
516 | 	}
517 | 
518 | 	// Template is enabled always in Markdown.
519 | 	// It can only be disabled for HTML files.
520 | 	isTemplate, _ := p.page["template"].(bool)
521 | 	if !isTemplate && !isMarkdown {
522 | 		p.page["Content"] = template.HTML(src)
523 | 	}
524 | 	s.ServePage(w, r, p.page)
525 | }
526 | 
527 | func (s *Site) serveDir(w http.ResponseWriter, r *http.Request, relpath string) {
528 | 	if maybeRedirect(w, r) {
529 | 		return
530 | 	}
531 | 
532 | 	list, err := fs.ReadDir(s.fs, relpath)
533 | 	if err != nil {
534 | 		s.ServeError(w, r, err)
535 | 		return
536 | 	}
537 | 
538 | 	var info []fs.FileInfo
539 | 	for _, d := range list {
540 | 		i, err := d.Info()
541 | 		if err == nil {
542 | 			info = append(info, i)
543 | 		}
544 | 	}
545 | 
546 | 	s.ServePage(w, r, Page{
547 | 		"URL":    r.URL.Path,
548 | 		"File":   relpath,
549 | 		"layout": "dir",
550 | 		"dir":    info,
551 | 	})
552 | }
553 | 
554 | func (s *Site) serveText(w http.ResponseWriter, r *http.Request, relpath string) {
555 | 	src, err := fs.ReadFile(s.fs, relpath)
556 | 	if err != nil {
557 | 		log.Printf("ReadFile: %s", err)
558 | 		s.ServeError(w, r, err)
559 | 		return
560 | 	}
561 | 
562 | 	if r.FormValue("m") == "text" {
563 | 		s.serveRawText(w, src)
564 | 		return
565 | 	}
566 | 
567 | 	cfg := texthtml.Config{
568 | 		GoComments: path.Ext(relpath) == ".go",
569 | 		Highlight:  r.FormValue("h"),
570 | 		Selection:  rangeSelection(r.FormValue("s")),
571 | 		Line:       1,
572 | 	}
573 | 
574 | 	var buf bytes.Buffer
575 | 	buf.WriteString("<pre>")
576 | 	buf.Write(texthtml.Format(src, cfg))
577 | 	buf.WriteString("</pre>")
578 | 
579 | 	fmt.Fprintf(&buf, `<p><a href="/%s?m=text">View as plain text</a></p>`, html.EscapeString(relpath))
580 | 
581 | 	s.ServePage(w, r, Page{
582 | 		"URL":      r.URL.Path,
583 | 		"File":     relpath,
584 | 		"layout":   "texthtml",
585 | 		"texthtml": template.HTML(buf.String()),
586 | 	})
587 | }
588 | 
589 | var selRx = regexp.MustCompile(`^([0-9]+):([0-9]+)`)
590 | 
591 | // rangeSelection computes the Selection for a text range described
592 | // by the argument str, of the form Start:End, where Start and End
593 | // are decimal byte offsets.
594 | func rangeSelection(str string) texthtml.Selection {
595 | 	m := selRx.FindStringSubmatch(str)
596 | 	if len(m) >= 2 {
597 | 		from, _ := strconv.Atoi(m[1])
598 | 		to, _ := strconv.Atoi(m[2])
599 | 		if from < to {
600 | 			return texthtml.Spans(texthtml.Span{Start: from, End: to})
601 | 		}
602 | 	}
603 | 	return nil
604 | }
605 | 
606 | func (s *Site) serveRawText(w http.ResponseWriter, text []byte) {
607 | 	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
608 | 	w.Write(text)
609 | }
610 | 


--------------------------------------------------------------------------------