taler-merchant-demos

articles.go (6022B)

---

 package web
 
 import (
 	"bytes"
 	"fmt"
 	"html"
 	"html/template"
 	"io/fs"
 	"net/http"
 	"net/url"
 	"path"
 	"regexp"
 	"sort"
 	"strings"
 	"time"
 )
 
 type Article struct {
 	Slug       string
 	Title      string
 	Teaser     template.HTML
 	Summary    string
 	Contents   template.HTML
 	Lang       string
 	ExtraFiles map[string]string
 }
 
 type articleLibrary map[string]map[string]Article
 
 var (
 	h2Pattern                 = regexp.MustCompile(`(?is)<h2(?:\s[^>]*)?>(.*?)</h2>`)
 	teaserPattern             = regexp.MustCompile(`(?is)<p(?:\s[^>]*)?\bid\s*=\s*["']teaser["'][^>]*>.*?</p>`)
 	paragraph                 = regexp.MustCompile(`(?is)<p(?:\s[^>]*)?>.*?</p>`)
 	tagPattern                = regexp.MustCompile(`(?s)<[^>]*>`)
 	spacePattern              = regexp.MustCompile(`\s+`)
 	localFileReferencePattern = regexp.MustCompile(`(?i)(?:src|href)\s*=\s*["'](/[^"'?#]+)["']`)
 )
 
 var articleLocales = map[string]string{
 	"en": "en", "fr": "fr", "it": "it", "ru": "ru", "tr": "tr",
 	"uk": "uk", "de": "de", "es": "es", "br": "pt", "pt": "pt",
 }
 
 var selectedArticleSlugs = map[string]bool{
 	"free-sw": true, "thegnuproject": true, "initial-announcement": true,
 	"manifesto": true, "why-free": true, "free-doc": true, "selling": true,
 	"categories": true, "open-source-misses-the-point": true, "not-ipr": true,
 	"words-to-avoid": true, "right-to-read": true, "misinterpreting-copyright": true,
 	"why-copyleft": true, "pragmatic": true, "trivial-patent": true,
 	"can-you-trust": true, "javascript-trap": true,
 	"who-does-that-server-really-serve": true, "compromise": true,
 }
 
 func loadArticles() (articleLibrary, error) {
 	library := make(articleLibrary)
 	extraFiles, err := availableArticleData()
 	if err != nil {
 		return nil, err
 	}
 	languages, err := fs.ReadDir(Assets, "assets/articles")
 	if err != nil {
 		return nil, fmt.Errorf("read articles: %w", err)
 	}
 	for _, language := range languages {
 		sourceLang := language.Name()
 		locale, supported := articleLocales[sourceLang]
 		if !language.IsDir() || !supported {
 			continue
 		}
 		files, err := fs.ReadDir(Assets, path.Join("assets/articles", sourceLang))
 		if err != nil {
 			return nil, err
 		}
 		library[locale] = make(map[string]Article)
 		for _, file := range files {
 			if file.IsDir() {
 				continue
 			}
 			contents, err := Assets.ReadFile(path.Join("assets/articles", sourceLang, file.Name()))
 			if err != nil {
 				return nil, err
 			}
 			slug := strings.TrimSuffix(file.Name(), path.Ext(file.Name()))
 			if !selectedArticleSlugs[slug] {
 				continue
 			}
 			article, ok := parseArticle(locale, slug, string(contents))
 			if !ok {
 				continue
 			}
 			article.Contents, article.ExtraFiles = rewriteArticleData(article.Slug, article.Contents, extraFiles)
 			article.Teaser, _ = rewriteArticleData(article.Slug, article.Teaser, extraFiles)
 			library[locale][article.Slug] = article
 		}
 	}
 	return library, nil
 }
 
 func availableArticleData() (map[string]string, error) {
 	entries, err := fs.ReadDir(Assets, "assets/data")
 	if err != nil {
 		return nil, fmt.Errorf("read article data: %w", err)
 	}
 	files := make(map[string]string)
 	for _, entry := range entries {
 		if !entry.IsDir() {
 			files[entry.Name()] = path.Join("assets/data", entry.Name())
 		}
 	}
 	return files, nil
 }
 
 func rewriteArticleData(slug string, contents template.HTML, available map[string]string) (template.HTML, map[string]string) {
 	raw := string(contents)
 	matches := localFileReferencePattern.FindAllStringSubmatchIndex(raw, -1)
 	linked := make(map[string]string)
 	var rewritten strings.Builder
 	last := 0
 	for _, match := range matches {
 		name := path.Base(raw[match[2]:match[3]])
 		assetPath, ok := available[name]
 		if !ok {
 			continue
 		}
 		rewritten.WriteString(raw[last:match[2]])
 		rewritten.WriteString(url.PathEscape(slug) + "/data/" + url.PathEscape(name))
 		last = match[3]
 		linked[name] = assetPath
 	}
 	if last == 0 {
 		return contents, linked
 	}
 	rewritten.WriteString(raw[last:])
 	return template.HTML(rewritten.String()), linked
 }
 
 func (a *App) articleData(w http.ResponseWriter, r *http.Request) {
 	lang, ok := a.blogLanguage(w, r)
 	if !ok {
 		return
 	}
 	article, exists := a.articles[lang][r.PathValue("article")]
 	if !exists {
 		a.renderError(w, r, http.StatusNotFound, lang, "Page not found", nil)
 		return
 	}
 	name := r.PathValue("file")
 	assetPath, exists := article.ExtraFiles[name]
 	if !exists {
 		a.renderError(w, r, http.StatusNotFound, lang, "Supplemental file not found", nil)
 		return
 	}
 	contents, err := Assets.ReadFile(assetPath)
 	if err != nil {
 		a.renderError(w, r, http.StatusInternalServerError, lang, "Internal error", err)
 		return
 	}
 	w.Header().Set("Cache-Control", "public, max-age=3600")
 	w.Header().Set("X-Content-Type-Options", "nosniff")
 	http.ServeContent(w, r, name, time.Time{}, bytes.NewReader(contents))
 }
 
 func parseArticle(lang, slug, contents string) (Article, bool) {
 	titleMatch := h2Pattern.FindStringSubmatch(contents)
 	if len(titleMatch) != 2 {
 		return Article{}, false
 	}
 	title := strings.TrimSpace(html.UnescapeString(spacePattern.ReplaceAllString(tagPattern.ReplaceAllString(titleMatch[1], ""), " ")))
 	if title == "" {
 		return Article{}, false
 	}
 	teaser := teaserPattern.FindString(contents)
 	if teaser == "" {
 		for _, candidate := range paragraph.FindAllString(contents, -1) {
 			if len(strings.TrimSpace(tagPattern.ReplaceAllString(candidate, ""))) >= 100 {
 				teaser = candidate
 				break
 			}
 		}
 	}
 	if teaser == "" {
 		return Article{}, false
 	}
 	summary := strings.TrimSpace(html.UnescapeString(spacePattern.ReplaceAllString(tagPattern.ReplaceAllString(teaser, ""), " ")))
 	return Article{
 		Slug: slug, Title: title, Teaser: template.HTML(teaser), Summary: summary,
 		Contents: template.HTML(contents), Lang: lang,
 	}, true
 }
 
 func sortedArticles(articles map[string]Article) []Article {
 	result := make([]Article, 0, len(articles))
 	for _, article := range articles {
 		result = append(result, article)
 	}
 	sort.Slice(result, func(i, j int) bool { return result[i].Title < result[j].Title })
 	return result
 }