Commit `d6789522d3`

d6789522d3dd076f7c98dafa3e7d42df09252093

parent: 7eb5e5e223

Verified · cmc

cmc <hello@cleberg.net> · 2026-07-15 07:25 UTC

fix: document exported API, fix naming, and harden Download

The remaining golangci-lint findings. These land together because the
Url -> URL rename spans util.go, parsers.go and wrapper.go, and splitting
it would leave an intermediate commit that does not compile.

Download() carried the most serious bug here: try() only prints an error,
it does not return, so a failed request fell through to
resp.Body.Close() on a nil resp and panicked. Every failure path now
returns the zero Downloaded, and callers check Status. ReturnHTTPError
guards against the resulting status 0, which would otherwise panic
WriteHeader. Requests carry a context with a timeout (noctx), and a
download-proxy now routes through ProxiedTransport so it keeps the DA
throttle and timeouts.

Also:
- doc comments on all 48 exported symbols (revive's exported rule, with
  checkPrivateReceivers, since most of app is exported methods on the
  unexported skunkyart type), plus package docs in new doc.go files so
  both the embed and non-embed builds are covered.
- ST1003 naming: UrlBuilder -> URLBuilder, id_search -> idSearch,
  cache_config -> cacheConfig, TXT_RAW -> TxtRaw, mediaUrl -> mediaURL.
- explicit json tags on structs that are unmarshaled (musttag); the
  hyphenated keys already had tags, the rest relied on case-insensitive
  fallback. Behaviour is unchanged.
- modernization: range-over-int, WaitGroup.Go, stale +build lines,
  interface{} -> any, strings.Builder over string concatenation in a loop.

Layout: unified · split

app/config.go +23 −15

 	"github.com/zerolabsco/devianter"
 )
+// Release carries the build's version and description, set at link time and
+// shown by --help and the API.
 var Release struct {
 	Version     string
 	Description string
 }
-type cache_config struct {
+type cacheConfig struct {
-	Enabled        bool
+	Enabled        bool   `json:"enabled"`
-	MemCache       bool `json:"memcache"`
+	MemCache       bool   `json:"memcache"`
-	Path           string
+	Path           string `json:"path"`
-	MaxSize        int64 `json:"max-size"`
+	MaxSize        int64  `json:"max-size"`
-	Lifetime       string
+	Lifetime       string `json:"lifetime"`
-	UpdateInterval int64 `json:"update-interval"`
+	UpdateInterval int64  `json:"update-interval"`
 }
 type config struct {
 	cfg           string
-	Listen        string
+	Listen        string      `json:"listen"`
-	URI           string `json:"uri"`
+	URI           string      `json:"uri"`
-	Cache         cache_config
+	Cache         cacheConfig `json:"cache"`
-	Proxy, Nsfw   bool
+	Proxy         bool        `json:"proxy"`
-	UserAgent     string `json:"user-agent"`
+	Nsfw          bool        `json:"nsfw"`
-	DownloadProxy string `json:"download-proxy"`
+	UserAgent     string      `json:"user-agent"`
-	StaticPath    string `json:"static-path"`
+	DownloadProxy string      `json:"download-proxy"`
+	StaticPath    string      `json:"static-path"`
 }
+// CFG is the running instance's configuration, holding the defaults below until
+// ExecuteConfig overwrites them from the config file.
 var CFG = config{
 	cfg:    "config.json",
 	Listen: "127.0.0.1:3003",
 	URI:    "/",
-	Cache: cache_config{
+	Cache: cacheConfig{
 		Enabled:        false,
 		Path:           "cache",
 		UpdateInterval: 1,
 var lifetimeParsed int64
+// ExecuteConfig loads the config file into CFG, validates it, and starts the
+// cache rotation loop if caching is on. It exits the process on a config that
+// cannot be read or that asks for caching without proxying.
 func ExecuteConfig() {
 	if CFG.cfg != "" {
 		f, err := os.ReadFile(CFG.cfg)

app/doc.go added +7

@@ -0,0 +1,7 @@
	1	// Package app implements SkunkyArt: a JavaScript-free alternative frontend for
	2	// DeviantArt.
	3	//
	4	// It fetches upstream data through the devianter library, renders it into static
	5	// HTML (or Atom feeds) server-side, and optionally proxies and caches media so
	6	// that no request from the browser reaches DeviantArt directly.
	7	package app

app/httpclient_test.go +8 −10

 	return httptest.NewRecorder().Result(), nil
 }
-func newTestThrottle(base http.RoundTripper, gap time.Duration, max int) *daThrottle {
+func newTestThrottle(base http.RoundTripper, gap time.Duration, maxConcurrent int) *daThrottle {
-	return &daThrottle{base: base, sem: make(chan struct{}, max)}
+	return &daThrottle{base: base, sem: make(chan struct{}, maxConcurrent)}
 }
 // DeviantArt requests must be spaced by at least daMinInterval.
 	start := time.Now()
 	const n = 3
-	for i := 0; i < n; i++ {
+	for range n {
 		req, _ := http.NewRequest("GET", "https://www.deviantart.com/_puppy/x", nil)
 		if _, err := tr.RoundTrip(req); err != nil {
 			t.Fatalf("unexpected error: %v", err)
 	tr := newTestThrottle(stub, daMinInterval, daMaxConcurrent)
 	start := time.Now()
-	for i := 0; i < 5; i++ {
+	for range 5 {
 		req, _ := http.NewRequest("GET", "https://images-wixmp-ed30a86b8c4ca887773594c2.wixmp.com/f/x.jpg", nil)
 		if _, err := tr.RoundTrip(req); err != nil {
 			t.Fatalf("unexpected error: %v", err)
 	tr := newTestThrottle(counting, daMinInterval, daMaxConcurrent)
 	var wg sync.WaitGroup
-	for i := 0; i < 6; i++ {
+	for range 6 {
-		wg.Add(1)
+		wg.Go(func() {
-		go func() {
-			defer wg.Done()
 			req, _ := http.NewRequest("GET", "https://www.deviantart.com/_puppy/x", nil)
-			tr.RoundTrip(req)
+			_, _ = tr.RoundTrip(req)
-		}()
+		})
 	}
 	wg.Wait()

app/parsers.go +65 −45

 	"golang.org/x/net/html"
 )
+// ParseComments renders a comment thread, nesting replies under the comment they
+// answer. It returns a placeholder message rather than failing if the upstream
+// fetch errored.
 func (s skunkyart) ParseComments(c devianter.Comments, daError devianter.Error) string {
 	if daError.RAW != nil {
 		return "Failed to fetch comments :("
 		cmmts.WriteString(`"><p id="`)
 		cmmts.WriteString(strconv.Itoa(x.ID))
 		cmmts.WriteString(`"><img src="`)
-		cmmts.WriteString(UrlBuilder("media", "emojitar", x.User.Username, "?type=a"))
+		cmmts.WriteString(URLBuilder("media", "emojitar", x.User.Username, "?type=a"))
 		cmmts.WriteString(`" width="30px" height="30px"><a href="`)
-		cmmts.WriteString(UrlBuilder("group_user", "?q=", x.User.Username, "&type=a"))
+		cmmts.WriteString(URLBuilder("group_user", "?q=", x.User.Username, "&type=a"))
 		cmmts.WriteString(`"><b`)
 		cmmts.WriteString(` class="`)
 		if x.User.Banned {
 	return cmmts.String()
 }
+// DeviationList renders devs as an HTML grid, or as an Atom feed when the
+// request asked for one and allowAtom permits it. NSFW entries are dropped
+// unless the instance allows them. Passing content adds a navigation bar.
 func (s skunkyart) DeviationList(devs []devianter.Deviation, allowAtom bool, content ...DeviationList) string {
 	if s.Atom && s.Page > 1 {
 		s.ReturnHTTPError(400)
 	for i, l := 0, len(devs); i < l; i++ {
 		data := &devs[i]
-		if preview, fullview := ParseMedia(data.Media, 320), ParseMedia(data.Media); !(data.NSFW && !CFG.Nsfw) {
+		if preview, fullview := ParseMedia(data.Media, 320), ParseMedia(data.Media); !data.NSFW || CFG.Nsfw {
 			if allowAtom && s.Atom {
-				s.Writer.Header().Add("Content-type", "application/atom+xml")
+				s.Writer.Header().Add("Content-Type", "application/atom+xml")
 				id := strconv.Itoa(data.ID)
 				listContent.WriteString(`<entry><author><name>`)
 				listContent.WriteString(data.Author.Username)
 				listContent.WriteString(`</name></author><title>`)
 				listContent.WriteString(data.Title)
 				listContent.WriteString(`</title><link rel="alternate" type="text/html" href="`)
-				listContent.WriteString(UrlBuilder("post", data.Author.Username, "atom-"+id))
+				listContent.WriteString(URLBuilder("post", data.Author.Username, "atom-"+id))
 				listContent.WriteString(`"/><id>`)
 				listContent.WriteString(id)
 				listContent.WriteString(`</id><published>`)
 				listContent.WriteString(`</media:title><media:thumbinal url="`)
 				listContent.WriteString(preview)
 				listContent.WriteString(`"/></media:group><content type="xhtml"><div xmlns="http://www.w3.org/1999/xhtml"><a href="`)
-				listContent.WriteString(ConvertDeviantArtUrlToSkunkyArt(data.Url))
+				listContent.WriteString(ConvertDeviantArtURLToSkunkyArt(data.Url))
 				listContent.WriteString(`"><img src="`)
 				listContent.WriteString(fullview)
 				listContent.WriteString(`"/></a><p>`)
 					listContent.WriteString(`<h1>[ TEXT ]</h1>`)
 				}
 				listContent.WriteString(`<br><a href="`)
-				listContent.WriteString(ConvertDeviantArtUrlToSkunkyArt(data.Url))
+				listContent.WriteString(ConvertDeviantArtURLToSkunkyArt(data.Url))
 				listContent.WriteString(`">`)
 				listContent.WriteString(data.Author.Username)
 				listContent.WriteString(" - ")
 		list.WriteString(`<?xml version="1.0" encoding="UTF-8"?><feed xmlns:media="http://search.yahoo.com/mrss/" xmlns="http://www.w3.org/2005/Atom">`)
 		list.WriteString(`<title>`)
-		if s.Type == 0 {
+		switch {
+		case s.Type == 0:
 			list.WriteString("Daily Deviations")
-		} else if s.Type == 'g' && len(devs) != 0 {
+		case s.Type == 'g' && len(devs) != 0:
 			list.WriteString(devs[0].Author.Username)
-		} else {
+		default:
 			list.WriteString("SkunkyArt")
 		}
 		list.WriteString(`</title>`)
 }
 /* DESCRIPTION/COMMENT PARSER */
+// text is one styled run within a description: the rendered HTML, the raw source
+// it came from, and the offsets it spans in the original block.
 type text struct {
-	TXT     string
+	Txt    string
-	TXT_RAW string
+	TxtRaw string
-	From    int
+	From   int
-	To      int
+	To     int
 }
-// TODO: rewrite this whole mess
+// ParseDescription renders a DeviantArt description into HTML, handling both the
+// Draft.js-style JSON payload and the plain HTML markup DeviantArt returns, and
+// rewriting embedded links and artwork references to point at this instance.
+//
+// TODO: rewrite this whole mess.
 func ParseDescription(dscr devianter.Text) string {
 	var parsedDescription strings.Builder
 	TagBuilder := func(content string, tags ...string) string {
 		l := len(tags)
-		for x := 0; x < l; x++ {
+		for x := range l {
 			var htm strings.Builder
 			htm.WriteString("<")
 			htm.WriteString(tags[x])
 		}
 		return content
 	}
-	DeleteTrackingFromUrl := func(url string) string {
+	DeleteTrackingFromURL := func(url string) string {
 		if len(url) > 42 && url[:42] == "https://www.deviantart.com/users/outgoing?" {
 			url = url[42:]
 		}
 		description[dl-1] == '}' {
 		var descr struct {
 			Blocks []struct {
-				Text, Type        string
+				Text              string `json:"text"`
+				Type              string `json:"type"`
 				InlineStyleRanges []struct {
-					Offset, Length int
+					Offset int    `json:"offset"`
-					Style          string
+					Length int    `json:"length"`
-				}
+					Style  string `json:"style"`
+				} `json:"inlineStyleRanges"`
 				EntityRanges []struct {
-					Offset, Length int
+					Offset int `json:"offset"`
-					Key            int
+					Length int `json:"length"`
-				}
+					Key    int `json:"key"`
+				} `json:"entityRanges"`
 				Data struct {
-					TextAlignment string
+					TextAlignment string `json:"textAlignment"`
-				}
+				} `json:"data"`
-			}
+			} `json:"blocks"`
 			EntityMap map[string]struct {
-				Type string
+				Type string `json:"type"`
 				Data struct {
-					Url    string
+					URL    string `json:"url"`
 					Config struct {
-						Aligment string
+						// "aligment" is DeviantArt's own spelling; do not correct it.
-						Width    int
+						Aligment string `json:"aligment"`
-					}
+						Width    int    `json:"width"`
-					Data devianter.Deviation
+					} `json:"config"`
-				}
+					Data devianter.Deviation `json:"data"`
-			}
+				} `json:"data"`
+			} `json:"entityMap"`
 		}
 		e := json.Unmarshal([]byte(description), &descr)
 		try(e)
 		urls := make(map[int]string)
 		for n, x := range descr.EntityMap {
 			num, _ := strconv.Atoi(n)
-			if x.Data.Url != "" {
+			if x.Data.URL != "" {
-				urls[num] = DeleteTrackingFromUrl(x.Data.Url)
+				urls[num] = DeleteTrackingFromURL(x.Data.URL)
 			}
 			entities[num] = x.Data.Data
 		}
 					FT := Styles.From * Styles.To
 					tags[FT] = append(tags[FT], rngs.Style)
 				}
-				for n := 0; n < len(Styles); n++ {
+				for n := range Styles {
 					Styles := &Styles[n]
-					Styles.TXT_RAW = x.Text[Styles.From:Styles.To]
+					Styles.TxtRaw = x.Text[Styles.From:Styles.To]
-					Styles.TXT = TagBuilder(Styles.TXT_RAW, tags[Styles.From*Styles.To]...)
+					Styles.Txt = TagBuilder(Styles.TxtRaw, tags[Styles.From*Styles.To]...)
 				}
 			}
 				if len(x.EntityRanges) != 0 {
 					d := entities[x.EntityRanges[0].Key]
 					parsedDescription.WriteString(`<a href="`)
-					parsedDescription.WriteString(ConvertDeviantArtUrlToSkunkyArt(d.Url))
+					parsedDescription.WriteString(ConvertDeviantArtURLToSkunkyArt(d.Url))
 					parsedDescription.WriteString(`"><img width="50%" src="`)
 					parsedDescription.WriteString(ParseMedia(d.Media))
 					parsedDescription.WriteString(`" title="`)
 							parsedDescription.WriteString(`<a target="_blank" href="`)
 							parsedDescription.WriteString(urls[ra.Key])
 							parsedDescription.WriteString(`">`)
-							parsedDescription.WriteString(r.TXT)
+							parsedDescription.WriteString(r.Txt)
 							parsedDescription.WriteString(`</a>`)
 						} else if l > n+1 {
-							parsedDescription.WriteString(r.TXT)
+							parsedDescription.WriteString(r.Txt)
 						}
 						parsedDescription.WriteString(TagBuilder(tag, x.Text[r.To:]))
 					}
 			switch tt.Next() {
 			case html.ErrorToken:
 				return parsedDescription.String()
+			case html.CommentToken, html.DoctypeToken:
+				// No renderable content; skip.
 			case html.StartTagToken, html.EndTagToken, html.SelfClosingTagToken:
 				token := tt.Token()
 				switch token.Data {
 				case "a":
 					for _, a := range token.Attr {
 						if a.Key == "href" {
-							url := DeleteTrackingFromUrl(a.Val)
+							url := DeleteTrackingFromURL(a.Val)
 							parsedDescription.WriteString(`<a target="_blank" href="`)
 							parsedDescription.WriteString(url)
 							parsedDescription.WriteString(`">`)
 						switch a.Key {
 						case "src":
 							if len(a.Val) > 9 && a.Val[8:9] == "e" {
-								uri = UrlBuilder("media", "emojitar", a.Val[37:len(a.Val)-4], "?type=e")
+								uri = URLBuilder("media", "emojitar", a.Val[37:len(a.Val)-4], "?type=e")
 							}
 						case "title":
 							title = a.Val

app/stat-darwin.go −1

	@@ -1,5 +1,4 @@
1	//go:build darwin	1	//go:build darwin
2	// +build darwin
3		2
4	package app	3	package app
5		4

app/util.go +95 −32

	@@ -1,7 +1,9 @@
1	package app	1	package app
2		2
3	import (	3	import (
		4	"context"
4	"encoding/json"	5	"encoding/json"
		6	"fmt"
5	"io"	7	"io"
6	"net/http"	8	"net/http"
7	"net/url"	9	"net/url"
	@@ -17,7 +19,12 @@ import (
17	)	19	)
18		20
19	/* INTERNAL */	21	/* INTERNAL */
20	var wr = io.WriteString	22
		23	// wr writes s to w. A write error here means the client went away mid-response,
		24	// which a handler cannot act on, so it is deliberately discarded.
		25	func wr(w io.Writer, s string) {
		26	_, _ = io.WriteString(w, s)
		27	}
21		28
22	func exit(msg string, code int) {	29	func exit(msg string, code int) {
23	println(msg)	30	println(msg)
	@@ -34,15 +41,22 @@ func tryWithExitStatus(err error, code int) {
34	}	41	}
35	}	42	}
36		43
		44	// restore swallows a panic in the calling goroutine so that one bad parse cannot
		45	// take the whole process down. The panic is logged rather than dropped silently.
37	func restore() {	46	func restore() {
38	if r := recover(); r != nil {	47	if r := recover(); r != nil {
39	recover()	48	println("recovered from panic:", fmt.Sprint(r))
40	}	49	}
41	}	50	}
42		51
43	var instances []byte	52	var instances []byte
		53
		54	// About is the instance list and settings shown in the frontend, refreshed by
		55	// RefreshInstances.
44	var About instanceAbout	56	var About instanceAbout
45		57
		58	// RefreshInstances re-fetches the published instance list every hour, forever.
		59	// Run it in its own goroutine; fetch failures are logged and retried next cycle.
46	func RefreshInstances() {	60	func RefreshInstances() {
47	for {	61	for {
48	func() {	62	func() {
	@@ -54,11 +68,11 @@ func RefreshInstances() {
54	}	68	}
55	}	69	}
56		70
57	// some crap for frontend	71	// instanceAbout is the instance metadata exposed to the frontend and the API.
58	type instanceAbout struct {	72	type instanceAbout struct {
59	Proxy bool	73	Proxy bool `json:"proxy"`
60	Nsfw bool	74	Nsfw bool `json:"nsfw"`
61	Instances []settings	75	Instances []settings `json:"instances"`
62	}	76	}
63		77
64	type skunkyart struct {	78	type skunkyart struct {
	@@ -118,6 +132,8 @@ type skunkyart struct {
118	}	132	}
119	}	133	}
120		134
		135	// ExecuteTemplate renders the named template from dir with data, responding 500
		136	// if the template cannot be parsed.
121	func (s skunkyart) ExecuteTemplate(file, dir string, data any) {	137	func (s skunkyart) ExecuteTemplate(file, dir string, data any) {
122	var buf strings.Builder	138	var buf strings.Builder
123	tmp := template.New(file)	139	tmp := template.New(file)
	@@ -131,26 +147,30 @@ func (s skunkyart) ExecuteTemplate(file, dir string, data any) {
131	wr(s.Writer, buf.String())	147	wr(s.Writer, buf.String())
132	}	148	}
133		149
134	func UrlBuilder(strs ...string) string {	150	// URLBuilder joins strs into an absolute instance URL, prefixing the current
		151	// Host and configured URI and inserting slashes between path segments but not
		152	// before query separators.
		153	func URLBuilder(strs ...string) string {
135	var str strings.Builder	154	var str strings.Builder
136	l := len(strs)	155	l := len(strs)
137	str.WriteString(Host)	156	str.WriteString(Host)
138	str.WriteString(CFG.URI)	157	str.WriteString(CFG.URI)
139	for n, x := range strs {	158	for n, x := range strs {
140	str.WriteString(x)	159	str.WriteString(x)
141	if n := n + 1; n < l && len(strs[n]) != 0 && !(strs[n][0] == '?' \|\| strs[n][0] == '&') && !(x[0] == '?' \|\| x[0] == '&') {	160	if n := n + 1; n < l && len(strs[n]) != 0 && (strs[n][0] != '?' && strs[n][0] != '&') && (x[0] != '?' && x[0] != '&') {
142	str.WriteString("/")	161	str.WriteString("/")
143	}	162	}
144	}	163	}
145	return str.String()	164	return str.String()
146	}	165	}
147		166
		167	// Error responds 502 with the error DeviantArt reported upstream.
148	func (s skunkyart) Error(dAerr devianter.Error) {	168	func (s skunkyart) Error(dAerr devianter.Error) {
149	s.Writer.WriteHeader(502)	169	s.Writer.WriteHeader(502)
150		170
151	var msg strings.Builder	171	var msg strings.Builder
152	msg.WriteString(`<html><link rel="stylesheet" href="`)	172	msg.WriteString(`<html><link rel="stylesheet" href="`)
153	msg.WriteString(UrlBuilder("stylesheet"))	173	msg.WriteString(URLBuilder("stylesheet"))
154	msg.WriteString(`" /><h3>DeviantArt error — '`)	174	msg.WriteString(`" /><h3>DeviantArt error — '`)
155	msg.WriteString(dAerr.Error)	175	msg.WriteString(dAerr.Error)
156	msg.WriteString("'</h3></html>")	176	msg.WriteString("'</h3></html>")
	@@ -158,12 +178,18 @@ func (s skunkyart) Error(dAerr devianter.Error) {
158	wr(s.Writer, msg.String())	178	wr(s.Writer, msg.String())
159	}	179	}
160		180
		181	// ReturnHTTPError responds with a styled error page for the given status.
161	func (s skunkyart) ReturnHTTPError(status int) {	182	func (s skunkyart) ReturnHTTPError(status int) {
		183	// A failed upstream fetch reports status 0, and WriteHeader panics on any
		184	// code outside 1xx-5xx. Treat anything unusable as a gateway failure.
		185	if status < 100 \|\| status > 599 {
		186	status = http.StatusBadGateway
		187	}
162	s.Writer.WriteHeader(status)	188	s.Writer.WriteHeader(status)
163		189
164	var msg strings.Builder	190	var msg strings.Builder
165	msg.WriteString(`<html><link rel="stylesheet" href="`)	191	msg.WriteString(`<html><link rel="stylesheet" href="`)
166	msg.WriteString(UrlBuilder("stylesheet"))	192	msg.WriteString(URLBuilder("stylesheet"))
167	msg.WriteString(`" /><h1>`)	193	msg.WriteString(`" /><h1>`)
168	msg.WriteString(strconv.Itoa(status))	194	msg.WriteString(strconv.Itoa(status))
169	msg.WriteString(" - ")	195	msg.WriteString(" - ")
	@@ -173,6 +199,7 @@ func (s skunkyart) ReturnHTTPError(status int) {
173	wr(s.Writer, msg.String())	199	wr(s.Writer, msg.String())
174	}	200	}
175		201
		202	// SetFilename sets the Content-Disposition filename for the response.
176	func (s skunkyart) SetFilename(name string) {	203	func (s skunkyart) SetFilename(name string) {
177	var filename strings.Builder	204	var filename strings.Builder
178	filename.WriteString(`filename="`)	205	filename.WriteString(`filename="`)
	@@ -181,29 +208,50 @@ func (s skunkyart) SetFilename(name string) {
181	s.Writer.Header().Add("Content-Disposition", filename.String())	208	s.Writer.Header().Add("Content-Disposition", filename.String())
182	}	209	}
183		210
		211	// Downloaded is the result of a Download. A Status of 0 means the request never
		212	// completed, in which case Body and Headers are empty.
184	type Downloaded struct {	213	type Downloaded struct {
185	Headers http.Header	214	Headers http.Header
186	Status int	215	Status int
187	Body []byte	216	Body []byte
188	}	217	}
189		218
		219	// Download fetches urlString with the configured User-Agent, routing through
		220	// download-proxy when one is set. Every failure path returns the zero
		221	// Downloaded, so callers must check Status before trusting Body or Headers.
190	func Download(urlString string) (d Downloaded) {	222	func Download(urlString string) (d Downloaded) {
191	cli := &http.Client{}	223	cli := &http.Client{}
192	if CFG.DownloadProxy != "" {	224	if CFG.DownloadProxy != "" {
193	u, e := url.Parse(CFG.DownloadProxy)	225	u, err := url.Parse(CFG.DownloadProxy)
194	try(e)	226	if err != nil {
195	cli.Transport = &http.Transport{Proxy: http.ProxyURL(u)}	227	try(err)
		228	return
		229	}
		230	cli.Transport = ProxiedTransport(u)
196	}	231	}
197		232
198	req, e := http.NewRequest("GET", urlString, nil)	233	ctx, cancel := context.WithTimeout(context.Background(), downloadTimeout)
199	try(e)	234	defer cancel()
		235
		236	req, err := http.NewRequestWithContext(ctx, http.MethodGet, urlString, nil)
		237	if err != nil {
		238	try(err)
		239	return
		240	}
200	req.Header.Set("User-Agent", CFG.UserAgent)	241	req.Header.Set("User-Agent", CFG.UserAgent)
201		242
202	resp, e := cli.Do(req)	243	resp, err := cli.Do(req)
203	try(e)	244	if err != nil {
204	defer resp.Body.Close()	245	try(err)
205	b, e := io.ReadAll(resp.Body)	246	return
206	try(e)	247	}
		248	defer func() { try(resp.Body.Close()) }()
		249
		250	b, err := io.ReadAll(resp.Body)
		251	if err != nil {
		252	try(err)
		253	return
		254	}
207		255
208	d.Body = b	256	d.Body = b
209	d.Status = resp.StatusCode	257	d.Status = resp.StatusCode
	@@ -212,45 +260,56 @@ func Download(urlString string) (d Downloaded) {
212	}	260	}
213		261
214	/* PARSING HELPERS */	262	/* PARSING HELPERS */
		263
		264	// ParseMedia returns the URL to serve for media: a link back through this
		265	// instance's media proxy when proxying is on, or DeviantArt's own URL when it is
		266	// off. An optional thumb width selects a thumbnail instead of the full image.
215	func ParseMedia(media devianter.Media, thumb ...int) string {	267	func ParseMedia(media devianter.Media, thumb ...int) string {
216	mediaUrl, filename := devianter.UrlFromMedia(media, thumb...)	268	mediaURL, filename := devianter.UrlFromMedia(media, thumb...)
217	if len(mediaUrl) != 0 && CFG.Proxy {	269	if len(mediaURL) != 0 && CFG.Proxy {
218	mediaUrl = mediaUrl[21:]	270	mediaURL = mediaURL[21:]
219	dot := strings.Index(mediaUrl, ".")	271	dot := strings.Index(mediaURL, ".")
220	if filename == "" {	272	if filename == "" {
221	filename = "image.gif"	273	filename = "image.gif"
222	}	274	}
223	return UrlBuilder("media", "file", mediaUrl[:dot], mediaUrl[dot+11:], "&filename=", filename)	275	return URLBuilder("media", "file", mediaURL[:dot], mediaURL[dot+11:], "&filename=", filename)
224	} else if !CFG.Proxy {	276	} else if !CFG.Proxy {
225	return mediaUrl	277	return mediaURL
226	}	278	}
227	return ""	279	return ""
228	}	280	}
229		281
230	func ConvertDeviantArtUrlToSkunkyArt(url string) (output string) {	282	// ConvertDeviantArtURLToSkunkyArt rewrites a deviantart.com post link into the
		283	// equivalent link on this instance. It returns an empty string for URLs it does
		284	// not handle, including sta.sh links.
		285	func ConvertDeviantArtURLToSkunkyArt(url string) (output string) {
231	if len(url) > 32 && url[27:32] != "stash" {	286	if len(url) > 32 && url[27:32] != "stash" {
232	url = url[27:]	287	url = url[27:]
233	firstshash := strings.Index(url, "/")	288	firstshash := strings.Index(url, "/")
234	lastshash := firstshash + strings.Index(url[firstshash+1:], "/")	289	lastshash := firstshash + strings.Index(url[firstshash+1:], "/")
235	if lastshash != -1 {	290	if lastshash != -1 {
236	output = UrlBuilder("post", url[:firstshash], url[lastshash+2:])	291	output = URLBuilder("post", url[:firstshash], url[lastshash+2:])
237	}	292	}
238	}	293	}
239	return	294	return
240	}	295	}
241		296
		297	// BuildUserPlate renders the small avatar-and-username block linking to a user's
		298	// about page.
242	func BuildUserPlate(name string) string {	299	func BuildUserPlate(name string) string {
243	var htm strings.Builder	300	var htm strings.Builder
244	htm.WriteString(`<div class="user-plate"><img src="`)	301	htm.WriteString(`<div class="user-plate"><img src="`)
245	htm.WriteString(UrlBuilder("media", "emojitar", name, "?type=a"))	302	htm.WriteString(URLBuilder("media", "emojitar", name, "?type=a"))
246	htm.WriteString(`"><a href="`)	303	htm.WriteString(`"><a href="`)
247	htm.WriteString(UrlBuilder("group_user", "?type=about&q=", name))	304	htm.WriteString(URLBuilder("group_user", "?type=about&q=", name))
248	htm.WriteString(`">`)	305	htm.WriteString(`">`)
249	htm.WriteString(name)	306	htm.WriteString(name)
250	htm.WriteString(`</a></div>`)	307	htm.WriteString(`</a></div>`)
251	return htm.String()	308	return htm.String()
252	}	309	}
253		310
		311	// GetValueOfTag returns the text of the tokenizer's next token, or an empty
		312	// string if that token is not text.
254	func GetValueOfTag(t *html.Tokenizer) string {	313	func GetValueOfTag(t *html.Tokenizer) string {
255	for tt := t.Next(); ; {	314	for tt := t.Next(); ; {
256	if tt == html.TextToken {	315	if tt == html.TextToken {
	@@ -261,13 +320,17 @@ func GetValueOfTag(t *html.Tokenizer) string {
261	}	320	}
262	}	321	}
263		322
264	// page navigation	323	// DeviationList describes the pagination state of a list of artworks: how many
		324	// pages exist, and whether another page follows the current one.
265	type DeviationList struct {	325	type DeviationList struct {
266	Pages int	326	Pages int
267	More bool	327	More bool
268	}	328	}
269		329
270	// FIXME: on some artworks the first page can make the navigation panel disappear entirely.	330	// NavBase renders the page navigation bar for a list.
		331	//
		332	// FIXME: on some artworks the first page can make the navigation panel disappear
		333	// entirely.
271	func (s skunkyart) NavBase(c DeviationList) string {	334	func (s skunkyart) NavBase(c DeviationList) string {
272	var list strings.Builder	335	var list strings.Builder
273		336

app/wrapper.go +20 −12

 	"golang.org/x/net/html"
 )
+// GRUser renders a group or user page: the about tab, the gallery, or favourites,
+// selected by the request's type argument.
 func (s skunkyart) GRUser() {
 	if len(s.Query) < 1 {
 		s.ReturnHTTPError(400)
 			case "cover_deviation":
 				group.About.BGMeta = x.ModuleData.CoverDeviation.Deviation
-				group.About.BGMeta.Url = ConvertDeviantArtUrlToSkunkyArt(group.About.BGMeta.Url)
+				group.About.BGMeta.Url = ConvertDeviantArtURLToSkunkyArt(group.About.BGMeta.Url)
 				group.About.BG = ParseMedia(group.About.BGMeta.Media)
 			case "group_admins":
 				var htm strings.Builder
 						if x.FolderId != -1 && x.Size != 0 {
 							folders.WriteString(`<div class="block folder-item">`)
-							if !(x.Thumb.NSFW && !CFG.Nsfw) {
+							if !x.Thumb.NSFW || CFG.Nsfw {
 								folders.WriteString(`<a href="`)
-								folders.WriteString(ConvertDeviantArtUrlToSkunkyArt(x.Thumb.Url))
+								folders.WriteString(ConvertDeviantArtURLToSkunkyArt(x.Thumb.Url))
 								folders.WriteString(`"><img loading="lazy" src="`)
 								folders.WriteString(ParseMedia(x.Thumb.Media))
 								folders.WriteString(`" title="`)
 							folders.WriteString("&q=")
 							folders.WriteString(s.Query)
 							folders.WriteString("&type=")
-							folders.WriteString(string(s.Type))
+							folders.WriteRune(s.Type)
 							folders.WriteString(`">`)
 							folders.WriteString(x.Name)
 							folders.WriteString(`</a>`)
 	}
 }
-// posts
+// Deviation renders a single artwork page, with its description, tags, comments
+// and related work. It responds 403 for NSFW posts on instances that disallow them.
 func (s skunkyart) Deviation(author, postname string) {
-	id_search := regexp.MustCompile("[0-9]+").FindAllString(postname, -1)
+	idSearch := regexp.MustCompile("[0-9]+").FindAllString(postname, -1)
-	if len(id_search) < 1 {
+	if len(idSearch) < 1 {
 		s.ReturnHTTPError(400)
 		return
 	}
 	var err devianter.Error
 	post := &s.Templates.Deviation
-	id := id_search[len(id_search)-1]
+	id := idSearch[len(idSearch)-1]
 	post.Post, err = devianter.GetDeviation(id, author)
 	if err.RAW != nil {
 		s.Error(err)
 	if post.Post.Deviation.NSFW && !CFG.Nsfw {
 		s.Writer.WriteHeader(403)
 		wr(s.Writer, `<html><link rel="stylesheet" href="`+
-			UrlBuilder("stylesheet")+
+			URLBuilder("stylesheet")+
 			`" /><h1>NSFW content are disabled on this instance.</h1></html>`)
 		return
 	}
 	for _, x := range post.Post.Deviation.Extended.Tags {
 		var tag strings.Builder
 		tag.WriteString(` <a href="`)
-		tag.WriteString(UrlBuilder("search", "?q=", x.Name, "&type=tag"))
+		tag.WriteString(URLBuilder("search", "?q=", x.Name, "&type=tag"))
 		tag.WriteString(`">#`)
 		tag.WriteString(x.Name)
 		tag.WriteString("</a>")
 	s.ExecuteTemplate("deviantion.htm", "html", &s)
 }
+// DD renders the Daily Deviations page, including each themed strip.
 func (s skunkyart) DD() {
 	dd, err := devianter.GetDailyDeviations(s.Page)
 	if err.RAW != nil {
 	}
 }
+// Search renders search results for the request's query. Group search is scraped
+// rather than fetched from the API, which DeviantArt does not expose to guests.
 func (s skunkyart) Search() {
 	if s.Query == "" {
 		s.ReturnHTTPError(400)
 		if l := len(usernames); l != 0 {
 			ss.List += `<div class="content plates">`
-			for x := 0; x < len(usernames); x++ {
+			for x := range len(usernames) {
 				ss.List += BuildUserPlate(usernames[x])
 			}
 			ss.List += `</div>`
 	s.ExecuteTemplate("search.htm", "html", &s)
 }
+// Emojitar proxies a user's avatar or emoji image, selected by the request's
+// type argument.
 func (s skunkyart) Emojitar(name string) {
-	if name == "" || !(s.Type == 'a' || s.Type == 'e') {
+	if name == "" || (s.Type != 'a' && s.Type != 'e') {
 		s.ReturnHTTPError(400)
 		return
 	}

static/doc.go added +8

@@ -0,0 +1,8 @@
	1	// Package static provides the HTML templates, stylesheet and images the
	2	// frontend serves.
	3	//
	4	// It has two implementations selected by the 'embed' build tag. With the tag,
	5	// the assets are compiled into the binary via go:embed. Without it, they are
	6	// read from the directory named by StaticPath at startup and held in memory,
	7	// which is what makes editing templates without a rebuild possible.
	8	package static

static/templates-noembed.go +26 −3

 //go:build !embed
-// +build !embed
 package static
 	"time"
 )
+// Templates is the in-memory asset filesystem populated by CopyTemplatesToMemory.
 var Templates FS
 type file struct {
 var templateNames = []string{}
 var templates = make(map[string][]file)
+// StaticPath is the directory assets are read from at startup.
 var StaticPath string
+// CopyTemplatesToMemory reads every asset under StaticPath into memory. It exits
+// the process on failure, since the frontend cannot serve anything without them.
 func CopyTemplatesToMemory() {
 	baseDir, err := os.ReadDir(StaticPath)
 	try(err)
 	}
 }
+// FS serves the in-memory assets. It implements the subset of fs.FS that
+// template.ParseFS requires.
 type FS struct{}
+// Open returns the asset stored at name, or an fs.PathError if there is none.
 func (FS) Open(name string) (fs.File, error) {
 	for i, l := 0, len(templateNames); i < l; i++ {
 		for _, x := range templates[templateNames[i]] {
 	return nil, &fs.PathError{}
 }
+// Glob returns the paths of every asset in the directory named by pattern's
+// first segment, or an fs.PathError if none match.
 func (FS) Glob(pattern string) ([]string, error) {
 	trimmed := strings.Split(pattern, "/")
 	var matches = []string{}
 	}
 }
-/* based on https://github.com/psanford/memfs; required for templates.ParseFS to work correctly */
+// fileInfo is a minimal fs.FileInfo. Assets are held in memory and never stat'd
+// for anything but their name, so the remaining fields report fixed values.
+//
+// Based on https://github.com/psanford/memfs; required for templates.ParseFS to
+// work correctly.
 type fileInfo struct {
 	name string
 }
+// Name returns the asset's path.
 func (fi fileInfo) Name() string {
 	return fi.name
 }
+// Size reports a fixed placeholder size; callers here never use it.
 func (fi fileInfo) Size() int64 {
 	return 4096
 }
+// Mode reports no mode bits: in-memory assets have no filesystem permissions.
 func (fileInfo) Mode() fs.FileMode {
 	return 0
 }
+// ModTime reports the zero time, as in-memory assets are never modified.
 func (fileInfo) ModTime() time.Time {
 	return time.Time{}
 }
+// IsDir always reports false: only files are stored, never directories.
 func (fileInfo) IsDir() bool {
 	return false
 }
-func (fileInfo) Sys() interface{} {
+// Sys returns nil, as there is no underlying data source.
+func (fileInfo) Sys() any {
 	return nil
 }
+// File is a read-once handle to an in-memory asset.
 type File struct {
 	name    string
 	content *bytes.Buffer
 	closed  bool
 }
+// Stat returns the file's fileInfo. It never fails.
 func (f *File) Stat() (fs.FileInfo, error) {
 	return fileInfo{
 		name: f.name,
 	}, nil
 }
+// Read consumes the asset's contents, reporting fs.ErrClosed once closed.
 func (f *File) Read(b []byte) (int, error) {
 	if f.closed {
 		return 0, fs.ErrClosed
 	return f.content.Read(b)
 }
+// Close marks the file closed. Closing twice reports fs.ErrClosed.
 func (f *File) Close() error {
 	if f.closed {
 		return fs.ErrClosed

static/templates.go +7 −1

	@@ -1,16 +1,22 @@
1	//go:build embed	1	//go:build embed
2	// +build embed
3		2
4	package static	3	package static
5		4
6	import "embed"	5	import "embed"
7		6
		7	// Templates is the asset filesystem compiled into the binary.
		8	//
8	//go:embed *	9	//go:embed *
9	var Templates embed.FS	10	var Templates embed.FS
		11
		12	// Enabled reports that assets are embedded in this build.
10	var Enabled bool = true	13	var Enabled bool = true
11		14
		15	// StaticPath is accepted for parity with the non-embed build, where it names the
		16	// directory assets are read from. It is ignored here.
12	var StaticPath string	17	var StaticPath string
13		18
		19	// CopyTemplatesToMemory is a no-op in this build: the assets are already embedded.
14	func CopyTemplatesToMemory() {	20	func CopyTemplatesToMemory() {
15	_ = StaticPath	21	_ = StaticPath
16	}	22	}

Commit d6789522d3

Commit `d6789522d3`