// Package card bouwt Open Graph-kaarten: tekst, SVG en een PNG.
package card
import (
"bytes"
"encoding/base64"
"encoding/xml"
"fmt"
"image"
"image/color"
_ "image/gif"
_ "image/jpeg"
"image/png"
"regexp"
"strconv"
"strings"
"sync"
"unicode/utf8"
"golang.org/x/image/font"
"golang.org/x/image/font/gofont/gomono"
"golang.org/x/image/font/gofont/goregular"
"golang.org/x/image/font/opentype"
"golang.org/x/image/math/fixed"
)
const (
Width = 1200
Height = 630
// LockedTitle is de enige tekst op een niet-openbare kaart.
LockedTitle = "BlueGit – inloggen vereist"
lockedBody = "This page is not public."
)
// Meta is wat in de HTML-head en in oEmbed staat.
type Meta struct {
Title string
Description string
URL string
Image string
OEmbed string
Theme string
Kind string
Facts []string
Initial string
}
// Render is een kaart plus een optionele avatar (PNG of JPEG).
type Render struct {
Meta
Avatar []byte
}
// Blurb is de tekst voor og:description, zonder regeleinden.
func (m Meta) Blurb() string {
prose := strings.ReplaceAll(m.Description, "\n", " / ")
prose = strings.Join(strings.Fields(prose), " ")
facts := strings.Join(m.Facts, " · ")
if prose == "" {
return facts
}
if facts == "" {
return prose
}
return prose + " · " + facts
}
// Locked is de generieke kaart. url en image mogen geen bronnaam bevatten.
func Locked(pageURL, imageURL, oembed string) Render {
return Render{Meta: Meta{
Title: LockedTitle, Description: lockedBody, URL: pageURL, Image: imageURL,
OEmbed: oembed, Theme: "#142033", Kind: "locked",
}}
}
// Site is de kaart van BlueGit zelf.
func Site(pageURL, imageURL, oembed string) Render {
return Render{Meta: Meta{
Title: "BlueGit", Description: "Git hosting with merge requests, issues and pipelines.",
URL: pageURL, Image: imageURL, OEmbed: oembed, Theme: "#1f6feb", Kind: "site",
Initial: "B",
}}
}
// Excerpt haalt de eerste alinea uit Markdown en kort die in.
// Een kop boven de alinea telt niet mee.
func Excerpt(src string, limit int) string {
src = fenceRe.ReplaceAllString(src, "\n")
src = imageRe.ReplaceAllString(src, " ")
src = linkRe.ReplaceAllString(src, "$1")
src = htmlRe.ReplaceAllString(src, " ")
var paras []string
var cur []string
flush := func() {
if len(cur) == 0 {
return
}
text := strings.Join(strings.Fields(cleanLine(strings.Join(cur, " "))), " ")
cur = nil
if text != "" {
paras = append(paras, text)
}
}
for _, line := range strings.Split(src, "\n") {
line = strings.TrimSpace(line)
if line == "" || strings.HasPrefix(line, "#") {
flush()
continue
}
cur = append(cur, line)
}
flush()
if len(paras) == 0 {
return ""
}
return Clip(paras[0], limit)
}
func cleanLine(s string) string {
s = strings.TrimLeft(s, ">*-_ ")
s = strings.ReplaceAll(s, "`", "")
s = strings.ReplaceAll(s, "*", "")
s = strings.ReplaceAll(s, "_", "")
return s
}
// Clip kapt op een runengrens af.
func Clip(s string, limit int) string {
if limit < 1 || utf8.RuneCountInString(s) <= limit {
return s
}
out := make([]rune, 0, limit)
for _, r := range s {
if len(out) == limit-1 {
break
}
out = append(out, r)
}
return strings.TrimSpace(string(out)) + "…"
}
var (
fenceRe = regexp.MustCompile("(?s)```.*?```")
imageRe = regexp.MustCompile(`!\[[^\]]*\]\([^)]*\)`)
linkRe = regexp.MustCompile(`\[([^\]]*)\]\([^)]*\)`)
htmlRe = regexp.MustCompile(`<[^>]+>`)
lineRe = regexp.MustCompile(`(?i)^L?(\d+)(?:-(\d+))?$`)
)
// ParseLines leest #L10-20, L10-20 of 10-20. De tweede grens is inclusief.
func ParseLines(token string) (from, to int, ok bool) {
token = strings.TrimSpace(strings.TrimPrefix(token, "#"))
m := lineRe.FindStringSubmatch(token)
if m == nil {
return 0, 0, false
}
from, _ = strconv.Atoi(m[1])
if from < 1 {
return 0, 0, false
}
to = from
if m[2] != "" {
to, _ = strconv.Atoi(m[2])
}
if to < from {
return 0, 0, false
}
if to-from > 11 {
to = from + 11
}
return from, to, true
}
// Snippet geeft de gevraagde regels, of anders de eerste regels.
func Snippet(text string, from, to int, withRange bool) string {
lines := strings.Split(strings.ReplaceAll(text, "\r\n", "\n"), "\n")
if len(lines) > 0 && lines[len(lines)-1] == "" {
lines = lines[:len(lines)-1]
}
if !withRange {
from, to = 1, 8
}
if from < 1 {
from = 1
}
var out []string
for n := from; n <= to && n <= len(lines); n++ {
out = append(out, lines[n-1])
}
return strings.Join(out, "\n")
}
// SVG tekent de kaart. Avatar is PNG of JPEG, of leeg.
func SVG(r Render) string {
theme := r.Theme
if theme == "" {
theme = "#1f6feb"
}
var b strings.Builder
b.WriteString(``)
return b.String()
}
func kindLabel(kind string) string {
switch kind {
case "repository":
return "Repository"
case "merge_request":
return "Merge request"
case "issue":
return "Issue"
case "group":
return "Group"
case "user":
return "User"
case "commit":
return "Commit"
case "pipeline":
return "Pipeline"
case "release":
return "Release"
case "file":
return "File"
case "locked":
return "Private"
default:
return "BlueGit"
}
}
func icon(kind string, x, y int, fill string) string {
switch kind {
case "merge_request":
return fmt.Sprintf(``,
x+6, y+8, fill, x+22, y+8, fill, x+14, y+28, fill)
case "issue":
return fmt.Sprintf(``,
x+18, y+18, x+18, y+18, fill, x+18, y+18)
case "group":
return fmt.Sprintf(``,
x+6, y+16, fill, x+22, y+16, fill, x+14, y+30, fill)
case "pipeline":
return fmt.Sprintf(``,
x+4, y+4, fill, x+16, y+14, fill, x+28, y+8, fill)
case "release":
return fmt.Sprintf(``,
x+6, y+10, fill, x+16, y+20)
case "file":
return fmt.Sprintf(``, x+8, y+4, fill)
case "locked":
return fmt.Sprintf(``,
x+18, y+10, x+7, y+16, fill, x+18, y+8, fill)
default:
return fmt.Sprintf(``, x+6, y+10, fill)
}
}
func clipInitial(s string) string {
s = strings.TrimSpace(s)
if s == "" {
return ""
}
r, _ := utf8.DecodeRuneInString(s)
return strings.ToUpper(string(r))
}
func wrap(s string, width, max int) []string {
s = strings.Join(strings.Fields(s), " ")
if s == "" || max < 1 {
return nil
}
words := strings.Fields(s)
var lines []string
var cur string
for _, w := range words {
if cur == "" {
cur = w
continue
}
if utf8.RuneCountInString(cur)+1+utf8.RuneCountInString(w) > width {
lines = append(lines, cur)
cur = w
if len(lines) == max {
break
}
continue
}
cur += " " + w
}
if len(lines) < max && cur != "" {
lines = append(lines, cur)
}
if len(lines) > max {
lines = lines[:max]
}
return lines
}
func xmlText(s string) string {
var b bytes.Buffer
_ = xml.EscapeText(&b, []byte(s))
return b.String()
}
// PNG rastert de SVG van deze kaart. Alleen de vormen die SVG() schrijft.
func PNG(r Render) ([]byte, error) {
return Raster(SVG(r))
}
// Raster maakt een PNG van een kaart-SVG.
func Raster(svg string) ([]byte, error) {
img := image.NewNRGBA(image.Rect(0, 0, Width, Height))
dec := xml.NewDecoder(strings.NewReader(svg))
for {
tok, err := dec.Token()
if err != nil {
break
}
se, ok := tok.(xml.StartElement)
if !ok {
continue
}
switch se.Name.Local {
case "rect":
fillRound(img, atoi(attr(se, "x")), atoi(attr(se, "y")), atoi(attr(se, "width")), atoi(attr(se, "height")), atoi(attr(se, "rx")), parseColor(attr(se, "fill")))
case "circle":
fillCircle(img, atoi(attr(se, "cx")), atoi(attr(se, "cy")), atoi(attr(se, "r")), parseColor(attr(se, "fill")))
case "image":
drawDataImage(img, attr(se, "href"), atoi(attr(se, "x")), atoi(attr(se, "y")), atoi(attr(se, "width")), atoi(attr(se, "height")))
case "text":
var text string
for {
t, err := dec.Token()
if err != nil {
break
}
if _, ok := t.(xml.EndElement); ok {
break
}
if cd, ok := t.(xml.CharData); ok {
text += string(cd)
}
}
drawText(img, text, atoi(attr(se, "x")), atoi(attr(se, "y")), atoi(attr(se, "font-size")), attr(se, "font-family"), attr(se, "text-anchor"), parseColor(attr(se, "fill")))
}
}
var buf bytes.Buffer
if err := png.Encode(&buf, img); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
func attr(se xml.StartElement, name string) string {
for _, a := range se.Attr {
if a.Name.Local == name {
return a.Value
}
}
return ""
}
func atoi(s string) int {
n, _ := strconv.Atoi(strings.TrimSpace(s))
return n
}
func parseColor(s string) color.NRGBA {
s = strings.TrimSpace(s)
if s == "" || s == "none" {
return color.NRGBA{}
}
s = strings.TrimPrefix(s, "#")
if len(s) == 3 {
s = string([]byte{s[0], s[0], s[1], s[1], s[2], s[2]})
}
if len(s) != 6 {
return color.NRGBA{A: 255}
}
v, err := strconv.ParseUint(s, 16, 32)
if err != nil {
return color.NRGBA{A: 255}
}
return color.NRGBA{R: uint8(v >> 16), G: uint8(v >> 8), B: uint8(v), A: 255}
}
func fillRound(img *image.NRGBA, x, y, w, h, rx int, c color.NRGBA) {
if c.A == 0 || w <= 0 || h <= 0 {
return
}
if rx <= 0 {
fillRect(img, x, y, w, h, c)
return
}
if rx > w/2 {
rx = w / 2
}
if rx > h/2 {
rx = h / 2
}
fillRect(img, x+rx, y, w-2*rx, h, c)
fillRect(img, x, y+rx, w, h-2*rx, c)
fillCircle(img, x+rx, y+rx, rx, c)
fillCircle(img, x+w-rx, y+rx, rx, c)
fillCircle(img, x+rx, y+h-rx, rx, c)
fillCircle(img, x+w-rx, y+h-rx, rx, c)
}
func fillRect(img *image.NRGBA, x, y, w, h int, c color.NRGBA) {
b := img.Bounds()
for yy := y; yy < y+h; yy++ {
if yy < b.Min.Y || yy >= b.Max.Y {
continue
}
for xx := x; xx < x+w; xx++ {
if xx < b.Min.X || xx >= b.Max.X {
continue
}
img.SetNRGBA(xx, yy, c)
}
}
}
func fillCircle(img *image.NRGBA, cx, cy, r int, c color.NRGBA) {
if c.A == 0 || r <= 0 {
return
}
rr := r * r
for y := cy - r; y <= cy+r; y++ {
for x := cx - r; x <= cx+r; x++ {
dx, dy := x-cx, y-cy
if dx*dx+dy*dy <= rr {
if image.Pt(x, y).In(img.Bounds()) {
img.SetNRGBA(x, y, c)
}
}
}
}
}
func drawDataImage(img *image.NRGBA, href string, x, y, w, h int) {
i := strings.Index(href, "base64,")
if i < 0 || w < 1 || h < 1 {
return
}
raw, err := base64.StdEncoding.DecodeString(href[i+7:])
if err != nil {
return
}
src, _, err := image.Decode(bytes.NewReader(raw))
if err != nil {
return
}
sb := src.Bounds()
rad := w / 2
for yy := 0; yy < h; yy++ {
for xx := 0; xx < w; xx++ {
dx, dy := xx-w/2, yy-h/2
if dx*dx+dy*dy > rad*rad {
continue
}
sx := sb.Min.X + xx*sb.Dx()/w
sy := sb.Min.Y + yy*sb.Dy()/h
c := color.NRGBAModel.Convert(src.At(sx, sy)).(color.NRGBA)
if c.A == 0 {
continue
}
img.SetNRGBA(x+xx, y+yy, c)
}
}
}
func drawText(img *image.NRGBA, text string, x, y, size int, family, anchor string, c color.NRGBA) {
if text == "" || c.A == 0 || size < 8 {
return
}
face := faceFor(family, size)
if face == nil {
return
}
d := font.Drawer{Dst: img, Src: image.NewUniform(c), Face: face}
if anchor == "middle" {
x -= d.MeasureString(text).Round() / 2
}
d.Dot = fixed.P(x, y)
d.DrawString(text)
}
var (
faceOnce sync.Once
sansFont *opentype.Font
monoFont *opentype.Font
faceMu sync.Mutex
faces = map[string]font.Face{}
)
func faceFor(family string, size int) font.Face {
faceOnce.Do(func() {
sansFont, _ = opentype.Parse(goregular.TTF)
monoFont, _ = opentype.Parse(gomono.TTF)
})
src := sansFont
if family == "mono" {
src = monoFont
}
if src == nil {
return nil
}
key := family + "/" + strconv.Itoa(size)
faceMu.Lock()
defer faceMu.Unlock()
if f, ok := faces[key]; ok {
return f
}
f, err := opentype.NewFace(src, &opentype.FaceOptions{Size: float64(size), DPI: 72, Hinting: font.HintingNone})
if err != nil {
return nil
}
faces[key] = f
return f
}
// Cache bewaart PNG-bytes op de SVG-tekst.
type Cache struct {
mu sync.Mutex
max int
order []string
png map[string][]byte
hits int
}
// NewCache maakt een cache met een maximum aantal kaarten.
func NewCache(max int) *Cache {
if max < 1 {
max = 1
}
return &Cache{max: max, png: map[string][]byte{}}
}
// Get levert een eerder gerasterde SVG.
func (c *Cache) Get(svg string) ([]byte, bool) {
c.mu.Lock()
defer c.mu.Unlock()
b, ok := c.png[svg]
if ok {
c.hits++
}
return b, ok
}
// Put bewaart een PNG.
func (c *Cache) Put(svg string, b []byte) {
c.mu.Lock()
defer c.mu.Unlock()
if _, ok := c.png[svg]; ok {
c.png[svg] = b
return
}
if len(c.order) >= c.max {
drop := c.order[0]
c.order = c.order[1:]
delete(c.png, drop)
}
c.order = append(c.order, svg)
c.png[svg] = b
}
// Hits telt treffers sinds het starten.
func (c *Cache) Hits() int {
c.mu.Lock()
defer c.mu.Unlock()
return c.hits
}