no git submodules

vendor/github.com/flosch/pongo2-addons/.gitignore

@@ -0,0 +1,24 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+.idea

vendor/github.com/flosch/pongo2-addons/.travis.yml

@@ -0,0 +1,13 @@
+language: go
+
+go:
+  - tip
+install:
+  - go get golang.org/x/tools/cmd/cover
+  - go get gopkg.in/check.v1
+  - go get github.com/flosch/pongo2
+  - go get github.com/russross/blackfriday
+  - go get github.com/extemporalgenome/slug
+  - go get github.com/flosch/go-humanize
+script:
+  - go test -v -covermode=count -coverprofile=coverage.out

vendor/github.com/flosch/pongo2-addons/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Florian Schlachter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/flosch/pongo2-addons/README.md

@@ -0,0 +1,52 @@
+# pongo2-addons
+
+[![Build Status](https://travis-ci.org/flosch/pongo2-addons.svg?branch=master)](https://travis-ci.org/flosch/pongo2-addons)
+[![Gratipay](http://img.shields.io/badge/gratipay-support%20pongo-brightgreen.svg)](https://gratipay.com/flosch/)
+
+Official filter and tag add-ons for [pongo2](https://github.com/flosch/pongo2). Since this package uses
+3rd-party-libraries, it's in its own package.
+
+## How to install and use
+
+Install via `go get -u github.com/flosch/pongo2-addons`. All dependencies will be automatically fetched and installed.
+
+Simply add the following import line **after** importing pongo2:
+
+    _ "github.com/flosch/pongo2-addons"
+
+All additional filters/tags will be registered automatically.
+
+## Addons
+
+### Filters
+
+  - Regulars
+     - **[filesizeformat](https://docs.djangoproject.com/en/dev/ref/templates/builtins/#filesizeformat)** (human-readable filesize; takes bytes as input)
+     - **[slugify](https://docs.djangoproject.com/en/dev/ref/templates/builtins/#slugify)** (creates a slug for a given input)
+     - **truncatesentences** / **truncatesentences_html** (returns the first X sentences [like truncatechars/truncatewords]; please provide X as a parameter)
+     - **random** (returns a random element of the input slice)
+
+  - Markup
+     - **markdown**
+
+  - Humanize
+     - **[intcomma](https://docs.djangoproject.com/en/dev/ref/contrib/humanize/#intcomma)** (put decimal marks into the number)
+     - **[ordinal](https://docs.djangoproject.com/en/dev/ref/contrib/humanize/#ordinal)** (convert integer to its ordinal as string)
+     - **[naturalday](https://docs.djangoproject.com/en/dev/ref/contrib/humanize/#naturalday)** (converts `time.Time`-object into today/yesterday/tomorrow if possible; otherwise it will use `naturaltime`)
+     - **[timesince](https://docs.djangoproject.com/en/dev/ref/templates/builtins/#timesince)/[timeuntil](https://docs.djangoproject.com/en/1.6/ref/templates/builtins/#timeuntil)/[naturaltime](https://docs.djangoproject.com/en/dev/ref/contrib/humanize/#naturaltime)** (human-readable time [duration] indicator)
+
+### Tags
+
+(nothing yet)
+
+## TODO
+
+ - Support i18n/i10n
+
+## Used libraries
+
+I want to thank the authors of these libraries (which are being used in `pongo2-addons`):
+
+ * [github.com/extemporalgenome/slug](https://github.com/extemporalgenome/slug)
+ * [github.com/dustin/go-humanize](https://github.com/dustin/go-humanize)
+ * [github.com/russross/blackfriday](https://github.com/russross/blackfriday)

vendor/github.com/flosch/pongo2-addons/filters.go

@@ -0,0 +1,311 @@
+package pongo2addons
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"math/rand"
+	"regexp"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/flosch/pongo2/v4"
+
+	"github.com/extemporalgenome/slug"
+	"github.com/flosch/go-humanize"
+	"github.com/russross/blackfriday/v2"
+)
+
+func init() {
+	rand.Seed(time.Now().UTC().UnixNano())
+
+	// Regulars
+	pongo2.RegisterFilter("slugify", filterSlugify)
+	pongo2.RegisterFilter("filesizeformat", filterFilesizeformat)
+	pongo2.RegisterFilter("truncatesentences", filterTruncatesentences)
+	pongo2.RegisterFilter("truncatesentences_html", filterTruncatesentencesHTML)
+	pongo2.RegisterFilter("random", filterRandom)
+
+	// Markup
+	pongo2.RegisterFilter("markdown", filterMarkdown)
+
+	// Humanize
+	pongo2.RegisterFilter("timeuntil", filterTimeuntilTimesince)
+	pongo2.RegisterFilter("timesince", filterTimeuntilTimesince)
+	pongo2.RegisterFilter("naturaltime", filterTimeuntilTimesince)
+	pongo2.RegisterFilter("naturalday", filterNaturalday)
+	pongo2.RegisterFilter("intcomma", filterIntcomma)
+	pongo2.RegisterFilter("ordinal", filterOrdinal)
+}
+
+func filterMarkdown(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	return pongo2.AsSafeValue(string(blackfriday.Run([]byte(in.String())))), nil
+}
+
+func filterSlugify(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	return pongo2.AsValue(slug.Slug(in.String())), nil
+}
+
+func filterFilesizeformat(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	return pongo2.AsValue(humanize.IBytes(uint64(in.Integer()))), nil
+}
+
+var filterTruncatesentencesRe = regexp.MustCompile(`(?U:.*[\w]{3,}.*([\d][\.!?][\D]|[\D][\.!?][\s]|[\n$]))`)
+
+func filterTruncatesentences(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	count := param.Integer()
+	if count <= 0 {
+		return pongo2.AsValue(""), nil
+	}
+	sentencens := filterTruncatesentencesRe.FindAllString(strings.TrimSpace(in.String()), -1)
+	return pongo2.AsValue(strings.TrimSpace(strings.Join(sentencens[:min(count, len(sentencens))], ""))), nil
+}
+
+// Taken from pongo2/filters_builtin.go
+func filterTruncateHTMLHelper(value string, newOutput *bytes.Buffer, cond func() bool, fn func(c rune, s int, idx int) int, finalize func()) {
+	vLen := len(value)
+	tagStack := make([]string, 0)
+	idx := 0
+
+	for idx < vLen && !cond() {
+		c, s := utf8.DecodeRuneInString(value[idx:])
+		if c == utf8.RuneError {
+			idx += s
+			continue
+		}
+
+		if c == '<' {
+			newOutput.WriteRune(c)
+			idx += s // consume "<"
+
+			if idx+1 < vLen {
+				if value[idx] == '/' {
+					// Close tag
+
+					newOutput.WriteString("/")
+
+					tag := ""
+					idx++ // consume "/"
+
+					for idx < vLen {
+						c2, size2 := utf8.DecodeRuneInString(value[idx:])
+						if c2 == utf8.RuneError {
+							idx += size2
+							continue
+						}
+
+						// End of tag found
+						if c2 == '>' {
+							idx++ // consume ">"
+							break
+						}
+						tag += string(c2)
+						idx += size2
+					}
+
+					if len(tagStack) > 0 {
+						// Ideally, the close tag is TOP of tag stack
+						// In malformed HTML, it must not be, so iterate through the stack and remove the tag
+						for i := len(tagStack) - 1; i >= 0; i-- {
+							if tagStack[i] == tag {
+								// Found the tag
+								tagStack[i] = tagStack[len(tagStack)-1]
+								tagStack = tagStack[:len(tagStack)-1]
+								break
+							}
+						}
+					}
+
+					newOutput.WriteString(tag)
+					newOutput.WriteString(">")
+				} else {
+					// Open tag
+
+					tag := ""
+
+					params := false
+					for idx < vLen {
+						c2, size2 := utf8.DecodeRuneInString(value[idx:])
+						if c2 == utf8.RuneError {
+							idx += size2
+							continue
+						}
+
+						newOutput.WriteRune(c2)
+
+						// End of tag found
+						if c2 == '>' {
+							idx++ // consume ">"
+							break
+						}
+
+						if !params {
+							if c2 == ' ' {
+								params = true
+							} else {
+								tag += string(c2)
+							}
+						}
+
+						idx += size2
+					}
+
+					// Add tag to stack
+					tagStack = append(tagStack, tag)
+				}
+			}
+		} else {
+			idx = fn(c, s, idx)
+		}
+	}
+
+	finalize()
+
+	for i := len(tagStack) - 1; i >= 0; i-- {
+		tag := tagStack[i]
+		// Close everything from the regular tag stack
+		newOutput.WriteString(fmt.Sprintf("</%s>", tag))
+	}
+}
+
+func filterTruncatesentencesHTML(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	count := param.Integer()
+	if count <= 0 {
+		return pongo2.AsValue(""), nil
+	}
+
+	value := in.String()
+	newLen := max(param.Integer(), 0)
+
+	newOutput := bytes.NewBuffer(nil)
+
+	sentencefilter := 0
+
+	filterTruncateHTMLHelper(value, newOutput, func() bool {
+		return sentencefilter >= newLen
+	}, func(_ rune, _ int, idx int) int {
+		// Get next word
+		wordFound := false
+
+		for idx < len(value) {
+			c2, size2 := utf8.DecodeRuneInString(value[idx:])
+			if c2 == utf8.RuneError {
+				idx += size2
+				continue
+			}
+
+			if c2 == '<' {
+				// HTML tag start, don't consume it
+				return idx
+			}
+
+			newOutput.WriteRune(c2)
+			idx += size2
+
+			if (c2 == '.' && !(idx+1 < len(value) && value[idx+1] >= '0' && value[idx+1] <= '9')) ||
+				c2 == '!' || c2 == '?' || c2 == '\n' {
+				// Sentence ends here, stop capturing it now
+				break
+			} else {
+				wordFound = true
+			}
+		}
+
+		if wordFound {
+			sentencefilter++
+		}
+
+		return idx
+	}, func() {})
+
+	return pongo2.AsSafeValue(newOutput.String()), nil
+}
+
+func filterRandom(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	if !in.CanSlice() {
+		return nil, &pongo2.Error{
+			Sender:    "filter:random",
+			OrigError: errors.New("input is not sliceable"),
+		}
+	}
+
+	if in.Len() <= 0 {
+		return nil, &pongo2.Error{
+			Sender:    "filter:random",
+			OrigError: errors.New("input slice is empty"),
+		}
+	}
+
+	return in.Index(rand.Intn(in.Len())), nil
+}
+
+func filterTimeuntilTimesince(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	basetime, isTime := in.Interface().(time.Time)
+	if !isTime {
+		return nil, &pongo2.Error{
+			Sender:    "filter:timeuntil/timesince",
+			OrigError: errors.New("time-value is not a time.Time-instance"),
+		}
+	}
+	var paramtime time.Time
+	if !param.IsNil() {
+		paramtime, isTime = param.Interface().(time.Time)
+		if !isTime {
+			return nil, &pongo2.Error{
+				Sender:    "filter:timeuntil/timesince",
+				OrigError: errors.New("time-parameter is not a time.Time-instance"),
+			}
+		}
+	} else {
+		paramtime = time.Now()
+	}
+
+	return pongo2.AsValue(humanize.TimeDuration(basetime.Sub(paramtime))), nil
+}
+
+func filterIntcomma(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	return pongo2.AsValue(humanize.Comma(int64(in.Integer()))), nil
+}
+
+func filterOrdinal(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	return pongo2.AsValue(humanize.Ordinal(in.Integer())), nil
+}
+
+func filterNaturalday(in *pongo2.Value, param *pongo2.Value) (*pongo2.Value, *pongo2.Error) {
+	basetime, isTime := in.Interface().(time.Time)
+	if !isTime {
+		return nil, &pongo2.Error{
+			Sender:    "filter:naturalday",
+			OrigError: errors.New("naturalday-value is not a time.Time-instance"),
+		}
+	}
+
+	var referenceTime time.Time
+	if !param.IsNil() {
+		referenceTime, isTime = param.Interface().(time.Time)
+		if !isTime {
+			return nil, &pongo2.Error{
+				Sender:    "filter:naturalday",
+				OrigError: errors.New("naturalday-parameter is not a time.Time-instance"),
+			}
+		}
+	} else {
+		referenceTime = time.Now()
+	}
+
+	d := referenceTime.Sub(basetime) / time.Hour
+
+	switch {
+	case d >= 0 && d < 24:
+		// Today
+		return pongo2.AsValue("today"), nil
+	case d >= 24:
+		return pongo2.AsValue("yesterday"), nil
+	case d < 0 && d >= -24:
+		return pongo2.AsValue("tomorrow"), nil
+	}
+
+	// Default behaviour
+	return pongo2.ApplyFilter("naturaltime", in, param)
+}

vendor/github.com/flosch/pongo2-addons/go.mod

@@ -0,0 +1,15 @@
+module github.com/flosch/pongo2-addons
+
+go 1.14
+
+require (
+	github.com/extemporalgenome/slug v0.0.0-20150414033109-0320c85e32e0
+	github.com/flosch/go-humanize v0.0.0-20140728123800-3ba51eabe506
+	github.com/flosch/pongo2 v0.0.0-20200529170236-5abacdfa4915
+	github.com/flosch/pongo2/v4 v4.0.2 // indirect
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
+	github.com/russross/blackfriday/v2 v2.0.1
+	github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect
+	golang.org/x/text v0.3.3 // indirect
+	gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b
+)

vendor/github.com/flosch/pongo2-addons/go.sum

@@ -0,0 +1,25 @@
+github.com/extemporalgenome/slug v0.0.0-20150414033109-0320c85e32e0 h1:0A9+8DBvlpto0mr+SD1NadV5liSIAZkWnvyshwk88Bc=
+github.com/extemporalgenome/slug v0.0.0-20150414033109-0320c85e32e0/go.mod h1:96eSBMO0aE2dcsEygXzIsvGyOf7bM5kWuqVCPEgwLEI=
+github.com/flosch/go-humanize v0.0.0-20140728123800-3ba51eabe506 h1:tN043XK9BV76qc31Z2GACIO5Dsh99q21JtYmR2ltXBg=
+github.com/flosch/go-humanize v0.0.0-20140728123800-3ba51eabe506/go.mod h1:pSiPkAThBLWmIzJ2fukUGkcxxWR4HoLT7Bp8/krrl5g=
+github.com/flosch/pongo2 v0.0.0-20200529170236-5abacdfa4915 h1:rNVrewdFbSujcoKZifC6cHJfqCTbCIR7XTLHW5TqUWU=
+github.com/flosch/pongo2 v0.0.0-20200529170236-5abacdfa4915/go.mod h1:fB4mx6dzqFinCxIf3a7Mf5yLk+18Bia9mPAnuejcvDA=
+github.com/flosch/pongo2/v4 v4.0.2 h1:gv+5Pe3vaSVmiJvh/BZa82b7/00YUGm0PIyVVLop0Hw=
+github.com/flosch/pongo2/v4 v4.0.2/go.mod h1:B5ObFANs/36VwxxlgKpdchIJHMvHB562PW+BWPhwZD8=
+github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
+github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q=
+github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
+gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

vendor/github.com/flosch/pongo2-addons/helpers.go

@@ -0,0 +1,15 @@
+package pongo2addons
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}