err = create(info, f)
return
-
}
// GetOrCreate tries to get the file with the given id from cache. If not found or expired, create will
return info, nil, err
}
return info, b, nil
-
}
// GetBytes gets the file content with the given id from the cahce, nil if none found.
}
f, err := c.Fs.Open(id)
-
if err != nil {
return nil
}
defer c.nlocker.Unlock(id)
f, err := c.Fs.Open(id)
-
if err != nil {
return ""
}
b, _ := ioutil.ReadAll(f)
return string(b)
-
}
// Caches is a named set of caches.
c3 := decoded["images"]
c.Assert(c3.MaxAge, qt.Equals, time.Duration(-1))
c.Assert(c3.Dir, qt.Equals, filepath.FromSlash("/path/to/c3/filecache/images"))
-
}
func TestDecodeConfigIgnoreCache(t *testing.T) {
for _, v := range decoded {
c.Assert(v.MaxAge, qt.Equals, time.Duration(0))
}
-
}
func TestDecodeConfigDefault(t *testing.T) {
_, err = DecodeConfig(fs, cfg)
c.Assert(err, qt.Not(qt.IsNil))
-
}
func newTestConfig() *viper.Viper {
}
func (c *Cache) pruneRootDir(force bool) (int, error) {
-
info, err := c.Fs.Stat(c.pruneAllRootDir)
if err != nil {
if os.IsNotExist(err) {
}
return hugofs.MakeReadableAndRemoveAllModulePkgDir(c.Fs, c.pruneAllRootDir)
-
}
c.Assert(string(b), qt.Equals, "Hugo is great!")
}
-
}
func TestFileCacheConcurrent(t *testing.T) {
var result string
rf := func(failLevel int) func(info ItemInfo, r io.ReadSeeker) error {
-
return func(info ItemInfo, r io.ReadSeeker) error {
if failLevel > 0 {
if failLevel > 1 {
p, err := helpers.NewPathSpec(hugofs.NewFrom(fs, cfg), cfg, nil)
c.Assert(err, qt.IsNil)
return p
-
}
c.cache = make(map[string]cacheEntry)
c.nlocker = locker.NewLocker()
-
}
// GetOrCreate tries to get the value with the given cache key, if not found
var methods Methods
- var excludes = make(map[string]bool)
+ excludes := make(map[string]bool)
if len(exclude) > 0 {
for _, m := range c.MethodsFromTypes(exclude, nil) {
name = pkgPrefix + name
return name, pkg
-
}
for _, t := range include {
-
for i := 0; i < t.NumMethod(); i++ {
m := t.Method(i)
methods = append(methods, method)
}
-
}
sort.SliceStable(methods, func(i, j int) bool {
}
return wi < wj
-
})
return methods
-
}
func (c *Inspector) parseSource() {
c.init.Do(func() {
-
if !strings.Contains(c.ProjectRootDir, "hugo") {
panic("dir must be set to the Hugo root")
}
filenames = append(filenames, path)
return nil
-
})
for _, filename := range filenames {
c.methodWeight[iface] = weights
}
}
-
}
return true
})
}
}
}
-
})
}
fmt.Fprintf(&sb, "func Marshal%sToJSON(%s %s) ([]byte, error) {\n", what, r, receiver)
var methods Methods
- var excludeRes = make([]*regexp.Regexp, len(excludes))
+ excludeRes := make([]*regexp.Regexp, len(excludes))
for i, exclude := range excludes {
excludeRes[i] = regexp.MustCompile(exclude)
}
return sb.String(), pkgImports
-
}
func collectMethodsRecursive(pkg string, f []*ast.Field) []string {
}
return methodNames
-
}
func firstToLower(name string) string {
}
return name
-
}
)
func TestMethods(t *testing.T) {
-
var (
zeroIE = reflect.TypeOf((*IEmbed)(nil)).Elem()
zeroIEOnly = reflect.TypeOf((*IEOnly)(nil)).Elem()
methodsStr := fmt.Sprint(methods)
c.Assert(methodsStr, qt.Contains, "MethodEmbed3(arg0 string) string")
-
})
t.Run("ToMarshalJSON", func(t *testing.T) {
c.Assert(pkg, qt.Contains, "encoding/json")
fmt.Println(pkg)
-
})
-
}
type I interface {
}
func newCheckCmd() *checkCmd {
- return &checkCmd{baseCmd: &baseCmd{cmd: &cobra.Command{
- Use: "check",
- Short: "Contains some verification checks",
- },
+ return &checkCmd{baseCmd: &baseCmd{
+ cmd: &cobra.Command{
+ Use: "check",
+ Short: "Contains some verification checks",
+ },
}}
}
}
func newCheckCmd() *checkCmd {
- cc := &checkCmd{baseCmd: &baseCmd{cmd: &cobra.Command{
- Use: "check",
- Short: "Contains some verification checks",
- },
+ cc := &checkCmd{baseCmd: &baseCmd{
+ cmd: &cobra.Command{
+ Use: "check",
+ Short: "Contains some verification checks",
+ },
}}
cc.cmd.AddCommand(newLimitCmd().getCommand())
import (
"bytes"
"errors"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "regexp"
"sync"
+ "time"
hconfig "github.com/gohugoio/hugo/config"
"golang.org/x/sync/semaphore"
- "io/ioutil"
-
"github.com/gohugoio/hugo/common/herrors"
"github.com/gohugoio/hugo/common/hugo"
jww "github.com/spf13/jwalterweatherman"
- "os"
- "path/filepath"
- "regexp"
- "time"
-
"github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/config"
}
func newCommandeer(mustHaveConfigFile, running bool, h *hugoBuilderCommon, f flagsToConfigHandler, cfgInit func(c *commandeer) error, subCmdVs ...*cobra.Command) (*commandeer, error) {
-
var rebuildDebouncer func(f func())
if running {
// The time value used is tested with mass content replacements in a fairly big Hugo site.
}
func (c *commandeer) loadConfig(mustHaveConfigFile, running bool) error {
-
if c.DepsCfg == nil {
c.DepsCfg = &deps.DepsCfg{}
}
environment := c.h.getEnvironment(running)
doWithConfig := func(cfg config.Provider) error {
-
if c.ftch != nil {
c.ftch.flagsToConfig(cfg)
}
Filename: c.h.cfgFile,
AbsConfigDir: c.h.getConfigDir(dir),
Environ: os.Environ(),
- Environment: environment},
+ Environment: environment,
+ },
cfgSetAndInit,
doWithConfig)
}
// To debug hard-to-find path issues.
- //fs.Destination = hugofs.NewStacktracerFs(fs.Destination, `fr/fr`)
+ // fs.Destination = hugofs.NewStacktracerFs(fs.Destination, `fr/fr`)
err = c.initFs(fs)
if err != nil {
h, err = hugolib.NewHugoSites(*c.DepsCfg)
c.hugoSites = h
close(c.created)
-
})
if err != nil {
cfg.Logger.Infoln("Using config file:", config.ConfigFileUsed())
return nil
-
}
type commandsBuilderGetter interface {
getCommandsBuilder() *commandsBuilder
}
+
type baseBuilderCmd struct {
*baseCmd
*commandsBuilder
}
func (c *nilCommand) flagsToConfig(cfg config.Provider) {
-
}
func (b *commandsBuilder) newHugoCmd() *hugoCmd {
)
func TestExecute(t *testing.T) {
-
c := qt.New(t)
createSite := func(c *qt.C) (string, func()) {
c.Assert(config, qt.Contains, "baseURL = \"http://example.org/\"")
checkNewSiteInited(c, siteDir)
})
-
}
func checkNewSiteInited(c *qt.C, basepath string) {
},
{
name: "Persistent flags",
- args: []string{"server",
+ args: []string{
+ "server",
"--config=myconfig.toml",
"--configDir=myconfigdir",
"--contentDir=mycontent",
// The flag is named i18n-warnings
c.Assert(cfg.GetBool("logI18nWarnings"), qt.Equals, true)
-
- }}}
+ },
+ },
+ }
for _, test := range tests {
c.Run(test.name, func(c *qt.C) {
-
b := newCommandsBuilder()
root := b.addAll().build()
test.check(c, b.commands[0].(*serverCmd))
})
}
-
}
func TestCommandsExecute(t *testing.T) {
-
c := qt.New(t)
dir, clean, err := createSimpleTestSite(t, testSiteConfig{})
}
}
-
}
type testSiteConfig struct {
`)
return d, clean, nil
-
}
func writeFile(t *testing.T, filename, content string) {
import (
"bytes"
"fmt"
+ "path/filepath"
"strings"
"time"
"github.com/gohugoio/hugo/hugolib"
- "path/filepath"
-
"github.com/spf13/cobra"
)
-var (
- _ cmder = (*convertCmd)(nil)
-)
+var _ cmder = (*convertCmd)(nil)
type convertCmd struct {
outputDir string
}
func newEnvCmd() *envCmd {
- return &envCmd{baseCmd: newBaseCmd(&cobra.Command{
- Use: "env",
- Short: "Print Hugo version and environment info",
- Long: `Print Hugo version and environment info. This is useful in Hugo bug reports.`,
- RunE: func(cmd *cobra.Command, args []string) error {
- printHugoVersion()
- jww.FEEDBACK.Printf("GOOS=%q\n", runtime.GOOS)
- jww.FEEDBACK.Printf("GOARCH=%q\n", runtime.GOARCH)
- jww.FEEDBACK.Printf("GOVERSION=%q\n", runtime.Version())
+ return &envCmd{
+ baseCmd: newBaseCmd(&cobra.Command{
+ Use: "env",
+ Short: "Print Hugo version and environment info",
+ Long: `Print Hugo version and environment info. This is useful in Hugo bug reports.`,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ printHugoVersion()
+ jww.FEEDBACK.Printf("GOOS=%q\n", runtime.GOOS)
+ jww.FEEDBACK.Printf("GOARCH=%q\n", runtime.GOARCH)
+ jww.FEEDBACK.Printf("GOVERSION=%q\n", runtime.Version())
- return nil
- },
- }),
+ return nil
+ },
+ }),
}
}
}
err := cmd.Root().GenBashCompletionFile(cc.autocompleteTarget)
-
if err != nil {
return err
}
"github.com/spf13/cobra"
)
-var (
- _ cmder = (*genChromaStyles)(nil)
-)
+var _ cmder = (*genChromaStyles)(nil)
type genChromaStyles struct {
style string
"github.com/spf13/cobra"
)
-var (
- _ cmder = (*genDocsHelper)(nil)
-)
+var _ cmder = (*genDocsHelper)(nil)
type genDocsHelper struct {
target string
fmt.Println("Done!")
return nil
-
}
"context"
"fmt"
"io/ioutil"
+ "os"
"os/signal"
+ "path/filepath"
+ "runtime"
"runtime/pprof"
"runtime/trace"
+ "strings"
"sync/atomic"
+ "syscall"
+ "time"
"github.com/gohugoio/hugo/hugofs"
"github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/common/terminal"
- "syscall"
-
"github.com/gohugoio/hugo/hugolib/filesystems"
"golang.org/x/sync/errgroup"
- "os"
- "path/filepath"
- "runtime"
- "strings"
- "time"
-
"github.com/gohugoio/hugo/config"
flag "github.com/spf13/pflag"
// Execute adds all child commands to the root command HugoCmd and sets flags appropriately.
// The args are usually filled with os.Args[1:].
func Execute(args []string) Response {
-
hugoCmd := newCommandsBuilder().addAll().build()
cmd := hugoCmd.getCommand()
cmd.SetArgs(args)
h *hugoBuilderCommon,
f flagsToConfigHandler,
cfgInit func(c *commandeer) error) (*commandeer, error) {
-
c, err := newCommandeer(mustHaveConfigFile, running, h, f, cfgInit)
if err != nil {
return nil, err
}
return c, nil
-
}
func (c *commandeer) createLogger(cfg config.Provider, running bool) (loggers.Logger, error) {
setValueFromFlag(cmd.Flags(), "destination", cfg, "publishDir", false)
setValueFromFlag(cmd.Flags(), "i18n-warnings", cfg, "logI18nWarnings", false)
setValueFromFlag(cmd.Flags(), "path-warnings", cfg, "logPathWarnings", false)
-
}
func setValueFromFlag(flags *flag.FlagSet, key string, cfg config.Provider, targetKey string, force bool) {
}
func (c *commandeer) fullBuild() error {
-
var (
g errgroup.Group
langCount map[string]uint64
}
copyStaticFunc := func() error {
-
cnt, err := c.copyStatic()
if err != nil {
return errors.Wrap(err, "Error copying static files")
}
return nil
-
}
func (c *commandeer) initCPUProfile() (func(), error) {
pprof.Lookup("mutex").WriteTo(f, 0)
f.Close()
}, nil
-
}
func (c *commandeer) initMemTicker() func() {
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("\n\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\n\n", formatByteCount(m.Alloc), formatByteCount(m.TotalAlloc), formatByteCount(m.Sys), m.NumGC)
-
}
go func() {
printMem()
return
}
-
}
}()
}
func (c *commandeer) initProfiling() (func(), error) {
-
stopCPUProf, err := c.initCPUProfile()
if err != nil {
return nil, err
checkErr(c.Logger, err)
defer watcher.Close()
- var sigs = make(chan os.Signal, 1)
+ sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
<-sigs
}
func (c *commandeer) doWithPublishDirs(f func(sourceFs *filesystems.SourceFilesystem) (uint64, error)) (map[string]uint64, error) {
-
langCount := make(map[string]uint64)
staticFilesystems := c.hugo().BaseFs.SourceFilesystems.Static
}
return nil
-
}
watchFiles := c.hugo().PathSpec.BaseFs.WatchDirs()
c.buildErr = nil
visited := c.visitedURLs.PeekAllSet()
if c.fastRenderMode {
-
// Make sure we always render the home pages
for _, l := range c.languages {
langPath := c.hugo().PathSpec.GetLangSubDir(l.Lang)
home := c.hugo().PathSpec.PrependBasePath("/"+langPath, false)
visited[home] = true
}
-
}
return c.hugo().Build(hugolib.BuildCfg{RecentlyVisited: visited, ErrRecovery: c.wasError}, events...)
}
c.fullRebuildSem.Acquire(context.Background(), 1)
go func() {
-
defer c.fullRebuildSem.Release(1)
c.printChangeDetected(changeType)
defer func() {
-
// Allow any file system events to arrive back.
// This will block any rebuild on config changes for the
// duration of the sleep.
}
watcher, err := watcher.New(1 * time.Second)
-
if err != nil {
return nil, err
}
staticSyncer *staticSyncer,
evs []fsnotify.Event,
configSet map[string]bool) {
-
defer func() {
c.wasError = false
}()
time.Sleep(100 * time.Millisecond)
}
}
-
}
// Config file(s) changed. Need full rebuild.
}
}
return
-
}
func pickOneWriteOrCreatePath(events []fsnotify.Event) string {
_, err = cmd.ExecuteC()
c.Assert(err, qt.IsNil)
-
}
cc.cmd.AddCommand(importJekyllCmd)
return cc
-
}
func (i *importCmd) importFromJekyll(cmd *cobra.Command, args []string) error {
-
if len(args) < 2 {
return newUserError(`import from jekyll requires two paths, e.g. ` + "`hugo import jekyll jekyll_root_path target_path`.")
}
defer f.Close()
b, err := ioutil.ReadAll(f)
-
if err != nil {
return nil
}
c, err := metadecoders.Default.UnmarshalToMap(b, metadecoders.YAML)
-
if err != nil {
return nil
}
}
} else {
lowerEntryName := strings.ToLower(entry.Name())
- exceptSuffix := []string{".md", ".markdown", ".html", ".htm",
- ".xml", ".textile", "rakefile", "gemfile", ".lock"}
+ exceptSuffix := []string{
+ ".md", ".markdown", ".html", ".htm",
+ ".xml", ".textile", "rakefile", "gemfile", ".lock",
+ }
isExcept := false
for _, suffix := range exceptSuffix {
if strings.HasSuffix(lowerEntryName, suffix) {
}
result.WriteString(">}}")
return result.String()
-
}
+
func replaceOptionalPart(buffer *bytes.Buffer, partName string, part string) {
if len(part) > 0 {
buffer.WriteString(partName + "=\"" + part + "\" ")
draft bool
expect string
}{
- {map[interface{}]interface{}{}, "testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
- `{"date":"2015-10-01T00:00:00Z"}`},
- {map[interface{}]interface{}{}, "testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), true,
- `{"date":"2015-10-01T00:00:00Z","draft":true}`},
- {map[interface{}]interface{}{"Permalink": "/permalink.html", "layout": "post"},
+ {
+ map[interface{}]interface{}{},
"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
- `{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`},
- {map[interface{}]interface{}{"permalink": "/permalink.html"},
+ `{"date":"2015-10-01T00:00:00Z"}`,
+ },
+ {
+ map[interface{}]interface{}{},
+ "testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), true,
+ `{"date":"2015-10-01T00:00:00Z","draft":true}`,
+ },
+ {
+ map[interface{}]interface{}{"Permalink": "/permalink.html", "layout": "post"},
"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
- `{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`},
- {map[interface{}]interface{}{"category": nil, "permalink": 123},
+ `{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`,
+ },
+ {
+ map[interface{}]interface{}{"permalink": "/permalink.html"},
"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
- `{"date":"2015-10-01T00:00:00Z"}`},
- {map[interface{}]interface{}{"Excerpt_Separator": "sep"},
+ `{"date":"2015-10-01T00:00:00Z","url":"/permalink.html"}`,
+ },
+ {
+ map[interface{}]interface{}{"category": nil, "permalink": 123},
"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
- `{"date":"2015-10-01T00:00:00Z","excerpt_separator":"sep"}`},
- {map[interface{}]interface{}{"category": "book", "layout": "post", "Others": "Goods", "Date": "2015-10-01 12:13:11"},
+ `{"date":"2015-10-01T00:00:00Z"}`,
+ },
+ {
+ map[interface{}]interface{}{"Excerpt_Separator": "sep"},
"testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
- `{"Others":"Goods","categories":["book"],"date":"2015-10-01T12:13:11Z"}`},
+ `{"date":"2015-10-01T00:00:00Z","excerpt_separator":"sep"}`,
+ },
+ {
+ map[interface{}]interface{}{"category": "book", "layout": "post", "Others": "Goods", "Date": "2015-10-01 12:13:11"},
+ "testPost", time.Date(2015, 10, 1, 0, 0, 0, 0, time.UTC), false,
+ `{"Others":"Goods","categories":["book"],"date":"2015-10-01T12:13:11Z"}`,
+ },
}
for _, data := range testDataList {
content string
expect string
}{
- {map[interface{}]interface{}{},
- "Test content\r\n<!-- more -->\npart2 content", "Test content\n<!--more-->\npart2 content"},
- {map[interface{}]interface{}{},
- "Test content\n<!-- More -->\npart2 content", "Test content\n<!--more-->\npart2 content"},
- {map[interface{}]interface{}{"excerpt_separator": "<!--sep-->"},
+ {
+ map[interface{}]interface{}{},
+ "Test content\r\n<!-- more -->\npart2 content", "Test content\n<!--more-->\npart2 content",
+ },
+ {
+ map[interface{}]interface{}{},
+ "Test content\n<!-- More -->\npart2 content", "Test content\n<!--more-->\npart2 content",
+ },
+ {
+ map[interface{}]interface{}{"excerpt_separator": "<!--sep-->"},
"Test content\n<!--sep-->\npart2 content",
- "---\nexcerpt_separator: <!--sep-->\n---\nTest content\n<!--more-->\npart2 content"},
+ "---\nexcerpt_separator: <!--sep-->\n---\nTest content\n<!--more-->\npart2 content",
+ },
{map[interface{}]interface{}{}, "{% raw %}text{% endraw %}", "text"},
{map[interface{}]interface{}{}, "{%raw%} text2 {%endraw %}", "text2"},
- {map[interface{}]interface{}{},
+ {
+ map[interface{}]interface{}{},
"{% highlight go %}\nvar s int\n{% endhighlight %}",
- "{{< highlight go >}}\nvar s int\n{{< / highlight >}}"},
- {map[interface{}]interface{}{},
+ "{{< highlight go >}}\nvar s int\n{{< / highlight >}}",
+ },
+ {
+ map[interface{}]interface{}{},
"{% highlight go linenos hl_lines=\"1 2\" %}\nvar s string\nvar i int\n{% endhighlight %}",
- "{{< highlight go \"linenos=table,hl_lines=1 2\" >}}\nvar s string\nvar i int\n{{< / highlight >}}"},
+ "{{< highlight go \"linenos=table,hl_lines=1 2\" >}}\nvar s string\nvar i int\n{{< / highlight >}}",
+ },
// Octopress image tag
- {map[interface{}]interface{}{},
+ {
+ map[interface{}]interface{}{},
"{% img http://placekitten.com/890/280 %}",
- "{{< figure src=\"http://placekitten.com/890/280\" >}}"},
- {map[interface{}]interface{}{},
+ "{{< figure src=\"http://placekitten.com/890/280\" >}}",
+ },
+ {
+ map[interface{}]interface{}{},
"{% img left http://placekitten.com/320/250 Place Kitten #2 %}",
- "{{< figure class=\"left\" src=\"http://placekitten.com/320/250\" title=\"Place Kitten #2\" >}}"},
- {map[interface{}]interface{}{},
+ "{{< figure class=\"left\" src=\"http://placekitten.com/320/250\" title=\"Place Kitten #2\" >}}",
+ },
+ {
+ map[interface{}]interface{}{},
"{% img right http://placekitten.com/300/500 150 250 'Place Kitten #3' %}",
- "{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #3\" >}}"},
- {map[interface{}]interface{}{},
+ "{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #3\" >}}",
+ },
+ {
+ map[interface{}]interface{}{},
"{% img right http://placekitten.com/300/500 150 250 'Place Kitten #4' 'An image of a very cute kitten' %}",
- "{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}"},
- {map[interface{}]interface{}{},
+ "{{< figure class=\"right\" src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
+ },
+ {
+ map[interface{}]interface{}{},
"{% img http://placekitten.com/300/500 150 250 'Place Kitten #4' 'An image of a very cute kitten' %}",
- "{{< figure src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}"},
- {map[interface{}]interface{}{},
+ "{{< figure src=\"http://placekitten.com/300/500\" width=\"150\" height=\"250\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
+ },
+ {
+ map[interface{}]interface{}{},
"{% img right /placekitten/300/500 'Place Kitten #4' 'An image of a very cute kitten' %}",
- "{{< figure class=\"right\" src=\"/placekitten/300/500\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}"},
- {map[interface{}]interface{}{"category": "book", "layout": "post", "Date": "2015-10-01 12:13:11"},
+ "{{< figure class=\"right\" src=\"/placekitten/300/500\" title=\"Place Kitten #4\" alt=\"An image of a very cute kitten\" >}}",
+ },
+ {
+ map[interface{}]interface{}{"category": "book", "layout": "post", "Date": "2015-10-01 12:13:11"},
"somecontent",
- "---\nDate: \"2015-10-01 12:13:11\"\ncategory: book\nlayout: post\n---\nsomecontent"},
+ "---\nDate: \"2015-10-01 12:13:11\"\ncategory: book\nlayout: post\n---\nsomecontent",
+ },
}
for _, data := range testDataList {
result, err := convertJekyllContent(data.metadata, data.content)
}
sites, err := hugolib.NewHugoSites(*c.DepsCfg)
-
if err != nil {
return nil, newSystemError("Error creating sites", err)
}
Long: `List all of the drafts in your content directory.`,
RunE: func(cmd *cobra.Command, args []string) error {
sites, err := cc.buildSites(map[string]interface{}{"buildDrafts": true})
-
if err != nil {
return newSystemError("Error building sites", err)
}
Long: `List all of the posts in your content directory which will be posted in the future.`,
RunE: func(cmd *cobra.Command, args []string) error {
sites, err := cc.buildSites(map[string]interface{}{"buildFuture": true})
-
if err != nil {
return newSystemError("Error building sites", err)
}
Long: `List all of the posts in your content directory which has already expired.`,
RunE: func(cmd *cobra.Command, args []string) error {
sites, err := cc.buildSites(map[string]interface{}{"buildExpired": true})
-
if err != nil {
return newSystemError("Error building sites", err)
}
"buildDrafts": true,
"buildFuture": true,
})
-
if err != nil {
return newSystemError("Error building sites", err)
}
}
func (b *commandsBuilder) newModCmd() *modCmd {
-
c := &modCmd{}
const commonUsage = `
c.baseBuilderCmd = b.newBuilderCmd(cmd)
return c
-
}
func (c *modCmd) withModsClient(failOnMissingConfig bool, f func(*modules.Client) error) error {
)
func newModNPMCmd(c *modCmd) *cobra.Command {
-
cmd := &cobra.Command{
Use: "npm",
Short: "Various npm helpers.",
so this may/will change in future versions of Hugo.
`,
RunE: func(cmd *cobra.Command, args []string) error {
-
return c.withHugo(func(h *hugolib.HugoSites) error {
return npm.Pack(h.BaseFs.SourceFs, h.BaseFs.Assets.Dirs)
})
}
c, err := initializeConfig(true, false, &n.hugoBuilderCommon, n, cfgInit)
-
if err != nil {
return err
}
cc.baseBuilderCmd = b.newBuilderBasicCmd(cmd)
return cc
-
}
func (n *newSiteCmd) doNewSite(fs *hugofs.Fs, basepath string, force bool) error {
// newTheme creates a new Hugo theme template
func (n *newThemeCmd) newTheme(cmd *cobra.Command, args []string) error {
c, err := initializeConfig(false, false, &n.hugoBuilderCommon, n, nil)
-
if err != nil {
return err
}
}
func (n *newThemeCmd) createThemeMD(fs *hugofs.Fs, inpath string) (err error) {
-
by := []byte(`# theme.toml template for a Hugo theme
# See https://github.com/gohugoio/hugoThemes#themetoml for an example
import (
"errors"
+
"github.com/spf13/cobra"
)
}
func (c *releaseCommandeer) flagsToConfig(cfg config.Provider) {
-
}
func (r *releaseCommandeer) release() error {
}
return err
-
}
if err := memStats(); err != nil {
jww.FEEDBACK.Printf("Watching for changes in %s\n", group)
}
watcher, err := c.newWatcher(watchDirs...)
-
if err != nil {
return err
}
}
return c.serve(sc)
-
}
func getRootWatchDirsStr(baseDir string, watchDirs []string) string {
r2.Header.Set("X-Rewrite-Original-URI", r.URL.RequestURI())
return r2
-
}
func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, error) {
} else {
doRedirect = false
}
-
}
}
}
if f.c.fastRenderMode && f.c.buildErr == nil {
-
if strings.HasSuffix(requestURI, "/") || strings.HasSuffix(requestURI, "html") || strings.HasSuffix(requestURI, "htm") {
if !f.c.visitedURLs.Contains(requestURI) {
// If not already on stack, re-render that single page.
func removeErrorPrefixFromLog(content string) string {
return logErrorRe.ReplaceAllLiteralString(content, "")
}
-func (c *commandeer) serve(s *serverCmd) error {
+func (c *commandeer) serve(s *serverCmd) error {
isMultiHost := c.hugo().IsMultihost()
var (
livereload.Initialize()
}
- var sigs = make(chan os.Signal, 1)
+ sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
for i := range baseURLs {
// Stop the server.
stop <- true
-
}
func TestFixURL(t *testing.T) {
withoutError := removeErrorPrefixFromLog(content)
c.Assert(strings.Contains(withoutError, "ERROR"), qt.Equals, false)
-
}
func isWindowsCI() bool {
_, err := c.doWithPublishDirs(syncFn)
return err
-
}
} else if !fromt.AssignableTo(tot) {
// Fall back to a []interface{} slice.
return appendToInterfaceSliceFromValues(tov, fromv)
-
}
}
}
{nil, []interface{}{"a", "b"}, []string{"a", "b"}},
{nil, []interface{}{nil}, []interface{}{nil}},
{[]interface{}{}, []interface{}{[]string{"c", "d", "e"}}, []string{"c", "d", "e"}},
- {tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
+ {
+ tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
[]interface{}{&tstSlicer{"c"}},
- tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}, &tstSlicer{"c"}}},
- {&tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
+ tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}, &tstSlicer{"c"}},
+ },
+ {
+ &tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}},
[]interface{}{&tstSlicer{"c"}},
- tstSlicers{&tstSlicer{"a"},
+ tstSlicers{
+ &tstSlicer{"a"},
&tstSlicer{"b"},
- &tstSlicer{"c"}}},
- {testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}},
+ &tstSlicer{"c"},
+ },
+ },
+ {
+ testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}},
[]interface{}{&tstSlicerIn1{"c"}},
- testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}, &tstSlicerIn1{"c"}}},
+ testSlicerInterfaces{&tstSlicerIn1{"a"}, &tstSlicerIn1{"b"}, &tstSlicerIn1{"c"}},
+ },
//https://github.com/gohugoio/hugo/issues/5361
- {[]string{"a", "b"}, []interface{}{tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
- []interface{}{"a", "b", &tstSlicer{"a"}, &tstSlicer{"b"}}},
- {[]string{"a", "b"}, []interface{}{&tstSlicer{"a"}},
- []interface{}{"a", "b", &tstSlicer{"a"}}},
+ {
+ []string{"a", "b"},
+ []interface{}{tstSlicers{&tstSlicer{"a"}, &tstSlicer{"b"}}},
+ []interface{}{"a", "b", &tstSlicer{"a"}, &tstSlicer{"b"}},
+ },
+ {
+ []string{"a", "b"},
+ []interface{}{&tstSlicer{"a"}},
+ []interface{}{"a", "b", &tstSlicer{"a"}},
+ },
// Errors
{"", []interface{}{[]string{"a", "b"}}, false},
// No string concatenation.
- {"ab",
+ {
+ "ab",
[]interface{}{"c"},
- false},
+ false,
+ },
} {
result, err := Append(test.start, test.addend...)
c.Assert(err, qt.IsNil)
c.Assert(result, qt.DeepEquals, test.expected)
}
-
}
qt "github.com/frankban/quicktest"
)
-var _ Slicer = (*tstSlicer)(nil)
-var _ Slicer = (*tstSlicerIn1)(nil)
-var _ Slicer = (*tstSlicerIn2)(nil)
-var _ testSlicerInterface = (*tstSlicerIn1)(nil)
-var _ testSlicerInterface = (*tstSlicerIn1)(nil)
+var (
+ _ Slicer = (*tstSlicer)(nil)
+ _ Slicer = (*tstSlicerIn1)(nil)
+ _ Slicer = (*tstSlicerIn2)(nil)
+ _ testSlicerInterface = (*tstSlicerIn1)(nil)
+ _ testSlicerInterface = (*tstSlicerIn1)(nil)
+)
type testSlicerInterface interface {
Name() string
default:
return nil, errors.New("invalid type")
}
-
}
return result, nil
}
c.Assert(test.expected, qt.DeepEquals, result, errMsg)
}
-
}
c.Assert(location.Lines, qt.DeepEquals, []string{"A", "B", "C", "D"})
c.Assert(location.Position().LineNumber, qt.Equals, 2)
c.Assert(location.LinesPos, qt.Equals, 1)
-
}
"github.com/pkg/errors"
)
-var (
- _ causer = (*fileError)(nil)
-)
+var _ causer = (*fileError)(nil)
// FileError represents an error when handling a file: Parsing a config file,
// execute a template etc.
c.Assert(pos.ColumnNumber, qt.Equals, test.columnNumber, errMsg)
c.Assert(errors.Cause(got), qt.Not(qt.IsNil))
}
-
}
default:
return IsTruthfulValue(reflect.ValueOf(in))
}
-
}
var zeroType = reflect.TypeOf((*types.Zeroer)(nil)).Elem()
devHugoInfo := NewInfo("development")
c.Assert(devHugoInfo.IsProduction(), qt.Equals, false)
-
}
import (
"fmt"
"io"
-
"runtime"
"strings"
}
return fmt.Sprintf("%s %s %s BuildDate: %s", program, version, osArch, date)
-
}
func version(version float32, patchVersion int, suffix string) string {
statementsSet := make(map[string]bool)
for _, s := range statements {
statementsSet[strings.ToLower(s)] = true
-
}
return ignorableLogger{
Logger: logger,
jww "github.com/spf13/jwalterweatherman"
)
-var (
- // Counts ERROR logs to the global jww logger.
- GlobalErrorCounter *jww.Counter
-)
+// Counts ERROR logs to the global jww logger.
+var GlobalErrorCounter *jww.Counter
func init() {
GlobalErrorCounter = &jww.Counter{}
// bytes, so we lie a little.
_, err = a.w.Write([]byte(replaced))
return len(p), err
-
}
// InitGlobalLogger initializes the global logger, used in some rare cases.
jww.SetLogOutput(logHandle)
jww.SetLogThreshold(logThreshold)
jww.SetStdoutThreshold(stdoutThreshold)
-
}
func getLogWriters(outHandle, logHandle io.Writer) (io.Writer, io.Writer) {
}
return outHandle, logHandle
-
}
type fatalLogWriter int
l.Warnln("A warning")
c.Assert(l.LogCounters().ErrorCounter.Count(), qt.Equals, uint64(2))
-
}
func TestLoggerToWriterWithPrefix(t *testing.T) {
if !reflect.DeepEqual(expected, m) {
t.Errorf("Expected\n%#v, got\n%#v\n", expected, m)
}
-
}
}
return nil, nil
-
}
func GetNestedParamFn(keyStr, separator string, lookupFn func(key string) interface{}) (interface{}, string, map[string]interface{}, error) {
)
func TestGetNestedParam(t *testing.T) {
-
m := map[string]interface{}{
"string": "value",
"first": 1,
c.Assert(must("nested.nestednested.color", ".", m), qt.Equals, "green")
c.Assert(must("string.name", ".", m), qt.IsNil)
c.Assert(must("nested.foo", ".", m), qt.IsNil)
-
}
// https://github.com/gohugoio/hugo/issues/7903
func TestGetNestedParamFnNestedNewKey(t *testing.T) {
-
c := qt.New(t)
nested := map[string]interface{}{
c.Assert(existing, qt.IsNil)
c.Assert(nestedKey, qt.Equals, "new")
c.Assert(owner, qt.DeepEquals, nested)
-
}
//
// If the first add for a key is an array or slice, then the next value(s) will be appended.
func (c *Scratch) Add(key string, newAddend interface{}) (string, error) {
-
var newVal interface{}
c.mu.RLock()
existingAddend, found := c.values[key]
if err == nil {
t.Errorf("Expected error from invalid arithmetic")
}
-
}
func TestScratchAddSlice(t *testing.T) {
_, err := scratch.Add("slice", []int{1, 2})
c.Assert(err, qt.IsNil)
c.Assert(scratch.Get("slice"), qt.DeepEquals, []int{1, 2})
-
}
// https://github.com/gohugoio/hugo/issues/5361
_, err := scratch.Add("slice", []int{1, 2})
c.Assert(err, qt.IsNil)
c.Assert(scratch.Get("slice"), qt.DeepEquals, []interface{}{"foo", 1, 2})
-
}
func TestScratchSet(t *testing.T) {
import (
"context"
"runtime"
-
"sort"
"sync"
"sync/atomic"
c.Assert(sort.IntsAreSorted(result), qt.Equals, false, qt.Commentf("Para does not seem to be parallel"))
sort.Ints(result)
c.Assert(result, qt.DeepEquals, ints)
-
})
c.Run("Time", func(c *qt.C) {
c.Assert(r.Wait(), qt.IsNil)
c.Assert(counter, qt.Equals, int64(n))
c.Assert(time.Since(start) < n/2*time.Millisecond, qt.Equals, true)
-
})
-
}
var positionStringFormatfunc func(p Position) string
func createPositionStringFormatter(formatStr string) func(p Position) string {
-
if formatStr == "" {
formatStr = "\":file::line::col\""
}
- var identifiers = []string{":file", ":line", ":col"}
+ identifiers := []string{":file", ":line", ":col"}
var identifiersFound []string
for i := range formatStr {
c.Assert(createPositionStringFormatter("好::col")(pos), qt.Equals, "好:13")
c.Assert(createPositionStringFormatter("")(pos), qt.Equals, "\"/my/file.txt:12:13\"")
c.Assert(pos.String(), qt.Equals, "\"/my/file.txt:12:13\"")
-
}
c.Assert(string(RemoveAccents([]byte("Resumé"))), qt.Equals, "Resume")
c.Assert(string(RemoveAccents([]byte("Hugo Rocks!"))), qt.Equals, "Hugo Rocks!")
c.Assert(string(RemoveAccentsString("Resumé")), qt.Equals, "Resume")
-
}
c.Assert(ToStringSlicePreserveString("Hugo"), qt.DeepEquals, []string{"Hugo"})
c.Assert(ToStringSlicePreserveString([]interface{}{"A", "B"}), qt.DeepEquals, []string{"A", "B"})
c.Assert(ToStringSlicePreserveString(nil), qt.IsNil)
-
}
func TestToString(t *testing.T) {
c.Assert(ToString([]byte("Hugo")), qt.Equals, "Hugo")
c.Assert(ToString(json.RawMessage("Hugo")), qt.Equals, "Hugo")
-
}
})
c.Assert(s, qt.DeepEquals, []string{"A", "b", "Ba", "ba", "ba", "Bz"})
-
}
package config
import (
- "github.com/pkg/errors"
-
"sort"
"strings"
"sync"
+ "github.com/pkg/errors"
+
"github.com/gohugoio/hugo/common/types"
"github.com/gobwas/glob"
}
func DecodeSitemap(prototype Sitemap, input map[string]interface{}) Sitemap {
-
for key, value := range input {
switch key {
case "changefreq":
}
func (s *Server) init() {
-
s.compiledInit.Do(func() {
for _, h := range s.Headers {
s.compiledHeaders = append(s.compiledHeaders, glob.MustCompile(h.For))
})
return matches
-
}
func (s *Server) MatchRedirect(pattern string) Redirect {
}
return Redirect{}
-
}
type Headers struct {
c.Assert(b.UseResourceCache(herrors.ErrFeatureNotAvailable), qt.Equals, false)
c.Assert(b.UseResourceCache(errors.New("err")), qt.Equals, false)
c.Assert(b.UseResourceCache(nil), qt.Equals, false)
-
}
func TestServer(t *testing.T) {
c.Assert(s.MatchHeaders("/foo.jpg"), qt.DeepEquals, []types.KeyValueStr{
{Key: "X-Content-Type-Options", Value: "nosniff"},
{Key: "X-Frame-Options", Value: "DENY"},
- {Key: "X-XSS-Protection", Value: "1; mode=block"}})
+ {Key: "X-XSS-Protection", Value: "1; mode=block"},
+ })
c.Assert(s.MatchRedirect("/foo/bar/baz"), qt.DeepEquals, Redirect{
From: "/foo/**",
c.Assert(s.MatchRedirect("/default/index.html"), qt.DeepEquals, Redirect{})
c.Assert(s.MatchRedirect("/default/"), qt.DeepEquals, Redirect{})
- for _, errorCase := range []string{`[[server.redirects]]
+ for _, errorCase := range []string{
+ `[[server.redirects]]
from = "/**"
to = "/file"
status = 301`,
c.Assert(err, qt.Not(qt.IsNil))
}
-
}
RenameKeys(m)
return m, nil
-
}
func loadConfigFromFile(fs afero.Fs, filename string) (map[string]interface{}, error) {
}
c.Assert(got, qt.All(qt.Equals), true)
-
}
func TestDecodeConfigFromTOMLCaseInsensitive(t *testing.T) {
c.Assert(config.Disqus.Shortname, qt.Equals, "root_short")
c.Assert(config.GoogleAnalytics.ID, qt.Equals, "ga_root")
-
}
import (
"bytes"
-
- "github.com/pkg/errors"
-
"io"
"os"
"os/exec"
"path/filepath"
"strings"
+ "github.com/pkg/errors"
+
"github.com/gohugoio/hugo/hugofs/files"
"github.com/gohugoio/hugo/hugofs"
sites *hugolib.HugoSites,
targetFs afero.Fs,
cm archetypeMap, name, targetPath string) error {
-
for _, f := range cm.otherFiles {
meta := f.Meta()
filename := meta.Path()
ps *helpers.PathSpec,
fs afero.Fs,
archetypeDir string) (archetypeMap, error) {
-
var m archetypeMap
walkFn := func(path string, fi hugofs.FileMetaInfo, err error) error {
-
if err != nil {
return err
}
}
if siteContentDir == "" {
-
}
if siteContentDir != "" {
}
return s.PathSpec.AbsPathify(filepath.Join(contentDir, targetPath)), s
}
-
}
// FindArchetype takes a given kind/archetype of content and returns the path
)
func executeArcheTypeAsTemplate(s *hugolib.Site, name, kind, targetPath, archetypeFilename string) ([]byte, error) {
-
var (
archetypeContent []byte
archetypeTemplate []byte
archetypeContent = []byte(archetypeShortcodeReplacementsPost.Replace(buff.String()))
return archetypeContent, nil
-
}
package create_test
import (
+ "fmt"
"os"
"path/filepath"
"strings"
"github.com/gohugoio/hugo/hugolib"
- "fmt"
-
"github.com/gohugoio/hugo/hugofs"
qt "github.com/frankban/quicktest"
)
func TestNewContent(t *testing.T) {
-
cases := []struct {
kind string
path string
`title = "GO"`,
"{{< myshortcode >}}",
"{{% myshortcode %}}",
- "{{</* comment */>}}\n{{%/* comment */%}}"}}, // shortcodes
+ "{{</* comment */>}}\n{{%/* comment */%}}",
+ }}, // shortcodes
}
for i, cas := range cases {
c.Assert(create.NewContent(h, "my-theme-bundle", "post/my-theme-post"), qt.IsNil)
cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-theme-post/index.md")), `File: index.md`, `Site Lang: en`, `Name: My Theme Post`, `i18n: Hugo Rocks!`)
cContains(c, readFileFromFs(t, fs.Source, filepath.Join("content", "post/my-theme-post/resources/hugo1.json")), `hugo1: {{ printf "no template handling in here" }}`)
-
}
func initFs(fs afero.Fs) error {
}
func newTestCfg(c *qt.C, mm afero.Fs) (*viper.Viper, *hugofs.Fs) {
-
cfg := `
theme = "mytheme"
c.Assert(err, qt.IsNil)
return v, hugofs.NewFrom(mm, v)
-
}
// knownHiddenDirectory checks if the specified name is a well known
// hidden directory.
func knownHiddenDirectory(name string) bool {
- var knownDirectories = []string{
+ knownDirectories := []string{
".well-known",
}
//
// The subslices are sorted by Local.SlashPath.
func applyOrdering(ordering []*regexp.Regexp, uploads []*fileToUpload) [][]*fileToUpload {
-
// Sort the whole slice by Local.SlashPath first.
sort.Slice(uploads, func(i, j int) bool { return uploads[i].Local.SlashPath < uploads[j].Local.SlashPath })
// decode creates a config from a given Hugo configuration.
func decodeConfig(cfg config.Provider) (deployConfig, error) {
-
var (
mediaTypesConfig []map[string]interface{}
dcfg deployConfig
}
func TestWalkLocal(t *testing.T) {
-
tests := map[string]struct {
Given []string
Expect []string
MediaTypesConfig: []map[string]interface{}{
{
"hugo/custom": map[string]interface{}{
- "suffixes": []string{"hugo"}}}},
+ "suffixes": []string{"hugo"},
+ },
+ },
+ },
WantContent: contentBytes,
WantSize: contentLen,
WantMD5: contentMD5[:],
}
ps, err := helpers.NewPathSpec(fs, cfg.Language, logger)
-
if err != nil {
return nil, errors.Wrap(err, "create PathSpec")
}
d.BuildStartListeners = &Listeners{}
return &d, nil
-
}
// DepsCfg contains configuration options that can be used to configure Hugo
)
func TestBuildFlags(t *testing.T) {
-
c := qt.New(t)
var bf BuildState
bf.Incr()
bf.Incr()
c.Assert(bf.Incr(), qt.Equals, 4)
-
}
import (
"bytes"
"html/template"
+ "strings"
"unicode"
"unicode/utf8"
bp "github.com/gohugoio/hugo/bufferpool"
"github.com/gohugoio/hugo/config"
-
- "strings"
)
// SummaryDivider denotes where content summarization should end. The default is "<!--more-->".
// NewContentSpec returns a ContentSpec initialized
// with the appropriate fields from the given config.Provider.
func NewContentSpec(cfg config.Provider, logger loggers.Logger, contentFs afero.Fs) (*ContentSpec, error) {
-
spec := &ContentSpec{
summaryLength: cfg.GetInt("summaryLength"),
BuildFuture: cfg.GetBool("buildFuture"),
ContentFs: contentFs,
Logger: logger,
})
-
if err != nil {
return nil, err
}
// StripHTML accepts a string, strips out all HTML tags and returns it.
func StripHTML(s string) string {
-
// Shortcut strings with no tags in them
if !strings.ContainsAny(s, "<>") {
return s
c.Assert(spec.BuildFuture, qt.Equals, true)
c.Assert(spec.BuildExpired, qt.Equals, true)
c.Assert(spec.BuildDrafts, qt.Equals, true)
-
}
var benchmarkTruncateString = strings.Repeat("This is a sentence about nothing.", 20)
content := []byte("<nav>\n<ul>\nTOC This is a very long content which will definitely be greater than seventy, I promise you that.<li><a href=\"#")
actualTocLessContent, actualToc := ExtractTOC(content)
- //Because the start of Toc is greater than 70+startpoint of <li> content and empty TOC will be returned
+ // Because the start of Toc is greater than 70+startpoint of <li> content and empty TOC will be returned
expectedToc := []byte("")
if !bytes.Equal(actualTocLessContent, content) {
var totalWordsBenchmarkString = strings.Repeat("Hugo Rocks ", 200)
func TestTotalWords(t *testing.T) {
-
for i, this := range []struct {
s string
words int
// This is is just some helpers used to create some JSON used in the Hugo docs.
func init() {
-
docsProvider := func() docshelper.DocProvider {
-
var chromaLexers []interface{}
sort.Sort(lexers.Registry.Lexers)
}
return docshelper.DocProvider{"chroma": map[string]interface{}{"lexers": chromaLexers}}
-
}
docshelper.AddDocProviderFunc(docsProvider)
emojiMaxSize = len(k)
}
}
-
}
// Hugo have a byte slice, wants a byte slice and doesn't mind if the original is modified.
func BenchmarkEmojiKyokomiFprint(b *testing.B) {
-
f := func(in []byte) []byte {
buff := bufferpool.GetBuffer()
defer bufferpool.PutBuffer(buff)
}
func BenchmarkEmojiKyokomiSprint(b *testing.B) {
-
f := func(in []byte) []byte {
return []byte(emoji.Sprint(string(in)))
}
}
func doBenchmarkEmoji(b *testing.B, f func(in []byte) []byte) {
-
type input struct {
in []byte
expect []byte
{"No smiles for you or " + strings.Repeat("you ", 1000), "No smiles for you or " + strings.Repeat("you ", 1000)},
}
- var in = make([]input, b.N*len(data))
- var cnt = 0
+ in := make([]input, b.N*len(data))
+ cnt := 0
for i := 0; i < b.N; i++ {
for _, this := range data {
in[cnt] = input{[]byte(this.input), []byte(this.expect)}
b.Fatalf("[%d] emoji std, got \n%q but expected \n%q", j, result, currIn.expect)
}
}
-
}
}
// ReaderContains reports whether subslice is within r.
func ReaderContains(r io.Reader, subslice []byte) bool {
-
if r == nil || len(subslice) == 0 {
return false
}
func Deprecated(item, alternative string, err bool) {
if err {
DistinctErrorLog.Printf("%s is deprecated and will be removed in Hugo %s. %s", item, hugo.CurrentVersion.Next().ReleaseVersion(), alternative)
-
} else {
DistinctWarnLog.Printf("%s is deprecated and will be removed in a future release. %s", item, alternative)
}
c.Assert(GetTitleFunc("ap")(title), qt.Equals, "Somewhere Over the Rainbow")
c.Assert(GetTitleFunc("")(title), qt.Equals, "Somewhere Over the Rainbow")
c.Assert(GetTitleFunc("unknown")(title), qt.Equals, "Somewhere Over the Rainbow")
-
}
func BenchmarkReaderContains(b *testing.B) {
}
})
}
-
}
func BenchmarkUniqueStrings(b *testing.B) {
}
}
})
-
}
func TestHashString(t *testing.T) {
"github.com/spf13/afero"
)
-var (
- // ErrThemeUndefined is returned when a theme has not be defined by the user.
- ErrThemeUndefined = errors.New("no theme set")
-)
+// ErrThemeUndefined is returned when a theme has not be defined by the user.
+var ErrThemeUndefined = errors.New("no theme set")
// filepathPathBridge is a bridge for common functionality in filepath vs path
type filepathPathBridge interface {
}
func makePathRelative(inPath string, possibleDirectories ...string) (string, error) {
-
for _, currentPath := range possibleDirectories {
if strings.HasPrefix(inPath, currentPath) {
return strings.TrimPrefix(inPath, currentPath), nil
}
func extractFilename(in, ext, base, pathSeparator string) (name string) {
-
// No file name cases. These are defined as:
// 1. any "in" path that ends in a pathSeparator
// 2. any "base" consisting of just an pathSeparator
name = base
}
return
-
}
// GetRelativePath returns the relative path of a given path.
r[i] = root
}
return r
-
}
// FindCWD returns the current working directory from where the Hugo
// executable is run.
func FindCWD() (string, error) {
serverFile, err := filepath.Abs(os.Args[0])
-
if err != nil {
return "", fmt.Errorf("can't get absolute path for executable: %v", err)
}
path := filepath.Dir(serverFile)
realFile, err := filepath.EvalSymlinks(serverFile)
-
if err != nil {
if _, err = os.Stat(serverFile + ".exe"); err == nil {
realFile = filepath.Clean(serverFile + ".exe")
})
return w.Walk()
-
}
// LstatIfPossible can be used to call Lstat if possible, else Stat.
}
return hugio.NewMultiWriteCloser(writeClosers...), nil
-
}
// OpenFileForWriting opens or creates the given file. If the target directory
// Fall back to a cache in /tmp.
return GetTempDir("hugo_cache", fs), nil
-
}
func getCacheDir(cfg config.Provider) string {
// is this project:
// https://github.com/philhawksworth/content-shards/blob/master/gulpfile.js
return "/opt/build/cache/hugo_cache/"
-
}
// This will fall back to an hugo_cache folder in the tmp dir, which should work fine for most CI
for _, f := range []func(string) string{filepath.FromSlash, func(s string) string { return s }} {
doTestGetDottedRelativePath(f, t)
}
-
}
func doTestGetDottedRelativePath(urlFixer func(string) string, t *testing.T) {
}
// the dir now has one, zero length file in it
return d, nil
-
}
func createTempDirWithNonZeroLengthFiles() (string, error) {
// the dir now has one, zero length file in it
return d, nil
-
}
func deleteTempDir(d string) {
t.Errorf("Test %d failed. Expected %q got %q", i, d.expectedErr, err)
}
}
-
}
func TestAbsPathify(t *testing.T) {
}
}
}
-
}
func TestExtNoDelimiter(t *testing.T) {
t.Errorf("Test %d failed. Expected extension %q got %q.", i, d.expectedExt, ext)
}
}
-
}
func TestPathPrep(t *testing.T) {
-
}
func TestPrettifyPath(t *testing.T) {
-
}
func TestExtractAndGroupRootPaths(t *testing.T) {
// Make sure the original is preserved
c.Assert(in, qt.DeepEquals, inCopy)
-
}
func TestExtractRootPaths(t *testing.T) {
tests := []struct {
input []string
expected []string
- }{{[]string{filepath.FromSlash("a/b"), filepath.FromSlash("a/b/c/"), "b",
- filepath.FromSlash("/c/d"), filepath.FromSlash("d/"), filepath.FromSlash("//e//")},
- []string{"a", "a", "b", "c", "d", "e"}}}
+ }{{
+ []string{
+ filepath.FromSlash("a/b"), filepath.FromSlash("a/b/c/"), "b",
+ filepath.FromSlash("/c/d"), filepath.FromSlash("d/"), filepath.FromSlash("//e//"),
+ },
+ []string{"a", "a", "b", "c", "d", "e"},
+ }}
for _, test := range tests {
output := ExtractRootPaths(test.input)
expectedErr error
}
- //cwd, _ := os.Getwd()
+ // cwd, _ := os.Getwd()
data := []test{
//{cwd, nil},
// Commenting this out. It doesn't work properly.
// NewPathSpecWithBaseBaseFsProvided creats a new PathSpec from the given filesystems and language.
// If an existing BaseFs is provided, parts of that is reused.
func NewPathSpecWithBaseBaseFsProvided(fs *hugofs.Fs, cfg config.Provider, logger loggers.Logger, baseBaseFs *filesystems.BaseFs) (*PathSpec, error) {
-
p, err := paths.New(fs, cfg)
if err != nil {
return nil, err
baseURL += "/"
}
return baseURL + link
-
}
c.Assert(p.BaseURL.String(), qt.Equals, "http://base.com")
c.Assert(p.ThemesDir, qt.Equals, "thethemes")
c.Assert(p.WorkingDir, qt.Equals, "thework")
-
}
table.SetHeader([]string{"", s.Name})
table.SetBorder(false)
table.Render()
-
}
// ProcessingStatsTable writes a table-formatted representation of stats to w.
} else {
data[j] = append(data[j], strconv.Itoa(int(tv.val)))
}
-
}
}
table.SetHeader(names)
table.SetBorder(false)
table.Render()
-
}
v.SetFs(fs.Source)
return v
-
}
func newTestCfg() *viper.Viper {
return u.String()
// End temporary kludge
- //return s
+ // return s
}
// urlize: vim-text-editor
func (p *PathSpec) URLize(uri string) string {
return p.URLEscape(p.MakePathSanitized(uri))
-
}
// URLizeFilename creates an URL from a filename by esacaping unicode letters
// path: post/how-i-blog
// result: http://spf13.com/post/how-i-blog
func MakePermalink(host, plink string) *url.URL {
-
base, err := url.Parse(host)
if err != nil {
panic(err)
// For relative URL entries on sites with a base url with a context root set (i.e. http://example.com/mysite),
// relative URLs must not include the context root if canonifyURLs is enabled. But if it's disabled, it must be set.
func AddContextRoot(baseURL, relativePath string) string {
-
url, err := url.Parse(baseURL)
if err != nil {
panic(err)
)
func TestURLize(t *testing.T) {
-
v := newTestCfg()
l := langs.NewDefaultLanguage(v)
p, _ := NewPathSpec(hugofs.NewMem(v), l, nil)
} else {
expected = strings.Replace(expected, "MULTI", lang+"/", 1)
}
-
} else {
expected = strings.Replace(expected, "MULTI", "", 1)
}
t.Errorf("Test #%d failed. Expected %q got %q", i, d.output, output)
}
}
-
}
func TestAddContextRoot(t *testing.T) {
runtime.Stack(buf, true)
panic(string(buf))
})
-
}
// Rnd is used only for testing.
ffs.decorate = decorator
return ffs
-
}
func decoratePath(fs afero.Fs, createPath func(name string) string) afero.Fs {
-
ffs := &baseFileDecoratorFs{Fs: fs}
decorator := func(fi os.FileInfo, name string) (os.FileInfo, error) {
ffs.decorate = decorator
return ffs
-
}
// DecorateBasePathFs adds Path info to files and directories in the
// NewBaseFileDecorator decorates the given Fs to provide the real filename
// and an Opener func.
func NewBaseFileDecorator(fs afero.Fs, callbacks ...func(fi FileMetaInfo)) afero.Fs {
-
ffs := &baseFileDecoratorFs{Fs: fs}
decorator := func(fi os.FileInfo, filename string) (os.FileInfo, error) {
}
return fim, nil
-
}
ffs.decorate = decorator
}
return fs.decorate(fi, name)
-
}
func (fs *baseFileDecoratorFs) LstatIfPossible(name string) (os.FileInfo, bool, error) {
func (f FileMeta) SkipDir() bool {
return f.GetBool(metaKeySkipDir)
}
+
func (f FileMeta) TranslationBaseName() string {
return f.stringV(metaKeyTranslationBaseName)
}
}
func NewFileMetaInfo(fi os.FileInfo, m FileMeta) FileMetaInfo {
-
if fim, ok := fi.(FileMetaInfo); ok {
mergeFileMeta(fim.Meta(), m)
}
fi os.FileInfo,
fs afero.Fs, opener func() (afero.File, error),
filename, filepath string, inMeta FileMeta) FileMetaInfo {
-
var meta FileMeta
var fim FileMetaInfo
mergeFileMeta(inMeta, meta)
return fim
-
}
func isSymlink(fi os.FileInfo) bool {
sort.Slice(fis, func(i, j int) bool {
fimi, fimj := fis[i].(FileMetaInfo), fis[j].(FileMetaInfo)
return fimi.Meta().Filename() < fimj.Meta().Filename()
-
})
}
"rest", "rst",
"mmark",
"org",
- "pandoc", "pdc"}
+ "pandoc", "pdc",
+ }
contentFileExtensionsSet map[string]bool
htmlFileExtensions = []string{
- "html", "htm"}
+ "html", "htm",
+ }
htmlFileExtensionsSet map[string]bool
)
c.Assert(isHTMLContent(strings.NewReader(" <!--")), qt.Equals, true)
c.Assert(isHTMLContent(strings.NewReader(" ---<")), qt.Equals, false)
c.Assert(isHTMLContent(strings.NewReader(" foo <")), qt.Equals, false)
-
}
func TestComponentFolders(t *testing.T) {
c.Assert(IsComponentFolder("content"), qt.Equals, true)
c.Assert(IsComponentFolder("foo"), qt.Equals, false)
c.Assert(IsComponentFolder(""), qt.Equals, false)
-
}
)
func NewLanguageFs(langs map[string]int, fs afero.Fs) (afero.Fs, error) {
-
applyMeta := func(fs *FilterFs, name string, fis []os.FileInfo) {
-
for i, fi := range fis {
if fi.IsDir() {
filename := filepath.Join(name, fi.Name())
applyPerSource: applyMeta,
applyAll: all,
}, nil
-
}
func NewFilterFs(fs afero.Fs) (afero.Fs, error) {
-
applyMeta := func(fs *FilterFs, name string, fis []os.FileInfo) {
for i, fi := range fis {
if fi.IsDir() {
}
return ffs, nil
-
}
// FilterFs is an ordered composite filesystem.
func (fs *FilterFs) LstatIfPossible(name string) (os.FileInfo, bool, error) {
fi, b, err := lstatIfPossible(fs.fs, name)
-
if err != nil {
return nil, false, err
}
fs.applyFilters(parent, -1, fi)
return fi, b, nil
-
}
func (fs *FilterFs) Mkdir(n string, p os.FileMode) error {
File: f,
ffs: fs,
}, nil
-
}
func (fs *FilterFs) OpenFile(name string, flag int, perm os.FileMode) (afero.File, error) {
}
return fis, nil
-
}
type filterDir struct {
}
return lang, translationBaseName, translationBaseNameWithExt
-
}
func printFs(fs afero.Fs, path string, w io.Writer) {
)
func TestLangInfoFrom(t *testing.T) {
-
langs := map[string]int{
"sv": 10,
"en": 20,
v1, v2, v3 := langInfoFrom(langs, test.input)
c.Assert([]string{v1, v2, v3}, qt.DeepEquals, test.expected)
}
-
}
"github.com/spf13/afero"
)
-var (
- // Os points to the (real) Os filesystem.
- Os = &afero.OsFs{}
-)
+// Os points to the (real) Os filesystem.
+var Os = &afero.OsFs{}
// Fs abstracts the file system to separate source and destination file systems
// and allows both to be mocked for testing.
c.Assert(f.Source, hqt.IsSameType, new(afero.OsFs))
c.Assert(f.Os, qt.Not(qt.IsNil))
c.Assert(f.WorkingDir, qt.IsNil)
-
}
func TestNewMem(t *testing.T) {
c.Assert(f.WorkingDir, qt.Not(qt.IsNil))
c.Assert(f.WorkingDir, hqt.IsSameType, new(afero.BasePathFs))
-
}
globMu.Unlock()
return eg.glob, eg.err
-
}
func NormalizePath(p string) string {
}
}
return false
-
}
{"dat?a/foo.json", ""},
{"a/b[a-c]/foo.json", "a"},
} {
-
c.Assert(ResolveRootDir(test.input), qt.Equals, test.expected)
}
}
}{
{[]string{"a", "*", "c"}, []string{"a", "c"}},
} {
-
c.Assert(FilterGlobParts(test.input), qt.DeepEquals, test.expected)
}
}
{filepath.FromSlash("./FOO.json"), "foo.json"},
{"//", ""},
} {
-
c.Assert(NormalizePath(test.input), qt.Equals, test.expected)
}
}
b.Fatal(err)
}
}
-
}
c.Assert(collect("*.json"), qt.HasLen, 1)
c.Assert(collect("**.xml"), qt.HasLen, 1)
c.Assert(collect(filepath.FromSlash("/jsonfiles/*.json")), qt.HasLen, 2)
-
}
"github.com/spf13/afero"
)
-var (
- _ afero.Fs = (*md5HashingFs)(nil)
-)
+var _ afero.Fs = (*md5HashingFs)(nil)
// FileHashReceiver will receive the filename an the content's MD5 sum on file close.
type FileHashReceiver interface {
c.Assert(err, qt.IsNil)
c.Assert(f.Close(), qt.IsNil)
c.Assert(observer.sum, qt.Equals, "d41d8cd98f00b204e9800998ecf8427e")
-
}
"github.com/spf13/afero"
)
-var (
- ErrPermissionSymlink = errors.New("symlinks not allowed in this filesystem")
-)
+var ErrPermissionSymlink = errors.New("symlinks not allowed in this filesystem")
// NewNoSymlinkFs creates a new filesystem that prevents symlinks.
func NewNoSymlinkFs(fs afero.Fs, logger loggers.Logger, allowFiles bool) afero.Fs {
}
func (fs *noSymlinkFs) stat(name string) (os.FileInfo, bool, error) {
-
var (
fi os.FileInfo
wasLstat bool
"github.com/spf13/afero"
)
-var (
- filepathSeparator = string(filepath.Separator)
-)
+var filepathSeparator = string(filepath.Separator)
// NewRootMappingFs creates a new RootMappingFs on top of the provided with
// root mappings with some optional metadata about the root.
fs afero.Fs,
fromTo ...string,
) (*RootMappingFs, error) {
-
rms := make([]RootMapping, len(fromTo)/2)
for i, j := 0, 0; j < len(fromTo); i, j = i+1, j+2 {
rms[i] = RootMapping{
// Open opens the named file for reading.
func (fs *RootMappingFs) Open(name string) (afero.File, error) {
fis, err := fs.doLstat(name)
-
if err != nil {
return nil, err
}
func (fs *RootMappingFs) Stat(name string) (os.FileInfo, error) {
fi, _, err := fs.LstatIfPossible(name)
return fi, err
-
}
func (fs *RootMappingFs) hasPrefix(prefix string) bool {
return "", nil
}
return s, v.([]RootMapping)
-
}
func (fs *RootMappingFs) debug() {
fmt.Println("Key", s)
return false
})
-
}
func (fs *RootMappingFs) getRootsWithPrefix(prefix string) []RootMapping {
}
return uf, nil
-
}
func (fs *RootMappingFs) cleanName(name string) string {
// Next add any file mounts inside the given directory.
prefixInside := prefix + filepathSeparator
fs.rootMapToReal.WalkPrefix(prefixInside, func(s string, v interface{}) bool {
-
if (strings.Count(s, filepathSeparator) - level) != 1 {
// This directory is not part of the current, but we
// need to include the first name part to make it
if fileCount > 1 {
// Not supported by this filesystem.
return nil, errors.Errorf("found multiple files with name %q, use .Readdir or the source filesystem directly", name)
-
}
return []FileMetaInfo{roots[0].fi}, nil
-
}
func (fs *RootMappingFs) statRoot(root RootMapping, name string) (FileMetaInfo, bool, error) {
}
return decorateFileInfo(fi, fs.Fs, opener, "", "", root.Meta), b, nil
-
}
func (fs *RootMappingFs) virtualDirOpener(name string) func() (afero.File, error) {
c.Assert(getDirnames("content", rfsSv), qt.DeepEquals, []string{"blog", "docs"})
c.Assert(getDirnames("content", rfs), qt.DeepEquals, []string{"blog", "docs"})
-
}
func TestRootMappingFsDirnames(t *testing.T) {
dirnames, err := root.Readdirnames(-1)
c.Assert(err, qt.IsNil)
c.Assert(dirnames, qt.DeepEquals, []string{"af3", "bf1", "cf2"})
-
}
func TestRootMappingFsFilename(t *testing.T) {
bfs := afero.NewBasePathFs(fs, "themes/a").(*afero.BasePathFs)
rm := []RootMapping{
// Directories
- RootMapping{
+ {
From: "content/blog",
To: "mynoblogcontent",
Meta: FileMeta{"lang": "no"},
},
- RootMapping{
+ {
From: "content/blog",
To: "myenblogcontent",
Meta: FileMeta{"lang": "en"},
},
- RootMapping{
+ {
From: "content/blog",
To: "mysvblogcontent",
Meta: FileMeta{"lang": "sv"},
},
// Files
- RootMapping{
+ {
From: "content/singles/p1.md",
To: "singlefiles/no.txt",
ToBasedir: "singlefiles",
Meta: FileMeta{"lang": "no"},
},
- RootMapping{
+ {
From: "content/singles/p1.md",
To: "singlefiles/sv.txt",
ToBasedir: "singlefiles",
c.Assert(afero.WriteFile(fs, filepath.FromSlash("de/e.txt"), []byte("some no content"), 0755), qt.IsNil)
rm := []RootMapping{
- RootMapping{
+ {
From: "static",
To: "da",
},
- RootMapping{
+ {
From: "static/b",
To: "db",
},
- RootMapping{
+ {
From: "static/b/c",
To: "dc",
},
- RootMapping{
+ {
From: "/static/e/",
To: "de",
},
fi, err := rfs.Stat(filepath.FromSlash("static/b/b.txt"))
c.Assert(err, qt.IsNil)
c.Assert(fi.Name(), qt.Equals, "b.txt")
-
}
func TestRootMappingFsOs(t *testing.T) {
}
c.Assert(getDirnames("static/a/b/c"), qt.DeepEquals, []string{"d4", "f-1.txt", "f-2.txt", "f-3.txt", "ms-1.txt"})
-
}
}
return fs, nil
-
}
// SliceFs is an ordered composite filesystem.
func (fs *SliceFs) LstatIfPossible(name string) (os.FileInfo, bool, error) {
fi, _, err := fs.pickFirst(name)
-
if err != nil {
return nil, false, err
}
}
return nil, false, errors.Errorf("lstat: files not supported: %q", name)
-
}
func (fs *SliceFs) Mkdir(n string, p os.FileMode) error {
idx: idx,
dirname: name,
}, nil
-
}
func (fs *SliceFs) OpenFile(name string, flag int, perm os.FileMode) (afero.File, error) {
}
return dirs, nil
-
}
type sliceDir struct {
hookPre: cfg.HookPre,
hookPost: cfg.HookPost,
logger: logger,
- seen: make(map[string]bool)}
+ seen: make(map[string]bool),
+ }
}
func (w *Walkway) Walk() error {
}
return w.walk(w.root, fi, w.dirEntries, w.walkFn)
-
}
// if the filesystem supports it, use Lstat, else use fs.Stat
c.Assert(afero.WriteFile(fs, filepath.Join("e/f", testfile), []byte("some content"), 0755), qt.IsNil)
rm := []RootMapping{
- RootMapping{
+ {
From: "static/b",
To: "e/f",
},
- RootMapping{
+ {
From: "static/a",
To: "c/d",
},
- RootMapping{
+ {
From: "static/c",
To: "a/b",
},
c.Assert(err, qt.IsNil)
c.Assert(names, qt.DeepEquals, []string{"a/test.txt", "b/test.txt", "c/test.txt"})
-
}
func skipSymlink() bool {
// Note: the docsreal folder is considered cyclic when walking from the root, but this works.
c.Assert(names, qt.DeepEquals, []string{"b.txt", "docsreal/sub/a.txt"})
})
-
}
func collectFilenames(fs afero.Fs, base, root string) ([]string, error) {
err := w.Walk()
return names, err
-
}
func collectFileinfos(fs afero.Fs, base, root string) ([]FileMetaInfo, error) {
err := w.Walk()
return fis, err
-
}
func BenchmarkWalk(b *testing.B) {
b.Fatal(err)
}
}
-
}
Data: 1|
`)
-
}
func Test404WithBase(t *testing.T) {
b.AssertFileContent("public/404.html", `
Base:
Page not found`)
-
}
}
func (a aliasHandler) renderAlias(permalink string, p page.Page) (io.Reader, error) {
-
var templ tpl.Template
var found bool
For some moments the old man did not reply. He stood with bowed head, buried in deep thought. But at last he spoke.
`
-const basicTemplate = "<html><body>{{.Content}}</body></html>"
-const aliasTemplate = "<html><body>ALIASTEMPLATE</body></html>"
+const (
+ basicTemplate = "<html><body>{{.Content}}</body></html>"
+ aliasTemplate = "<html><body>ALIASTEMPLATE</body></html>"
+)
func TestAlias(t *testing.T) {
t.Parallel()
)
func Test073(t *testing.T) {
-
asertDisabledTaxonomyAndTerm := func(b *sitesBuilder, taxonomy, term bool) {
b.Assert(b.CheckExists("public/tags/index.html"), qt.Equals, taxonomy)
b.Assert(b.CheckExists("public/tags/tag1/index.html"), qt.Equals, term)
-
}
assertOutputTaxonomyAndTerm := func(b *sitesBuilder, taxonomy, term bool) {
func(err error, out string, b *sitesBuilder) {
b.Assert(err, qt.IsNil)
assertOutputTaxonomyAndTerm(b, true, true)
-
},
},
{
func(err error, out string, b *sitesBuilder) {
b.Assert(err, qt.IsNil)
assertOutputTaxonomyAndTerm(b, true, false)
-
},
},
{
func(err error, out string, b *sitesBuilder) {
b.Assert(err, qt.Not(qt.IsNil))
b.Assert(out, qt.Contains, `ignoreErrors = ["error-output-taxonomy"]`)
-
},
},
{
func(err error, out string, b *sitesBuilder) {
b.Assert(err, qt.IsNil)
assertOutputTaxonomyAndTerm(b, true, false)
-
},
},
{
func(err error, out string, b *sitesBuilder) {
b.Assert(err, qt.IsNil)
asertDisabledTaxonomyAndTerm(b, false, false)
-
},
},
{
func(err error, out string, b *sitesBuilder) {
b.Assert(err, qt.IsNil)
asertDisabledTaxonomyAndTerm(b, false, true)
-
},
},
{
},
},
} {
-
t.Run(this.name, func(t *testing.T) {
b := newTestSitesBuilder(t).WithConfigFile("toml", this.config)
b.WithTemplatesAdded("_default/list.json", "JSON")
fmt.Println(out)
this.assert(err, out, b)
})
-
}
-
}
}
func TestCascade(t *testing.T) {
-
allLangs := []string{"en", "nn", "nb", "sv"}
langs := allLangs[:3]
// Check cascade into bundled page
b.AssertFileContent("public/bundle1/index.html", `Resources: bp1.md|home.png|`)
-
})
-
}
func TestCascadeEdit(t *testing.T) {
metaStr := "---\n" + yamlStr + "\n---"
return metaStr
-
}
createLangConfig := func(lang string) string {
b := newTestSitesBuilder(t).WithConfigFile("toml", config)
createContentFiles := func(lang string) {
-
withContent := func(filenameContent ...string) {
for i := 0; i < len(filenameContent); i += 2 {
b.WithContent(path.Join(lang, filenameContent[i]), filenameContent[i+1])
b.WithContent("s2/p1/index.md", "---\ntitle: p1_2\n---")
return b
-
}
c.Run("slice", func(c *qt.C) {
b.Build(BuildCfg{})
b.AssertFileContent("public/index.html", "P1|p1:p1|p2:p2")
-
})
c.Run("slice with _target", func(c *qt.C) {
P1|p1:p1|p2:|
S1|p1:|p2:p2|
`)
-
})
c.Run("slice with yaml _target", func(c *qt.C) {
P1|p1:p1|p2:|
S1|p1:|p2:p2|
`)
-
})
c.Run("slice with json _target", func(c *qt.C) {
P1|p1:p1|p2:|
S1|p1:|p2:p2|
`)
-
})
-
}
`)
writeToFs(t, fs, "config.toml", caseMixingSiteConfigTOML)
-
}
func TestCaseInsensitiveConfigurationVariations(t *testing.T) {
`)
sites, err := NewHugoSites(deps.DepsCfg{Fs: fs, Cfg: cfg})
-
if err != nil {
t.Fatalf("Failed to create sites: %s", err)
}
// LoadConfig loads Hugo configuration into a new Viper and then adds
// a set of defaults.
func LoadConfig(d ConfigSourceDescriptor, doWithConfig ...func(cfg config.Provider) error) (*viper.Viper, []string, error) {
-
if d.Environment == "" {
d.Environment = hugo.EnvironmentProduction
}
}
return v, configFiles, err
-
}
func loadLanguageSettings(cfg config.Provider, oldLangs langs.Languages) error {
}
return filename, nil
-
}
func (l configLoader) wrapFileError(err error, filename string) error {
}
return nil
-
})
-
if err != nil {
return nil, err
}
}
func (l configLoader) loadModulesConfig(v1 *viper.Viper) (modules.Config, error) {
-
modConfig, err := modules.DecodeConfig(v1)
if err != nil {
return modules.Config{}, err
}
return nil
-
}
modulesClient := modules.NewClient(modules.ClientConfig{
}
return moduleConfig.ActiveModules, configFilenames, err
-
}
func (l configLoader) applyThemeConfig(v1 *viper.Viper, theme modules.Module) error {
-
const (
paramsKey = "params"
languagesKey = "languages"
}
return nil
-
}
func (configLoader) mergeStringMapKeepLeft(rootKey, key string, v1, v2 config.Provider) {
}
func loadDefaultSettingsFor(v *viper.Viper) error {
-
v.RegisterAlias("indexes", "taxonomies")
/*
c.Assert(err, qt.IsNil)
c.Assert(cfg.GetString("paginatePath"), qt.Equals, "side")
-
}
func TestLoadMultiConfig(t *testing.T) {
},
},
}`, got["menu"])
-
}
func TestPrivacyConfig(t *testing.T) {
b.Build(BuildCfg{SkipRender: true})
c.Assert(b.H.Sites[0].Info.Config().Privacy.YouTube.PrivacyEnhanced, qt.Equals, true)
-
}
func TestLoadConfigModules(t *testing.T) {
`
c.Assert(graphb.String(), qt.Equals, expected)
-
}
func TestLoadConfigWithOsEnvOverrides(t *testing.T) {
-
c := qt.New(t)
baseConfig := `
c.Assert(cfg.Get("intSlice"), qt.DeepEquals, []interface{}{5, 8, 9})
c.Assert(cfg.Get("params.api_config.api_key"), qt.Equals, "new_key")
c.Assert(cfg.Get("params.api_config.another_key"), qt.Equals, "default another_key")
-
}
noMenus := cfg.Get("languages.no.menus.docs")
c.Assert(noMenus, qt.Not(qt.IsNil))
c.Assert(len(noMenus.(([]map[string]interface{}))), qt.Equals, 1)
-
}
func TestLoadConfigDirError(t *testing.T) {
fe := herrors.UnwrapErrorWithFileContext(err)
c.Assert(fe, qt.Not(qt.IsNil))
c.Assert(fe.Position().Filename, qt.Equals, filepath.FromSlash("config/development/config.toml"))
-
}
}
func (b cmInsertKeyBuilder) ForPage(s string) *cmInsertKeyBuilder {
- //fmt.Println("ForPage:", s, "baseKey:", b.baseKey, "key:", b.key)
+ // fmt.Println("ForPage:", s, "baseKey:", b.baseKey, "key:", b.key)
baseKey := b.baseKey
b.baseKey = s
}
func (b cmInsertKeyBuilder) ForResource(s string) *cmInsertKeyBuilder {
- //fmt.Println("ForResource:", s, "baseKey:", b.baseKey, "key:", b.key)
+ // fmt.Println("ForResource:", s, "baseKey:", b.baseKey, "key:", b.key)
baseKey := helpers.AddTrailingSlash(b.baseKey)
s = strings.TrimPrefix(s, baseKey)
}
return []string{c.name.plural, c.termKey}
-
}
func (c *contentBundleViewInfo) term() string {
}
return nil
-
}
func (m *contentMap) CreateMissingNodes() error {
}
return nil
-
}
func (m *contentMap) getBundleDir(meta hugofs.FileMeta) string {
if s != "" {
m.resources.Delete(s)
}
-
}
// Deletes any empty root section that's not backed by a content file.
}
return strings.Split(k, "/")[1:]
-
}
func (m *contentMap) testDump() string {
}
for i, r := range []*contentTree{m.pages, m.sections} {
-
r.Walk(func(s string, v interface{}) bool {
c := v.(*contentNode)
cpToString := func(c *contentNode) string {
m.resources.WalkPrefix(resourcesPrefix, func(s string, v interface{}) bool {
sb.WriteString("\t - R: " + filepath.ToSlash((v.(*contentNode).fi.(hugofs.FileMetaInfo)).Meta().Filename()) + "\n")
return false
-
})
return false
}
return sb.String()
-
}
type contentMapConfig struct {
return b.path
}
return b.path[:firstSlash]
-
}
type contentTree struct {
}
return fn(s, v)
})
-
}
func (c *contentTree) getMatch(matches func(b *contentNode) bool) string {
}
func (m *pageMap) newResource(fim hugofs.FileMetaInfo, owner *pageState) (resource.Resource, error) {
-
if owner == nil {
panic("owner is nil")
}
}
func (m *pageMap) assembleSections() error {
-
var sectionsToDelete []string
var err error
}
func (m *pageMap) assembleTaxonomies() error {
-
var taxonomiesToDelete []string
var err error
}
return err
-
}
func (m *pageMap) attachPageToViews(s string, b *contentNode) {
}
func (m *pageMap) collectSectionsFn(query pageMapQuery, fn func(s string, c *contentNode) bool) error {
-
if !strings.HasSuffix(query.Prefix, "/") {
query.Prefix += "/"
}
return w.walkLevel("/", func() sectionWalkHandler {
return §ionAggregateHandler{}
}).(*sectionAggregateHandler)
-
}
func (w *sectionWalker) walkLevel(prefix string, createVisitor func() sectionWalkHandler) sectionWalkHandler {
-
level := strings.Count(prefix, "/")
visitor := createVisitor()
})
return visitor
-
}
type viewName struct {
mfi := fi.(hugofs.FileMetaInfo)
return mfi
-
}
createFs := func(fs afero.Fs, lang string) afero.Fs {
meta["lang"] = lang
meta["path"] = meta.Filename()
meta["classifier"] = files.ClassifyContentFile(fi.Name(), meta.GetOpener())
-
})
}
b.StartTimer()
}
})
-
}
func TestContentMap(t *testing.T) {
mfi := fi.(hugofs.FileMetaInfo)
return mfi
-
}
createFs := func(fs afero.Fs, lang string) afero.Fs {
meta["path"] = meta.Filename()
meta["classifier"] = files.ClassifyContentFile(fi.Name(), meta.GetOpener())
meta["translationBaseName"] = helpers.Filename(fi.Name())
-
})
}
c.Run("AddFiles", func(c *qt.C) {
-
memfs := afero.NewMemMapFs()
fsl := func(lang string) afero.Fs {
`, qt.Commentf(m.testDump()))
-
})
c.Run("CreateMissingNodes", func(c *qt.C) {
-
memfs := afero.NewMemMapFs()
fsl := func(lang string) afero.Fs {
- P: blog/page.md
`, qt.Commentf(got))
-
})
c.Run("cleanKey", func(c *qt.C) {
{filepath.FromSlash("/a/b/"), "/a/b"},
{"/a//b/", "/a/b"},
} {
-
c.Assert(cleanTreeKey(test.in), qt.Equals, test.expected)
-
}
})
}
func TestContentMapSite(t *testing.T) {
-
b := newTestSitesBuilder(t)
pageTempl := `
b.Build(BuildCfg{})
b.AssertFileContent("public/p1/index.html", `Link First Link|PARTIAL1_EDITED PARTIAL2_EDITEDEND`)
-
}
func TestRenderHooks(t *testing.T) {
// https://github.com/gohugoio/hugo/issues/7349
b.AssertFileContent("public/docs/p8/index.html", "Docs Level: 1")
-
}
func TestRenderHooksDeleteTemplate(t *testing.T) {
b.Build(BuildCfg{})
b.AssertFileContent("public/p1/index.html", `<p><a href="https://www.google.com" title="Google's Homepage">First Link</a></p>`)
-
}
func TestRenderHookAddTemplate(t *testing.T) {
b.Build(BuildCfg{})
b.AssertFileContent("public/p1/index.html", `<p>html-render-link</p>`)
-
}
func TestRenderHooksRSS(t *testing.T) {
-
b := newTestSitesBuilder(t)
b.WithTemplates("index.html", `
P2: <p>P1. xml-link: https://www.bep.is|</p>
P3: <p>P3. xml-link: https://www.example.org|</p>
`)
-
}
// https://github.com/gohugoio/hugo/issues/6629
func TestRenderLinkWithMarkupInText(t *testing.T) {
-
b := newTestSitesBuilder(t)
b.WithConfigFile("toml", `
<p>Some regular <strong>markup</strong>.</p>
<p>html-image: image.jpg|Text: Hello<br> Goodbye|Plain: Hello GoodbyeEND</p>
`)
-
}
func TestRenderString(t *testing.T) {
-
b := newTestSitesBuilder(t)
b.WithTemplates("index.html", `
RSTART:<em>italic org mode</em>:REND
RSTART:Hook Heading: 2:REND
`)
-
}
// https://github.com/gohugoio/hugo/issues/6882
} {
b.AssertFileContent("public/"+filename, `<strong>Hello</strong>`)
}
-
}
package hugolib
import (
+ "fmt"
"path/filepath"
"reflect"
+ "runtime"
"testing"
"github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/deps"
- "fmt"
- "runtime"
-
qt "github.com/frankban/quicktest"
)
doTestDataDir(t, dd, expected,
"theme", "mytheme")
-
}
// test (and show) the way values from four different sources,
expected :=
map[string]interface{}{
"a": []interface{}{"1", "2", "3"},
- "test1": map[string]interface{}{"20": map[string]interface{}{"05": map[string]interface{}{"b": map[string]interface{}{"artist": "Charlie Parker"}}, "06": map[string]interface{}{"a": map[string]interface{}{"artist": "Michael Brecker"}}}}}
+ "test1": map[string]interface{}{"20": map[string]interface{}{"05": map[string]interface{}{"b": map[string]interface{}{"artist": "Charlie Parker"}}, "06": map[string]interface{}{"a": map[string]interface{}{"artist": "Michael Brecker"}}}},
+ }
doTestDataDir(t, dd, expected, "theme", "mytheme")
}
}
func doTestDataDirImpl(t *testing.T, dd dataDir, expected interface{}, configKeyValues ...interface{}) (err string) {
- var (
- cfg, fs = newTestCfg()
- )
+ cfg, fs := newTestCfg()
for i := 0; i < len(configKeyValues); i += 2 {
cfg.Set(configKeyValues[i].(string), configKeyValues[i+1])
package hugolib
import (
- "testing"
-
"fmt"
+ "testing"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/resources/page"
b.WithSourceFile("content/sect/no-publishresources/data.json", "DATA")
return b
-
}
getPage := func(b *sitesBuilder, ref string) page.Page {
b.Assert(getPageInPagePages(sect, "/sect/page.md"), qt.Not(qt.IsNil))
b.AssertFileContent("public/sitemap.xml", "sitemap")
b.AssertFileContent("public/index.xml", "rss")
-
})
disableKind = kindRSS
b.Assert(getPageInSitePages(b, ref), qt.IsNil)
sect := getPage(b, "/sect")
b.Assert(getPageInPagePages(sect, ref), qt.IsNil)
-
})
c.Run("Build config, local list", func(c *qt.C) {
// In Hugo 0.65 we consolidated the code paths and made RSS a pure output format,
// but we should make sure to not break existing sites.
b.Assert(b.CheckExists("public/index.xml"), qt.Equals, false)
-
}
func TestBundleNoPublishResources(t *testing.T) {
b.Assert(b.CheckExists("public/sect/no-render/index.html"), qt.Equals, false)
b.Assert(b.CheckExists("public/sect-no-render/index.html"), qt.Equals, false)
-
}
"encoding/json"
"fmt"
"html/template"
+ "path/filepath"
"strings"
"testing"
"github.com/spf13/cast"
- "path/filepath"
-
"github.com/gohugoio/hugo/deps"
qt "github.com/frankban/quicktest"
for _, this := range []struct {
in, expected string
}{
- {`{{< highlight java >}}
+ {
+ `{{< highlight java >}}
void do();
{{< /highlight >}}`,
`(?s)<div class="highlight"><pre style="background-color:#fff;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java"`,
},
- {`{{< highlight java "style=friendly" >}}
+ {
+ `{{< highlight java "style=friendly" >}}
void do();
{{< /highlight >}}`,
`(?s)<div class="highlight"><pre style="background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-java" data-lang="java">`,
th.assertFileContentRegexp(filepath.Join("public", "simple", "index.html"), this.expected)
}
-
}
func TestShortcodeVimeo(t *testing.T) {
<meta property="og:image" content="https://example.org/siteimg1.jpg"/>
<meta itemprop="image" content="https://example.org/siteimg1.jpg"/>
`)
-
}
// TODO(bep) rename
func newFileInfo(sp *source.SourceSpec, fi hugofs.FileMetaInfo) (*fileInfo, error) {
-
baseFi, err := sp.NewFileInfo(fi)
if err != nil {
return nil, err
}
return f, nil
-
}
type bundleDirType int
package filesystems
import (
+ "fmt"
"io"
"os"
"path"
"github.com/gohugoio/hugo/hugofs"
- "fmt"
-
"github.com/gohugoio/hugo/hugolib/paths"
"github.com/spf13/afero"
)
fs.Content.Dirs,
fs.Assets.Dirs,
fs.Layouts.Dirs,
- //fs.Resources.Dirs,
+ // fs.Resources.Dirs,
fs.StaticDirs,
} {
dirs = append(dirs, dirSet...)
s.Archetypes,
// TODO(bep) static
}
-
}
// A SourceFilesystem holds the filesystem for a given source type in Hugo (data,
base := afero.NewCopyOnWriteFs(s.Assets.Fs, staticFs)
return afero.NewCopyOnWriteFs(base, s.Content.Fs)
-
}
// StaticFs returns the static filesystem for the given language.
// MakePathRelative creates a relative path from the given filename.
func (d *SourceFilesystem) MakePathRelative(filename string) (string, bool) {
-
for _, dir := range d.Dirs {
meta := dir.(hugofs.FileMetaInfo).Meta()
currentPath := meta.Filename()
}
func (b *sourceFilesystemsBuilder) Build() (*SourceFilesystems, error) {
-
if b.theBigFs == nil {
theBigFs, err := b.createMainOverlayFs(b.p)
dirs := b.theBigFs.overlayDirs[componentID]
return b.newSourceFilesystem(componentID, afero.NewBasePathFs(b.theBigFs.overlayMounts, componentID), dirs)
-
}
b.theBigFs.finalizeDirs()
}
return b.result, nil
-
}
func (b *sourceFilesystemsBuilder) createMainOverlayFs(p *paths.Paths) (*filesystemsCollector, error) {
-
var staticFsMap map[string]afero.Fs
if b.p.Cfg.GetBool("multihost") {
staticFsMap = make(map[string]afero.Fs)
err := b.createOverlayFs(collector, modsReversed)
return collector, err
-
}
func (b *sourceFilesystemsBuilder) isContentMount(mnt modules.Mount) bool {
func (b *sourceFilesystemsBuilder) createModFs(
collector *filesystemsCollector,
md mountsDescriptor) error {
-
var (
fromTo []hugofs.RootMapping
fromToContent []hugofs.RootMapping
sfs, found := collector.staticPerLanguage[lang]
if found {
collector.staticPerLanguage[lang] = afero.NewCopyOnWriteFs(sfs, bfs)
-
} else {
collector.staticPerLanguage[lang] = bfs
}
}
return nil
-
}
func printFs(fs afero.Fs, path string, w io.Writer) {
for _, componentFolder := range files.ComponentFolders {
c.addDir(rfs, componentFolder)
}
-
}
func (c *filesystemsCollector) addDir(rfs *hugofs.RootMappingFs, componentFolder string) {
c.reverseFis(dirs)
}
})
-
}
func (c *filesystemsCollector) reverseFis(fis []hugofs.FileMetaInfo) {
c.Assert(realDirs[len(realDirs)-1], qt.Equals, filepath.Join(themesDir, "mytheme/assets/scss"))
c.Assert(bfs.theBigFs, qt.Not(qt.IsNil))
-
}
func TestStaticFs(t *testing.T) {
sfs := bfs.StaticFs("en")
checkFileContent(sfs, "f1.txt", c, "Hugo Rocks!")
checkFileContent(sfs, "f2.txt", c, "Hugo Themes Still Rocks!")
-
}
func TestStaticFsMultiHost(t *testing.T) {
c.Assert(makeRel(filepath.Join(workDir, "dist", "d1", "foo.txt")), qt.Equals, filepath.FromSlash("mydist/d1/foo.txt"))
c.Assert(makeRel(filepath.Join(workDir, "static", "d2", "foo.txt")), qt.Equals, filepath.FromSlash("d2/foo.txt"))
c.Assert(makeRel(filepath.Join(workDir, "dust", "d3", "foo.txt")), qt.Equals, filepath.FromSlash("foo/bar/d3/foo.txt"))
-
}
func checkFileCount(fs afero.Fs, dirname string, c *qt.C, expected int) {
}
func checkFileContent(fs afero.Fs, filename string, c *qt.C, expected ...string) {
-
b, err := afero.ReadFile(fs, filename)
c.Assert(err, qt.IsNil)
name = strings.TrimPrefix(name, "/")
return g.repo.Files[name]
-
}
func newGitInfo(cfg config.Provider) (*gitInfo, error) {
`)
return b, clean
-
}
t.Run("Target in subfolder", func(t *testing.T) {
-
b, clean := newTestBuilder(t, "ignoreImports=true")
defer clean()
})
t.Run("Ignore config", func(t *testing.T) {
-
b, clean := newTestBuilder(t, "ignoreConfig=true")
defer clean()
})
t.Run("Ignore imports", func(t *testing.T) {
-
b, clean := newTestBuilder(t, "ignoreImports=true")
defer clean()
})
t.Run("Create package.json", func(t *testing.T) {
-
b, clean := newTestBuilder(t, "")
defer clean()
})
t.Run("Create package.json, no default", func(t *testing.T) {
-
b, clean := newTestBuilder(t, "")
defer clean()
// https://github.com/gohugoio/hugo/issues/7690
b.AssertFileContent("package.hugo.json", origPackageJSON)
-
})
t.Run("Create package.json, no default, no package.json", func(t *testing.T) {
-
b, clean := newTestBuilder(t, "")
defer clean()
"name": "myhugosite",
"version": "0.1.0"
}`
-
})
-
})
-
}
// TODO(bep) this fails when testmodBuilder is also building ...
"i18n theme: Theme C",
"i18n theme2: Theme2 D",
)
-
}
func TestModulesIgnoreConfig(t *testing.T) {
b.AssertFileContentFn("public/index.html", func(s string) bool {
return !strings.Contains(s, "Ignored")
})
-
}
func TestModulesDisabled(t *testing.T) {
b.AssertFileContentFn("public/index.html", func(s string) bool {
return strings.Contains(s, "A param") && !strings.Contains(s, "B param")
})
-
}
func TestModulesIncompatible(t *testing.T) {
c := qt.New(t)
c.Assert(logger.LogCounters().WarnCounter.Count(), qt.Equals, uint64(3))
-
}
func TestModulesSymlinks(t *testing.T) {
bfs.Content.Fs,
bfs.Data.Fs,
bfs.Assets.Fs,
- bfs.I18n.Fs} {
+ bfs.I18n.Fs,
+ } {
if i != 0 {
continue
}
_, err := fs.Stat(filepath.FromSlash(filename))
-
if err != nil {
if i > 0 && strings.HasSuffix(filename, "toml") && strings.Contains(err.Error(), "files not supported") {
// OK
b.Build(BuildCfg{})
- //helpers.PrintFs(b.H.Fs.Source, "public", os.Stdout)
+ // helpers.PrintFs(b.H.Fs.Source, "public", os.Stdout)
b.AssertFileContent("public/mypage/index.html", "Permalink: https://example.org/mypage/")
}
b.AssertFileContent("public/index.html", `
Readme Edit
`)
-
}
func TestMountsPaths(t *testing.T) {
clean: clean,
workingDir: workingDir,
}
-
}
c.Run("Default", func(c *qt.C) {
b.Assert(filepath.ToSlash(f.PathFile()), qt.Equals, "content/blog/p1.md")
b.Assert(b.H.BaseFs.Layouts.Path(filepath.Join(test.workingDir, "layouts", "_default", "single.html")), qt.Equals, filepath.FromSlash("_default/single.html"))
-
})
c.Run("Mounts", func(c *qt.C) {
b.Assert(b.H.BaseFs.Layouts.Path(filepath.Join(absShortcodesDir, "myshort.html")), qt.Equals, filepath.FromSlash("shortcodes/myshort.html"))
b.Assert(b.H.BaseFs.Content.Path(filepath.Join(subContentDir, "p1.md")), qt.Equals, filepath.FromSlash("blog/sub/p1.md"))
b.Assert(b.H.BaseFs.Content.Path(filepath.Join(test.workingDir, "README.md")), qt.Equals, filepath.FromSlash("_index.md"))
-
})
-
}
// https://github.com/gohugoio/hugo/issues/6299
b.WithSourceFile("go.mod", "")
b.Build(BuildCfg{})
-
}
// https://github.com/gohugoio/hugo/issues/6622
b.Build(BuildCfg{})
b.AssertFileContent("public/index.html", "P1: Abs|/p1/", "Filename: "+contentFilename)
-
}
// NewHugoSites creates a new collection of sites given the input sites, building
// a language configuration based on those.
func newHugoSites(cfg deps.DepsCfg, sites ...*Site) (*HugoSites, error) {
-
if cfg.Language != nil {
return nil, errors.New("Cannot provide Language in Cfg when sites are provided")
}
langConfig, err := newMultiLingualFromSites(cfg.Cfg, sites...)
-
if err != nil {
return nil, errors.Wrap(err, "failed to create language config")
}
s.outputFormatsConfig,
s.mediaTypesConfig,
)
-
if err != nil {
return err
}
}
func createSitesFromConfig(cfg deps.DepsCfg) ([]*Site, error) {
-
- var (
- sites []*Site
- )
+ var sites []*Site
languages := getLanguages(cfg.Cfg)
depsCfg := deps.DepsCfg{Fs: h.Fs, Cfg: cfg}
sites, err := createSitesFromConfig(depsCfg)
-
if err != nil {
return err
}
langConfig, err := newMultiLingualFromSites(depsCfg.Cfg, sites...)
-
if err != nil {
return err
}
}
func (h *HugoSites) renderCrossSitesSitemap() error {
-
if !h.multilingual.enabled() || h.IsMultihost() {
return nil
}
},
},
output.RobotsTxtFormat)
-
if err != nil {
return err
}
})
return nil
})
-
}
func (h *HugoSites) createPageCollections() error {
-
allPages := newLazyPagesFactory(func() page.Pages {
var pages page.Pages
for _, s := range h.Sites {
}
return dir, bundleNot
-
}
func (m *contentChangeMap) addSymbolicLinkMapping(fim hugofs.FileMetaInfo) {
// Build builds all sites. If filesystem events are provided,
// this is considered to be a potential partial rebuild.
func (h *HugoSites) Build(config BuildCfg, events ...fsnotify.Event) error {
-
if h.running {
// Make sure we don't trigger rebuilds in parallel.
h.runningMu.Lock()
to <- h.pickOneAndLogTheRest(errors)
close(to)
-
}(errCollector, errs)
if h.Metrics != nil {
}
return nil
-
}
// Build lifecycle methods below.
}
return firstSite.process(*config)
-
}
func (h *HugoSites) assemble(bcfg *BuildCfg) error {
-
if len(h.Sites) > 1 {
// The first is initialized during process; initialize the rest
for _, site := range h.Sites[1:] {
}
return nil
-
}
func (h *HugoSites) render(config *BuildCfg) error {
}
}
-
}
if !config.SkipRender {
b, err := json.MarshalIndent(jsConfig, "", " ")
if err != nil {
h.Log.Warnf("Failed to create jsconfig.json: %s", err)
-
} else {
filename := filepath.Join(assetsDir, "jsconfig.json")
if h.running {
g, _ := workers.Start(context.Background())
handleFile := func(filename string) error {
-
content, err := afero.ReadFile(h.BaseFs.PublishFs, filename)
if err != nil {
return err
}
return nil
-
}
_ = afero.Walk(h.BaseFs.PublishFs, "", func(path string, info os.FileInfo, err error) error {
}
return g.Wait()
-
}
type publishStats struct {
}
return nil
-
}
// The error message will contain filenames with OS slashes. Normalize before compare.
e1, e2 = filepath.ToSlash(e1), filepath.ToSlash(e2)
t.c.Assert(e2, qt.Contains, e1)
-
}
func TestSiteBuildErrors(t *testing.T) {
-
const (
yamlcontent = "yamlcontent"
tomlcontent = "tomlcontent"
a.c.Assert(fe.Position().ColumnNumber, qt.Equals, 1)
a.c.Assert(fe.ChromaLexer, qt.Equals, "go-html-template")
a.assertErrorMessage("\"layouts/foo/single.html:5:1\": parse failed: template: foo/single.html:5: unexpected \"}\" in operand", fe.Error())
-
},
},
{
a.c.Assert(fe.Position().ColumnNumber, qt.Equals, 14)
a.c.Assert(fe.ChromaLexer, qt.Equals, "go-html-template")
a.assertErrorMessage("\"layouts/_default/single.html:5:14\": execute of template failed", fe.Error())
-
},
},
{
a.c.Assert(fe.Position().ColumnNumber, qt.Equals, 14)
a.c.Assert(fe.ChromaLexer, qt.Equals, "go-html-template")
a.assertErrorMessage("\"layouts/_default/single.html:5:14\": execute of template failed", fe.Error())
-
},
},
{
fe := a.getFileError(err)
a.c.Assert(fe.Position().LineNumber, qt.Equals, 6)
a.c.Assert(fe.ErrorContext.ChromaLexer, qt.Equals, "toml")
-
},
},
{
a.c.Assert(fe.Position().LineNumber, qt.Equals, 3)
a.c.Assert(fe.ErrorContext.ChromaLexer, qt.Equals, "json")
-
},
},
{
return content
}
return test.fileFixer(content)
-
}
b.WithTemplatesAdded("layouts/shortcodes/sc.html", f(shortcode, `SHORTCODE L1
---
{{< c >}}`)
-
}
b.CreateSites().BuildFail(BuildCfg{})
-
}
import (
"fmt"
+ "path/filepath"
"strings"
"testing"
-
- "path/filepath"
"time"
qt "github.com/frankban/quicktest"
}
func TestMultiSitesBuild(t *testing.T) {
-
for _, config := range []struct {
content string
suffix string
{multiSiteYAMLConfigTemplate, "yml"},
{multiSiteJSONConfigTemplate, "json"},
} {
-
t.Run(config.suffix, func(t *testing.T) {
t.Parallel()
doTestMultiSitesBuild(t, config.content, config.suffix)
c.Assert(enSite.language.Lang, qt.Equals, "en")
- //dumpPages(enSite.RegularPages()...)
+ // dumpPages(enSite.RegularPages()...)
c.Assert(len(enSite.RegularPages()), qt.Equals, 5)
c.Assert(len(enSite.AllPages()), qt.Equals, 32)
c.Assert(logoEn, qt.Not(qt.IsNil))
b.AssertFileContent("public/en/bundles/b1/index.html", "Resources: image/png: /blog/en/bundles/b1/logo.png")
b.AssertFileContent("public/en/bundles/b1/logo.png", "PNG Data")
-
}
func TestMultiSitesRebuild(t *testing.T) {
[]fsnotify.Event{{Name: filepath.FromSlash("content/sect/doc2.en.md"), Op: fsnotify.Remove}},
func(t *testing.T) {
c.Assert(len(enSite.RegularPages()), qt.Equals, 4, qt.Commentf("1 en removed"))
-
},
},
{
c.Assert(len(enSite.RegularPages()), qt.Equals, 6)
doc1 := readDestination(t, fs, "public/en/sect/doc1-slug/index.html")
c.Assert(strings.Contains(doc1, "CHANGED"), qt.Equals, true)
-
},
},
// Rename a file
c.Assert(enSite.RegularPages()[1].Title(), qt.Equals, "new_en_1")
rendered := readDestination(t, fs, "public/en/new1renamed/index.html")
c.Assert(rendered, qt.Contains, "new_en_1")
- }},
+ },
+ },
{
// Change a template
func(t *testing.T) {
c.Assert(homeEn, qt.Not(qt.IsNil))
c.Assert(len(homeEn.Translations()), qt.Equals, 3)
c.Assert(homeEn.Translations()[0].Language().Lang, qt.Equals, "fr")
-
},
},
// Change a shortcode
}
err := b.H.Build(BuildCfg{}, this.events...)
-
if err != nil {
t.Fatalf("[%d] Failed to rebuild sites: %s", i, err)
}
this.assertFunc(t)
}
-
}
// https://github.com/gohugoio/hugo/issues/4706
`)
for _, lang := range []string{"en", "nn"} {
-
b.WithContent(lang+"/mysection/page.md", `
---
Title: My Page
---
`)
-
}
b.Build(BuildCfg{})
"/categories",
"/categories/mycat",
} {
-
t.Run(path, func(t *testing.T) {
c := qt.New(t)
c.Assert(len(m1), qt.Equals, 1)
c.Assert(len(m2), qt.Equals, 1)
})
-
}
}
c := qt.New(t)
- var configTemplate = `
+ configTemplate := `
paginate = 1
disablePathToLower = true
defaultContentLanguage = "fr"
c.Assert(len(bundleFr.Resources()), qt.Equals, 1)
b.AssertFileContent("public/fr/bundles/b1/logo.png", "PNG Data")
b.AssertFileContent("public/fr/bundles/b1/index.html", " image/png: /bundles/b1/logo.png")
-
}
)
func TestSitesRebuild(t *testing.T) {
-
configFile := `
baseURL = "https://example.com"
title = "Rebuild this"
b.AssertFileContent("public/index.html", `
Data: Rules!
Data Inline: Rules!`)
-
})
// https://github.com/gohugoio/hugo/issues/6968
b.Build(BuildCfg{testCounters: counters})
b.Assert(int(counters.contentRenderCounter), qt.Equals, 0)
-
})
t.Run("Page.Render, edit baseof", func(t *testing.T) {
b.AssertFileContent("public/index.html", `
Render /prender/: Baseof Edited:Single Main: Page 1|Mypartial1: Mypartial1:END
`)
-
})
t.Run("Page.Render, edit partial in baseof", func(t *testing.T) {
b.AssertFileContent("public/index.html", `
Render /prender/: Baseof:Single Main: Page 1|Mypartial1: Mypartial1|Mypartial3: Mypartial3 Edited:END
`)
-
})
t.Run("Edit RSS shortcode", func(t *testing.T) {
b.AssertFileContent("public/amp/output/index.html", `
Output Shortcode AMP Edited
`)
-
})
-
}
// Issues #7623 #7625
P5 changed content
P6 changed content
`)
-
}
`
- var pageContentAutoSummary = strings.Replace(pageContentAndSummaryDivider, "<!--more-->", "", 1)
+ pageContentAutoSummary := strings.Replace(pageContentAndSummaryDivider, "<!--more-->", "", 1)
b := newTestSitesBuilder(t).WithConfigFile("toml", configFile)
b.WithTemplatesAdded("shortcodes/markdown-shortcode.html", `
// Markdown vs shortcodes
// Check that all footnotes are grouped (even those from inside the shortcode)
b.AssertFileContentRe("public/blog/markyshort/index.html", `Footnotes:.*<ol>.*Fn 1.*Fn 2.*Fn 3.*</ol>`)
-
}
// https://github.com/golang/go/issues/30286
func TestDataRace(t *testing.T) {
-
const page = `
---
title: "The Page"
defer clean()
newBuilder := func(timeout interface{}) *sitesBuilder {
-
v := viper.New()
v.Set("workingDir", workDir)
v.Set("baseURL", "https://example.org")
b.Build(BuildCfg{})
assertImages()
-
}
func TestImageResizeMultilingual(t *testing.T) {
-
b := newTestSitesBuilder(t).WithConfigFile("toml", `
baseURL="https://example.org"
defaultContentLanguage = "en"
// TODO(bep) add this as a default assertion after Build()?
b.AssertNoDuplicateWrites()
-
}
var React = __toModule(require("react"));
function greeter(person) {
`)
-
}
func TestJSBuild(t *testing.T) {
Hello from lib in the main project
Hello5 from mod2.
var myparam = "Hugo Rocks!";`)
-
}
var contentFiles []string
section := "sect"
- var contentRoot = func(lang string) string {
+ contentRoot := func(lang string) string {
switch lang {
case "nn":
return "content/norsk"
default:
return "content/main"
}
-
}
- var contentSectionRoot = func(lang string) string {
+ contentSectionRoot := func(lang string) string {
return contentRoot(lang) + "/" + section
}
err := b.BuildE(BuildCfg{})
- //dumpPages(b.H.Sites[1].RegularPages()...)
+ // dumpPages(b.H.Sites[1].RegularPages()...)
c.Assert(err, qt.IsNil)
b.AssertFileContent("/my/project/public/en/mystatic/file1.yaml", "en")
b.AssertFileContent("/my/project/public/nn/mystatic/file1.yaml", "nn")
- //dumpPages(nnSite.RegularPages()...)
+ // dumpPages(nnSite.RegularPages()...)
c.Assert(len(nnSite.RegularPages()), qt.Equals, 12)
c.Assert(len(enSite.RegularPages()), qt.Equals, 13)
c.Assert(len(nnSect.Pages()), qt.Equals, 12)
nnHome, _ := nnSite.Info.Home()
c.Assert(nnHome.RelPermalink(), qt.Equals, "/nn/")
-
}
// https://github.com/gohugoio/hugo/issues/6463
Page: /fr/event/page2/|ev-fr2
Page: /fr/other/page1/|other-fr1
Page: /fr/other/page2/|other-fr2`)
-
}
)
func TestI18n(t *testing.T) {
-
c := qt.New(t)
//https://github.com/gohugoio/hugo/issues/7804
package hugolib
import (
- "testing"
-
"fmt"
+ "testing"
qt "github.com/frankban/quicktest"
)
"/sect1/|Section One|Section One|100|-|-|"+
"/sect2/|Sect2s|Sect2s|0|-|HasMenuCurrent|"+
"/sect3/|Sect3s|Sect3s|0|-|-|")
-
}
func TestMenuFrontMatter(t *testing.T) {
-
b := newTestSitesBuilder(t).WithSimpleConfigFile()
b.WithTemplatesAdded("index.html", `
"Main|P1: /blog/page1/",
"Other|P2: /blog/page2/",
)
-
}
// https://github.com/gohugoio/hugo/issues/5849
func TestMenuPageMultipleOutputFormats(t *testing.T) {
-
config := `
baseURL = "https://example.com"
// https://github.com/gohugoio/hugo/issues/5989
func TestMenuPageSortByDate(t *testing.T) {
-
b := newTestSitesBuilder(t).WithSimpleConfigFile()
b.WithContent("blog/a.md", `
}
func TestMenuParams(t *testing.T) {
-
b := newTestSitesBuilder(t).WithSimpleConfigFile()
b.WithTemplatesAdded("index.html", `
"Main|P1: /blog/page1/|map[]",
"Main|P2: /blog/page2/|map[]",
)
-
}
package hugolib
import (
- "sync"
-
"errors"
+ "sync"
"github.com/gohugoio/hugo/langs"
}
return &Multilingual{Languages: languages, DefaultLang: langs.NewLanguage(defaultLang, cfg)}, nil
-
}
func (ml *Multilingual) enabled() bool {
b.Build(BuildCfg{})
b.AssertFileContent("public/index.html", `API: Hugo API`)
-
}
}
p.regularPages = pages
-
})
return p.regularPages
} else if p.IsNode() {
p.translationKey = path.Join(p.Kind(), p.SectionsPath())
}
-
})
return p.translationKey
-
}
// AllTranslations returns all translations, including the current Page.
})
return p.layoutDescriptor
-
}
func (p *pageState) resolveTemplate(layouts ...string) (tpl.Template, bool, error) {
}
return nil
-
}
// Must be run after the site section tree etc. is built and ready.
for _, i := range toBeDeleted {
p.deleteResource(i)
}
-
})
return
return "", p.wrapError(errors.Wrapf(err, "failed to execute template %q v", layout))
}
return template.HTML(res), nil
-
}
// wrapError adds some more context to the given error if possible/needed
markup = "markdown"
}
p.m.contentConverter, err = p.m.newContentConverter(p, markup, p.m.renderingConfigOverrides)
-
})
if err != nil {
}
func (p *pageState) mapContent(bucket *pagesMapBucket, meta *pageMeta) error {
-
s := p.shortcodeState
rn := &pageContentMap{
}
pos := p.posFromInput(input, offset)
return herrors.NewFileError("md", -1, pos.LineNumber, pos.ColumnNumber, err)
-
}
func (p *pageState) pathOrTitle() string {
if isRenderingSite {
cp := p.pageOutput.cp
if cp == nil {
-
// Look for content to reuse.
for i := 0; i < len(p.pageOutputs); i++ {
if i == idx {
// Insert the placeholder so we can insert the content after
// markdown processing.
c = append(c, []byte(v.placeholder)...)
-
}
default:
panic(fmt.Sprintf("unknown item type %T", it))
// Assign the function to the map to make sure it is lazily initialized
p.data["pages"] = p.Pages
-
})
return p.data
func (p *pageMenus) menus() navigation.PageMenus {
p.init()
return p.pm
-
}
func (p *pageMenus) init() {
if err != nil {
p.p.s.Log.Errorln(p.p.wrapError(err))
}
-
})
-
}
// RelatedKeywords implements the related.Document interface needed for fast page searches.
func (p *pageMeta) RelatedKeywords(cfg related.IndexConfig) ([]related.Keyword, error) {
-
v, err := p.Param(cfg.Name)
if err != nil {
return nil, err
}
panic("invalid page state")
-
}
func (p *pageMeta) SectionsEntries() []string {
}
} else {
p.bucket.cascade = map[page.PageMatcher]maps.Params{
- page.PageMatcher{}: maps.ToStringMap(cv),
+ {}: maps.ToStringMap(cv),
}
-
}
}
}
// this may get its language path added twice.
// TODO(bep) eventually remove this.
p.s.Log.Warnf(`Front matter in %q with the url %q with no leading / has what looks like the language prefix added. In Hugo 0.55 we added support for page relative URLs in front matter, no language prefix needed. Check the URL and consider to either add a leading / or remove the language prefix.`, p.pathOrTitle(), url)
-
}
}
pm.urlPaths.URL = url
}
func (p *pageMeta) getListFilter(local bool) contentTreeNodeCallback {
-
return newContentTreeFilter(func(n *contentNode) bool {
if n == nil {
return true
}
return nil
-
}
func (p *pageMeta) newContentConverter(ps *pageState, markup string, renderingConfigOverrides map[string]interface{}) (converter.Converter, error) {
ConfigOverrides: renderingConfigOverrides,
},
)
-
if err != nil {
return converter.NopConverter, err
}
ps.AlternativeOutputFormatsProvider = ps
return ps, nil
-
}
func newPageBucket(p *pageState) *pagesMapBucket {
parentBucket *pagesMapBucket,
meta map[string]interface{},
metaProvider *pageMeta) (*pageState, error) {
-
if metaProvider.f == nil {
metaProvider.f = page.NewZeroFile(metaProvider.s.DistinctWarningLog)
}
}
return nil, nil
-
})
return ps, err
-
}
// Used by the legacy 404, sitemap and robots.txt rendering
m.configuredOutputFormats = output.Formats{f}
m.standalone = true
p, err := newPageFromMeta(nil, nil, nil, m)
-
if err != nil {
return nil, err
}
}
return p, nil
-
}
type pageDeprecatedWarning struct {
func (p *pageDeprecatedWarning) GetParam(key string) interface{} {
return p.p.m.params[strings.ToLower(key)]
}
+
func (p *pageDeprecatedWarning) RSSLink() template.URL {
f := p.p.OutputFormats().Get("RSS")
if f == nil {
}
return template.URL(f.Permalink())
}
+
func (p *pageDeprecatedWarning) URL() string {
if p.p.IsPage() && p.p.m.urlPaths.URL != "" {
// This is the url set in front matter
}
// Fall back to the relative permalink.
return p.p.RelPermalink()
-
}
pp pagePaths,
f output.Format,
render bool) *pageOutput {
-
var targetPathsProvider targetPathsHolder
var linksProvider resource.ResourceLinksProvider
}
return po
-
}
// We create a pageOutput for every output format combination, even if this
})
return initErr
-
}
func (p *pageOutput) initContentProvider(cp *pageContentOutput) {
if p.cp != nil {
p.cp.enablePlaceholders()
}
-
}
}
p.current = paginator.Pagers()[0]
-
})
if initErr != nil {
}
p.current = paginator.Pagers()[0]
-
})
if initErr != nil {
s *Site,
p page.Page,
pm *pageMeta) (pagePaths, error) {
-
targetPathDescriptor, err := createTargetPathDescriptor(s, p, pm)
if err != nil {
return pagePaths{}, err
targets[f.Name] = targetPathsHolder{
paths: paths,
- OutputFormat: pageOutputFormats[permalinksIndex]}
+ OutputFormat: pageOutputFormats[permalinksIndex],
+ }
}
targetPaths: targets,
targetPathDescriptor: targetPathDescriptor,
}, nil
-
}
type pagePaths struct {
}
return desc, nil
-
}
var pageContentOutputDependenciesID = identity.KeyValueIdentity{Key: "pageOutput", Value: "dependencies"}
func newPageContentOutput(p *pageState, po *pageOutput) (*pageContentOutput, error) {
-
parent := p.init
var dependencyTracker identity.Manager
cp.content = helpers.BytesToHTML(cp.workContent)
return nil
-
}
// Recursive loops can only happen in content files with template code (shortcodes etc.)
})
return cp, nil
-
}
type renderHooks struct {
p.truncated = truncated
return nil
-
}
func (cp *pageContentOutput) renderContent(content []byte, renderTOC bool) (converter.Result, error) {
}
func (cp *pageContentOutput) renderContentWithConverter(c converter.Converter, content []byte, renderTOC bool) (converter.Result, error) {
-
r, err := c.Convert(
converter.RenderContext{
Src: content,
}
return r, err
-
}
func (p *pageContentOutput) setWordCounts(isCJKLanguage bool) {
return "", err
}
return b.String(), nil
-
}
func splitUserDefinedSummaryAndContent(markup string, c []byte) (summary []byte, content []byte, err error) {
switch markup {
case "asciidocext":
startTag = "div"
-
}
// Walk back and forward to the surrounding tags.
func newPagePositionInSection(n *nextPrev) pagePositionInSection {
return pagePositionInSection{nextPrev: n}
-
}
type nextPrev struct {
}
return s.refLink(args.Path, source, false, args.OutputFormat)
-
}
func (p pageRef) relRef(argsm map[string]interface{}, source interface{}) (string, error) {
}
return s.refLink(args.Path, source, true, args.OutputFormat)
-
}
type refArgs struct {
}
return strings.HasPrefix(ref2.key, ref1.key+cmBranchSeparator), nil
-
}
func (pt pageTree) CurrentSection() page.Page {
}
return strings.HasPrefix(ref1.key, ref2.key+cmBranchSeparator), nil
-
}
func (pt pageTree) FirstSection() page.Page {
s2, _ := ref2.getCurrentSection()
return s1 == s2, nil
-
}
func (pt pageTree) Page() page.Page {
"github.com/gohugoio/hugo/resources/page"
)
-var (
-
- // This is all the kinds we can expect to find in .Site.Pages.
- allKindsInPages = []string{page.KindPage, page.KindHome, page.KindSection, page.KindTerm, page.KindTaxonomy}
-)
+// This is all the kinds we can expect to find in .Site.Pages.
+var allKindsInPages = []string{page.KindPage, page.KindHome, page.KindSection, page.KindTerm, page.KindTaxonomy}
const (
}
})
}
-
}
func TestRelativeURLInFrontMatter(t *testing.T) {
-
config := `
baseURL = "https://example.com"
defaultContentLanguage = "en"
b.AssertFileContent("public/myblog/p1/index.html", "Single: A page|Hello|en|RelPermalink: /myblog/p1/|Permalink: https://example.com/myblog/p1/|")
b.AssertFileContent("public/myblog/p2/index.html", "Single: A page|Hello|en|RelPermalink: /myblog/p2/|Permalink: https://example.com/myblog/p2/|")
b.AssertFileContent("public/myblog/p3/index.html", "Single: A page|Hello|en|RelPermalink: /myblog/p3/|Permalink: https://example.com/myblog/p3/|")
-
}
"fmt"
"html/template"
"os"
+ "path/filepath"
+ "strings"
+ "testing"
+ "time"
"github.com/gohugoio/hugo/markup/rst"
"github.com/gohugoio/hugo/common/loggers"
- "path/filepath"
- "strings"
- "testing"
- "time"
-
"github.com/gohugoio/hugo/hugofs"
"github.com/gohugoio/hugo/resources/page"
func testAllMarkdownEnginesForPages(t *testing.T,
assertFunc func(t *testing.T, ext string, pages page.Pages), settings map[string]interface{}, pageSources ...string) {
-
engines := []struct {
ext string
shouldExecute func() bool
cfg.Set(k, v)
}
return nil
-
})
contentDir := "content"
b.Assert(content(home), qt.Contains, "Home Page Content")
}
-
}
// Issue #1076
checkDated(p, p.Kind())
}
checkDate(s.Info.LastChange(), "site")
-
}
func TestPageDatesSections(t *testing.T) {
for _, p := range pages {
c.Assert(hasDate(p), qt.Equals, true)
}
-
}
fields := []string{"date", "publishdate", "pubdate", "published"}
p := s.RegularPages()[0]
c.Assert("**Raw**", qt.Equals, p.RawContent())
-
}
func TestPageWithShortCodeInSummary(t *testing.T) {
}
func TestTableOfContents(t *testing.T) {
-
cfg, fs := newTestCfg()
c := qt.New(t)
checkPageContent(t, p, normalizeExpected(ext, "<p>Summary Same Line</p>\n\n<p>Some more text</p>\n"))
checkPageSummary(t, p, normalizeExpected(ext, "<p>Summary Same Line</p>"))
checkPageType(t, p, "page")
-
}
testAllMarkdownEnginesForPages(t, assertFunc, nil, simplePageWithSummaryDelimiterSameLine)
// #2973
func TestSummaryWithHTMLTagsOnNextLine(t *testing.T) {
-
assertFunc := func(t *testing.T, ext string, pages page.Pages) {
c := qt.New(t)
p := pages[0]
// 2018-08-11 is the Git author date for testsite/content_nn/first-post.md
c.Assert(nnSite.RegularPages()[0].Lastmod().Format("2006-01-02"), qt.Equals, "2018-08-11")
-
}
func TestPageWithFrontMatterConfig(t *testing.T) {
}
})
}
-
}
func TestWordCountWithAllCJKRunesWithoutHasCJKLanguage(t *testing.T) {
}
testAllMarkdownEnginesForPages(t, assertFunc, settings, simplePageWithIsCJKLanguageFalse)
-
}
func TestWordCount(t *testing.T) {
if p.ReadingTime() != 3 {
t.Fatalf("[%s] incorrect min read. expected %v, got %v", ext, 3, p.ReadingTime())
}
-
}
testAllMarkdownEnginesForPages(t, assertFunc, nil, simplePageWithLongContent)
p2 := s.RegularPages()[1]
c.Assert(p2.TranslationKey(), qt.Equals, "page/sect/simple")
-
}
func TestChompBOM(t *testing.T) {
}
}
-
}
func TestPageHTMLContent(t *testing.T) {
"Summary: \n<p>This is summary</p>\n|Truncated: true",
"|<p>This is the main content.</p>|",
)
-
}
// https://github.com/gohugoio/hugo/issues/5381
"Title: hello",
"Content:<p>This is the content.</p>",
)
-
}
// https://github.com/gohugoio/hugo/issues/5781
func TestShouldBuild(t *testing.T) {
t.Parallel()
- var past = time.Date(2009, 11, 17, 20, 34, 58, 651387237, time.UTC)
- var future = time.Date(2037, 11, 17, 20, 34, 58, 651387237, time.UTC)
- var zero = time.Time{}
+ past := time.Date(2009, 11, 17, 20, 34, 58, 651387237, time.UTC)
+ future := time.Date(2037, 11, 17, 20, 34, 58, 651387237, time.UTC)
+ zero := time.Time{}
- var publishSettings = []struct {
+ publishSettings := []struct {
buildFuture bool
buildExpired bool
buildDrafts bool
} else {
c.Assert(p.RelPermalink(), qt.Equals, "/post/test0.dot/")
}
-
})
}
}
// https://github.com/gohugoio/hugo/issues/4675
func TestWordCountAndSimilarVsSummary(t *testing.T) {
-
t.Parallel()
c := qt.New(t)
b.AssertFileContent("public/p4/index.html", "WordCount: 7\nFuzzyWordCount: 100\nReadingTime: 1\nLen Plain: 638\nLen PlainWords: 7\nTruncated: true\nLen Summary: 43\nLen Content: 651")
b.AssertFileContent("public/p5/index.html", "WordCount: 206\nFuzzyWordCount: 300\nReadingTime: 1\nLen Plain: 638\nLen PlainWords: 7\nTruncated: true\nLen Summary: 229\nLen Content: 652")
b.AssertFileContent("public/p6/index.html", "WordCount: 7\nFuzzyWordCount: 100\nReadingTime: 1\nLen Plain: 638\nLen PlainWords: 7\nTruncated: false\nLen Summary: 637\nLen Content: 652")
-
}
func TestScratchSite(t *testing.T) {
"Author name page string: Kurt Vonnegut|",
"Author page string: Jo Nesbø|",
"Author site config: Kurt Vonnegut")
-
}
func TestGoldmark(t *testing.T) {
for i, ext := range []string{"md", "html"} {
b.WithContent(fmt.Sprintf("page%d.%s", i+1, ext), content)
-
}
b.Build(BuildCfg{})
package hugolib
import (
+ "fmt"
+ "io"
"os"
"path"
+ "path/filepath"
"regexp"
"strings"
"testing"
"github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/resources/page"
- "io"
-
"github.com/gohugoio/hugo/htesting"
"github.com/gohugoio/hugo/media"
- "path/filepath"
-
- "fmt"
-
"github.com/gohugoio/hugo/deps"
"github.com/spf13/viper"
b.AssertFileContent(filepath.FromSlash("/work/public/root/index.html"), "Single Title")
}
-
})
}
}
}
-
}
func TestPageBundlerSiteMultilingual(t *testing.T) {
c.Assert(len(s.RegularPages()), qt.Equals, 8)
c.Assert(len(s.Pages()), qt.Equals, 16)
- //dumpPages(s.AllPages()...)
+ // dumpPages(s.AllPages()...)
c.Assert(len(s.AllPages()), qt.Equals, 31)
bundleWithSubPath := s.getPage(page.KindPage, "lb/index")
b.AssertFileContent("public/nn/bc/data1.nn.json", "data1.nn")
b.AssertFileContent("public/nn/bc/data2.json", "data2")
b.AssertFileContent("public/nn/bc/logo-bc.png", "logo")
-
})
}
}
c.Assert(p.Language().Lang != "nn", qt.Equals, true)
return false
})
-
}
func TestPageBundlerSiteWitSymbolicLinksInContent(t *testing.T) {
b.AssertFileContent(filepath.FromSlash(workDir+"/public/a/page/index.html"), "TheContent")
b.AssertFileContent(filepath.FromSlash(workDir+"/public/symbolic1/s1/index.html"), "TheContent")
b.AssertFileContent(filepath.FromSlash(workDir+"/public/symbolic2/a1/index.html"), "TheContent")
-
}
func TestPageBundlerHeadless(t *testing.T) {
c.Assert(s.RegularPages(), qt.HasLen, 1)
c.Assert(s.home.RegularPages(), qt.HasLen, 1)
c.Assert(s.home.Pages(), qt.HasLen, 1)
-
}
func TestPageBundlerHeadlessIssue6552(t *testing.T) {
b.AssertFileContent("public/section-not-bundle/index.html", "Section Page", "Content: <p>Section content.</p>")
b.AssertFileContent("public/section-not-bundle/single/index.html", "Section Single", "|<p>Single content.</p>")
-
}
func newTestBundleSources(t testing.TB) (*hugofs.Fs, *viper.Viper) {
c.Assert(err, qt.IsNil)
return fs, cfg
-
}
func newTestBundleSourcesMultilingual(t *testing.T) (*hugofs.Fs, *viper.Viper) {
writeSource(t, fs, filepath.Join(workDir, "base", "lb", "c", "one.png"), "content")
writeSource(t, fs, filepath.Join(workDir, "base", "lb", "c", "d", "deep.png"), "content")
- //Translated bundle in some sensible sub path.
+ // Translated bundle in some sensible sub path.
writeSource(t, fs, filepath.Join(workDir, "base", "bf", "my-bf-bundle", "index.md"), pageContent)
writeSource(t, fs, filepath.Join(workDir, "base", "bf", "my-bf-bundle", "index.nn.md"), pageContent)
writeSource(t, fs, filepath.Join(workDir, "base", "bf", "my-bf-bundle", "page.md"), pageContent)
b.Build(BuildCfg{})
b.AssertFileContent("public/mybundle/data.json", "My changed data")
-
}
// https://github.com/gohugoio/hugo/issues/4870
c.Assert(b.CheckExists("public/about/services1/this-is-the-slug/index.html"), qt.Equals, true)
c.Assert(b.CheckExists("public/about/services2/this-is-another-slug/index.html"), qt.Equals, true)
-
}
func TestBundleMisc(t *testing.T) {
b.AssertFileContentFn("public/en/index.html", func(s string) bool {
// Check ignored files
return !regexp.MustCompile("README|ignore").MatchString(s)
-
})
b.AssertFileContent("public/nn/index.html", filepath.FromSlash("page|sect1/sect2/page.md|CurrentSection: sect1"))
b.AssertFileContentFn("public/nn/index.html", func(s string) bool {
return !strings.Contains(s, "enonly")
-
})
// Check order of inherited data file
b.AssertFileContent("public/en/b2/index.html",
"/en/b2/leaf/",
filepath.FromSlash("section|sect1/sect2/_index.md|CurrentSection: sect1/sect2/_index.md"))
-
}
// Issue 6136
"page|/en/blog/sect2/b1/|Content: s2.b1|Resources: R: data.json|s2.b1.data|",
"page|/en/blog/sect2/b2/|Content: s2.b2|Resources: R: s2.b2.bundlecontent|",
)
-
}
// #6208
page|bundle sub index|
page|bundle sub p2|
`)
-
}
func TestBundleTransformMany(t *testing.T) {
-
b := newTestSitesBuilder(t).WithSimpleConfigFile().Running()
for i := 1; i <= 50; i++ {
}
return m.getPage(s, name), name
-
}
// For Ref/Reflink and .Site.GetPage do simple name lookups for the potentially ambigous myarticle.md and /myarticle.md,
// Ref/relref supports this potentially ambigous lookup.
return getByName(path.Base(name))
-
}
func (*PageCollections) findPagesByKindIn(kind string, inPages page.Pages) page.Pages {
}
func createGetPageRegularBenchmarkSite(t testing.TB) *Site {
-
var (
c = qt.New(t)
cfg, fs = newTestCfg()
}
return buildSingleSite(c, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{SkipRender: true})
-
}
func TestBenchmarkGetPageRegular(t *testing.T) {
c.Assert(page, qt.Not(qt.IsNil))
}
})
-
}
type getPageTest struct {
}
func TestGetPage(t *testing.T) {
-
var (
cfg, fs = newTestCfg()
c = qt.New(t)
{"Absolute, page in subsection", page.KindPage, nil, []string{"/sect3/page1.md", "/Sect3/Page1.md"}, "Title3_1"},
{"Absolute, section, subsection with same name", page.KindSection, nil, []string{"/sect3/sect7"}, "another sect7"},
{"Absolute, page, deep", page.KindPage, nil, []string{"/sect3/subsect/deep.md"}, "deep page"},
- {"Absolute, page, OS slashes", page.KindPage, nil, []string{filepath.FromSlash("/sect5/page3.md")}, "Title5_3"}, //test OS-specific path
+ {"Absolute, page, OS slashes", page.KindPage, nil, []string{filepath.FromSlash("/sect5/page3.md")}, "Title5_3"}, // test OS-specific path
{"Absolute, unique", page.KindPage, nil, []string{"/sect3/unique.md"}, "UniqueBase"},
{"Absolute, unique, case", page.KindPage, nil, []string{"/sect3/Unique2.md", "/sect3/unique2.md", "/sect3/unique2", "/sect3/Unique2"}, "UniqueBase2"},
- //next test depends on this page existing
+ // next test depends on this page existing
// {"NoPage", nil, []string{"/unique.md"}, ""}, // ISSUE #4969: this is resolving to /sect3/unique.md
{"Absolute, missing page", "NoPage", nil, []string{"/missing-page.md"}, ""},
{"Absolute, missing section", "NoPage", nil, []string{"/missing-section"}, ""},
{"Rel sect7 dot", page.KindSection, sec3, []string{"./sect7"}, "another sect7"},
{"Dot deep", page.KindPage, sec3, []string{"./subsect/deep.md"}, "deep page"},
{"Dot dot inner", page.KindPage, sec3, []string{"./subsect/../../sect7/page9.md"}, "Title7_9"},
- {"Dot OS slash", page.KindPage, sec3, []string{filepath.FromSlash("../sect5/page3.md")}, "Title5_3"}, //test OS-specific path
+ {"Dot OS slash", page.KindPage, sec3, []string{filepath.FromSlash("../sect5/page3.md")}, "Title5_3"}, // test OS-specific path
{"Dot unique", page.KindPage, sec3, []string{"./unique.md"}, "UniqueBase"},
{"Dot sect", "NoPage", sec3, []string{"./sect2"}, ""},
//{"NoPage", sec3, []string{"sect2"}, ""}, // ISSUE: /sect3 page relative query is resolving to /sect2
{"Abs, ignore context, home", page.KindHome, sec3, []string{"/"}, "home page"},
{"Abs, ignore context, about", page.KindPage, sec3, []string{"/about.md"}, "about page"},
{"Abs, ignore context, page in section", page.KindPage, sec3, []string{"/sect4/page2.md"}, "Title4_2"},
- {"Abs, ignore context, page subsect deep", page.KindPage, sec3, []string{"/sect3/subsect/deep.md"}, "deep page"}, //next test depends on this page existing
+ {"Abs, ignore context, page subsect deep", page.KindPage, sec3, []string{"/sect3/subsect/deep.md"}, "deep page"}, // next test depends on this page existing
{"Abs, ignore context, page deep", "NoPage", sec3, []string{"/subsect/deep.md"}, ""},
// Taxonomies
page2, err := s.getPageNew(test.context, ref)
test.check(page2, err, errorMsg, c)
}
-
})
}
-
}
// https://github.com/gohugoio/hugo/issues/6034
b.AssertFileContent("public/what/index.html", `Members: members what`)
b.AssertFileContent("public/where/index.html", `Members: members where`)
b.AssertFileContent("public/who/index.html", `NOT FOUND`)
-
}
// https://github.com/gohugoio/hugo/issues/7016
b.AssertFileContent("public/index.html", `Docs p1: p1`)
b.AssertFileContent("public/en/index.html", `NOT FOUND`)
-
}
func TestShouldDoSimpleLookup(t *testing.T) {
c.Assert(shouldDoSimpleLookup("/foo.md"), qt.Equals, true)
c.Assert(shouldDoSimpleLookup("./foo.md"), qt.Equals, false)
c.Assert(shouldDoSimpleLookup("docs/foo.md"), qt.Equals, false)
-
}
func TestRegularPagesRecursive(t *testing.T) {
`)
-
}
logger loggers.Logger,
contentTracker *contentChangeMap,
proc pagesCollectorProcessorProvider, filenames ...string) *pagesCollector {
-
return &pagesCollector{
fs: sp.SourceFs,
contentMap: contentMap,
}
return false
-
}
type pageBundles map[string]*fileinfoBundle
}
return true
-
})
return isCascade, section
}
return
-
}
func (c *pagesCollector) isBundleHeader(fi hugofs.FileMetaInfo) bool {
dir hugofs.FileMetaInfo,
path string,
readdir []hugofs.FileMetaInfo) error {
-
if btype > bundleNot && c.tracker != nil {
c.tracker.add(path, btype)
}
}
return nil
-
}
filter := func(fim hugofs.FileMetaInfo) bool {
// Keep walking.
return readdir, nil
-
}
var postHook hugofs.WalkHook
Info: fim,
HookPre: preHook,
HookPost: postHook,
- WalkFn: wfn})
+ WalkFn: wfn,
+ })
return w.Walk()
-
}
func (c *pagesCollector) handleBundleBranch(readdir []hugofs.FileMetaInfo) error {
-
// Maps bundles to its language.
bundles := pageBundles{}
}
return c.handleFiles(contentFiles...)
-
}
func (c *pagesCollector) handleBundleLeaf(dir hugofs.FileMetaInfo, path string, readdir []hugofs.FileMetaInfo) error {
}
return c.addToBundle(info, bundleLeaf, bundles)
-
}
// Start a new walker from the given path.
Logger: c.logger,
Info: dir,
DirEntries: readdir,
- WalkFn: walk})
+ WalkFn: walk,
+ })
if err := w.Walk(); err != nil {
return err
}
return c.proc.Process(bundles)
-
}
func (c *pagesCollector) handleFiles(fis ...hugofs.FileMetaInfo) error {
)
func TestPagesCapture(t *testing.T) {
-
cfg, hfs := newTestCfg()
fs := hfs.Source
c := qt.New(t)
- var writeFile = func(filename string) {
+ writeFile := func(filename string) {
c.Assert(afero.WriteFile(fs, filepath.FromSlash(filename), []byte(fmt.Sprintf("content-%s", filename)), 0755), qt.IsNil)
}
c.Assert(coll.Collect(), qt.IsNil)
c.Assert(len(proc.items), qt.Equals, 4)
})
-
}
type testPagesCollectorProcessor struct {
proc.items = append(proc.items, item)
return nil
}
+
func (proc *testPagesCollectorProcessor) Start(ctx context.Context) context.Context {
return ctx
}
unchanged, err := nnSite.RegularPages().MergeByLanguageInterface(nil)
c.Assert(err, qt.IsNil)
c.Assert(unchanged, deepEqualsPages, nnSite.RegularPages())
-
}
func TestMergeLanguagesTemplate(t *testing.T) {
defer f.Close()
return s.publish(&s.PathSpec.ProcessingStats.Files, target, f)
-
}
func (p *sitePagesProcessor) doProcess(item interface{}) error {
panic(fmt.Sprintf("unrecognized item type in Process: %T", item))
}
return nil
-
}
func (p *sitePagesProcessor) shouldSkip(fim hugofs.FileMetaInfo) bool {
}
for _, variant := range []Variant{
- Variant{".Next", nil, func(p page.Page, pages page.Pages) { p.Next() }},
- Variant{".Prev", nil, func(p page.Page, pages page.Pages) { p.Prev() }},
- Variant{"Pages.Next", nil, func(p page.Page, pages page.Pages) { pages.Next(p) }},
- Variant{"Pages.Prev", nil, func(p page.Page, pages page.Pages) { pages.Prev(p) }},
- Variant{"Pages.Shuffled.Next", shufflePages, func(p page.Page, pages page.Pages) { pages.Next(p) }},
- Variant{"Pages.Shuffled.Prev", shufflePages, func(p page.Page, pages page.Pages) { pages.Prev(p) }},
- Variant{"Pages.ByTitle.Next", func(pages page.Pages) page.Pages { return pages.ByTitle() }, func(p page.Page, pages page.Pages) { pages.Next(p) }},
+ {".Next", nil, func(p page.Page, pages page.Pages) { p.Next() }},
+ {".Prev", nil, func(p page.Page, pages page.Pages) { p.Prev() }},
+ {"Pages.Next", nil, func(p page.Page, pages page.Pages) { pages.Next(p) }},
+ {"Pages.Prev", nil, func(p page.Page, pages page.Pages) { pages.Prev(p) }},
+ {"Pages.Shuffled.Next", shufflePages, func(p page.Page, pages page.Pages) { pages.Next(p) }},
+ {"Pages.Shuffled.Prev", shufflePages, func(p page.Page, pages page.Pages) { pages.Prev(p) }},
+ {"Pages.ByTitle.Next", func(pages page.Pages) page.Pages { return pages.ByTitle() }, func(p page.Page, pages page.Pages) { pages.Next(p) }},
} {
for _, numPages := range []int{300, 5000} {
b.Run(fmt.Sprintf("%s-pages-%d", variant.name, numPages), func(b *testing.B) {
Content.
`, i))
}
-
}
b.WithContent(content...)
b.AssertFileContent("public/nn/index.xml",
"Page Number: 1",
"0: 1/1 true")
-
}
// Issue 6023
func New(fs *hugofs.Fs, cfg config.Provider) (*Paths, error) {
baseURLstr := cfg.GetString("baseURL")
baseURL, err := newBaseURLFromString(baseURLstr)
-
if err != nil {
return nil, errors.Wrapf(err, "Failed to create baseURL from %q:", baseURLstr)
}
if l, ok := cfg.(*langs.Language); ok {
language = l
-
}
if l, ok := cfg.Get("languagesSorted").(langs.Languages); ok {
}
return strings.TrimPrefix(strings.TrimPrefix(filename, p.WorkingDir), FilePathSeparator)
-
}
// AbsPathify creates an absolute path if given a working dir and arelative path.
package hugolib
-var (
- _ Permalinker = (*pageState)(nil)
-)
+var _ Permalinker = (*pageState)(nil)
// Permalinker provides permalinks of both the relative and absolute kind.
type Permalinker interface {
this.carname = brand;
};
`)
-
}
import (
"bytes"
-
- jww "github.com/spf13/jwalterweatherman"
-
"fmt"
"io"
"math/rand"
"os"
-
"os/exec"
"path/filepath"
"runtime"
"testing"
"time"
+ jww "github.com/spf13/jwalterweatherman"
+
"github.com/gohugoio/hugo/common/herrors"
"github.com/gohugoio/hugo/htesting"
b.Build(BuildCfg{})
b.AssertFileContent(filepath.Join(workDir, "public/index.html"), `T1: moo{color:#fff}`)
-
}
func TestSCSSWithRegularCSSImport(t *testing.T) {
/* foo */
`)
-
}
func TestSCSSWithThemeOverrides(t *testing.T) {
b.Build(BuildCfg{})
b.AssertFileContent(filepath.Join(workDir, "public/index.html"), `T1: moo{color:#ccc}boo{color:green}`)
-
}
// https://github.com/gohugoio/hugo/issues/6274
b.Build(BuildCfg{})
b.AssertFileContent(filepath.Join(workDir, "public/index.html"), `T1: foo{color:#ccc}`)
-
}
func TestResourceChainBasic(t *testing.T) {
b.AssertFileContent("public/page1/index.html", `HELLO: /hello.min.a2d1cb24f24b322a7dad520414c523e9.html`)
b.AssertFileContent("public/page2/index.html", `HELLO: /hello.min.a2d1cb24f24b322a7dad520414c523e9.html`)
-
}
func BenchmarkResourceChainPostProcess(b *testing.B) {
-
for i := 0; i < b.N; i++ {
b.StopTimer()
s := newTestSitesBuilder(b)
s.Build(BuildCfg{})
}
-
}
func TestResourceChains(t *testing.T) {
c.Assert(b.CheckExists("public/styles/templ.min.css"), qt.Equals, false)
b.AssertFileContent("public/styles/bundle1.css", `.home{color:blue}body{color:#333}`)
-
}},
{"minify", func() bool { return true }, func(b *sitesBuilder) {
Fingerprinted: {{ $fingerprinted.RelPermalink }}
`)
}, func(b *sitesBuilder) {
-
b.AssertFileContent("public/index.html", "Fingerprinted: /bundle/concat.b5d4045c3f466fa91fe2cc6abe79232a1a57cdf104f7a26e716e0a1e2789df78.txt")
b.AssertFileContent("public/bundle/concat.b5d4045c3f466fa91fe2cc6abe79232a1a57cdf104f7a26e716e0a1e2789df78.txt", "ABC")
-
}},
{"fromstring", func() bool { return true }, func(b *sitesBuilder) {
{{ $r := "Hugo Rocks!" | resources.FromString "rocks/hugo.txt" }}
{{ $r.Content }}|{{ $r.RelPermalink }}|{{ $r.Permalink }}|{{ $r.MediaType.Type }}
`)
-
}, func(b *sitesBuilder) {
b.AssertFileContent("public/index.html", `Hugo Rocks!|/rocks/hugo.txt|http://example.com/rocks/hugo.txt|text/plain`)
b.AssertFileContent("public/rocks/hugo.txt", "Hugo Rocks!")
-
}},
{"execute-as-template", func() bool {
return true
{{ $result := "{{ .Kind | upper }}" | resources.FromString "mytpl.txt" | resources.ExecuteAsTemplate "result.txt" . }}
T2: {{ $result.Content }}|{{ $result.RelPermalink}}|{{$result.MediaType.Type }}
`)
-
}, func(b *sitesBuilder) {
b.AssertFileContent("public/index.html", `T2: HOME|/result.txt|text/plain`, `T1: Hugo Home`)
-
}},
{"fingerprint", func() bool { return true }, func(b *sitesBuilder) {
b.WithTemplates("home.html", `
b.AssertFileContent("public/index.html", `T2: ab|/rocks/hugo.2d408a0717ec188158278a796c689044361dc6fdde28d6f04973b80896e1823975cdbf12eb63f9e0591328ee235d80e9b5bf1aa6a44f4617ff3caf6400eb172d.txt|text/plain|sha512-LUCKBxfsGIFYJ4p5bGiQRDYdxv3eKNbwSXO4CJbhgjl1zb8S62P54FkTKO4jXYDptb8apqRPRhf/PK9kAOsXLQ==|`)
b.AssertFileContent("public/index.html", `T3: ab|/rocks/hugo.187ef4436122d1cc2f40dc2b92f0eba0.txt|text/plain|md5-GH70Q2Ei0cwvQNwrkvDroA==|`)
b.AssertFileContent("public/index.html", `T4: sha256-Hgu9bGhroFC46wP/7txk/cnYCUf86CGrvl1tyNJSxaw=|`)
-
}},
// https://github.com/gohugoio/hugo/issues/5226
{"baseurl-path", func() bool { return true }, func(b *sitesBuilder) {
`)
}, func(b *sitesBuilder) {
b.AssertFileContent("public/index.html", `T1: https://example.com/hugo/rocks/hugo.txt|/hugo/rocks/hugo.txt`)
-
}},
// https://github.com/gohugoio/hugo/issues/4944
Publish 1: {{ $cssPublish1.Content }} {{ $cssPublish1.RelPermalink }}
Publish 2: {{ $cssPublish2.Permalink }}
`)
-
}, func(b *sitesBuilder) {
b.AssertFileContent("public/index.html",
`Inline: body{color:green}`,
test.prepare(b)
b.Build(BuildCfg{})
test.verify(b)
-
})
}
}
c.Assert(b.CheckExists("public/en/text/pipes.txt"), qt.Equals, false)
b.AssertFileContent("public/en/index.html", "Default Home Page", "String Resource: /blog/text/pipes.txt")
b.AssertFileContent("public/text/pipes.txt", "Hugo Pipes")
-
}
func TestResourcesMatch(t *testing.T) {
Hello1: Bonjour
Hello2: Bonjour
`)
-
}
func TestResourceChainPostCSS(t *testing.T) {
b.Assert(strings.Contains(content, "class-in-a"), qt.Equals, true)
b.Assert(strings.Contains(content, "class-in-b"), qt.Equals, true)
-
}
assertCss(b)
build("always", true)
build("fallback", true)
build("never", true)
-
}
func TestResourceMinifyDisabled(t *testing.T) {
b.Build(BuildCfg{})
b.AssertFileContent("public/robots.txt", "User-agent: Googlebot")
-
}
import (
"bytes"
"fmt"
+ "html/template"
+ "path"
+ "reflect"
+ "regexp"
+ "sort"
"strconv"
+ "strings"
+ "sync"
"github.com/gohugoio/hugo/helpers"
- "html/template"
- "path"
-
"github.com/gohugoio/hugo/common/herrors"
"github.com/pkg/errors"
- "reflect"
-
- "regexp"
- "sort"
-
"github.com/gohugoio/hugo/parser/pageparser"
"github.com/gohugoio/hugo/resources/page"
_errors "github.com/pkg/errors"
- "strings"
- "sync"
-
"github.com/gohugoio/hugo/common/maps"
"github.com/gohugoio/hugo/common/text"
"github.com/gohugoio/hugo/common/urls"
}
return x.Interface()
-
}
func (scp *ShortcodeWithPage) page() page.Page {
keys = append(keys, k)
}
sort.Strings(keys)
- var tmp = make(map[string]interface{})
+ tmp := make(map[string]interface{})
for _, k := range keys {
tmp[k] = v[k]
}
func newShortcodeHandler(p *pageState, s *Site, placeholderFunc func() string) *shortcodeHandler {
-
sh := &shortcodeHandler{
p: p,
s: s,
sc *shortcode,
parent *ShortcodeWithPage,
p *pageState) (string, bool, error) {
-
var tmpl tpl.Template
// Tracks whether this shortcode or any of its children has template variations
if sc.doMarkup && (level > 0 || sc.configVersion() == 1) {
var err error
b, err := p.pageOutput.cp.renderContent([]byte(inner), false)
-
if err != nil {
return "", false, err
}
}
func (s *shortcodeHandler) renderShortcodesForPage(p *pageState, f output.Format) (map[string]string, bool, error) {
-
rendered := make(map[string]string)
tplVariants := tpl.TemplateVariants{
}
sc := &shortcode{ordinal: ordinal}
- var cnt = 0
- var nestedOrdinal = 0
- var nextLevel = level + 1
+ cnt := 0
+ nestedOrdinal := 0
+ nextLevel := level + 1
fail := func(err error, i pageparser.Item) error {
return s.parseError(err, pt.Input(), i.Pos)
} else {
return sc, errShortCodeIllegalState
}
-
}
} else {
// positional params
} else {
return sc, errShortCodeIllegalState
}
-
}
}
case currItem.IsDone():
// Replace prefixed shortcode tokens with the real content.
// Note: This function will rewrite the input slice.
func replaceShortcodeTokens(source []byte, replacements map[string]string) ([]byte, error) {
-
if len(replacements) == 0 {
return source, nil
}
"fmt"
"path/filepath"
"reflect"
+ "strings"
+ "testing"
"github.com/gohugoio/hugo/markup/asciidocext"
"github.com/gohugoio/hugo/markup/rst"
"github.com/gohugoio/hugo/parser/pageparser"
"github.com/gohugoio/hugo/resources/page"
- "strings"
- "testing"
-
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/tpl"
"github.com/spf13/cast"
func TestHyphenatedSC(t *testing.T) {
t.Parallel()
wt := func(tem tpl.TemplateManager) error {
-
tem.AddTemplate("_internal/shortcodes/hyphenated-video.html", `Playing Video {{ .Get 0 }}`)
return nil
}
}
CheckShortCodeMatch(t, `{{< r1 pr1="p1" >}}1: {{< r2 pr2="p2" >}}2: {{< r3 pr3="p3" >}}{{< /r3 >}}{{< /r2 >}}{{< /r1 >}}`,
"1: p1 1: 2: p1p2 2: 3: p1p2p3 ", wt)
-
}
func TestFigureOnlySrc(t *testing.T) {
return func(c *qt.C, shortcode *shortcode, err error) {
c.Assert(err, qt.IsNil)
c.Assert(str(shortcode), qt.Matches, ".*"+re+".*")
-
}
}
{"inner", `{{< inner >}}Inner Content{{< / inner >}}`, regexpCheck("inner;inline:false;closing:true;inner:{Inner Content};")},
// issue #934
{"inner self-closing", `{{< inner />}}`, regexpCheck("inner;.*inner:{}")},
- {"nested inner", `{{< inner >}}Inner Content->{{% inner2 param1 %}}inner2txt{{% /inner2 %}}Inner close->{{< / inner >}}`,
- regexpCheck("inner;.*inner:{Inner Content->.*Inner close->}")},
- {"nested, nested inner", `{{< inner >}}inner2->{{% inner2 param1 %}}inner2txt->inner3{{< inner3>}}inner3txt{{</ inner3 >}}{{% /inner2 %}}final close->{{< / inner >}}`,
- regexpCheck("inner:{inner2-> inner2.*{{inner2txt->inner3.*final close->}")},
+ {
+ "nested inner", `{{< inner >}}Inner Content->{{% inner2 param1 %}}inner2txt{{% /inner2 %}}Inner close->{{< / inner >}}`,
+ regexpCheck("inner;.*inner:{Inner Content->.*Inner close->}"),
+ },
+ {
+ "nested, nested inner", `{{< inner >}}inner2->{{% inner2 param1 %}}inner2txt->inner3{{< inner3>}}inner3txt{{</ inner3 >}}{{% /inner2 %}}final close->{{< / inner >}}`,
+ regexpCheck("inner:{inner2-> inner2.*{{inner2txt->inner3.*final close->}"),
+ },
{"closed without content", `{{< inner param1 >}}{{< / inner >}}`, regexpCheck("inner.*inner:{}")},
{"inline", `{{< my.inline >}}Hi{{< /my.inline >}}`, regexpCheck("my.inline;inline:true;closing:true;inner:{Hi};")},
} {
short, err := handler.extractShortcode(0, 0, iter)
test.check(c, short, err)
-
})
}
-
}
func TestShortcodesInSite(t *testing.T) {
outFile string
expected interface{}
}{
- {"sect/doc1.md", `a{{< b >}}c`,
- filepath.FromSlash("public/sect/doc1/index.html"), "<p>abc</p>\n"},
+ {
+ "sect/doc1.md", `a{{< b >}}c`,
+ filepath.FromSlash("public/sect/doc1/index.html"), "<p>abc</p>\n",
+ },
// Issue #1642: Multiple shortcodes wrapped in P
// Deliberately forced to pass even if they maybe shouldn't.
- {"sect/doc2.md", `a
+ {
+ "sect/doc2.md", `a
{{< b >}}
{{< c >}}
e`,
filepath.FromSlash("public/sect/doc2/index.html"),
- "<p>a</p>\n\n<p>b<br />\nc\nd</p>\n\n<p>e</p>\n"},
- {"sect/doc3.md", `a
+ "<p>a</p>\n\n<p>b<br />\nc\nd</p>\n\n<p>e</p>\n",
+ },
+ {
+ "sect/doc3.md", `a
{{< b >}}
{{< c >}}
e`,
filepath.FromSlash("public/sect/doc3/index.html"),
- "<p>a</p>\n\n<p>b<br />\nc</p>\n\nd\n\n<p>e</p>\n"},
- {"sect/doc4.md", `a
+ "<p>a</p>\n\n<p>b<br />\nc</p>\n\nd\n\n<p>e</p>\n",
+ },
+ {
+ "sect/doc4.md", `a
{{< b >}}
{{< b >}}
{{< b >}}
`,
filepath.FromSlash("public/sect/doc4/index.html"),
- "<p>a\nb\nb\nb\nb\nb</p>\n"},
+ "<p>a\nb\nb\nb\nb\nb</p>\n",
+ },
// #2192 #2209: Shortcodes in markdown headers
- {"sect/doc5.md", `# {{< b >}}
+ {
+ "sect/doc5.md", `# {{< b >}}
## {{% c %}}`,
- filepath.FromSlash("public/sect/doc5/index.html"), `-hbhb">b</h1>`},
+ filepath.FromSlash("public/sect/doc5/index.html"), `-hbhb">b</h1>`,
+ },
// #2223 pygments
- {"sect/doc6.md", "\n```bash\nb = {{< b >}} c = {{% c %}}\n```\n",
+ {
+ "sect/doc6.md", "\n```bash\nb = {{< b >}} c = {{% c %}}\n```\n",
filepath.FromSlash("public/sect/doc6/index.html"),
- `<span class="nv">b</span>`},
+ `<span class="nv">b</span>`,
+ },
// #2249
- {"sect/doc7.ad", `_Shortcodes:_ *b: {{< b >}} c: {{% c %}}*`,
+ {
+ "sect/doc7.ad", `_Shortcodes:_ *b: {{< b >}} c: {{% c %}}*`,
filepath.FromSlash("public/sect/doc7/index.html"),
- "<div class=\"paragraph\">\n<p><em>Shortcodes:</em> <strong>b: b c: c</strong></p>\n</div>\n"},
- {"sect/doc8.rst", `**Shortcodes:** *b: {{< b >}} c: {{% c %}}*`,
+ "<div class=\"paragraph\">\n<p><em>Shortcodes:</em> <strong>b: b c: c</strong></p>\n</div>\n",
+ },
+ {
+ "sect/doc8.rst", `**Shortcodes:** *b: {{< b >}} c: {{% c %}}*`,
filepath.FromSlash("public/sect/doc8/index.html"),
- "<div class=\"document\">\n\n\n<p><strong>Shortcodes:</strong> <em>b: b c: c</em></p>\n</div>"},
- {"sect/doc9.mmark", `
+ "<div class=\"document\">\n\n\n<p><strong>Shortcodes:</strong> <em>b: b c: c</em></p>\n</div>",
+ },
+ {
+ "sect/doc9.mmark", `
---
menu:
main:
---
**Shortcodes:** *b: {{< b >}} c: {{% c %}}*`,
filepath.FromSlash("public/sect/doc9/index.html"),
- "<p><strong>Shortcodes:</strong> <em>b: b c: c</em></p>\n"},
+ "<p><strong>Shortcodes:</strong> <em>b: b c: c</em></p>\n",
+ },
// Issue #1229: Menus not available in shortcode.
- {"sect/doc10.md", `---
+ {
+ "sect/doc10.md", `---
menu:
main:
identifier: 'parent'
---
**Menus:** {{< menu >}}`,
filepath.FromSlash("public/sect/doc10/index.html"),
- "<p><strong>Menus:</strong> 1</p>\n"},
+ "<p><strong>Menus:</strong> 1</p>\n",
+ },
// Issue #2323: Taxonomies not available in shortcode.
- {"sect/doc11.md", `---
+ {
+ "sect/doc11.md", `---
tags:
- Bugs
---
**Tags:** {{< tags >}}`,
filepath.FromSlash("public/sect/doc11/index.html"),
- "<p><strong>Tags:</strong> 2</p>\n"},
- {"sect/doc12.md", `---
+ "<p><strong>Tags:</strong> 2</p>\n",
+ },
+ {
+ "sect/doc12.md", `---
title: "Foo"
---
{{% html-indented-v1 %}}`,
"public/sect/doc12/index.html",
- "<h1>Hugo!</h1>"},
+ "<h1>Hugo!</h1>",
+ },
}
temp := tests[:0]
templ.AddTemplate("_internal/shortcodes/tags.html", `{{ len .Page.Site.Taxonomies.tags }}`)
return nil
-
}
cfg, fs := newTestCfg()
})
}
-
}
func TestShortcodeMultipleOutputFormats(t *testing.T) {
"Single CSV",
"ShortCSV",
)
-
}
func BenchmarkReplaceShortcodeTokens(b *testing.B) {
-
type input struct {
in []byte
replacements map[string]string
{strings.Repeat("A ", 3000) + " HAHAHUGOSHORTCODE-1HBHB." + strings.Repeat("BC ", 1000) + " HAHAHUGOSHORTCODE-1HBHB.", map[string]string{"HAHAHUGOSHORTCODE-1HBHB": "Hello World"}, []byte(strings.Repeat("A ", 3000) + " Hello World." + strings.Repeat("BC ", 1000) + " Hello World.")},
}
- var in = make([]input, b.N*len(data))
- var cnt = 0
+ in := make([]input, b.N*len(data))
+ cnt := 0
for i := 0; i < b.N; i++ {
for _, this := range data {
in[cnt] = input{[]byte(this.input), this.replacements, this.expect}
currIn := in[cnt]
cnt++
results, err := replaceShortcodeTokens(currIn.in, currIn.replacements)
-
if err != nil {
b.Fatalf("[%d] failed: %s", i, err)
continue
}
}
-
}
}
{"Hello <p>HAHAHUGOSHORTCODE-1HBHB. END</p>.", "PREFIX", map[string]string{"HAHAHUGOSHORTCODE-1HBHB": "World"}, "Hello <p>World. END</p>."},
{"<p>Hello HAHAHUGOSHORTCODE-1HBHB</p>. END.", "PREFIX", map[string]string{"HAHAHUGOSHORTCODE-1HBHB": "World"}, "<p>Hello World</p>. END."},
{"Hello <p>HAHAHUGOSHORTCODE-1HBHB12", "PREFIX", map[string]string{"HAHAHUGOSHORTCODE-1HBHB": "World"}, "Hello <p>World12"},
- {"Hello HAHAHUGOSHORTCODE-1HBHB. HAHAHUGOSHORTCODE-1HBHB-HAHAHUGOSHORTCODE-1HBHB HAHAHUGOSHORTCODE-1HBHB HAHAHUGOSHORTCODE-1HBHB HAHAHUGOSHORTCODE-1HBHB END", "P", map[string]string{"HAHAHUGOSHORTCODE-1HBHB": strings.Repeat("BC", 100)},
+ {
+ "Hello HAHAHUGOSHORTCODE-1HBHB. HAHAHUGOSHORTCODE-1HBHB-HAHAHUGOSHORTCODE-1HBHB HAHAHUGOSHORTCODE-1HBHB HAHAHUGOSHORTCODE-1HBHB HAHAHUGOSHORTCODE-1HBHB END", "P",
+ map[string]string{"HAHAHUGOSHORTCODE-1HBHB": strings.Repeat("BC", 100)},
fmt.Sprintf("Hello %s. %s-%s %s %s %s END",
- strings.Repeat("BC", 100), strings.Repeat("BC", 100), strings.Repeat("BC", 100), strings.Repeat("BC", 100), strings.Repeat("BC", 100), strings.Repeat("BC", 100))},
+ strings.Repeat("BC", 100), strings.Repeat("BC", 100), strings.Repeat("BC", 100), strings.Repeat("BC", 100), strings.Repeat("BC", 100), strings.Repeat("BC", 100)),
+ },
} {
results, err := replaceShortcodeTokens([]byte(this.input), this.replacements)
}
}
-
}
func TestShortcodeGetContent(t *testing.T) {
"Single Content: <p>Logo:P1:|P2:logo.png/PNG logo|:P1: P1:|P2:docs1p1/<p>C-s1p1</p>\n|",
"P2:docbp1/<p>C-bp1</p>",
)
-
}
// https://github.com/gohugoio/hugo/issues/5833
b.Build(BuildCfg{})
assert("Edit.")
-
}
func TestShortcodePreserveOrder(t *testing.T) {
ordinal: 0 scratch ordinal: 1 scratch get ordinal: 0
ordinal: 2 scratch ordinal: 3 scratch get ordinal: 2
ordinal: 4 scratch ordinal: 5 scratch get ordinal: 4`)
-
}
func TestShortcodeVariables(t *testing.T) {
filepath.FromSlash("String: \"content/page.md:7:4\""),
"Name: s1",
)
-
}
func TestInlineShortcodes(t *testing.T) {
`,
)
}
-
})
}
-
}
// https://github.com/gohugoio/hugo/issues/6857
err := b.BuildE(BuildCfg{})
b.Assert(err.Error(), qt.Contains, `failed to extract shortcode: shortcode "noinner" has no .Inner, yet a closing tag was provided`)
-
}
})
s.init.prevNextInSection = init.Branch(func() (interface{}, error) {
-
var sections page.Pages
s.home.treeRef.m.collectSectionsRecursiveIncludingSelf(pageMapQuery{Prefix: s.home.treeRef.key}, func(n *contentNode) {
sections = append(sections, n.p)
err := s.pageMap.assembleTaxonomies()
return nil, err
})
-
}
type siteRenderingContext struct {
// reset returns a new Site prepared for rebuild.
func (s *Site) reset() *Site {
- return &Site{Deps: s.Deps,
+ return &Site{
+ Deps: s.Deps,
disabledKinds: s.disabledKinds,
titleFunc: s.titleFunc,
relatedDocsHandler: s.relatedDocsHandler.Clone(),
PageCollections: s.PageCollections,
siteCfg: s.siteCfg,
}
-
}
// newSite creates a new site with the given configuration.
// This is a potentially ambigous situation. It may be correct.
ignorableLogger.Errorsf(constants.ErrIDAmbigousDisableKindTaxonomy, `You have the value 'taxonomy' in the disabledKinds list. In Hugo 0.73.0 we fixed these to be what most people expect (taxonomy and term).
But this also means that your site configuration may not do what you expect. If it is correct, you can suppress this message by following the instructions below.`)
-
}
var (
s.prepareInits()
return s, nil
-
}
// NewSite creates a new site with the given dependency configuration.
cfg := deps.DepsCfg{WithTemplate: withTemplates, Cfg: lang}
return NewSiteForCfg(cfg)
-
}
// NewSiteForCfg creates a new site for the given configuration.
return nil, err
}
return h.Sites[0], nil
-
}
type SiteInfo struct {
func (s *SiteInfo) Pages() page.Pages {
return s.s.Pages()
-
}
func (s *SiteInfo) RegularPages() page.Pages {
return s.s.RegularPages()
-
}
func (s *SiteInfo) AllPages() page.Pages {
// GoogleAnalytics is kept here for historic reasons.
func (s *SiteInfo) GoogleAnalytics() string {
return s.Config().Services.GoogleAnalytics.ID
-
}
// DisqusShortname is kept here for historic reasons.
}
return nil
-
}
func (s *Site) process(config BuildCfg) (err error) {
return
}
return err
-
}
func (s *Site) render(ctx *siteRenderContext) (err error) {
-
if err := page.Clear(); err != nil {
return err
}
return
}
}
-
}
if err = s.renderPages(ctx); err != nil {
languagePrefix = "/" + lang.Lang
}
- var uglyURLs = func(p page.Page) bool {
+ uglyURLs := func(p page.Page) bool {
return false
}
}
func (s *Site) getMenusFromConfig() navigation.Menus {
-
ret := navigation.Menus{}
if menus := s.language.GetStringMap("menus"); menus != nil {
}
func (s *SiteInfo) createNodeMenuEntryURL(in string) string {
-
if !strings.HasPrefix(in, "/") {
return in
}
return false
}
- me := navigation.MenuEntry{Identifier: id,
- Name: p.LinkTitle(),
- Weight: p.Weight(),
- Page: p}
+ me := navigation.MenuEntry{
+ Identifier: id,
+ Name: p.LinkTitle(),
+ Weight: p.Weight(),
+ Page: p,
+ }
flat[twoD{sectionPagesMenu, me.KeyName()}] = &me
return false
})
-
}
// Add menu entries provided by pages
// get any lanaguagecode to prefix the relative permalink with.
func (s *Site) getLanguagePermalinkLang(alwaysInSubDir bool) string {
-
if !s.Info.IsMultiLingual() || s.h.IsMultihost() {
return ""
}
}
return s.kindFromSectionPath(path.Join(sections...))
-
}
func (s *Site) kindFromSectionPath(sectionPath string) string {
parentbBucket *pagesMapBucket,
kind, title string,
sections ...string) *pageState {
-
m := map[string]interface{}{}
if title != "" {
m["title"] = title
kind: kind,
sections: sections,
})
-
if err != nil {
panic(err)
}
b.Build(BuildCfg{})
b.AssertFileContent("public/index.html", `"Date":"2019-02-28T00:00:00Z"`)
-
}
`
func getBenchmarkSiteNewTestCases() []siteBenchmarkTestcase {
-
pageContentWithCategory := func(size int, category string) string {
return getBenchmarkTestDataPageContentForMarkdown(size, category, benchmarkMarkdownSnippets)
}
`
benchmarks := []siteBenchmarkTestcase{
- {"Bundle with image", func(b testing.TB) *sitesBuilder {
- sb := newTestSitesBuilder(b).WithConfigFile("toml", config)
- sb.WithContent("content/blog/mybundle/index.md", pageContent(1))
- sb.WithSunset("content/blog/mybundle/sunset1.jpg")
+ {
+ "Bundle with image", func(b testing.TB) *sitesBuilder {
+ sb := newTestSitesBuilder(b).WithConfigFile("toml", config)
+ sb.WithContent("content/blog/mybundle/index.md", pageContent(1))
+ sb.WithSunset("content/blog/mybundle/sunset1.jpg")
- return sb
- },
+ return sb
+ },
func(s *sitesBuilder) {
s.AssertFileContent("public/blog/mybundle/index.html", "/blog/mybundle/sunset1.jpg")
s.CheckExists("public/blog/mybundle/sunset1.jpg")
-
},
},
- {"Bundle with JSON file", func(b testing.TB) *sitesBuilder {
- sb := newTestSitesBuilder(b).WithConfigFile("toml", config)
- sb.WithContent("content/blog/mybundle/index.md", pageContent(1))
- sb.WithContent("content/blog/mybundle/mydata.json", `{ "hello": "world" }`)
+ {
+ "Bundle with JSON file", func(b testing.TB) *sitesBuilder {
+ sb := newTestSitesBuilder(b).WithConfigFile("toml", config)
+ sb.WithContent("content/blog/mybundle/index.md", pageContent(1))
+ sb.WithContent("content/blog/mybundle/mydata.json", `{ "hello": "world" }`)
- return sb
- },
+ return sb
+ },
func(s *sitesBuilder) {
s.AssertFileContent("public/blog/mybundle/index.html", "Resources: application/json: /blog/mybundle/mydata.json")
s.CheckExists("public/blog/mybundle/mydata.json")
-
},
},
- {"Tags and categories", func(b testing.TB) *sitesBuilder {
- sb := newTestSitesBuilder(b).WithConfigFile("toml", `
+ {
+ "Tags and categories", func(b testing.TB) *sitesBuilder {
+ sb := newTestSitesBuilder(b).WithConfigFile("toml", `
title = "Tags and Cats"
baseURL = "https://example.com"
`)
- const pageTemplate = `
+ const pageTemplate = `
---
title: "Some tags and cats"
categories: ["caGR", "cbGR"]
Some content.
`
- for i := 1; i <= 100; i++ {
- content := strings.Replace(pageTemplate, "GR", strconv.Itoa(i/3), -1)
- sb.WithContent(fmt.Sprintf("content/page%d.md", i), content)
- }
+ for i := 1; i <= 100; i++ {
+ content := strings.Replace(pageTemplate, "GR", strconv.Itoa(i/3), -1)
+ sb.WithContent(fmt.Sprintf("content/page%d.md", i), content)
+ }
- return sb
- },
+ return sb
+ },
func(s *sitesBuilder) {
s.AssertFileContent("public/page3/index.html", "/page3/|Permalink: https://example.com/page3/")
s.AssertFileContent("public/tags/ta3/index.html", "|ta3|")
},
},
- {"Canonify URLs", func(b testing.TB) *sitesBuilder {
- sb := newTestSitesBuilder(b).WithConfigFile("toml", `
+ {
+ "Canonify URLs", func(b testing.TB) *sitesBuilder {
+ sb := newTestSitesBuilder(b).WithConfigFile("toml", `
title = "Canon"
baseURL = "https://example.com"
canonifyURLs = true
`)
- for i := 1; i <= 100; i++ {
- sb.WithContent(fmt.Sprintf("content/page%d.md", i), pageContent(i))
- }
+ for i := 1; i <= 100; i++ {
+ sb.WithContent(fmt.Sprintf("content/page%d.md", i), pageContent(i))
+ }
- return sb
- },
+ return sb
+ },
func(s *sitesBuilder) {
s.AssertFileContent("public/page8/index.html", "https://example.com/about/")
},
},
- {"Deep content tree", func(b testing.TB) *sitesBuilder {
- return getBenchmarkSiteDeepContent(b)
- },
+ {
+ "Deep content tree", func(b testing.TB) *sitesBuilder {
+ return getBenchmarkSiteDeepContent(b)
+ },
func(s *sitesBuilder) {
s.CheckExists("public/blog/mybundle/index.html")
s.Assert(len(s.H.Sites), qt.Equals, 4)
s.Assert(len(s.H.Sites[0].RegularPages()), qt.Equals, len(s.H.Sites[1].RegularPages()))
s.Assert(len(s.H.Sites[0].RegularPages()), qt.Equals, 30)
-
},
},
- {"Many HTML templates", func(b testing.TB) *sitesBuilder {
-
- pageTemplateTemplate := `
+ {
+ "Many HTML templates", func(b testing.TB) *sitesBuilder {
+ pageTemplateTemplate := `
<!DOCTYPE html>
<html>
<head>
</html>
`
- sb := newTestSitesBuilder(b).WithConfigFile("toml", `
+ sb := newTestSitesBuilder(b).WithConfigFile("toml", `
baseURL = "https://example.com"
[languages]
`)
- createContent := func(dir, name string) {
- sb.WithContent(filepath.Join("content", dir, name), pageContent(1))
- }
+ createContent := func(dir, name string) {
+ sb.WithContent(filepath.Join("content", dir, name), pageContent(1))
+ }
- for _, lang := range []string{"en", "fr", "no", "sv"} {
- sb.WithTemplatesAdded(fmt.Sprintf("_default/single.%s.html", lang), pageTemplateTemplate)
- sb.WithTemplatesAdded(fmt.Sprintf("_default/list.%s.html", lang), pageTemplateTemplate)
+ for _, lang := range []string{"en", "fr", "no", "sv"} {
+ sb.WithTemplatesAdded(fmt.Sprintf("_default/single.%s.html", lang), pageTemplateTemplate)
+ sb.WithTemplatesAdded(fmt.Sprintf("_default/list.%s.html", lang), pageTemplateTemplate)
- for level := 1; level <= 5; level++ {
- sectionDir := path.Join(lang, strings.Repeat("section/", level))
- createContent(sectionDir, "_index.md")
- for i := 1; i <= 3; i++ {
- leafBundleDir := path.Join(sectionDir, fmt.Sprintf("bundle%d", i))
- createContent(leafBundleDir, "index.md")
+ for level := 1; level <= 5; level++ {
+ sectionDir := path.Join(lang, strings.Repeat("section/", level))
+ createContent(sectionDir, "_index.md")
+ for i := 1; i <= 3; i++ {
+ leafBundleDir := path.Join(sectionDir, fmt.Sprintf("bundle%d", i))
+ createContent(leafBundleDir, "index.md")
+ }
}
}
- }
- return sb
- },
+ return sb
+ },
func(s *sitesBuilder) {
s.CheckExists("public/blog/mybundle/index.html")
s.Assert(len(s.H.Sites), qt.Equals, 4)
s.Assert(len(s.H.Sites[0].RegularPages()), qt.Equals, len(s.H.Sites[1].RegularPages()))
s.Assert(len(s.H.Sites[0].RegularPages()), qt.Equals, 15)
-
},
},
- {"Page collections", func(b testing.TB) *sitesBuilder {
-
- pageTemplateTemplate := `
+ {
+ "Page collections", func(b testing.TB) *sitesBuilder {
+ pageTemplateTemplate := `
{{ if .IsNode }}
{{ len .Paginator.Pages }}
{{ end }}
{{ with .Prev }}Prev: {{ .RelPermalink }}{{ end }}
`
- sb := newTestSitesBuilder(b).WithConfigFile("toml", `
+ sb := newTestSitesBuilder(b).WithConfigFile("toml", `
baseURL = "https://example.com"
[languages]
`)
- sb.WithTemplates("index.html", pageTemplateTemplate)
- sb.WithTemplates("_default/single.html", pageTemplateTemplate)
- sb.WithTemplates("_default/list.html", pageTemplateTemplate)
+ sb.WithTemplates("index.html", pageTemplateTemplate)
+ sb.WithTemplates("_default/single.html", pageTemplateTemplate)
+ sb.WithTemplates("_default/list.html", pageTemplateTemplate)
- r := rand.New(rand.NewSource(99))
+ r := rand.New(rand.NewSource(99))
- createContent := func(dir, name string) {
- var content string
- if strings.Contains(name, "_index") {
- content = pageContent(1)
+ createContent := func(dir, name string) {
+ var content string
+ if strings.Contains(name, "_index") {
+ content = pageContent(1)
+ } else {
+ content = pageContentWithCategory(1, fmt.Sprintf("category%d", r.Intn(5)+1))
+ }
- } else {
- content = pageContentWithCategory(1, fmt.Sprintf("category%d", r.Intn(5)+1))
+ sb.WithContent(filepath.Join("content", dir, name), content)
}
- sb.WithContent(filepath.Join("content", dir, name), content)
- }
-
- createBundledFiles := func(dir string) {
- sb.WithContent(filepath.Join("content", dir, "data.json"), `{ "hello": "world" }`)
- for i := 1; i <= 3; i++ {
- sb.WithContent(filepath.Join("content", dir, fmt.Sprintf("page%d.md", i)), pageContent(1))
+ createBundledFiles := func(dir string) {
+ sb.WithContent(filepath.Join("content", dir, "data.json"), `{ "hello": "world" }`)
+ for i := 1; i <= 3; i++ {
+ sb.WithContent(filepath.Join("content", dir, fmt.Sprintf("page%d.md", i)), pageContent(1))
+ }
}
- }
- for _, lang := range []string{"en", "fr", "no", "sv"} {
- for level := 1; level <= r.Intn(5)+1; level++ {
- sectionDir := path.Join(lang, strings.Repeat("section/", level))
- createContent(sectionDir, "_index.md")
- createBundledFiles(sectionDir)
- for i := 1; i <= r.Intn(20)+1; i++ {
- leafBundleDir := path.Join(sectionDir, fmt.Sprintf("bundle%d", i))
- createContent(leafBundleDir, "index.md")
- createBundledFiles(path.Join(leafBundleDir, "assets1"))
- createBundledFiles(path.Join(leafBundleDir, "assets1", "assets2"))
+ for _, lang := range []string{"en", "fr", "no", "sv"} {
+ for level := 1; level <= r.Intn(5)+1; level++ {
+ sectionDir := path.Join(lang, strings.Repeat("section/", level))
+ createContent(sectionDir, "_index.md")
+ createBundledFiles(sectionDir)
+ for i := 1; i <= r.Intn(20)+1; i++ {
+ leafBundleDir := path.Join(sectionDir, fmt.Sprintf("bundle%d", i))
+ createContent(leafBundleDir, "index.md")
+ createBundledFiles(path.Join(leafBundleDir, "assets1"))
+ createBundledFiles(path.Join(leafBundleDir, "assets1", "assets2"))
+ }
}
}
- }
- return sb
- },
+ return sb
+ },
func(s *sitesBuilder) {
s.CheckExists("public/blog/mybundle/index.html")
s.Assert(len(s.H.Sites), qt.Equals, 4)
s.Assert(len(s.H.Sites[0].RegularPages()), qt.Equals, 26)
-
},
},
- {"List terms", func(b testing.TB) *sitesBuilder {
-
- pageTemplateTemplate := `
+ {
+ "List terms", func(b testing.TB) *sitesBuilder {
+ pageTemplateTemplate := `
<ul>
{{ range (.GetTerms "categories") }}
<li><a href="{{ .Permalink }}">{{ .LinkTitle }}</a></li>
</ul>
`
- sb := newTestSitesBuilder(b).WithConfigFile("toml", `
+ sb := newTestSitesBuilder(b).WithConfigFile("toml", `
baseURL = "https://example.com"
`)
- sb.WithTemplates("_default/single.html", pageTemplateTemplate)
+ sb.WithTemplates("_default/single.html", pageTemplateTemplate)
- r := rand.New(rand.NewSource(99))
+ r := rand.New(rand.NewSource(99))
- createContent := func(dir, name string) {
- var content string
- if strings.Contains(name, "_index") {
- content = pageContent(1)
- } else {
- content = pageContentWithCategory(1, fmt.Sprintf("category%d", r.Intn(5)+1))
- sb.WithContent(filepath.Join("content", dir, name), content)
+ createContent := func(dir, name string) {
+ var content string
+ if strings.Contains(name, "_index") {
+ content = pageContent(1)
+ } else {
+ content = pageContentWithCategory(1, fmt.Sprintf("category%d", r.Intn(5)+1))
+ sb.WithContent(filepath.Join("content", dir, name), content)
+ }
}
- }
- for level := 1; level <= r.Intn(5)+1; level++ {
- sectionDir := path.Join(strings.Repeat("section/", level))
- createContent(sectionDir, "_index.md")
- for i := 1; i <= r.Intn(33); i++ {
- leafBundleDir := path.Join(sectionDir, fmt.Sprintf("bundle%d", i))
- createContent(leafBundleDir, "index.md")
+ for level := 1; level <= r.Intn(5)+1; level++ {
+ sectionDir := path.Join(strings.Repeat("section/", level))
+ createContent(sectionDir, "_index.md")
+ for i := 1; i <= r.Intn(33); i++ {
+ leafBundleDir := path.Join(sectionDir, fmt.Sprintf("bundle%d", i))
+ createContent(leafBundleDir, "index.md")
+ }
}
- }
- return sb
- },
+ return sb
+ },
func(s *sitesBuilder) {
s.AssertFileContent("public/section/bundle8/index.html", ` <li><a href="https://example.com/categories/category1/">category1</a></li>`)
s.Assert(len(s.H.Sites), qt.Equals, 1)
s.Assert(len(s.H.Sites[0].RegularPages()), qt.Equals, 35)
-
},
},
}
return benchmarks
-
}
// Run the benchmarks below as tests. Mostly useful when adding new benchmark
b.Fatal(err)
}
bm.check(s)
-
})
}
}
// We could probably optimize that case, but it's not trivial.
b.Assert(int(counters.contentRenderCounter), qt.Equals, 4)
b.AssertFileContent("public"+p.RelPermalink()+"index.html", "Edited!!")
-
}
func BenchmarkSiteNew(b *testing.B) {
}
return m
-
}
func createSiteOutputFormats(allFormats output.Formats, outputs map[string]interface{}, rssDisabled bool) (map[string]output.Formats, error) {
// This is legacy behaviour. We used to have both
// a RSS page kind and output format.
continue
-
}
return nil, fmt.Errorf("failed to resolve output format %q from site config", format)
}
}
return outFormats, nil
-
}
package hugolib
import (
+ "fmt"
"strings"
"testing"
"github.com/spf13/afero"
- "fmt"
-
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/output"
"github.com/spf13/viper"
}
func doTestSiteWithPageOutputs(t *testing.T, outputs []string) {
-
outputsStr := strings.Replace(fmt.Sprintf("%q", outputs), " ", ", ", -1)
siteConfig := `
b.Assert(home.HasShortcode("myShort"), qt.Equals, true)
b.Assert(home.HasShortcode("doesNotExist"), qt.Equals, false)
-
}
// Issue #3447
s := h.Sites[0]
- //Issue #3450
+ // Issue #3450
c.Assert(s.Info.RSSLink, qt.Equals, "http://example.com/blog/feed.xml")
-
}
// Issue #3614
c.Assert(outputs.Get("DEF").RelPermalink(), qt.Equals, "/blog/defaultdelimbase.defd")
c.Assert(outputs.Get("NOS").RelPermalink(), qt.Equals, "/blog/nosuffixbase")
c.Assert(outputs.Get("CUS").RelPermalink(), qt.Equals, "/blog/customdelimbase_del")
-
}
func TestCreateSiteOutputFormats(t *testing.T) {
-
t.Run("Basic", func(t *testing.T) {
c := qt.New(t)
c.Assert(outputs[kindSitemap], deepEqualsOutputFormats, output.Formats{output.SitemapFormat})
c.Assert(outputs[kindRobotsTXT], deepEqualsOutputFormats, output.Formats{output.RobotsTxtFormat})
c.Assert(outputs[kind404], deepEqualsOutputFormats, output.Formats{output.HTMLFormat})
-
})
// Issue #4528
outputs, err := createSiteOutputFormats(output.DefaultFormats, cfg.GetStringMap("outputs"), false)
c.Assert(err, qt.IsNil)
c.Assert(outputs[page.KindTaxonomy], deepEqualsOutputFormats, output.Formats{output.JSONFormat})
-
})
-
}
func TestCreateSiteOutputFormatsInvalidConfig(t *testing.T) {
// https://github.com/gohugoio/hugo/issues/5849
func TestOutputFormatPermalinkable(t *testing.T) {
-
config := `
baseURL = "https://example.com"
"This RelPermalink: /blog/html-base-nobase/",
outputFormats,
)
-
}
func TestSiteWithPageNoOutputs(t *testing.T) {
b.AssertFileContent("public/outputs-empty/index.html", "HTML:", "Word1. Word2.")
b.AssertFileContent("public/outputs-string/index.html", "O1:", "Word1. Word2.")
-
}
// 1 for all sites
return s.sitesOutIdx == 0
-
}
// renderPages renders pages each corresponding to a markdown file.
pages <-chan *pageState,
results chan<- error,
wg *sync.WaitGroup) {
-
defer wg.Done()
for p := range pages {
// renderPaginator must be run after the owning Page has been rendered.
func (s *Site) renderPaginator(p *pageState, templ tpl.Template) error {
-
paginatePath := s.Cfg.GetString("paginatePath")
d := p.targetPathDescriptor
},
output.HTMLFormat,
)
-
if err != nil {
return err
}
kind: kindSitemap,
urlPaths: pagemeta.URLPath{
URL: s.siteCfg.sitemap.Filename,
- }},
+ },
+ },
output.HTMLFormat,
)
-
if err != nil {
return err
}
},
},
output.RobotsTxtFormat)
-
if err != nil {
return err
}
templ := s.lookupLayouts("robots.txt", "_default/robots.txt", "_internal/_default/robots.txt")
return s.renderAndWritePage(&s.PathSpec.ProcessingStats.Pages, "Robots Txt", p.targetPaths().TargetFilename, p, templ)
-
}
// renderAliases renders shell pages that simply have a redirect in the header.
// renderMainLanguageRedirect creates a redirect to the main language home,
// depending on if it lives in sub folder (e.g. /en) or not.
func (s *Site) renderMainLanguageRedirect() error {
-
if !s.h.multilingual.enabled() || s.h.IsMultihost() {
// No need for a redirect
return nil
)
func TestNestedSections(t *testing.T) {
-
var (
c = qt.New(t)
cfg, fs = newTestCfg()
// > b,c
c.Assert(getPage(p, "/empty1/b"), qt.IsNil) // No _index.md page.
c.Assert(getPage(p, "/empty1/b/c"), qt.Not(qt.IsNil))
-
}},
{"empty2", func(c *qt.C, p page.Page) {
// > b,c,d where b and d have _index.md files.
c.Assert(cp.Eq(d), qt.Equals, false)
c.Assert(cp.Eq(cp), qt.Equals, true)
c.Assert(cp.Eq("asdf"), qt.Equals, false)
-
}},
{"empty3", func(c *qt.C, p page.Page) {
// b,c,d with regular page in b
e3 := getPage(p, "/empty3/b/empty3")
c.Assert(e3, qt.Not(qt.IsNil))
c.Assert(e3.File().LogicalName(), qt.Equals, "empty3.md")
-
}},
{"empty3", func(c *qt.C, p page.Page) {
xxx := getPage(p, "/empty3/nil")
}
c.Assert(p.Eq(p.CurrentSection()), qt.Equals, true)
-
}},
{"l1,l2_2", func(c *qt.C, p page.Page) {
c.Assert(p.Title(), qt.Equals, "T22_-1")
isAncestor, err = nilp.IsAncestor(l1)
c.Assert(err, qt.IsNil)
c.Assert(isAncestor, qt.Equals, false)
-
}},
{"perm a,link", func(c *qt.C, p page.Page) {
c.Assert(p.Title(), qt.Equals, "T9_-1")
last := p.Pages()[3]
c.Assert(last.RelPermalink(), qt.Equals, "/perm-a/link/t1_5/")
-
}},
}
c.Assert(sectionWithSpace.RelPermalink(), qt.Equals, "/spaces-in-section/")
th.assertFileContent("public/l1/l2/page/2/index.html", "L1/l2-IsActive: true", "PAG|T2_3|true")
-
}
func TestNextInSectionNested(t *testing.T) {
"Prev: /blog/cool/cool2/|", "Next: |")
b.AssertFileContent("public/blog/cool/cool2/index.html",
"Prev: |", "Next: /blog/cool/cool1/|")
-
}
stats := []*helpers.ProcessingStats{
h.Sites[0].PathSpec.ProcessingStats,
- h.Sites[1].PathSpec.ProcessingStats}
+ h.Sites[1].PathSpec.ProcessingStats,
+ }
stats[0].Table(ioutil.Discard)
stats[1].Table(ioutil.Discard)
helpers.ProcessingStatsTable(&buff, stats...)
c.Assert(buff.String(), qt.Contains, "Pages | 19 | 6")
-
}
withTemplate := createWithTemplateFromNameValues("missing", templateMissingFunc)
buildSingleSiteExpected(t, true, false, deps.DepsCfg{Fs: fs, Cfg: cfg, WithTemplate: withTemplate}, BuildCfg{})
-
}
func TestDraftAndFutureRender(t *testing.T) {
for _, src := range sources {
writeSource(t, fs, filepath.Join("content", src[0]), src[1])
-
}
return buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{})
if len(s.RegularPages()) != 4 {
t.Fatal("Drafts or Future posts not included as expected")
}
-
}
func TestFutureExpirationRender(t *testing.T) {
for _, src := range sources {
writeSource(t, fs, filepath.Join("content", src[0]), src[1])
-
}
return buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{})
s := buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{SkipRender: true})
c.Assert(len(s.RegularPages()), qt.Equals, 1)
-
}
// Issue #957
}
func doTestCrossrefs(t *testing.T, relative, uglyURLs bool) {
-
c := qt.New(t)
baseURL := "http://foo/bar"
deps.DepsCfg{
Fs: fs,
Cfg: cfg,
- WithTemplate: createWithTemplateFromNameValues("_default/single.html", "{{.Content}}")},
+ WithTemplate: createWithTemplateFromNameValues("_default/single.html", "{{.Content}}"),
+ },
BuildCfg{})
c.Assert(len(s.RegularPages()), qt.Equals, 4)
for _, test := range tests {
th.assertFileContent(test.doc, test.expected)
-
}
-
}
// Issue #939
}
func doTestShouldAlwaysHaveUglyURLs(t *testing.T, uglyURLs bool) {
-
cfg, fs := newTestCfg()
c := qt.New(t)
cfg.Set("baseURL", "http://auth/bub")
cfg.Set("blackfriday",
map[string]interface{}{
- "plainIDAnchors": true})
+ "plainIDAnchors": true,
+ })
cfg.Set("uglyURLs", uglyURLs)
t.Errorf("%s content expected:\n%q\ngot:\n%q", test.doc, test.expected, content)
}
}
-
}
// Issue #3355
} else {
b.AssertFileContent("public/index.html", "mainSections: [blog]", "Main section page: /blog/page3/")
}
-
})
}
}
th.assertFileContent(filepath.Join("public", test.doc), test.expected)
}
-
}
func TestAbsURLify(t *testing.T) {
for _, src := range sources {
writeSource(t, fs, filepath.Join("content", src[0]), src[1])
-
}
writeSource(t, fs, filepath.Join("layouts", "blue/single.html"), templateWithURLAbs)
for _, src := range weightedSources {
writeSource(t, fs, filepath.Join("content", src[0]), src[1])
-
}
s := buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{SkipRender: true})
map[string]interface{}{})
writeSourcesToSource(t, "content", fs, sources...)
return buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{})
-
}
func TestRefLinking(t *testing.T) {
// try to confuse parsing
{"embedded.dot.md", "", true, "/level2/level3/embedded.dot/"},
- //test empty link, as well as fragment only link
+ // test empty link, as well as fragment only link
{"", "", true, ""},
} {
-
t.Run(fmt.Sprint(i), func(t *testing.T) {
checkLinkCase(site, test.link, currentPage, test.relative, test.outputFormat, test.expected, t, i)
- //make sure fragment links are also handled
+ // make sure fragment links are also handled
checkLinkCase(site, test.link+"#intro", currentPage, test.relative, test.outputFormat, test.expected+"#intro", t, i)
})
}
b.AssertFileContent("public/post/b1/index.html", `Content: <p>Ref: http://example.com/post/b2/</p>`)
b.AssertFileContent("public/post/nested-a/content-a/index.html", `Content: http://example.com/post/nested-b/content-b/`)
-
}
func TestClassCollector(t *testing.T) {
-
for _, minify := range []bool{false, true} {
t.Run(fmt.Sprintf("minify-%t", minify), func(t *testing.T) {
statsFilename := "hugo_stats.json"
}
}
`)
-
})
-
}
}
`)
for _, lang := range []string{"en", "nb", "no", "sv"} {
-
for i := 100; i <= 999; i++ {
b.WithContent(fmt.Sprintf("p%d.%s.md", i, lang), fmt.Sprintf("---\ntitle: p%s%d\n---", lang, i))
}
b.Assert(els.Tags, qt.HasLen, 9)
b.Assert(els.IDs, qt.HasLen, 1)
}
-
}
import (
"fmt"
+ "html/template"
"path/filepath"
"testing"
"github.com/gohugoio/hugo/resources/page"
- "html/template"
-
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/deps"
)
{"http://base.com/", "http://base.com/"},
{"http://base.com/sub/", "http://base.com/sub/"},
{"http://base.com/sub", "http://base.com/sub"},
- {"http://base.com", "http://base.com"}} {
+ {"http://base.com", "http://base.com"},
+ } {
cfg, fs := newTestCfg()
cfg.Set("baseURL", this.in)
c.Assert(sect1.RelPermalink(), qt.Equals, "/ss1/")
th.assertFileContent(filepath.Join("public", "ss1", "index.html"), "P1|URL: /ss1/|Next: /ss1/page/2/")
th.assertFileContent(filepath.Join("public", "ss1", "page", "2", "index.html"), "P2|URL: /ss1/page/2/|Next: /ss1/page/3/")
-
}
package hugolib
import (
- "testing"
-
"reflect"
+ "testing"
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/config"
}
func doTestSitemapOutput(t *testing.T, internal bool) {
-
c := qt.New(t)
cfg, fs := newTestCfg()
cfg.Set("baseURL", "http://auth/bub/")
content := readDestination(th, th.Fs, outputSitemap)
c.Assert(content, qt.Not(qt.Contains), "404")
-
}
func TestParseSitemap(t *testing.T) {
if !reflect.DeepEqual(expected, result) {
t.Errorf("Got \n%v expected \n%v", result, expected)
}
-
}
// https://github.com/gohugoio/hugo/issues/5910
func TestSitemapOutputFormats(t *testing.T) {
-
b := newTestSitesBuilder(t).WithSimpleConfigFile()
b.WithContent("blog/html-amp.md", `
import (
"fmt"
"path/filepath"
-
- "github.com/gohugoio/hugo/resources/page"
-
"reflect"
"strings"
"testing"
+ "github.com/gohugoio/hugo/resources/page"
+
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/deps"
}
func doTestTaxonomiesWithAndWithoutContentFile(t *testing.T, uglyURLs bool) {
-
siteConfig := `
baseURL = "http://example.com/blog"
uglyURLs = %t
// Issue #2977
b.AssertFileContent(pathFunc("public/empties/index.html"), "Taxonomy Term Page", "Empties")
-
}
// https://github.com/gohugoio/hugo/issues/5513
b.AssertFileContent("public/news/categories/index.html", "Taxonomy Term Page 1|News/Categories|Hello|https://example.com/news/categories/|")
b.AssertFileContent("public/t1/t2/t3s/index.html", "Taxonomy Term Page 1|T1/T2/T3s|Hello|https://example.com/t1/t2/t3s/|")
b.AssertFileContent("public/s1/s2/s3s/index.html", "Taxonomy Term Page 1|This is S3s|Hello|https://example.com/s1/s2/s3s/|")
-
}
// https://github.com/gohugoio/hugo/issues/5719
b.AssertFileContent("public/index.html", `<li><a href="http://example.com/tags/hugo-rocks/">Hugo Rocks!</a> 10</li>`)
b.AssertFileContent("public/categories/index.html", `<li><a href="http://example.com/categories/this-is-cool/">This is Cool</a> 10</li>`)
b.AssertFileContent("public/tags/index.html", `<li><a href="http://example.com/tags/rocks-i-say/">Rocks I say!</a> 10</li>`)
-
}
// Issue 6213
dra, _ := s.getPageNew(nil, "categories/draft")
b.Assert(reg, qt.Not(qt.IsNil))
b.Assert(dra, qt.IsNil)
-
}
func TestTaxonomiesIndexDraft(t *testing.T) {
b.AssertFileContentFn("public/index.html", func(s string) bool {
return !strings.Contains(s, "categories")
})
-
}
// https://github.com/gohugoio/hugo/issues/6927
b.Assert(b.CheckExists("public/index.html"), qt.Equals, false)
b.Assert(b.CheckExists("public/categories/index.html"), qt.Equals, false)
b.Assert(b.CheckExists("public/posts/index.html"), qt.Equals, false)
-
}
// https://github.com/gohugoio/hugo/issues/6173
b.AssertFileContent("public/categories/index.html", `Resource: /categories/data.json|application/json`)
b.AssertFileContent("public/categories/funny/index.html", `Resource: /categories/funny/funnydata.json|application/json`)
-
}
func TestTaxonomiesRemoveOne(t *testing.T) {
Cats:|/p2/|
Funny:|/p1/|
Funny:|/p2/|`)
-
}
//https://github.com/gohugoio/hugo/issues/6590
categories.funny:|/|
categories.funny:|/blog/p1/|
`)
-
}
func TestTaxonomiesPageCollections(t *testing.T) {
b.AssertFileContent("public/404.html", "\n404 Terms: :END\n\t")
b.AssertFileContent("public/categories/funny/index.xml", `<link>http://example.com/section/p1/</link>`)
b.AssertFileContent("public/categories/index.xml", `<link>http://example.com/categories/funny/</link>`)
-
}
func TestTaxonomiesDirectoryOverlaps(t *testing.T) {
abc: /abcdefgs/abc/|abc|term|Parent: /abcdefgs/|CurrentSection: /abcdefgs/|FirstSection: /|IsAncestor: false|IsDescendant: true
abcdefgs: /abcdefgs/|Abcdefgs|taxonomy|Parent: /|CurrentSection: /|FirstSection: /|IsAncestor: true|IsDescendant: false
`)
-
}
func(t *testing.T) {
writeSource(t, fs, filepath.Join("layouts", "section", "sect1-baseof.html"), `Base: {{block "main" .}}block{{end}}`)
writeSource(t, fs, filepath.Join("layouts", "section", "sect1.html"), `{{define "main"}}sect{{ end }}`)
-
},
func(t *testing.T) {
th.assertFileContent(filepath.Join("public", "sect1", "index.html"), "Base: sect")
func(t *testing.T) {
writeSource(t, fs, filepath.Join("layouts", "baseof.html"), `Base: {{block "main" .}}block{{end}}`)
writeSource(t, fs, filepath.Join("layouts", "index.html"), `{{define "main"}}index{{ end }}`)
-
},
func(t *testing.T) {
th.assertFileContent(filepath.Join("public", "index.html"), "Base: index")
func(t *testing.T) {
writeSource(t, fs, filepath.Join("layouts", "_default", "list-baseof.html"), `Base: {{block "main" .}}block{{end}}`)
writeSource(t, fs, filepath.Join("layouts", "_default", "list.html"), `{{define "main"}}list{{ end }}`)
-
},
func(t *testing.T) {
th.assertFileContent(filepath.Join("public", "sect1", "index.html"), "Base: list")
func(t *testing.T) {
writeSource(t, fs, filepath.Join("layouts", "_default", "baseof.html"), `Base: {{block "main" .}}block{{end}}`)
writeSource(t, fs, filepath.Join("layouts", "_default", "list.html"), `{{define "main"}}list{{ end }}`)
-
},
func(t *testing.T) {
th.assertFileContent(filepath.Join("public", "sect1", "index.html"), "Base: list")
writeSource(t, fs, filepath.Join("layouts", "section", "sect1-baseof.html"), `Base: {{block "main" .}}block{{end}}`)
writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "section", "sect-baseof.html"), `Base Theme: {{block "main" .}}block{{end}}`)
writeSource(t, fs, filepath.Join("layouts", "section", "sect1.html"), `{{define "main"}}sect{{ end }}`)
-
},
func(t *testing.T) {
th.assertFileContent(filepath.Join("public", "sect1", "index.html"), "Base: sect")
cfg.Set("theme", "mytheme")
writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "section", "sect1-baseof.html"), `Base Theme: {{block "main" .}}block{{end}}`)
writeSource(t, fs, filepath.Join("layouts", "section", "sect1.html"), `{{define "main"}}sect{{ end }}`)
-
},
func(t *testing.T) {
th.assertFileContent(filepath.Join("public", "sect1", "index.html"), "Base Theme: sect")
writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "_default", "baseof.html"), `Base Theme: {{block "main" .}}block{{end}}`)
writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "_default", "list.html"), `{{define "main"}}list{{ end }}`)
writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "index.html"), `{{define "main"}}index{{ end }}`)
-
},
func(t *testing.T) {
th.assertFileContent(filepath.Join("public", "sect1", "index.html"), "Base: list")
cfg.Set("theme", "mytheme")
writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "_default", "baseof.html"), `Base Theme: {{block "main" .}}block{{end}}`)
writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "_default", "list.html"), `{{define "main"}}list{{ end }}`)
-
},
func(t *testing.T) {
th.assertFileContent(filepath.Join("public", "sect1", "index.html"), "Base Theme: list")
// sect2 with list template in /section
writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "section", "sect2.html"), `sect2 list`)
-
},
func(t *testing.T) {
th.assertFileContent(filepath.Join("public", "sect1", "index.html"), "sect list")
// Issue #2995
"Test section list and single template selection with base template",
func(t *testing.T) {
-
writeSource(t, fs, filepath.Join("layouts", "_default", "baseof.html"), `Base Default: {{block "main" .}}block{{end}}`)
writeSource(t, fs, filepath.Join("layouts", "sect1", "baseof.html"), `Base Sect1: {{block "main" .}}block{{end}}`)
writeSource(t, fs, filepath.Join("layouts", "section", "sect2-baseof.html"), `Base Sect2: {{block "main" .}}block{{end}}`)
// sect2 with list template in /section
writeSource(t, fs, filepath.Join("layouts", "section", "sect2.html"), `{{define "main"}}sect2 list{{ end }}`)
-
},
func(t *testing.T) {
th.assertFileContent(filepath.Join("public", "sect1", "index.html"), "Base Sect1", "sect1 list")
this.setup(t)
buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{})
- //helpers.PrintFs(s.BaseFs.Layouts.Fs, "", os.Stdout)
+ // helpers.PrintFs(s.BaseFs.Layouts.Fs, "", os.Stdout)
this.assert(t)
})
// https://github.com/gohugoio/hugo/issues/4895
func TestTemplateBOM(t *testing.T) {
-
b := newTestSitesBuilder(t).WithSimpleConfigFile()
bom := "\ufeff"
b.CreateSites().Build(BuildCfg{})
b.AssertFileContent("public/page/index.html", "Base: Hi!?")
-
}
func TestTemplateManyBaseTemplates(t *testing.T) {
id := i + 1
b.AssertFileContent(fmt.Sprintf("public/page%d/index.html", id), fmt.Sprintf(`Base %d: %d`, id, id))
}
-
}
// https://github.com/gohugoio/hugo/issues/6790
b.AssertFileContent("public/blog/p1/index.html", `single`)
b.AssertFileContent("public/blog/index.html", `list`)
-
}
// https://github.com/gohugoio/hugo/issues/6816
b.Build(BuildCfg{})
b.AssertFileContent("public/index.html", `Base:
Bonjour`)
-
}
func TestTemplateLookupSite(t *testing.T) {
b.AssertFileContent("public/fr/index.html", `Baseof fr: Main Home Fr`)
b.AssertFileContent("public/en/mysection/index.html", `Baseof mysection: Main Default List`)
b.AssertFileContent("public/en/mysection/p1/index.html", `Baseof mysection: Main Default Single`)
-
})
-
}
func TestTemplateFuncs(t *testing.T) {
-
b := newTestSitesBuilder(t).WithDefaultMultiSiteConfig()
homeTpl := `Site: {{ site.Language.Lang }} / {{ .Site.Language.Lang }} / {{ site.BaseURL }}
"Sites: en",
"Hugo: <meta name=\"generator\" content=\"Hugo",
)
-
}
func TestPartialWithReturn(t *testing.T) {
-
c := qt.New(t)
newBuilder := func(t testing.TB) *sitesBuilder {
)
return b
-
}
c.Run("Return", func(c *qt.C) {
complex: 80: 80
`,
)
-
})
c.Run("Zero argument", func(c *qt.C) {
e := b.CreateSites().BuildE(BuildCfg{})
b.Assert(e, qt.Not(qt.IsNil))
-
})
-
}
func TestPartialCached(t *testing.T) {
idset := make(map[identity.Identity]bool)
collectIdentities(idset, templ.(tpl.Info))
b.Assert(idset, qt.HasLen, 11)
-
}
func TestTemplateGoIssues(t *testing.T) {
}
func TestPartialInline(t *testing.T) {
-
b := newTestSitesBuilder(t)
b.WithContent("p1.md", "")
P1: Inline: p1
P2: 32`,
)
-
}
func TestPartialInlineBase(t *testing.T) {
-
b := newTestSitesBuilder(t)
b.WithContent("p1.md", "")
P3: Inline: p3
`,
)
-
}
// https://github.com/gohugoio/hugo/issues/7478
func TestBaseWithAndWithoutDefine(t *testing.T) {
-
b := newTestSitesBuilder(t)
b.WithContent("p1.md", "---\ntitle: P\n---\nContent")
This is single main
`,
)
-
}
package hugolib
import (
+ "bytes"
+ "fmt"
"image/jpeg"
"io"
"math/rand"
+ "os"
"path/filepath"
+ "regexp"
"runtime"
"sort"
"strconv"
+ "strings"
"testing"
+ "text/template"
"time"
"unicode/utf8"
"github.com/gohugoio/hugo/parser"
"github.com/pkg/errors"
- "bytes"
- "fmt"
- "regexp"
- "strings"
- "text/template"
-
"github.com/fsnotify/fsnotify"
"github.com/gohugoio/hugo/common/herrors"
"github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/tpl"
"github.com/spf13/viper"
- "os"
-
"github.com/gohugoio/hugo/resources/resource"
qt "github.com/frankban/quicktest"
Separator: " ",
}
- return &sitesBuilder{T: t, C: qt.New(t), Fs: fs, configFormat: "toml",
- dumper: litterOptions, rnd: rand.New(rand.NewSource(time.Now().Unix()))}
+ return &sitesBuilder{
+ T: t, C: qt.New(t), Fs: fs, configFormat: "toml",
+ dumper: litterOptions, rnd: rand.New(rand.NewSource(time.Now().Unix())),
+ }
}
func newTestSitesBuilderFromDepsCfg(t testing.TB, d deps.DepsCfg) *sitesBuilder {
b.WithWorkingDir(workingDir)
return b.WithViper(d.Cfg.(*viper.Viper))
-
}
func (s *sitesBuilder) Running() *sitesBuilder {
}
func (s *sitesBuilder) WithDefaultMultiSiteConfig() *sitesBuilder {
- var defaultMultiSiteConfig = `
+ defaultMultiSiteConfig := `
baseURL = "http://example.com/blog"
paginate = 1
` + commonConfigSections
return s.WithConfigFile("toml", defaultMultiSiteConfig)
-
}
func (s *sitesBuilder) WithSunset(in string) {
// That file system is backed by a map so not sure how this helps, but some
// randomness in tests doesn't hurt.
// TODO(bep) this turns out to be more confusing than helpful.
- //s.rnd.Shuffle(len(files), func(i, j int) { files[i], files[j] = files[j], files[i] })
+ // s.rnd.Shuffle(len(files), func(i, j int) { files[i], files[j] = files[j], files[i] })
for _, fc := range files {
target := folder
Fs: s.Fs.Source,
Logger: s.logger,
Environ: s.environ,
- Filename: "config." + s.configFormat}, func(cfg config.Provider) error {
-
+ Filename: "config." + s.configFormat,
+ }, func(cfg config.Provider) error {
return nil
})
-
if err != nil {
return err
}
}
func (s *sitesBuilder) changeEvents() []fsnotify.Event {
-
var events []fsnotify.Event
for _, v := range s.changedFiles {
}
func (s *sitesBuilder) addDefaults() {
-
var (
contentTemplate = `---
title: doc1
if !defaultInSubDir {
value = strings.Replace(value, replace, "", 1)
-
}
return value
}
fs := hugofs.NewFrom(hugofs.NewBaseFileDecorator(mm), v)
return v, fs
-
}
func newTestCfg(withConfig ...func(cfg config.Provider) error) (*viper.Viper, *hugofs.Fs) {
fs := hugofs.NewFrom(hugofs.NewBaseFileDecorator(mm), v)
return v, fs
-
}
func newTestSitesFromConfig(t testing.TB, afs afero.Fs, tomlConfig string, layoutPathContentPairs ...string) (testHelper, *HugoSites) {
}
func createWithTemplateFromNameValues(additionalTemplates ...string) func(templ tpl.TemplateManager) error {
-
return func(templ tpl.TemplateManager) error {
for i := 0; i < len(additionalTemplates); i += 2 {
err := templ.AddTemplate(additionalTemplates[i], additionalTemplates[i+1])
if runtime.GOOS == "windows" && os.Getenv("CI") == "" {
t.Skip("skip symlink test on local Windows (needs admin)")
}
-
}
func captureStderr(f func() error) (string, error) {
type Identities map[Identity]Provider
func (ids Identities) search(depth int, id Identity) Provider {
-
if v, found := ids[id.GetIdentity()]; found {
return v
}
}
func BenchmarkIdentityManager(b *testing.B) {
-
createIds := func(num int) []Identity {
ids := make([]Identity, num)
for i := 0; i < num; i++ {
ids[i] = testIdentity{name: fmt.Sprintf("id%d", i)}
}
return ids
-
}
b.Run("Add", func(b *testing.B) {
id := im.Search(testIdentity{name: name})
c.Assert(id.GetIdentity().Name(), qt.Equals, name)
}
-
})
-
}
type testIdentity struct {
}
func LoadLanguageSettings(cfg config.Provider, oldLangs Languages) (c LanguagesConfig, err error) {
-
defaultLang := strings.ToLower(cfg.GetString("defaultContentLanguage"))
if defaultLang == "" {
defaultLang = "en"
return c, errors.New("baseURL must be set on all or none of the languages")
}
}
-
}
return c, nil
for lang, langConf := range l {
langsMap, err := maps.ToStringMapE(langConf)
-
if err != nil {
return nil, fmt.Errorf("Language config is not a map: %T", langConf)
}
type translateFunc func(translationID string, templateData interface{}) string
-var (
- i18nWarningLogger = helpers.NewDistinctFeedbackLogger()
-)
+var i18nWarningLogger = helpers.NewDistinctFeedbackLogger()
// Translator handles i18n translations.
type Translator struct {
return func(translationID string, args interface{}) string {
return ""
}
-
}
func (t Translator) initFuncs(bndl *i18n.Bundle) {
currentLangKey := strings.ToLower(strings.TrimPrefix(currentLangStr, artificialLangTagPrefix))
localizer := i18n.NewLocalizer(bndl, currentLangStr)
t.translateFuncs[currentLangKey] = func(translationID string, templateData interface{}) string {
-
var pluralCount interface{}
if templateData != nil {
tp := prepareTranslationProvider(t, test, cfg)
f := tp.t.Func(test.lang)
return f(test.id, test.args)
-
}
func prepareTranslationProvider(t testing.TB, test i18nTest, cfg config.Provider) *TranslationProvider {
v.Set("allModules", modules.Modules{mod})
return v
-
}
func TestI18nTranslate(t *testing.T) {
}
})
}
-
}
d.Translate = tp.t.Func(d.Language.Lang)
return nil
-
}
const artificialLangTagPrefix = "art-x-"
herrors.SimpleLineMatcher)
return err
-
}
}
return wj == 0 || wi < wj
-
}
func (l Languages) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
}
}
return l.Cfg.IsSet(key)
-
}
ini.wait()
return ini.out, ini.err
-
}
// TODO(bep) investigate if we can use sync.Cond for this.
case ve := <-c:
return ve.v, ve.err
}
-
}
type verr struct {
}
_, err = branch1_2.Do()
c.Assert(err, qt.IsNil)
-
}(i)
wg.Wait()
c.Assert(result, qt.Equals, "root(1)|root(2)|branch_1|branch_1_1|branch_1_2|branch_1_2_1|")
}
-
}
func TestInitAddWithTimeout(t *testing.T) {
c.Assert(err.Error(), qt.Contains, "timed out")
time.Sleep(1 * time.Second)
-
}
func TestInitAddWithTimeoutError(t *testing.T) {
// V1 is A
ab := state.V1 + "B"
state.Add2(ab)
-
}))
}
}
defer atomic.StoreUint32(&t.done, 1)
f()
-
}
func (t *onceMore) InProgress() bool {
return h1 == h2
},
- ReadBufferSize: 1024, WriteBufferSize: 1024}
+ ReadBufferSize: 1024, WriteBufferSize: 1024,
+}
// Handler is a HandlerFunc handling the livereload
// Websocket interaction.
func runWith(env map[string]string, cmd string, inArgs ...interface{}) error {
s := argsToStrings(inArgs...)
return sh.RunWith(env, cmd, s...)
-
}
// Build hugo binary
}
func (a *asciidocConverter) parseArgs(ctx converter.DocumentContext) []string {
- var cfg = a.cfg.MarkupConfig.AsciidocExt
+ cfg := a.cfg.MarkupConfig.AsciidocExt
args := []string{}
args = a.appendArg(args, "-b", cfg.Backend, asciidocext_config.CliDefault.Backend, asciidocext_config.AllowedBackend)
file := filepath.Base(ctx.Filename)
if a.cfg.Cfg.GetBool("uglyUrls") || file == "_index.adoc" || file == "index.adoc" {
outDir, err = filepath.Abs(filepath.Dir(filepath.Join(destinationDir, ctx.DocumentName)))
-
} else {
postDir := ""
page, ok := ctx.Document.(pageSubset)
c.Assert(args[2], qt.Equals, "-a")
c.Assert(expectedValues[args[3]], qt.Equals, true)
c.Assert(args[4], qt.Equals, "--no-header-footer")
-
}
func TestConvert(t *testing.T) {
cfg: cfg,
}, nil
}), nil
-
}
type blackfridayConverter struct {
}
func getFlags(renderTOC bool, cfg blackfriday_config.Config) int {
-
var flags int
if renderTOC {
actualFlags := getFlags(false, b)
var expectedFlags int
- //OR-ing flags together...
+ // OR-ing flags together...
for _, d := range allFlags {
expectedFlags |= d.testFlag
}
RenderHooks *hooks.Renderers
}
-var (
- FeatureRenderHooks = identity.NewPathIdentity("markup", "renderingHooks")
-)
+var FeatureRenderHooks = identity.NewPathIdentity("markup", "renderingHooks")
}
ids.vals[buf.String()] = struct{}{}
-
})
}
c.Assert(sanitizeAnchorNameString("god is神真美好 good", goldmark_config.AutoHeadingIDTypeGitHubAscii), qt.Equals, "god-is-good")
c.Assert(sanitizeAnchorNameString("Resumé", goldmark_config.AutoHeadingIDTypeGitHubAscii), qt.Equals, "resume")
-
}
func TestSanitizeAnchorNameBlackfriday(t *testing.T) {
result := sanitizeAnchorName(input, goldmark_config.AutoHeadingIDTypeGitHub)
if len(result) != 24 {
b.Fatalf("got %d", len(result))
-
}
}
}
result := sanitizeAnchorName(input, goldmark_config.AutoHeadingIDTypeGitHubAscii)
if len(result) != 12 {
b.Fatalf("got %d", len(result))
-
}
}
}
result := sanitizeAnchorName(input, goldmark_config.AutoHeadingIDTypeBlackfriday)
if len(result) != 24 {
b.Fatalf("got %d", len(result))
-
}
}
}
}), nil
}
-var (
- _ converter.AnchorNameSanitizer = (*goldmarkConverter)(nil)
-)
+var _ converter.AnchorNameSanitizer = (*goldmarkConverter)(nil)
type goldmarkConverter struct {
md goldmark.Markdown
)
return md
-
}
var _ identity.IdentitiesProvider = (*converterResult)(nil)
ids: rcx.ids.GetIdentities(),
toc: pctx.TableOfContents(),
}, nil
-
}
var featureSet = map[identity.Identity]bool{
}
w.WriteString("</div>")
-
}),
)
}
)
func convert(c *qt.C, mconf markup_config.Config, content string) converter.Result {
-
p, err := Provider.New(
converter.ProviderConfig{
MarkupConfig: mconf,
c.Assert(ok, qt.Equals, true)
tocHTML := toc.TableOfContents().ToHTML(1, 2, false)
c.Assert(tocHTML, qt.Contains, "TableOfContents")
-
}
func TestConvertAutoIDAsciiOnly(t *testing.T) {
c.Assert(got, qt.Contains, "<custom-element>\n <div>This will be \"slotted\" into the custom element.</div>\n</custom-element>\n")
})
-
}
func TestCodeFence(t *testing.T) {
</code></pre></div>`)
result = convertForConfig(c, cfg, `echo "Hugo Rocks!"`, "unknown")
c.Assert(result, qt.Equals, "<pre><code class=\"language-unknown\" data-lang=\"unknown\">echo "Hugo Rocks!"\n</code></pre>")
-
})
c.Run("Highlight lines, default config", func(c *qt.C) {
// https://github.com/yuin/goldmark/blob/b611cd333a492416b56aa8d94b04a67bf0096ab2/renderer/html/html.go#L404
func (r *hookedRenderer) RenderAttributes(w util.BufWriter, node ast.Node) {
-
for _, attr := range node.Attributes() {
_, _ = w.WriteString(" ")
_, _ = w.Write(attr.Name)
ctx.AddIdentity(h.ImageRenderer)
return ast.WalkContinue, err
-
}
// Fall back to the default Goldmark render funcs. Method below borrowed from:
p, err := Provider.New(
converter.ProviderConfig{
MarkupConfig: markup_config.Default,
- Logger: loggers.NewErrorLogger()})
+ Logger: loggers.NewErrorLogger(),
+ })
c.Assert(err, qt.IsNil)
conv, err := p.New(converter.DocumentContext{})
c.Assert(err, qt.IsNil)
if cfg.LineAnchors != "" {
lineAnchors = cfg.LineAnchors + "-"
}
- var options = []html.Option{
+ options := []html.Option{
html.TabWidth(cfg.TabWidth),
html.WithLineNumbers(cfg.LineNos),
html.BaseLineNumber(cfg.LineNoStart),
}
return nil
-
}
func parseOptions(in string) (map[string]interface{}, error) {
ranges = append(ranges, r)
}
return ranges, nil
-
}
c.Assert(cfg.CodeFences, qt.Equals, false)
c.Assert(cfg.LineNos, qt.Equals, true)
c.Assert(cfg.LineNumbersInTable, qt.Equals, false)
-
})
c.Run("parseOptions", func(c *qt.C) {
c.Assert(cfg.LineNumbersInTable, qt.Equals, false)
c.Assert(cfg.LineNoStart, qt.Equals, 32)
c.Assert(cfg.Hl_Lines, qt.Equals, "3-8 10-20")
-
})
}
c.Assert(result, qt.Equals, `<div class="highlight"><pre class="chroma"><code class="language-bash" data-lang="bash"><span class="nb">echo</span> <span class="s2">"Hugo Rocks!"</span></code></pre></div>`)
result, _ = h.Highlight(`echo "Hugo Rocks!"`, "unknown", "")
c.Assert(result, qt.Equals, `<pre><code class="language-unknown" data-lang="unknown">echo "Hugo Rocks!"</code></pre>`)
-
})
c.Run("Highlight lines, default config", func(c *qt.C) {
c.Assert(result, qt.Contains, "hello")
c.Assert(result, qt.Contains, "}")
})
-
}
cfg converter.ProviderConfig,
ctx converter.DocumentContext,
content []byte, path string, args []string) []byte {
-
logger := cfg.Logger
cmd := exec.Command(path, args...)
cmd.Stdin = bytes.NewReader(content)
type ConverterProvider interface {
Get(name string) converter.Provider
- //Default() converter.Provider
+ // Default() converter.Provider
GetMarkupConfig() markup_config.Config
Highlight(code, lang, optsStr string) (string, error)
}
}
return nil
-
}
var Default = Config{
c.Assert(conf.Highlight.CodeFences, qt.Equals, true)
c.Assert(conf.Highlight.GuessSyntax, qt.Equals, true)
})
-
}
checkName("pandoc")
checkName("org")
checkName("blackfriday")
-
}
cfg: cfg,
}, nil
}), nil
-
}
type mmarkConverter struct {
ctx converter.DocumentContext,
cfg blackfriday_config.Config,
pcfg converter.ProviderConfig) mmark.Renderer {
-
var (
flags int
documentID string
Config: pcfg,
Renderer: mmark.HtmlRendererWithParameters(htmlFlags, "", "", renderParameters),
}
-
}
func getMmarkExtensions(cfg blackfriday_config.Config) int {
func TestGetMmarkExtensions(t *testing.T) {
b := blackfriday_config.Default
- //TODO: This is doing the same just with different marks...
+ // TODO: This is doing the same just with different marks...
type data struct {
testFlag int
}
cfg: cfg,
}, nil
}), nil
-
}
type pandocConverter struct {
// TODO(bep) check if rst2html has a body only option.
bodyStart := bytes.Index(result, []byte("<body>\n"))
if bodyStart < 0 {
- bodyStart = -7 //compensate for length
+ bodyStart = -7 // compensate for length
}
bodyEnd := bytes.Index(result, []byte("\n</body>"))
b.s.WriteString("\n")
b.indent(indent)
}
-
}
+
func (b *tocBuilder) writeHeader(level, indent int, h Header) {
b.indent(indent)
b.s.WriteString("<li>")
</li>
</ol>
</nav>`, qt.Commentf(got))
-
}
}
c.Assert(len(DefaultTypes), qt.Equals, 26)
-
}
func TestGetByType(t *testing.T) {
c.Assert(tp.String(), qt.Equals, "image/svg+xml")
c.Assert(found, qt.Equals, true)
c.Assert(tp.FullSuffix(), qt.Equals, ".svg")
-
}
func TestDecodeTypes(t *testing.T) {
c := qt.New(t)
- var tests = []struct {
+ tests := []struct {
name string
maps []map[string]interface{}
shouldError bool
[]map[string]interface{}{
{
"application/json": map[string]interface{}{
- "suffixes": []string{"jasn"}}}},
+ "suffixes": []string{"jasn"},
+ },
+ },
+ },
false,
func(t *testing.T, name string, tt Types) {
c.Assert(len(tt), qt.Equals, len(DefaultTypes))
c.Assert(found, qt.Equals, true)
c.Assert(json.String(), qt.Equals, "application/json")
c.Assert(json.FullSuffix(), qt.Equals, ".jasn")
- }},
+ },
+ },
{
"MIME suffix in key, multiple file suffixes, custom delimiter",
[]map[string]interface{}{
"application/hugo+hg": map[string]interface{}{
"suffixes": []string{"hg1", "hg2"},
"Delimiter": "_",
- }}},
+ },
+ },
+ },
false,
func(t *testing.T, name string, tt Types) {
c.Assert(len(tt), qt.Equals, len(DefaultTypes)+1)
hg, found = tt.GetByType("application/hugo+hg")
c.Assert(found, qt.Equals, true)
-
- }},
+ },
+ },
{
"Add custom media type",
[]map[string]interface{}{
{
"text/hugo+hgo": map[string]interface{}{
- "Suffixes": []string{"hgo2"}}}},
+ "Suffixes": []string{"hgo2"},
+ },
+ },
+ },
false,
func(t *testing.T, name string, tt Types) {
c.Assert(len(tt), qt.Equals, len(DefaultTypes)+1)
hugo, found := tt.GetBySuffix("hgo2")
c.Assert(found, qt.Equals, true)
c.Assert(hugo.String(), qt.Equals, "text/hugo+hgo")
- }},
+ },
+ },
}
for _, test := range tests {
package metrics
import (
- "reflect"
-
- "github.com/gohugoio/hugo/helpers"
-
- "github.com/gohugoio/hugo/common/types"
-
"fmt"
"io"
"math"
+ "reflect"
"sort"
"strconv"
"strings"
"sync"
"time"
+ "github.com/gohugoio/hugo/helpers"
+
+ "github.com/gohugoio/hugo/common/types"
+
"github.com/gohugoio/hugo/compare"
)
fmt.Fprintf(w, " %13s %12s %12s %5d %s\n", v.sum, v.avg, v.max, v.count, v.key)
}
}
-
}
// A result represents the calculated results for a given metric.
return 100
}
return 0
-
}
// howSimilar is a naive diff implementation that returns
c.Assert(howSimilar(template.HTML("Hugo Rules"), template.HTML("Hugo Rules")), qt.Equals, 100)
c.Assert(howSimilar(map[string]interface{}{"a": 32, "b": 33}, map[string]interface{}{"a": 32, "b": 33}), qt.Equals, 100)
c.Assert(howSimilar(map[string]interface{}{"a": 32, "b": 33}, map[string]interface{}{"a": 32, "b": 34}), qt.Equals, 0)
-
}
type testStruct struct {
c.Assert(howSimilar(page.Pages{}, page.Pages{}), qt.Equals, 90)
c.Assert(howSimilar(testStruct{Name: "A"}, testStruct{Name: "B"}), qt.Equals, 0)
c.Assert(howSimilar(testStruct{Name: "A"}, testStruct{Name: "A"}), qt.Equals, 100)
-
}
func BenchmarkHowSimilar(b *testing.B) {
conf, err := decodeConfig(v)
c.Assert(err, qt.IsNil)
c.Assert(conf.MinifyOutput, qt.Equals, true)
-
}
c.Assert(m.Minify(test.tp, &b, strings.NewReader(test.rawString)), qt.IsNil)
c.Assert(b.String(), qt.Equals, test.expectedMinString)
}
-
}
func TestConfigureMinify(t *testing.T) {
c.Assert(json.Unmarshal(b.Bytes(), &m2), qt.IsNil)
c.Assert(m1, qt.DeepEquals, m2)
}
-
}
func TestBugs(t *testing.T) {
c.Assert(m.Minify(test.tp, &b, strings.NewReader(test.rawString)), qt.IsNil)
c.Assert(b.String(), qt.Equals, test.expectedMinString)
}
-
}
"os/exec"
"path/filepath"
"regexp"
+ "strings"
+ "time"
hglob "github.com/gohugoio/hugo/hugofs/glob"
"github.com/gohugoio/hugo/common/loggers"
- "strings"
- "time"
-
"github.com/gohugoio/hugo/config"
"github.com/rogpeppe/go-internal/module"
"github.com/spf13/afero"
)
-var (
- fileSeparator = string(os.PathSeparator)
-)
+var fileSeparator = string(os.PathSeparator)
const (
goBinaryStatusOK goBinaryStatus = iota
if cfg.CacheDir != "" {
// Module cache stored below $GOPATH/pkg
config.SetEnvVars(&env, "GOPATH", cfg.CacheDir)
-
}
logger := cfg.Logger
noVendor: noVendor,
moduleConfig: mcfg,
environ: env,
- GoModulesFilename: goModFilename}
+ GoModulesFilename: goModFilename,
+ }
}
// Client contains most of the API provided by this package.
// Local dir.
dep += " => " + replace.Dir()
}
-
}
fmt.Fprintln(w, prefix+dep)
}
func (c *Client) Verify(clean bool) error {
// TODO1 add path to mod clean
err := c.runVerify()
-
if err != nil {
if clean {
m := verifyErrorDirRe.FindAllStringSubmatch(err.Error(), -1)
}
return modules, err
-
}
func (c *Client) rewriteGoMod(name string, isGoMod map[string]bool) error {
}
return b.Bytes(), nil
-
}
func (c *Client) rmVendorDir(vendorDir string) error {
ctx context.Context,
stdout io.Writer,
args ...string) error {
-
if c.goBinaryStatus != 0 {
return nil
}
)
func TestClient(t *testing.T) {
-
modName := "hugo-modules-basic-test"
modPath := "github.com/gohugoio/tests/" + modName
expect := `github.com/gohugoio/tests/hugo-modules-basic-test github.com/gohugoio/hugoTestModules1_darwin/modh2_2@v1.4.0
c := qt.New(t)
newClient := func(c *qt.C, withConfig func(cfg *ClientConfig)) (*Client, func()) {
-
workingDir, clean, err := htesting.CreateTempDir(hugofs.Os, modName)
c.Assert(err, qt.IsNil)
themesDir := filepath.Join(workingDir, "themes")
}
withConfig(&ccfg)
- ccfg.ModuleConfig.Imports = []Import{Import{Path: "github.com/gohugoio/hugoTestModules1_darwin/modh2_2"}}
+ ccfg.ModuleConfig.Imports = []Import{{Path: "github.com/gohugoio/hugoTestModules1_darwin/modh2_2"}}
client := NewClient(ccfg)
return client, clean
// Test Tidy
c.Assert(client.Tidy(), qt.IsNil)
-
})
c.Run("IgnoreVendor", func(c *qt.C) {
dirname, err = client.createThemeDirname(absDir, false)
fmt.Println(dirname)
c.Assert(err, qt.Not(qt.IsNil))
-
})
-
}
var globAll, _ = glob.GetGlob("**")
func TestGetModlineSplitter(t *testing.T) {
-
c := qt.New(t)
gomodSplitter := getModlineSplitter(true)
gosumSplitter := getModlineSplitter(false)
c.Assert(gosumSplitter("github.com/BurntSushi/toml v0.3.1"), qt.DeepEquals, []string{"github.com/BurntSushi/toml", "v0.3.1"})
-
}
AllModules: c.modules,
GoModulesFilename: c.GoModulesFilename,
}, c
-
}
type ModulesConfig struct {
c.modules = append(c.modules, ma)
return ma, nil
-
}
func (c *collector) addAndRecurse(owner *moduleAdapter, disabled bool) error {
if len(mounts) == 0 {
// Mounts not defined by the import.
mounts = modConfig.Mounts
-
}
if !mod.projectMod && len(mounts) == 0 {
}
func (c *collector) applyThemeConfig(tc *moduleAdapter) error {
-
var (
configFilename string
cfg config.Provider
tc.config = config
return nil
-
}
func (c *collector) collect() {
// Add the project mod on top.
c.modules = append(Modules{projectMod}, c.modules...)
-
}
func (c *collector) isVendored(dir string) bool {
filename := filepath.Join(vendorDir, vendorModulesFilename)
f, err := c.fs.Open(filename)
-
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
-
}
type vendoredModule struct {
projectMod: true,
config: conf,
}
-
}
// In the first iteration of Hugo Modules, we do not support multiple
} {
c.Assert(pathKey(test.in), qt.Equals, test.expect)
}
-
}
func TestFilterUnwantedMounts(t *testing.T) {
-
mounts := []Mount{
- Mount{Source: "a", Target: "b", Lang: "en"},
- Mount{Source: "a", Target: "b", Lang: "en"},
- Mount{Source: "b", Target: "c", Lang: "en"},
+ {Source: "a", Target: "b", Lang: "en"},
+ {Source: "a", Target: "b", Lang: "en"},
+ {Source: "b", Target: "c", Lang: "en"},
}
filtered := filterUnwantedMounts(mounts)
c := qt.New(t)
c.Assert(len(filtered), qt.Equals, 2)
- c.Assert(filtered, qt.DeepEquals, []Mount{Mount{Source: "a", Target: "b", Lang: "en"}, Mount{Source: "b", Target: "c", Lang: "en"}})
-
+ c.Assert(filtered, qt.DeepEquals, []Mount{{Source: "a", Target: "b", Lang: "en"}, {Source: "b", Target: "c", Lang: "en"}})
}
source := cfg.GetString(d.key)
componentsConfigured[d.component] = true
- return []Mount{Mount{
+ return []Mount{{
// No lang set for layouts etc.
Source: source,
- Target: d.component}}
+ Target: d.component,
+ }}
}
return nil
var mounts []Mount
for _, dirKey := range dirKeys {
if componentsConfigured[dirKey.component] {
-
continue
}
c.Imports[i] = imp
}
}
-
}
for i, mnt := range c.Mounts {
}
func getStringOrStringSlice(cfg config.Provider, key string, id int) []string {
-
if id >= 0 {
key = fmt.Sprintf("%s%d", key, id)
}
return config.GetStringSlicePreserveString(cfg, key)
-
}
}
})
-
}
func TestDecodeConfigBothOldAndNewProvided(t *testing.T) {
c.Assert(err, qt.IsNil)
c.Assert(len(modCfg.Imports), qt.Equals, 3)
c.Assert(modCfg.Imports[0].Path, qt.Equals, "a")
-
}
// Test old style theme import.
)
func Pack(fs afero.Fs, fis []hugofs.FileMetaInfo) error {
-
var b *packageBuilder
// Have a package.hugo.json?
}
return nil
-
}
func newPackageBuilder(source string, first io.Reader) *packageBuilder {
}
}
}
-
}
func (b *packageBuilder) unmarshal(r io.Reader) map[string]interface{} {
package navigation
import (
- "github.com/gohugoio/hugo/common/maps"
- "github.com/gohugoio/hugo/common/types"
- "github.com/gohugoio/hugo/compare"
-
"html/template"
"sort"
"strings"
+ "github.com/gohugoio/hugo/common/maps"
+ "github.com/gohugoio/hugo/common/types"
+ "github.com/gohugoio/hugo/compare"
+
"github.com/spf13/cast"
)
}
return pm, nil
-
}
func NewMenuQueryProvider(
pagem PageMenusGetter,
sitem MenusGetter,
p Page) MenuQueryProvider {
-
return &pageMenus{
p: p,
pagem: pagem,
}
func (pm *pageMenus) HasMenuCurrent(menuID string, me *MenuEntry) bool {
-
// page is labeled as "shadow-member" of the menu with the same identifier as the section
if pm.setionPagesMenu != "" {
section := pm.p.Section()
menus := pm.pagem.Menus()
if m, ok := menus[menuID]; ok {
-
for _, child := range me.Children {
if child.IsEqual(m) {
return true
}
return false
-
}
func (pm *pageMenus) IsMenuCurrent(menuID string, inme *MenuEntry) bool {
}
func createLayoutExamples() interface{} {
-
type Example struct {
Example string
Kind string
Kind: example.d.Kind,
OutputFormat: example.f.Name,
Suffix: example.f.MediaType.Suffix(),
- Layouts: makeLayoutsPresentable(layouts)})
+ Layouts: makeLayoutsPresentable(layouts),
+ })
}
return basicExamples
-
}
func makeLayoutsPresentable(l []string) []string {
expect []string
}{
{
- "Home", LayoutDescriptor{Kind: "home"}, "", ampType,
+ "Home",
+ LayoutDescriptor{Kind: "home"},
+ "", ampType,
[]string{
"index.amp.html",
"home.amp.html",
},
},
{
- "Home baseof", LayoutDescriptor{Kind: "home", Baseof: true}, "", ampType,
+ "Home baseof",
+ LayoutDescriptor{Kind: "home", Baseof: true},
+ "", ampType,
[]string{
"index-baseof.amp.html",
"home-baseof.amp.html",
},
},
{
- "Home, HTML", LayoutDescriptor{Kind: "home"}, "", htmlFormat,
+ "Home, HTML",
+ LayoutDescriptor{Kind: "home"},
+ "", htmlFormat,
// We will eventually get to index.html. This looks stuttery, but makes the lookup logic easy to understand.
[]string{
"index.html.html",
},
},
{
- "Home, HTML, baseof", LayoutDescriptor{Kind: "home", Baseof: true}, "", htmlFormat,
+ "Home, HTML, baseof",
+ LayoutDescriptor{Kind: "home", Baseof: true},
+ "", htmlFormat,
[]string{
"index-baseof.html.html",
"home-baseof.html.html",
},
},
{
- "Home, french language", LayoutDescriptor{Kind: "home", Lang: "fr"}, "", ampType,
+ "Home, french language",
+ LayoutDescriptor{Kind: "home", Lang: "fr"},
+ "", ampType,
[]string{
"index.fr.amp.html",
"home.fr.amp.html",
},
},
{
- "Home, no ext or delim", LayoutDescriptor{Kind: "home"}, "", noExtDelimFormat,
+ "Home, no ext or delim",
+ LayoutDescriptor{Kind: "home"},
+ "", noExtDelimFormat,
[]string{
"index.nem",
"home.nem",
},
},
{
- "Home, no ext", LayoutDescriptor{Kind: "home"}, "", noExt,
+ "Home, no ext",
+ LayoutDescriptor{Kind: "home"},
+ "", noExt,
[]string{
"index.nex",
"home.nex",
},
},
{
- "Page, no ext or delim", LayoutDescriptor{Kind: "page"}, "", noExtDelimFormat,
+ "Page, no ext or delim",
+ LayoutDescriptor{Kind: "page"},
+ "", noExtDelimFormat,
[]string{"_default/single.nem"},
},
{
- "Section", LayoutDescriptor{Kind: "section", Section: "sect1"}, "", ampType,
+ "Section",
+ LayoutDescriptor{Kind: "section", Section: "sect1"},
+ "", ampType,
[]string{
"sect1/sect1.amp.html",
"sect1/section.amp.html",
},
},
{
- "Section, baseof", LayoutDescriptor{Kind: "section", Section: "sect1", Baseof: true}, "", ampType,
+ "Section, baseof",
+ LayoutDescriptor{Kind: "section", Section: "sect1", Baseof: true},
+ "", ampType,
[]string{
"sect1/sect1-baseof.amp.html",
"sect1/section-baseof.amp.html",
},
},
{
- "Section, baseof, French, AMP", LayoutDescriptor{Kind: "section", Section: "sect1", Lang: "fr", Baseof: true}, "", ampType,
+ "Section, baseof, French, AMP",
+ LayoutDescriptor{Kind: "section", Section: "sect1", Lang: "fr", Baseof: true},
+ "", ampType,
[]string{
"sect1/sect1-baseof.fr.amp.html",
"sect1/section-baseof.fr.amp.html",
},
},
{
- "Section with layout", LayoutDescriptor{Kind: "section", Section: "sect1", Layout: "mylayout"}, "", ampType,
+ "Section with layout",
+ LayoutDescriptor{Kind: "section", Section: "sect1", Layout: "mylayout"},
+ "", ampType,
[]string{
"sect1/mylayout.amp.html",
"sect1/sect1.amp.html",
},
},
{
- "Term, French, AMP", LayoutDescriptor{Kind: "term", Section: "tags", Lang: "fr"}, "", ampType,
+ "Term, French, AMP",
+ LayoutDescriptor{Kind: "term", Section: "tags", Lang: "fr"},
+ "", ampType,
[]string{
"term/term.fr.amp.html",
"term/tags.fr.amp.html",
},
},
{
- "Term, baseof, French, AMP", LayoutDescriptor{Kind: "term", Section: "tags", Lang: "fr", Baseof: true}, "", ampType,
+ "Term, baseof, French, AMP",
+ LayoutDescriptor{Kind: "term", Section: "tags", Lang: "fr", Baseof: true},
+ "", ampType,
[]string{
"term/term-baseof.fr.amp.html",
"term/tags-baseof.fr.amp.html",
},
},
{
- "Term", LayoutDescriptor{Kind: "term", Section: "tags"}, "", ampType,
+ "Term",
+ LayoutDescriptor{Kind: "term", Section: "tags"},
+ "", ampType,
[]string{
"term/term.amp.html",
"term/tags.amp.html",
},
},
{
- "Taxonomy", LayoutDescriptor{Kind: "taxonomy", Section: "categories"}, "", ampType,
+ "Taxonomy",
+ LayoutDescriptor{Kind: "taxonomy", Section: "categories"},
+ "", ampType,
[]string{
"categories/categories.terms.amp.html",
"categories/terms.amp.html",
},
},
{
- "Page", LayoutDescriptor{Kind: "page"}, "", ampType,
+ "Page",
+ LayoutDescriptor{Kind: "page"},
+ "", ampType,
[]string{
"_default/single.amp.html",
"_default/single.html",
},
},
{
- "Page, baseof", LayoutDescriptor{Kind: "page", Baseof: true}, "", ampType,
+ "Page, baseof",
+ LayoutDescriptor{Kind: "page", Baseof: true},
+ "", ampType,
[]string{
"_default/single-baseof.amp.html",
"_default/baseof.amp.html",
},
},
{
- "Page with layout", LayoutDescriptor{Kind: "page", Layout: "mylayout"}, "", ampType,
+ "Page with layout",
+ LayoutDescriptor{Kind: "page", Layout: "mylayout"},
+ "", ampType,
[]string{
"_default/mylayout.amp.html",
"_default/single.amp.html",
},
},
{
- "Page with layout, baseof", LayoutDescriptor{Kind: "page", Layout: "mylayout", Baseof: true}, "", ampType,
+ "Page with layout, baseof",
+ LayoutDescriptor{Kind: "page", Layout: "mylayout", Baseof: true},
+ "", ampType,
[]string{
"_default/mylayout-baseof.amp.html",
"_default/single-baseof.amp.html",
},
},
{
- "Page with layout and type", LayoutDescriptor{Kind: "page", Layout: "mylayout", Type: "myttype"}, "", ampType,
+ "Page with layout and type",
+ LayoutDescriptor{Kind: "page", Layout: "mylayout", Type: "myttype"},
+ "", ampType,
[]string{
"myttype/mylayout.amp.html",
"myttype/single.amp.html",
},
},
{
- "Page baseof with layout and type", LayoutDescriptor{Kind: "page", Layout: "mylayout", Type: "myttype", Baseof: true}, "", ampType,
+ "Page baseof with layout and type",
+ LayoutDescriptor{Kind: "page", Layout: "mylayout", Type: "myttype", Baseof: true},
+ "", ampType,
[]string{
"myttype/mylayout-baseof.amp.html",
"myttype/single-baseof.amp.html",
},
},
{
- "Page baseof with layout and type in French", LayoutDescriptor{Kind: "page", Layout: "mylayout", Type: "myttype", Lang: "fr", Baseof: true}, "", ampType,
+ "Page baseof with layout and type in French",
+ LayoutDescriptor{Kind: "page", Layout: "mylayout", Type: "myttype", Lang: "fr", Baseof: true},
+ "", ampType,
[]string{
"myttype/mylayout-baseof.fr.amp.html",
"myttype/single-baseof.fr.amp.html",
},
},
{
- "Page with layout and type with subtype", LayoutDescriptor{Kind: "page", Layout: "mylayout", Type: "myttype/mysubtype"}, "", ampType,
+ "Page with layout and type with subtype",
+ LayoutDescriptor{Kind: "page", Layout: "mylayout", Type: "myttype/mysubtype"},
+ "", ampType,
[]string{
"myttype/mysubtype/mylayout.amp.html",
"myttype/mysubtype/single.amp.html",
},
// RSS
{
- "RSS Home", LayoutDescriptor{Kind: "home"}, "", RSSFormat,
+ "RSS Home",
+ LayoutDescriptor{Kind: "home"},
+ "", RSSFormat,
[]string{
"index.rss.xml",
"home.rss.xml",
},
},
{
- "RSS Home, baseof", LayoutDescriptor{Kind: "home", Baseof: true}, "", RSSFormat,
+ "RSS Home, baseof",
+ LayoutDescriptor{Kind: "home", Baseof: true},
+ "", RSSFormat,
[]string{
"index-baseof.rss.xml",
"home-baseof.rss.xml",
},
},
{
- "RSS Section", LayoutDescriptor{Kind: "section", Section: "sect1"}, "", RSSFormat,
+ "RSS Section",
+ LayoutDescriptor{Kind: "section", Section: "sect1"},
+ "", RSSFormat,
[]string{
"sect1/sect1.rss.xml",
"sect1/section.rss.xml",
},
},
{
- "RSS Term", LayoutDescriptor{Kind: "term", Section: "tag"}, "", RSSFormat,
+ "RSS Term",
+ LayoutDescriptor{Kind: "term", Section: "tag"},
+ "", RSSFormat,
[]string{
"term/term.rss.xml",
"term/tag.rss.xml",
},
},
{
- "RSS Taxonomy", LayoutDescriptor{Kind: "taxonomy", Section: "tag"}, "", RSSFormat,
+ "RSS Taxonomy",
+ LayoutDescriptor{Kind: "taxonomy", Section: "tag"},
+ "", RSSFormat,
[]string{
"tag/tag.terms.rss.xml",
"tag/terms.rss.xml",
},
},
{
- "Home plain text", LayoutDescriptor{Kind: "home"}, "", JSONFormat,
+ "Home plain text",
+ LayoutDescriptor{Kind: "home"},
+ "", JSONFormat,
[]string{
"index.json.json",
"home.json.json",
},
},
{
- "Page plain text", LayoutDescriptor{Kind: "page"}, "", JSONFormat,
+ "Page plain text",
+ LayoutDescriptor{Kind: "page"},
+ "", JSONFormat,
[]string{
"_default/single.json.json",
"_default/single.json",
},
},
{
- "Reserved section, shortcodes", LayoutDescriptor{Kind: "section", Section: "shortcodes", Type: "shortcodes"}, "", ampType,
+ "Reserved section, shortcodes",
+ LayoutDescriptor{Kind: "section", Section: "shortcodes", Type: "shortcodes"},
+ "", ampType,
[]string{
"section/shortcodes.amp.html",
"section/section.amp.html",
},
},
{
- "Reserved section, partials", LayoutDescriptor{Kind: "section", Section: "partials", Type: "partials"}, "", ampType,
+ "Reserved section, partials",
+ LayoutDescriptor{Kind: "section", Section: "partials", Type: "partials"},
+ "", ampType,
[]string{
"section/partials.amp.html",
"section/section.amp.html",
},
// This is currently always HTML only
{
- "404, HTML", LayoutDescriptor{Kind: "404"}, "", htmlFormat,
+ "404, HTML",
+ LayoutDescriptor{Kind: "404"},
+ "", htmlFormat,
[]string{
"404.html.html",
"404.html",
},
},
{
- "404, HTML baseof", LayoutDescriptor{Kind: "404", Baseof: true}, "", htmlFormat,
+ "404, HTML baseof",
+ LayoutDescriptor{Kind: "404", Baseof: true},
+ "", htmlFormat,
[]string{
"404-baseof.html.html",
"baseof.html.html",
},
},
{
- "Content hook", LayoutDescriptor{Kind: "render-link", RenderingHook: true, Layout: "mylayout", Section: "blog"}, "", ampType,
+ "Content hook",
+ LayoutDescriptor{Kind: "render-link", RenderingHook: true, Layout: "mylayout", Section: "blog"},
+ "", ampType,
[]string{
"blog/_markup/render-link.amp.html",
"blog/_markup/render-link.html",
import (
"encoding/json"
"fmt"
+ "reflect"
"sort"
"strings"
- "reflect"
-
"github.com/mitchellh/mapstructure"
"github.com/gohugoio/hugo/media"
}
return fi.Weight > 0 && fi.Weight < fj.Weight
-
}
// GetBySuffix gets a output format given as suffix, e.g. "html".
c.Assert(RSSFormat.IsPlainText, qt.Equals, false)
c.Assert(RSSFormat.NoUgly, qt.Equals, true)
c.Assert(CalendarFormat.IsHTML, qt.Equals, false)
-
}
func TestGetFormatByName(t *testing.T) {
c.Assert(f, eq, noExt)
_, found = formats.FromFilename("my.css")
c.Assert(found, qt.Equals, false)
-
}
func TestDecodeFormats(t *testing.T) {
mediaTypes := media.Types{media.JSONType, media.XMLType}
- var tests = []struct {
+ tests := []struct {
name string
maps []map[string]interface{}
shouldError bool
{
"JsON": map[string]interface{}{
"baseName": "myindex",
- "isPlainText": "false"}}},
+ "isPlainText": "false",
+ },
+ },
+ },
false,
func(t *testing.T, name string, f Formats) {
msg := qt.Commentf(name)
c.Assert(json.BaseName, qt.Equals, "myindex")
c.Assert(json.MediaType, eq, media.JSONType)
c.Assert(json.IsPlainText, qt.Equals, false)
-
- }},
+ },
+ },
{
"Add XML format with string as mediatype",
[]map[string]interface{}{
"MYXMLFORMAT": map[string]interface{}{
"baseName": "myxml",
"mediaType": "application/xml",
- }}},
+ },
+ },
+ },
false,
func(t *testing.T, name string, f Formats) {
c.Assert(len(f), qt.Equals, len(DefaultFormats)+1)
// Verify that we haven't changed the DefaultFormats slice.
json, _ := f.GetByName("JSON")
c.Assert(json.BaseName, qt.Equals, "index")
-
- }},
+ },
+ },
{
"Add format unknown mediatype",
[]map[string]interface{}{
"MYINVALID": map[string]interface{}{
"baseName": "mymy",
"mediaType": "application/hugo",
- }}},
+ },
+ },
+ },
true,
func(t *testing.T, name string, f Formats) {
-
- }},
+ },
+ },
{
"Add and redefine XML format",
[]map[string]interface{}{
"MYOTHERXMLFORMAT": map[string]interface{}{
"baseName": "myotherxml",
"mediaType": media.XMLType,
- }},
+ },
+ },
{
"MYOTHERXMLFORMAT": map[string]interface{}{
"baseName": "myredefined",
- }},
+ },
+ },
},
false,
func(t *testing.T, name string, f Formats) {
c.Assert(found, qt.Equals, true)
c.Assert(xml.BaseName, qt.Equals, "myredefined")
c.Assert(xml.MediaType, eq, media.XMLType)
- }},
+ },
+ },
}
for _, test := range tests {
c.Assert(formats[0].Name, qt.Equals, "JSON")
c.Assert(formats[1].Name, qt.Equals, "HTML")
c.Assert(formats[2].Name, qt.Equals, "AMP")
-
}
)
// Regexp definitions
-var keyMatchRegex = regexp.MustCompile(`\"(\w+)\":`)
-var wordBarrierRegex = regexp.MustCompile(`(\w)([A-Z])`)
+var (
+ keyMatchRegex = regexp.MustCompile(`\"(\w+)\":`)
+ wordBarrierRegex = regexp.MustCompile(`(\w)([A-Z])`)
+)
// Code adapted from https://gist.github.com/piersy/b9934790a8892db1a603820c0c23e4a7
type LowerCaseCamelJSONMarshaller struct {
converted := keyMatchRegex.ReplaceAllFunc(
marshalled,
func(match []byte) []byte {
-
// Attributes on the form XML, JSON etc.
if bytes.Equal(match, bytes.ToUpper(match)) {
return bytes.ToLower(match)
default:
return make(map[string]interface{}), nil
}
-
}
var v interface{}
err := d.UnmarshalTo(data, f, &v)
// UnmarshalTo unmarshals data in format f into v.
func (d Decoder) UnmarshalTo(data []byte, f Format, v interface{}) error {
-
var err error
switch f {
}
return toFileError(f, errors.Wrap(err, "unmarshal failed"))
-
}
func (d Decoder) unmarshalCSV(data []byte, v interface{}) error {
}
return nil
-
}
func parseORGDate(s string) string {
//
// Inspired by https://github.com/stripe/stripe-mock, MIT licensed
func stringifyMapKeys(in interface{}) (interface{}, bool) {
-
switch in := in.(type) {
case []interface{}:
for i, v := range in {
}
}
-
}
func TestUnmarshalStringTo(t *testing.T) {
if strings.Contains(formatStr, ".") {
// Assume a filename
formatStr = strings.TrimPrefix(filepath.Ext(formatStr), ".")
-
}
switch formatStr {
case "yaml", "yml":
}
return ""
-
}
// FormatFromMediaType gets the Format given a MIME type, empty string
c.Assert(Item{Val: []byte("true")}.ValTyped(), qt.Equals, true)
c.Assert(Item{Val: []byte("false")}.ValTyped(), qt.Equals, false)
c.Assert(Item{Val: []byte("trues")}.ValTyped(), qt.Equals, "trues")
-
}
func (l *pageLexer) Input() []byte {
return l.input
-
}
type Config struct {
}
func createSectionHandlers(l *pageLexer) *sectionHandlers {
-
shortCodeHandler := §ionHandler{
l: l,
skipFunc: func(l *pageLexer) int {
skipFunc: func(l *pageLexer) int {
if l.summaryDividerChecked || l.summaryDivider == nil {
return -1
-
}
return l.index(l.summaryDivider)
},
l.emit(TypeLeadSummaryDivider)
return origin, true
-
},
}
}
func lexMainSection(l *pageLexer) stateFunc {
-
if l.isEOF() {
return lexDone
}
l.pos = len(l.input)
return lexDone
-
}
func lexDone(l *pageLexer) stateFunc {
-
// Done!
if l.pos > l.start {
l.emit(tText)
l.emit(TypeFrontMatterORG)
return lexMainSection
-
}
// Handle YAML or TOML front matter.
func (l *pageLexer) lexFrontMatterSection(tp ItemType, delimr rune, name string, delim []byte) stateFunc {
-
for i := 0; i < 2; i++ {
if r := l.next(); r != delimr {
return l.errorf("invalid %s delimiter", name)
// 5. `param`
// 6. param=`123`
func lexShortcodeParam(l *pageLexer, escapedQuoteStart bool) stateFunc {
-
first := true
nextEq := false
l.emit(tScParam)
return lexInsideShortcode
-
}
func lexShortcodeParamVal(l *pageLexer) stateFunc {
return leftDelimScWithMarkup
}
return leftDelimScNoMarkup
-
}
func (l *pageLexer) currentRightShortcodeDelim() []byte {
c.Assert(minIndex(4, 0, -2, 2, 5), qt.Equals, 0)
c.Assert(minIndex(), qt.Equals, -1)
c.Assert(minIndex(-2, -3), qt.Equals, -1)
-
}
frontMatterSource = item.Val
}
return true
-
}
iter.PeekWalk(walkFn)
var cfg Config
return collectWithConfig(input, skipFrontMatter, stateStart, cfg)
-
}
// no positional checking, for now ...
func TestMain(t *testing.T) {
t.Parallel()
- var mainTests = []lexerTest{
+ mainTests := []lexerTest{
{"emoji #1", "Some text with :emoji:", []Item{nti(tText, "Some text with "), nti(TypeEmoji, ":emoji:"), tstEOF}},
{"emoji #2", "Some text with :emoji: and some text.", []Item{nti(tText, "Some text with "), nti(TypeEmoji, ":emoji:"), nti(tText, " and some text."), tstEOF}},
{"looks like an emoji #1", "Some text and then :emoji", []Item{nti(tText, "Some text and then "), nti(tText, ":"), nti(tText, "emoji"), tstEOF}},
{"simple with markup", `{{% sc1 %}}`, []Item{tstLeftMD, tstSC1, tstRightMD, tstEOF}},
{"with spaces", `{{< sc1 >}}`, []Item{tstLeftNoMD, tstSC1, tstRightNoMD, tstEOF}},
- {"mismatched rightDelim", `{{< sc1 %}}`, []Item{tstLeftNoMD, tstSC1,
- nti(tError, "unrecognized character in shortcode action: U+0025 '%'. Note: Parameters with non-alphanumeric args must be quoted")}},
+ {"mismatched rightDelim", `{{< sc1 %}}`, []Item{
+ tstLeftNoMD, tstSC1,
+ nti(tError, "unrecognized character in shortcode action: U+0025 '%'. Note: Parameters with non-alphanumeric args must be quoted"),
+ }},
{"inner, markup", `{{% sc1 %}} inner {{% /sc1 %}}`, []Item{
tstLeftMD,
tstSC1,
tstEOF,
}},
{"close, but no open", `{{< /sc1 >}}`, []Item{
- tstLeftNoMD, nti(tError, "got closing shortcode, but none is open")}},
+ tstLeftNoMD, nti(tError, "got closing shortcode, but none is open"),
+ }},
{"close wrong", `{{< sc1 >}}{{< /another >}}`, []Item{
tstLeftNoMD, tstSC1, tstRightNoMD, tstLeftNoMD, tstSCClose,
- nti(tError, "closing tag for shortcode 'another' does not match start tag")}},
+ nti(tError, "closing tag for shortcode 'another' does not match start tag"),
+ }},
{"close, but no open, more", `{{< sc1 >}}{{< /sc1 >}}{{< /another >}}`, []Item{
tstLeftNoMD, tstSC1, tstRightNoMD, tstLeftNoMD, tstSCClose, tstSC1, tstRightNoMD, tstLeftNoMD, tstSCClose,
- nti(tError, "closing tag for shortcode 'another' does not match start tag")}},
+ nti(tError, "closing tag for shortcode 'another' does not match start tag"),
+ }},
{"close with extra keyword", `{{< sc1 >}}{{< /sc1 keyword>}}`, []Item{
tstLeftNoMD, tstSC1, tstRightNoMD, tstLeftNoMD, tstSCClose, tstSC1,
- nti(tError, "unclosed shortcode")}},
+ nti(tError, "unclosed shortcode"),
+ }},
{"float param, positional", `{{< sc1 3.14 >}}`, []Item{
- tstLeftNoMD, tstSC1, nti(tScParam, "3.14"), tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, nti(tScParam, "3.14"), tstRightNoMD, tstEOF,
+ }},
{"float param, named", `{{< sc1 param1=3.14 >}}`, []Item{
- tstLeftNoMD, tstSC1, tstParam1, nti(tScParamVal, "3.14"), tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, tstParam1, nti(tScParamVal, "3.14"), tstRightNoMD, tstEOF,
+ }},
{"named param, raw string", `{{< sc1 param1=` + "`" + "Hello World" + "`" + " >}}", []Item{
- tstLeftNoMD, tstSC1, tstParam1, nti(tScParamVal, "Hello World"), tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, tstParam1, nti(tScParamVal, "Hello World"), tstRightNoMD, tstEOF,
+ }},
{"float param, named, space before", `{{< sc1 param1= 3.14 >}}`, []Item{
- tstLeftNoMD, tstSC1, tstParam1, nti(tScParamVal, "3.14"), tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, tstParam1, nti(tScParamVal, "3.14"), tstRightNoMD, tstEOF,
+ }},
{"Youtube id", `{{< sc1 -ziL-Q_456igdO-4 >}}`, []Item{
- tstLeftNoMD, tstSC1, nti(tScParam, "-ziL-Q_456igdO-4"), tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, nti(tScParam, "-ziL-Q_456igdO-4"), tstRightNoMD, tstEOF,
+ }},
{"non-alphanumerics param quoted", `{{< sc1 "-ziL-.%QigdO-4" >}}`, []Item{
- tstLeftNoMD, tstSC1, nti(tScParam, "-ziL-.%QigdO-4"), tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, nti(tScParam, "-ziL-.%QigdO-4"), tstRightNoMD, tstEOF,
+ }},
{"raw string", `{{< sc1` + "`" + "Hello World" + "`" + ` >}}`, []Item{
- tstLeftNoMD, tstSC1, nti(tScParam, "Hello World"), tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, nti(tScParam, "Hello World"), tstRightNoMD, tstEOF,
+ }},
{"raw string with newline", `{{< sc1` + "`" + `Hello
World` + "`" + ` >}}`, []Item{
tstLeftNoMD, tstSC1, nti(tScParam, `Hello
- World`), tstRightNoMD, tstEOF}},
+ World`), tstRightNoMD, tstEOF,
+ }},
{"raw string with escape character", `{{< sc1` + "`" + `Hello \b World` + "`" + ` >}}`, []Item{
- tstLeftNoMD, tstSC1, nti(tScParam, `Hello \b World`), tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, nti(tScParam, `Hello \b World`), tstRightNoMD, tstEOF,
+ }},
{"two params", `{{< sc1 param1 param2 >}}`, []Item{
- tstLeftNoMD, tstSC1, tstParam1, tstParam2, tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, tstParam1, tstParam2, tstRightNoMD, tstEOF,
+ }},
// issue #934
{"self-closing", `{{< sc1 />}}`, []Item{
- tstLeftNoMD, tstSC1, tstSCClose, tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, tstSCClose, tstRightNoMD, tstEOF,
+ }},
// Issue 2498
{"multiple self-closing", `{{< sc1 />}}{{< sc1 />}}`, []Item{
tstLeftNoMD, tstSC1, tstSCClose, tstRightNoMD,
- tstLeftNoMD, tstSC1, tstSCClose, tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, tstSCClose, tstRightNoMD, tstEOF,
+ }},
{"self-closing with param", `{{< sc1 param1 />}}`, []Item{
- tstLeftNoMD, tstSC1, tstParam1, tstSCClose, tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, tstParam1, tstSCClose, tstRightNoMD, tstEOF,
+ }},
{"multiple self-closing with param", `{{< sc1 param1 />}}{{< sc1 param1 />}}`, []Item{
tstLeftNoMD, tstSC1, tstParam1, tstSCClose, tstRightNoMD,
- tstLeftNoMD, tstSC1, tstParam1, tstSCClose, tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, tstParam1, tstSCClose, tstRightNoMD, tstEOF,
+ }},
{"multiple different self-closing with param", `{{< sc1 param1 />}}{{< sc2 param1 />}}`, []Item{
tstLeftNoMD, tstSC1, tstParam1, tstSCClose, tstRightNoMD,
- tstLeftNoMD, tstSC2, tstParam1, tstSCClose, tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC2, tstParam1, tstSCClose, tstRightNoMD, tstEOF,
+ }},
{"nested simple", `{{< sc1 >}}{{< sc2 >}}{{< /sc1 >}}`, []Item{
tstLeftNoMD, tstSC1, tstRightNoMD,
tstLeftNoMD, tstSC2, tstRightNoMD,
- tstLeftNoMD, tstSCClose, tstSC1, tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSCClose, tstSC1, tstRightNoMD, tstEOF,
+ }},
{"nested complex", `{{< sc1 >}}ab{{% sc2 param1 %}}cd{{< sc3 >}}ef{{< /sc3 >}}gh{{% /sc2 %}}ij{{< /sc1 >}}kl`, []Item{
tstLeftNoMD, tstSC1, tstRightNoMD,
nti(tText, "ab"),
}},
{"two quoted params", `{{< sc1 "param nr. 1" "param nr. 2" >}}`, []Item{
- tstLeftNoMD, tstSC1, nti(tScParam, "param nr. 1"), nti(tScParam, "param nr. 2"), tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, nti(tScParam, "param nr. 1"), nti(tScParam, "param nr. 2"), tstRightNoMD, tstEOF,
+ }},
{"two named params", `{{< sc1 param1="Hello World" param2="p2Val">}}`, []Item{
- tstLeftNoMD, tstSC1, tstParam1, tstVal, tstParam2, nti(tScParamVal, "p2Val"), tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, tstParam1, tstVal, tstParam2, nti(tScParamVal, "p2Val"), tstRightNoMD, tstEOF,
+ }},
{"escaped quotes", `{{< sc1 param1=\"Hello World\" >}}`, []Item{
- tstLeftNoMD, tstSC1, tstParam1, tstVal, tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, tstParam1, tstVal, tstRightNoMD, tstEOF,
+ }},
{"escaped quotes, positional param", `{{< sc1 \"param1\" >}}`, []Item{
- tstLeftNoMD, tstSC1, tstParam1, tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, tstParam1, tstRightNoMD, tstEOF,
+ }},
{"escaped quotes inside escaped quotes", `{{< sc1 param1=\"Hello \"escaped\" World\" >}}`, []Item{
tstLeftNoMD, tstSC1, tstParam1,
- nti(tScParamVal, `Hello `), nti(tError, `got positional parameter 'escaped'. Cannot mix named and positional parameters`)}},
- {"escaped quotes inside nonescaped quotes",
- `{{< sc1 param1="Hello \"escaped\" World" >}}`, []Item{
- tstLeftNoMD, tstSC1, tstParam1, nti(tScParamVal, `Hello "escaped" World`), tstRightNoMD, tstEOF}},
- {"escaped quotes inside nonescaped quotes in positional param",
- `{{< sc1 "Hello \"escaped\" World" >}}`, []Item{
- tstLeftNoMD, tstSC1, nti(tScParam, `Hello "escaped" World`), tstRightNoMD, tstEOF}},
+ nti(tScParamVal, `Hello `), nti(tError, `got positional parameter 'escaped'. Cannot mix named and positional parameters`),
+ }},
+ {
+ "escaped quotes inside nonescaped quotes",
+ `{{< sc1 param1="Hello \"escaped\" World" >}}`,
+ []Item{
+ tstLeftNoMD, tstSC1, tstParam1, nti(tScParamVal, `Hello "escaped" World`), tstRightNoMD, tstEOF,
+ },
+ },
+ {
+ "escaped quotes inside nonescaped quotes in positional param",
+ `{{< sc1 "Hello \"escaped\" World" >}}`,
+ []Item{
+ tstLeftNoMD, tstSC1, nti(tScParam, `Hello "escaped" World`), tstRightNoMD, tstEOF,
+ },
+ },
{"escaped raw string, named param", `{{< sc1 param1=` + `\` + "`" + "Hello World" + `\` + "`" + ` >}}`, []Item{
- tstLeftNoMD, tstSC1, tstParam1, nti(tError, "unrecognized escape character")}},
+ tstLeftNoMD, tstSC1, tstParam1, nti(tError, "unrecognized escape character"),
+ }},
{"escaped raw string, positional param", `{{< sc1 param1 ` + `\` + "`" + "Hello World" + `\` + "`" + ` >}}`, []Item{
- tstLeftNoMD, tstSC1, tstParam1, nti(tError, "unrecognized escape character")}},
+ tstLeftNoMD, tstSC1, tstParam1, nti(tError, "unrecognized escape character"),
+ }},
{"two raw string params", `{{< sc1` + "`" + "Hello World" + "`" + "`" + "Second Param" + "`" + ` >}}`, []Item{
- tstLeftNoMD, tstSC1, nti(tScParam, "Hello World"), nti(tScParam, "Second Param"), tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC1, nti(tScParam, "Hello World"), nti(tScParam, "Second Param"), tstRightNoMD, tstEOF,
+ }},
{"unterminated quote", `{{< sc1 param2="Hello World>}}`, []Item{
- tstLeftNoMD, tstSC1, tstParam2, nti(tError, "unterminated quoted string in shortcode parameter-argument: 'Hello World>}}'")}},
+ tstLeftNoMD, tstSC1, tstParam2, nti(tError, "unterminated quoted string in shortcode parameter-argument: 'Hello World>}}'"),
+ }},
{"unterminated raw string", `{{< sc1` + "`" + "Hello World" + ` >}}`, []Item{
- tstLeftNoMD, tstSC1, nti(tError, "unterminated raw string in shortcode parameter-argument: 'Hello World >}}'")}},
+ tstLeftNoMD, tstSC1, nti(tError, "unterminated raw string in shortcode parameter-argument: 'Hello World >}}'"),
+ }},
{"unterminated raw string in second argument", `{{< sc1` + "`" + "Hello World" + "`" + "`" + "Second Param" + ` >}}`, []Item{
- tstLeftNoMD, tstSC1, nti(tScParam, "Hello World"), nti(tError, "unterminated raw string in shortcode parameter-argument: 'Second Param >}}'")}},
+ tstLeftNoMD, tstSC1, nti(tScParam, "Hello World"), nti(tError, "unterminated raw string in shortcode parameter-argument: 'Second Param >}}'"),
+ }},
{"one named param, one not", `{{< sc1 param1="Hello World" p2 >}}`, []Item{
tstLeftNoMD, tstSC1, tstParam1, tstVal,
- nti(tError, "got positional parameter 'p2'. Cannot mix named and positional parameters")}},
+ nti(tError, "got positional parameter 'p2'. Cannot mix named and positional parameters"),
+ }},
{"one named param, one quoted positional param, both raw strings", `{{< sc1 param1=` + "`" + "Hello World" + "`" + "`" + "Second Param" + "`" + ` >}}`, []Item{
tstLeftNoMD, tstSC1, tstParam1, tstVal,
- nti(tError, "got quoted positional parameter. Cannot mix named and positional parameters")}},
+ nti(tError, "got quoted positional parameter. Cannot mix named and positional parameters"),
+ }},
{"one named param, one quoted positional param", `{{< sc1 param1="Hello World" "And Universe" >}}`, []Item{
tstLeftNoMD, tstSC1, tstParam1, tstVal,
- nti(tError, "got quoted positional parameter. Cannot mix named and positional parameters")}},
+ nti(tError, "got quoted positional parameter. Cannot mix named and positional parameters"),
+ }},
{"one quoted positional param, one named param", `{{< sc1 "param1" param2="And Universe" >}}`, []Item{
tstLeftNoMD, tstSC1, tstParam1,
- nti(tError, "got named parameter 'param2'. Cannot mix named and positional parameters")}},
+ nti(tError, "got named parameter 'param2'. Cannot mix named and positional parameters"),
+ }},
{"ono positional param, one not", `{{< sc1 param1 param2="Hello World">}}`, []Item{
tstLeftNoMD, tstSC1, tstParam1,
- nti(tError, "got named parameter 'param2'. Cannot mix named and positional parameters")}},
+ nti(tError, "got named parameter 'param2'. Cannot mix named and positional parameters"),
+ }},
{"commented out", `{{</* sc1 */>}}`, []Item{
- nti(tText, "{{<"), nti(tText, " sc1 "), nti(tText, ">}}"), tstEOF}},
+ nti(tText, "{{<"), nti(tText, " sc1 "), nti(tText, ">}}"), tstEOF,
+ }},
{"commented out, with asterisk inside", `{{</* sc1 "**/*.pdf" */>}}`, []Item{
- nti(tText, "{{<"), nti(tText, " sc1 \"**/*.pdf\" "), nti(tText, ">}}"), tstEOF}},
+ nti(tText, "{{<"), nti(tText, " sc1 \"**/*.pdf\" "), nti(tText, ">}}"), tstEOF,
+ }},
{"commented out, missing close", `{{</* sc1 >}}`, []Item{
- nti(tError, "comment must be closed")}},
+ nti(tError, "comment must be closed"),
+ }},
{"commented out, misplaced close", `{{</* sc1 >}}*/`, []Item{
- nti(tError, "comment must be closed")}},
+ nti(tError, "comment must be closed"),
+ }},
// Inline shortcodes
{"basic inline", `{{< sc1.inline >}}Hello World{{< /sc1.inline >}}`, []Item{tstLeftNoMD, tstSC1Inline, tstRightNoMD, tstText, tstLeftNoMD, tstSCClose, tstSC1Inline, tstRightNoMD, tstEOF}},
{"basic inline with space", `{{< sc1.inline >}}Hello World{{< / sc1.inline >}}`, []Item{tstLeftNoMD, tstSC1Inline, tstRightNoMD, tstText, tstLeftNoMD, tstSCClose, tstSC1Inline, tstRightNoMD, tstEOF}},
{"inline self closing", `{{< sc1.inline >}}Hello World{{< /sc1.inline >}}Hello World{{< sc1.inline />}}`, []Item{tstLeftNoMD, tstSC1Inline, tstRightNoMD, tstText, tstLeftNoMD, tstSCClose, tstSC1Inline, tstRightNoMD, tstText, tstLeftNoMD, tstSC1Inline, tstSCClose, tstRightNoMD, tstEOF}},
{"inline self closing, then a new inline", `{{< sc1.inline >}}Hello World{{< /sc1.inline >}}Hello World{{< sc1.inline />}}{{< sc2.inline >}}Hello World{{< /sc2.inline >}}`, []Item{
tstLeftNoMD, tstSC1Inline, tstRightNoMD, tstText, tstLeftNoMD, tstSCClose, tstSC1Inline, tstRightNoMD, tstText, tstLeftNoMD, tstSC1Inline, tstSCClose, tstRightNoMD,
- tstLeftNoMD, tstSC2Inline, tstRightNoMD, tstText, tstLeftNoMD, tstSCClose, tstSC2Inline, tstRightNoMD, tstEOF}},
+ tstLeftNoMD, tstSC2Inline, tstRightNoMD, tstText, tstLeftNoMD, tstSCClose, tstSC2Inline, tstRightNoMD, tstEOF,
+ }},
{"inline with template syntax", `{{< sc1.inline >}}{{ .Get 0 }}{{ .Get 1 }}{{< /sc1.inline >}}`, []Item{tstLeftNoMD, tstSC1Inline, tstRightNoMD, nti(tText, "{{ .Get 0 }}"), nti(tText, "{{ .Get 1 }}"), tstLeftNoMD, tstSCClose, tstSC1Inline, tstRightNoMD, tstEOF}},
{"inline with nested shortcode (not supported)", `{{< sc1.inline >}}Hello World{{< sc1 >}}{{< /sc1.inline >}}`, []Item{tstLeftNoMD, tstSC1Inline, tstRightNoMD, tstText, nti(tError, "inline shortcodes do not support nesting")}},
{"inline case mismatch", `{{< sc1.Inline >}}Hello World{{< /sc1.Inline >}}`, []Item{tstLeftNoMD, nti(tError, "period in shortcode name only allowed for inline identifiers")}},
package publisher
import (
- "regexp"
-
- "github.com/gohugoio/hugo/helpers"
- "golang.org/x/net/html"
-
"bytes"
+ "regexp"
"sort"
"strings"
"sync"
+
+ "github.com/gohugoio/hugo/helpers"
+ "golang.org/x/net/html"
)
func newHTMLElementsCollector() *htmlElementsCollector {
h.Tags = helpers.UniqueStringsReuse(h.Tags)
h.Classes = helpers.UniqueStringsReuse(h.Classes)
h.IDs = helpers.UniqueStringsReuse(h.IDs)
-
}
func (h *HTMLElements) Sort() {
}
newv := strings.Replace(el, tag, "div", 1)
return newv, strings.ToLower(tag)
-
}
func (c *cssClassCollectorWriter) endCollecting(drop bool) {
}
func (c *htmlElementsCollector) getHTMLElements() HTMLElements {
-
var (
classes []string
ids []string
</div>
</body>`, f("body div", "class1 class2 class3", "")},
- {"Alpine bind 2", `<div x-bind:class="{ 'bg-black': filter.checked }"
+ {
+ "Alpine bind 2", `<div x-bind:class="{ 'bg-black': filter.checked }"
class="inline-block mr-1 mb-2 rounded bg-gray-300 px-2 py-2">FOO</div>`,
- f("div", "bg-black bg-gray-300 inline-block mb-2 mr-1 px-2 py-2 rounded", "")},
+ f("div", "bg-black bg-gray-300 inline-block mb-2 mr-1 px-2 py-2 rounded", ""),
+ },
{"Alpine bind 3", `<div x-bind:class="{ 'text-gray-800': !checked, 'text-white': checked }"></div>`, f("div", "text-gray-800 text-white", "")},
{"Alpine bind 4", `<div x-bind:class="{ 'text-gray-800': !checked,
c.Assert(got, qt.DeepEquals, test.expect)
})
}
-
}
func BenchmarkClassCollectorWriter(b *testing.B) {
}
return transformers
-
}
}
return err
-
}
// queryElement holds the index name and keywords that can be used to compose a
}
func TestSearch(t *testing.T) {
-
config := Config{
Threshold: 90,
IncludeNewer: false,
}
idx := NewInvertedIndex(config)
- //idx.debug = true
+ // idx.debug = true
docs := []Document{
newTestDoc("tags", "a", "b", "c", "d"),
set2, found := idx.index["keywords"]
c.Assert(found, qt.Equals, true)
c.Assert(len(set2), qt.Equals, 2)
-
})
t.Run("search-tags", func(t *testing.T) {
c.Assert(m[i].Name(), qt.Equals, fmt.Sprintf("doc%d", i))
}
})
-
}
func TestToKeywordsToLower(t *testing.T) {
StringKeyword("b"),
StringKeyword("c"),
})
-
}
func BenchmarkRelatedNewIndex(b *testing.B) {
-
pages := make([]*testDoc, 100)
numkeywords := 30
allKeywords := make([]string, numkeywords)
idx.Add(docs...)
}
})
-
}
func BenchmarkRelatedMatchesIn(b *testing.B) {
-
q1 := newQueryElement("tags", StringsToKeywords("keyword2", "keyword5", "keyword32", "asdf")...)
q2 := newQueryElement("keywords", StringsToKeywords("keyword3", "keyword4")...)
for _, info := range infos {
los := strings.ToLower(info.Subject)
isFix := strings.Contains(los, "fix")
- var category = otherChanges
+ category := otherChanges
// TODO(bep) improve
if regexp.MustCompile("(?i)deprecate").MatchString(los) {
}
return c.Author[:strings.Index(c.Author, "@")]
-
}
type contribCounts []countribCount
func tagExists(tag string) (bool, error) {
out, err := git("tag", "-l", tag)
-
if err != nil {
return false, err
}
c.Assert(len(issues), qt.Equals, 4)
c.Assert(issues[0], qt.Equals, 123)
c.Assert(issues[2], qt.Equals, 543)
-
}
func TestGitVersionTagBefore(t *testing.T) {
b2, err := tagExists("adfagdsfg")
c.Assert(err, qt.IsNil)
c.Assert(b2, qt.Equals, false)
-
}
func skipIfCI(t *testing.T) {
repo.Contributors = contributors
return repo, err
-
}
func doGitHubRequest(req *http.Request, v interface{}) error {
}
return nil
-
}
func fetchThemeCount() (int, error) {
}
return releaseNotesNone, nil
-
}
func (r *ReleaseHandler) writeReleaseNotesToTemp(version string, isPatch bool, infosMain, infosDocs gitInfos) (string, error) {
-
docsTempPath, name := getReleaseNotesDocsTempDirAndName(version, isPatch)
- var (
- w io.WriteCloser
- )
+ var w io.WriteCloser
if !r.try {
os.Mkdir(docsTempPath, os.ModePerm)
}
return name, nil
-
}
func (r *ReleaseHandler) writeReleaseNotesToDocs(title, description, sourceFilename string) (string, error) {
}
return targetFullFilename, nil
-
}
c.Assert(writeReleaseNotes("0.21", infos, infos, &b), qt.IsNil)
fmt.Println(b.String())
-
}
}
func (i *imageResource) getExif() *exif.Exif {
-
i.metaInit.Do(func() {
-
supportsExif := i.Format == images.JPEG || i.Format == images.TIFF
if !supportsExif {
return
-
}
key := i.getImageMetaCacheTargetPath()
}
create := func(info filecache.ItemInfo, w io.WriteCloser) (err error) {
-
f, err := i.root.ReadSeekCloser()
if err != nil {
i.metaInitErr = err
// Also write it to cache
enc := json.NewEncoder(w)
return enc.Encode(i.meta)
-
}
_, i.metaInitErr = i.getSpec().imageCache.fileCache.ReadOrCreate(key, read, create)
-
})
if i.metaInitErr != nil {
return ci, converted, nil
})
-
if err != nil {
if i.root != nil && i.root.getFileInfo() != nil {
return nil, errors.Wrapf(err, "image %q", i.root.getFileInfo().Meta().Filename())
image = fetchResourceForSpec(spec, c, "sunset.jpg").(resource.Image)
// This will read from file cache.
getAndCheckExif(c, image)
-
}
func BenchmarkImageExif(b *testing.B) {
-
getImages := func(c *qt.C, b *testing.B, fs afero.Fs) []resource.Image {
spec := newTestResourceSpec(specDescriptor{fs: fs, c: c})
images := make([]resource.Image, b.N)
x := image.Exif()
c.Assert(x, qt.Not(qt.IsNil))
c.Assert(x.Long, qt.Equals, float64(-4.50846))
-
}
b.Run("Cold cache", func(b *testing.B) {
for i := 0; i < b.N; i++ {
getAndCheckExif(c, images[i])
}
-
})
b.Run("Cold cache, 10", func(b *testing.B) {
getAndCheckExif(c, images[i])
}
}
-
})
b.Run("Warm cache", func(b *testing.B) {
for i := 0; i < b.N; i++ {
getAndCheckExif(c, images[i])
}
-
})
-
}
// usesFMA indicates whether "fused multiply and add" (FMA) instruction is
f1.Close()
f2.Close()
}
-
}
func BenchmarkResizeParallel(b *testing.B) {
}
return color.RGBA{b[0], b[1], b[2], b[3]}, nil
-
}
c.Assert(AddColorToPalette(white, palette), qt.HasLen, 2)
c.Assert(AddColorToPalette(blue1, palette), qt.HasLen, 3)
c.Assert(AddColorToPalette(blue2, palette), qt.HasLen, 3)
-
}
func TestReplaceColorInPalette(t *testing.T) {
imaging = imagingConfig.Cfg
c.Assert(imaging.Exif.DisableLatLong, qt.Equals, true)
c.Assert(imaging.Exif.ExcludeFields, qt.Equals, "GPS|Exif|Exposure[M|P|B]|Contrast|Resolution|Sharp|JPEG|Metering|Sensing|Saturation|ColorSpace|Flash|WhiteBalance")
-
}
func TestDecodeImageConfig(t *testing.T) {
}
return regexp.Compile(expression)
-
}
func NewDecoder(options ...func(*Decoder) error) (*Decoder, error) {
x, err = _exif.Decode(r)
if err != nil {
if err.Error() == "EOF" {
-
// Found no Exif
return nil, nil
}
}
return rv, nil
-
}
// Code borrowed from exif.DateTime and adjusted.
timeZone = tz
}
return time.ParseInLocation(exifTimeLayout, dateStr, timeZone)
-
}
type exifWalker struct {
err = json.Unmarshal(data, x2)
c.Assert(x2, eq, x)
-
}
func TestExifPNG(t *testing.T) {
c.Assert(helpers.HashString(f.Grayscale()), qt.Not(qt.Equals), helpers.HashString(f.Invert()))
c.Assert(helpers.HashString(f.Gamma(32)), qt.Not(qt.Equals), helpers.HashString(f.Gamma(33)))
c.Assert(helpers.HashString(f.Gamma(32)), qt.Equals, helpers.HashString(f.Gamma(32)))
-
}
default:
return errors.New("format not supported")
}
-
}
// Height returns i's height.
exif.ExcludeFields(e.ExcludeFields),
exif.IncludeFields(e.IncludeFields),
)
-
if err != nil {
return nil, err
}
Cfg: cfg,
exifDecoder: exifDecoder,
}, nil
-
}
type ImageProcessor struct {
}
return img.Bounds().Intersect(rect), nil
-
}
}
return k.Name + "_" + helpers.HashString(k.elements...)
-
}
b.sourceRootsMu.Lock()
b.sourceRoots[root] = true
b.sourceRootsMu.Unlock()
-
}
// CompilerOptions holds compilerOptions for jsonconfig.json.
import (
"bytes"
"testing"
-
"text/template"
qt "github.com/frankban/quicktest"
c.Assert(templ.Execute(&buff, data), qt.IsNil)
c.Assert(buff.String(), qt.Contains, "Pages(2)")
-
}
func Generate(c *codegen.Inspector) error {
if err := generateMarshalJSON(c); err != nil {
return errors.Wrap(err, "failed to generate JSON marshaler")
-
}
if err := generateDeprecatedWrappers(c); err != nil {
func generateMarshalJSON(c *codegen.Inspector) error {
filename := filepath.Join(c.ProjectRootDir, packageDir, "page_marshaljson.autogen.go")
f, err := os.Create(filename)
-
if err != nil {
return err
}
c.Assert(GetKind("Page"), qt.Equals, KindPage)
c.Assert(GetKind("Home"), qt.Equals, KindHome)
c.Assert(GetKind("SEction"), qt.Equals, KindSection)
-
}
import (
"encoding/json"
+ "html/template"
+ "time"
+
"github.com/bep/gitmap"
"github.com/gohugoio/hugo/common/maps"
"github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/media"
"github.com/gohugoio/hugo/navigation"
"github.com/gohugoio/hugo/source"
- "html/template"
- "time"
)
func MarshalPageToJSON(p Page) ([]byte, error) {
// Matches returns whether p matches this matcher.
func (m PageMatcher) Matches(p Page) bool {
-
if m.Kind != "" {
g, err := glob.GetGlob(m.Kind)
if err == nil && !g.Match(p.Kind()) {
v.Path = filepath.ToSlash(strings.ToLower(v.Path))
return nil
-
}
c.Assert(m.Matches(p1), qt.Equals, true)
c.Assert(m.Matches(p2), qt.Equals, false)
c.Assert(m.Matches(p3), qt.Equals, true)
-
})
c.Run("Decode", func(c *qt.C) {
c.Assert(DecodePageMatcher(map[string]interface{}{"kind": "home", "path": filepath.FromSlash("/a/b/**")}, &v), qt.IsNil)
c.Assert(v, qt.Equals, PageMatcher{Kind: "home", Path: "/a/b/**"})
})
-
}
func (p *nopPage) Author() Author {
return Author{}
-
}
+
func (p *nopPage) Authors() AuthorList {
return nil
}
func (p *nopPage) RefFrom(argsm map[string]interface{}, source interface{}) (string, error) {
return "", nil
}
+
func (p *nopPage) RelRefFrom(argsm map[string]interface{}, source interface{}) (string, error) {
return "", nil
}
func (p *nopPage) PrevInSection() Page {
return nil
}
+
func (p *nopPage) NextInSection() Page {
return nil
}
import (
"path"
"path/filepath"
-
"strings"
"github.com/gohugoio/hugo/helpers"
}
func CreateTargetPaths(d TargetPathDescriptor) (tp TargetPaths) {
-
if d.Type.Name == "" {
panic("CreateTargetPath: missing type")
}
if d.ExpandedPermalink != "" {
pagePath = pjoin(pagePath, d.ExpandedPermalink)
-
} else {
if d.Dir != "" {
pagePath = pjoin(pagePath, d.Dir)
pagePath = path.Join(pagePath, addSuffix(base, d.Type.MediaType.FullSuffix()))
} else {
pagePath = addSuffix(pagePath, d.Type.MediaType.FullSuffix())
-
}
if !isHtmlIndex(pagePath) {
package page
import (
+ "fmt"
"path/filepath"
"strings"
"testing"
"github.com/gohugoio/hugo/media"
- "fmt"
-
"github.com/gohugoio/hugo/output"
)
func TestPageTargetPath(t *testing.T) {
-
pathSpec := newTestPathSpec()
noExtNoDelimMediaType := media.TextType
Kind: KindSection,
Sections: []string{"sect1"},
BaseName: "_index",
- Type: output.HTMLFormat}, TargetPaths{TargetFilename: "/sect1/index.html", SubResourceBaseTarget: "/sect1", Link: "/sect1/"}},
+ Type: output.HTMLFormat,
+ }, TargetPaths{TargetFilename: "/sect1/index.html", SubResourceBaseTarget: "/sect1", Link: "/sect1/"}},
{"HTML taxonomy term", TargetPathDescriptor{
Kind: KindTerm,
Sections: []string{"tags", "hugo"},
BaseName: "_index",
- Type: output.HTMLFormat}, TargetPaths{TargetFilename: "/tags/hugo/index.html", SubResourceBaseTarget: "/tags/hugo", Link: "/tags/hugo/"}},
+ Type: output.HTMLFormat,
+ }, TargetPaths{TargetFilename: "/tags/hugo/index.html", SubResourceBaseTarget: "/tags/hugo", Link: "/tags/hugo/"}},
{"HTML taxonomy", TargetPathDescriptor{
Kind: KindTaxonomy,
Sections: []string{"tags"},
BaseName: "_index",
- Type: output.HTMLFormat}, TargetPaths{TargetFilename: "/tags/index.html", SubResourceBaseTarget: "/tags", Link: "/tags/"}},
+ Type: output.HTMLFormat,
+ }, TargetPaths{TargetFilename: "/tags/index.html", SubResourceBaseTarget: "/tags", Link: "/tags/"}},
{
"HTML page", TargetPathDescriptor{
Kind: KindPage,
Dir: "/a/b",
BaseName: "mypage",
Sections: []string{"a"},
- Type: output.HTMLFormat}, TargetPaths{TargetFilename: "/a/b/mypage/index.html", SubResourceBaseTarget: "/a/b/mypage", Link: "/a/b/mypage/"}},
+ Type: output.HTMLFormat,
+ }, TargetPaths{TargetFilename: "/a/b/mypage/index.html", SubResourceBaseTarget: "/a/b/mypage", Link: "/a/b/mypage/"},
+ },
{
"HTML page with index as base", TargetPathDescriptor{
Dir: "/a/b",
BaseName: "index",
Sections: []string{"a"},
- Type: output.HTMLFormat}, TargetPaths{TargetFilename: "/a/b/index.html", SubResourceBaseTarget: "/a/b", Link: "/a/b/"}},
+ Type: output.HTMLFormat,
+ }, TargetPaths{TargetFilename: "/a/b/index.html", SubResourceBaseTarget: "/a/b", Link: "/a/b/"},
+ },
{
"HTML page with special chars", TargetPathDescriptor{
Kind: KindPage,
Dir: "/a/b",
BaseName: "My Page!",
- Type: output.HTMLFormat}, TargetPaths{TargetFilename: "/a/b/my-page/index.html", SubResourceBaseTarget: "/a/b/my-page", Link: "/a/b/my-page/"}},
+ Type: output.HTMLFormat,
+ }, TargetPaths{TargetFilename: "/a/b/my-page/index.html", SubResourceBaseTarget: "/a/b/my-page", Link: "/a/b/my-page/"},
+ },
{"RSS home", TargetPathDescriptor{Kind: "rss", Type: output.RSSFormat}, TargetPaths{TargetFilename: "/index.xml", SubResourceBaseTarget: "", Link: "/index.xml"}},
{"RSS section list", TargetPathDescriptor{
Kind: "rss",
Sections: []string{"sect1"},
- Type: output.RSSFormat}, TargetPaths{TargetFilename: "/sect1/index.xml", SubResourceBaseTarget: "/sect1", Link: "/sect1/index.xml"}},
+ Type: output.RSSFormat,
+ }, TargetPaths{TargetFilename: "/sect1/index.xml", SubResourceBaseTarget: "/sect1", Link: "/sect1/index.xml"}},
{
"AMP page", TargetPathDescriptor{
Kind: KindPage,
Dir: "/a/b/c",
BaseName: "myamp",
- Type: output.AMPFormat}, TargetPaths{TargetFilename: "/amp/a/b/c/myamp/index.html", SubResourceBaseTarget: "/amp/a/b/c/myamp", Link: "/amp/a/b/c/myamp/"}},
+ Type: output.AMPFormat,
+ }, TargetPaths{TargetFilename: "/amp/a/b/c/myamp/index.html", SubResourceBaseTarget: "/amp/a/b/c/myamp", Link: "/amp/a/b/c/myamp/"},
+ },
{
"AMP page with URL with suffix", TargetPathDescriptor{
Kind: KindPage,
Dir: "/sect/",
BaseName: "mypage",
URL: "/some/other/url.xhtml",
- Type: output.HTMLFormat}, TargetPaths{TargetFilename: "/some/other/url.xhtml", SubResourceBaseTarget: "/some/other", Link: "/some/other/url.xhtml"}},
+ Type: output.HTMLFormat,
+ }, TargetPaths{TargetFilename: "/some/other/url.xhtml", SubResourceBaseTarget: "/some/other", Link: "/some/other/url.xhtml"},
+ },
{
"JSON page with URL without suffix", TargetPathDescriptor{
Kind: KindPage,
Dir: "/sect/",
BaseName: "mypage",
URL: "/some/other/path/",
- Type: output.JSONFormat}, TargetPaths{TargetFilename: "/some/other/path/index.json", SubResourceBaseTarget: "/some/other/path", Link: "/some/other/path/index.json"}},
+ Type: output.JSONFormat,
+ }, TargetPaths{TargetFilename: "/some/other/path/index.json", SubResourceBaseTarget: "/some/other/path", Link: "/some/other/path/index.json"},
+ },
{
"JSON page with URL without suffix and no trailing slash", TargetPathDescriptor{
Kind: KindPage,
Dir: "/sect/",
BaseName: "mypage",
URL: "/some/other/path",
- Type: output.JSONFormat}, TargetPaths{TargetFilename: "/some/other/path/index.json", SubResourceBaseTarget: "/some/other/path", Link: "/some/other/path/index.json"}},
+ Type: output.JSONFormat,
+ }, TargetPaths{TargetFilename: "/some/other/path/index.json", SubResourceBaseTarget: "/some/other/path", Link: "/some/other/path/index.json"},
+ },
{
"HTML page with URL without suffix and no trailing slash", TargetPathDescriptor{
Kind: KindPage,
Dir: "/sect/",
BaseName: "mypage",
URL: "/some/other/path",
- Type: output.HTMLFormat}, TargetPaths{TargetFilename: "/some/other/path/index.html", SubResourceBaseTarget: "/some/other/path", Link: "/some/other/path/"}},
+ Type: output.HTMLFormat,
+ }, TargetPaths{TargetFilename: "/some/other/path/index.html", SubResourceBaseTarget: "/some/other/path", Link: "/some/other/path/"},
+ },
{
"HTML page with URL containing double hyphen", TargetPathDescriptor{
Kind: KindPage,
Dir: "/sect/",
BaseName: "mypage",
URL: "/some/other--url/",
- Type: output.HTMLFormat}, TargetPaths{TargetFilename: "/some/other--url/index.html", SubResourceBaseTarget: "/some/other--url", Link: "/some/other--url/"}},
+ Type: output.HTMLFormat,
+ }, TargetPaths{TargetFilename: "/some/other--url/index.html", SubResourceBaseTarget: "/some/other--url", Link: "/some/other--url/"},
+ },
{
"HTML page with expanded permalink", TargetPathDescriptor{
Kind: KindPage,
Dir: "/a/b",
BaseName: "mypage",
ExpandedPermalink: "/2017/10/my-title/",
- Type: output.HTMLFormat}, TargetPaths{TargetFilename: "/2017/10/my-title/index.html", SubResourceBaseTarget: "/2017/10/my-title", Link: "/2017/10/my-title/"}},
+ Type: output.HTMLFormat,
+ }, TargetPaths{TargetFilename: "/2017/10/my-title/index.html", SubResourceBaseTarget: "/2017/10/my-title", Link: "/2017/10/my-title/"},
+ },
{
"Paginated HTML home", TargetPathDescriptor{
Kind: KindHome,
BaseName: "_index",
Type: output.HTMLFormat,
- Addends: "page/3"}, TargetPaths{TargetFilename: "/page/3/index.html", SubResourceBaseTarget: "/page/3", Link: "/page/3/"}},
+ Addends: "page/3",
+ }, TargetPaths{TargetFilename: "/page/3/index.html", SubResourceBaseTarget: "/page/3", Link: "/page/3/"},
+ },
{
"Paginated Taxonomy terms list", TargetPathDescriptor{
Kind: KindTerm,
BaseName: "_index",
Sections: []string{"tags", "hugo"},
Type: output.HTMLFormat,
- Addends: "page/3"}, TargetPaths{TargetFilename: "/tags/hugo/page/3/index.html", SubResourceBaseTarget: "/tags/hugo/page/3", Link: "/tags/hugo/page/3/"}},
+ Addends: "page/3",
+ }, TargetPaths{TargetFilename: "/tags/hugo/page/3/index.html", SubResourceBaseTarget: "/tags/hugo/page/3", Link: "/tags/hugo/page/3/"},
+ },
{
"Regular page with addend", TargetPathDescriptor{
Kind: KindPage,
Dir: "/a/b",
BaseName: "mypage",
Addends: "c/d/e",
- Type: output.HTMLFormat}, TargetPaths{TargetFilename: "/a/b/mypage/c/d/e/index.html", SubResourceBaseTarget: "/a/b/mypage/c/d/e", Link: "/a/b/mypage/c/d/e/"}},
+ Type: output.HTMLFormat,
+ }, TargetPaths{TargetFilename: "/a/b/mypage/c/d/e/index.html", SubResourceBaseTarget: "/a/b/mypage/c/d/e", Link: "/a/b/mypage/c/d/e/"},
+ },
}
for i, test := range tests {
t.Run(fmt.Sprintf("langPrefixPath=%s,langPrefixLink=%s,uglyURLs=%t,name=%s", langPrefixPath, langPrefixLink, uglyURLs, test.name),
func(t *testing.T) {
-
test.d.ForcePrefix = true
test.d.PathSpec = pathSpec
test.d.UglyURLs = uglyURLs
if !eqTargetPaths(pagePath, expected) {
t.Fatalf("[%d] [%s] targetPath expected\n%#v, got:\n%#v", i, test.name, expected, pagePath)
-
}
})
}
}
-
}
}
}
d TargetPathDescriptor
expected TargetPaths
}{
- {"URL set, prefix both, no force", TargetPathDescriptor{Kind: KindPage, Type: output.JSONFormat, URL: "/mydir/my.json", ForcePrefix: false, PrefixFilePath: "pf", PrefixLink: "pl"},
- TargetPaths{TargetFilename: "/mydir/my.json", SubResourceBaseTarget: "/mydir", SubResourceBaseLink: "/mydir", Link: "/mydir/my.json"}},
- {"URL set, prefix both, force", TargetPathDescriptor{Kind: KindPage, Type: output.JSONFormat, URL: "/mydir/my.json", ForcePrefix: true, PrefixFilePath: "pf", PrefixLink: "pl"},
- TargetPaths{TargetFilename: "/pf/mydir/my.json", SubResourceBaseTarget: "/pf/mydir", SubResourceBaseLink: "/pl/mydir", Link: "/pl/mydir/my.json"}},
+ {
+ "URL set, prefix both, no force",
+ TargetPathDescriptor{Kind: KindPage, Type: output.JSONFormat, URL: "/mydir/my.json", ForcePrefix: false, PrefixFilePath: "pf", PrefixLink: "pl"},
+ TargetPaths{TargetFilename: "/mydir/my.json", SubResourceBaseTarget: "/mydir", SubResourceBaseLink: "/mydir", Link: "/mydir/my.json"},
+ },
+ {
+ "URL set, prefix both, force",
+ TargetPathDescriptor{Kind: KindPage, Type: output.JSONFormat, URL: "/mydir/my.json", ForcePrefix: true, PrefixFilePath: "pf", PrefixLink: "pl"},
+ TargetPaths{TargetFilename: "/pf/mydir/my.json", SubResourceBaseTarget: "/pf/mydir", SubResourceBaseLink: "/pl/mydir", Link: "/pl/mydir/my.json"},
+ },
}
for i, test := range tests {
}
})
}
-
}
func eqTargetPaths(p1, p2 TargetPaths) bool {
-
if p1.Link != p2.Link {
return false
}
package page
import (
+ "html/template"
+
"github.com/gohugoio/hugo/common/hugo"
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/hugofs"
- "html/template"
)
// NewDeprecatedWarningPage adds deprecation warnings to the given implementation.
helpers.Deprecated("Page.Filename", "Use .File.Filename", false)
return p.p.Filename()
}
+
func (p *pageDeprecated) Dir() string {
helpers.Deprecated("Page.Dir", "Use .File.Dir", false)
return p.p.Dir()
}
+
func (p *pageDeprecated) IsDraft() bool {
helpers.Deprecated("Page.IsDraft", "Use .Draft.", false)
return p.p.IsDraft()
}
+
func (p *pageDeprecated) Extension() string {
helpers.Deprecated("Page.Extension", "Use .File.Extension", false)
return p.p.Extension()
}
+
func (p *pageDeprecated) Hugo() hugo.Info {
helpers.Deprecated("Page.Hugo", "Use the global hugo function.", false)
return p.p.Hugo()
}
+
func (p *pageDeprecated) Ext() string {
helpers.Deprecated("Page.Ext", "Use .File.Ext", false)
return p.p.Ext()
}
+
func (p *pageDeprecated) LanguagePrefix() string {
helpers.Deprecated("Page.LanguagePrefix", "Use .Site.LanguagePrefix.", false)
return p.p.LanguagePrefix()
}
+
func (p *pageDeprecated) GetParam(arg0 string) interface{} {
helpers.Deprecated("Page.GetParam", "Use .Param or .Params.myParam.", false)
return p.p.GetParam(arg0)
}
+
func (p *pageDeprecated) LogicalName() string {
helpers.Deprecated("Page.LogicalName", "Use .File.LogicalName", false)
return p.p.LogicalName()
}
+
func (p *pageDeprecated) BaseFileName() string {
helpers.Deprecated("Page.BaseFileName", "Use .File.BaseFileName", false)
return p.p.BaseFileName()
}
+
func (p *pageDeprecated) RSSLink() template.URL {
helpers.Deprecated("Page.RSSLink", "Use the Output Format's link, e.g. something like: \n {{ with .OutputFormats.Get \"RSS\" }}{{ .RelPermalink }}{{ end }}", false)
return p.p.RSSLink()
}
+
func (p *pageDeprecated) TranslationBaseName() string {
helpers.Deprecated("Page.TranslationBaseName", "Use .File.TranslationBaseName", false)
return p.p.TranslationBaseName()
}
+
func (p *pageDeprecated) URL() string {
helpers.Deprecated("Page.URL", "Use .Permalink or .RelPermalink. If what you want is the front matter URL value, use .Params.url", false)
return p.p.URL()
}
+
func (p *pageDeprecated) ContentBaseName() string {
helpers.Deprecated("Page.ContentBaseName", "Use .File.ContentBaseName", false)
return p.p.ContentBaseName()
}
+
func (p *pageDeprecated) UniqueID() string {
helpers.Deprecated("Page.UniqueID", "Use .File.UniqueID", false)
return p.p.UniqueID()
}
+
func (p *pageDeprecated) FileInfo() hugofs.FileMetaInfo {
helpers.Deprecated("Page.FileInfo", "Use .File.FileInfo", false)
return p.p.FileInfo()
}
return p.Pages.ProbablyEq(otherP.Pages)
-
}
// Slice is not meant to be used externally. It's a bridge function
}
return true
-
}
// ToPagesGroup tries to convert seq into a PagesGroup.
c.Assert(err, qt.IsNil)
c.Assert(groups[0].Key, qt.Equals, testStr)
-
}
func TestGroupByParamCalledWithSomeUnavailableParams(t *testing.T) {
PageURLs *URLPath
}
-var (
- dateFieldAliases = map[string][]string{
- fmDate: {},
- fmLastmod: {"modified"},
- fmPubDate: {"pubdate", "published"},
- fmExpiryDate: {"unpublishdate"},
- }
-)
+var dateFieldAliases = map[string][]string{
+ fmDate: {},
+ fmLastmod: {"modified"},
+ fmPubDate: {"pubdate", "published"},
+ fmExpiryDate: {"unpublishdate"},
+}
// HandleDates updates all the dates given the current configuration and the
// supplied front matter params. Note that this requires all lower-case keys
// NewFrontmatterHandler creates a new FrontMatterHandler with the given logger and configuration.
// If no logger is provided, one will be created.
func NewFrontmatterHandler(logger loggers.Logger, cfg config.Provider) (FrontMatterHandler, error) {
-
if logger == nil {
logger = loggers.NewErrorLogger()
}
}
return f.newChainedFrontMatterFieldHandler(handlers...), nil
-
}
type frontmatterFieldHandlers int
)
func TestDateAndSlugFromBaseFilename(t *testing.T) {
-
t.Parallel()
c := qt.New(t)
c.Assert(fc.lastmod, qt.DeepEquals, []string{"d2", ":git", "lastmod", "modified", "date", "publishdate", "pubdate", "published"})
c.Assert(fc.expiryDate, qt.DeepEquals, []string{"d3", "expirydate", "unpublishdate"})
c.Assert(fc.publishDate, qt.DeepEquals, []string{"d4", "publishdate", "pubdate", "published", "date"})
-
}
func TestFrontMatterDatesHandlers(t *testing.T) {
c.Assert(handler.IsDateKey("mydate"), qt.Equals, true)
c.Assert(handler.IsDateKey("publishdate"), qt.Equals, true)
c.Assert(handler.IsDateKey("pubdate"), qt.Equals, true)
-
}
func TestFrontMatterDatesDefaultKeyword(t *testing.T) {
c.Assert(d.Dates.FLastmod.Day(), qt.Equals, 2)
c.Assert(d.Dates.FPublishDate.Day(), qt.Equals, 4)
c.Assert(d.Dates.FExpiryDate.IsZero(), qt.Equals, true)
-
}
func TestExpandDefaultValues(t *testing.T) {
c.Assert(expandDefaultValues([]string{"a", ":default", "d"}, []string{"b", "c"}), qt.DeepEquals, []string{"a", "b", "c", "d"})
c.Assert(expandDefaultValues([]string{"a", "b", "c"}, []string{"a", "b", "c"}), qt.DeepEquals, []string{"a", "b", "c"})
c.Assert(expandDefaultValues([]string{":default", "a", ":default", "d"}, []string{"b", "c"}), qt.DeepEquals, []string{"b", "c", "a", "b", "c", "d"})
-
}
func TestFrontMatterDateFieldHandler(t *testing.T) {
List: Always,
PublishResources: true,
set: true,
- }},
+ },
+ },
{[]interface{}{"true", "false"}, BuildConfig{
Render: Always,
List: Never,
c.Assert(bcfg, eq, test.expect)
}
-
}
}
return pagesCopy, false
-
}
// pagesEqual returns whether p1 and p2 are equal.
"fmt"
)
-var (
- _ pagesLanguageMerger = (*Pages)(nil)
-)
+var _ pagesLanguageMerger = (*Pages)(nil)
type pagesLanguageMerger interface {
MergeByLanguage(other Pages) Pages
c.Assert(w.Prev(w[0].Page), qt.Equals, w[1].Page)
c.Assert(w.Prev(w[1].Page), qt.Equals, w[2].Page)
c.Assert(w.Prev(w[4].Page), qt.IsNil)
-
}
func TestWeightedPagesNext(t *testing.T) {
c.Assert(w.Next(w[0].Page), qt.IsNil)
c.Assert(w.Next(w[1].Page), qt.Equals, w[0].Page)
c.Assert(w.Next(w[4].Page), qt.Equals, w[3].Page)
-
}
}
return result, nil
-
}
// RelatedIndices searches the given indices with the search keywords from the
}
return result, nil
-
}
// RelatedTo searches the given indices with the corresponding values.
}
return p.search(args...)
-
}
func (p Pages) search(args ...types.KeyValues) (Pages, error) {
return p.withInvertedIndex(func(idx *related.InvertedIndex) ([]related.Document, error) {
return idx.SearchKeyValues(args...)
})
-
}
func (p Pages) searchDoc(doc related.Document, indices ...string) (Pages, error) {
}
lessPageLanguage = func(p1, p2 Page) bool {
-
if p1.Language().Weight == p2.Language().Weight {
if p1.Date().Unix() == p2.Date().Unix() {
c := compare.Strings(p1.LinkTitle(), p2.LinkTitle())
//
// This may safely be executed in parallel.
func (p Pages) ByTitle() Pages {
-
const key = "pageSort.ByTitle"
pages, _ := spc.get(key, pageBy(lessPageTitle).Sort, p)
//
// This may safely be executed in parallel.
func (p Pages) ByLinkTitle() Pages {
-
const key = "pageSort.ByLinkTitle"
pages, _ := spc.get(key, pageBy(lessPageLinkTitle).Sort, p)
//
// This may safely be executed in parallel.
func (p Pages) ByDate() Pages {
-
const key = "pageSort.ByDate"
pages, _ := spc.get(key, pageBy(lessPageDate).Sort, p)
//
// This may safely be executed in parallel.
func (p Pages) ByPublishDate() Pages {
-
const key = "pageSort.ByPublishDate"
pages, _ := spc.get(key, pageBy(lessPagePubDate).Sort, p)
//
// This may safely be executed in parallel.
func (p Pages) ByExpiryDate() Pages {
-
const key = "pageSort.ByExpiryDate"
expDate := func(p1, p2 Page) bool {
//
// This may safely be executed in parallel.
func (p Pages) ByLastmod() Pages {
-
const key = "pageSort.ByLastmod"
date := func(p1, p2 Page) bool {
//
// This may safely be executed in parallel.
func (p Pages) ByLength() Pages {
-
const key = "pageSort.ByLength"
length := func(p1, p2 Page) bool {
-
p1l, ok1 := p1.(resource.LengthProvider)
p2l, ok2 := p2.(resource.LengthProvider)
//
// This may safely be executed in parallel.
func (p Pages) ByLanguage() Pages {
-
const key = "pageSort.ByLanguage"
pages, _ := spc.get(key, pageBy(lessPageLanguage).Sort, p)
s2 := cast.ToString(v2)
return compare.LessStrings(s1, s2)
-
}
pages, _ := spc.get(key, pageBy(paramsKeyComparator).Sort, p)
}
return searchPageLinear(p, pages, i)
-
}
// isProbablySorted tests if the pages slice is probably sorted.
c.Assert(idx, qt.Equals, i)
}
}
-
}
func BenchmarkSearchPage(b *testing.B) {
}
for _, variant := range []Variant{
- Variant{"Shuffled", shufflePages, searchPage},
- Variant{"ByWeight", func(pages Pages) Pages {
+ {"Shuffled", shufflePages, searchPage},
+ {"ByWeight", func(pages Pages) Pages {
return pages.ByWeight()
}, searchPage},
- Variant{"ByWeight.Reverse", func(pages Pages) Pages {
+ {"ByWeight.Reverse", func(pages Pages) Pages {
return pages.ByWeight().Reverse()
}, searchPage},
- Variant{"ByDate", func(pages Pages) Pages {
+ {"ByDate", func(pages Pages) Pages {
return pages.ByDate()
}, searchPage},
- Variant{"ByPublishDate", func(pages Pages) Pages {
+ {"ByPublishDate", func(pages Pages) Pages {
return pages.ByPublishDate()
}, searchPage},
- Variant{"ByTitle", func(pages Pages) Pages {
+ {"ByTitle", func(pages Pages) Pages {
return pages.ByTitle()
}, searchPage},
- Variant{"ByTitle Linear", func(pages Pages) Pages {
+ {"ByTitle Linear", func(pages Pages) Pages {
return pages.ByTitle()
}, linearSearch},
} {
c.Assert(isPagesProbablySorted(createSortTestPages(300).ByWeight(), DefaultPageSort), qt.Not(qt.IsNil))
c.Assert(isPagesProbablySorted(createSortTestPages(6), DefaultPageSort), qt.IsNil)
c.Assert(isPagesProbablySorted(createSortTestPages(300).ByTitle(), pageLessFunctions...), qt.Not(qt.IsNil))
-
}
t.Errorf("[%d] sort error", i)
}
}
-
}
func TestLimit(t *testing.T) {
for _, p := range pages {
p.(*testPage).content = ""
}
-
}
func createSortTestPages(num int) Pages {
)
func TestProbablyEq(t *testing.T) {
-
p1, p2, p3 := &testPage{title: "p1"}, &testPage{title: "p2"}, &testPage{title: "p3"}
pages12 := Pages{p1, p2}
pages21 := Pages{p2, p1}
c.Assert(PageGroup{Key: "a", Pages: pages12}.ProbablyEq(PageGroup{Key: "a", Pages: pages12}), qt.Equals, true)
c.Assert(PageGroup{Key: "a", Pages: pages12}.ProbablyEq(PageGroup{Key: "b", Pages: pages12}), qt.Equals, false)
-
})
t.Run("PagesGroup", func(t *testing.T) {
c.Assert(PagesGroup{pg1, pg2}.ProbablyEq(PagesGroup{pg1, pg2}), qt.Equals, true)
c.Assert(PagesGroup{pg1, pg2}.ProbablyEq(PagesGroup{pg2, pg1}), qt.Equals, false)
-
})
-
}
func TestToPages(t *testing.T) {
// page returns the Page with the given index
func (p *Pager) page(index int) (Page, error) {
-
if pages, ok := p.element().(Pages); ok {
if pages != nil && len(pages) > index {
return pages[index], nil
}
func splitPageGroups(pageGroups PagesGroup, size int) []paginatedElement {
-
type keyPage struct {
key interface{}
page Page
}
func Paginate(td TargetPathDescriptor, seq interface{}, pagerSize int) (*Paginator, error) {
-
if pagerSize <= 0 {
return nil, errors.New("'paginate' configuration setting must be positive to paginate")
}
// The motivation behind this is to avoid potential costly reflect.DeepEqual
// when "probably" is good enough.
func probablyEqualPageLists(a1 interface{}, a2 interface{}) bool {
-
if a1 == nil || a2 == nil {
return a1 == a2
}
}
func newPaginatorFromPages(pages Pages, size int, urlFactory paginationURLFactory) (*Paginator, error) {
-
if size <= 0 {
return nil, errors.New("Paginator size must be positive")
}
}
func newPaginatorFromPageGroups(pageGroups PagesGroup, size int, urlFactory paginationURLFactory) (*Paginator, error) {
-
if size <= 0 {
return nil, errors.New("Paginator size must be positive")
}
}
func newPaginationURLFactory(d TargetPathDescriptor) paginationURLFactory {
-
return func(pageNumber int) string {
pathDescriptor := d
var rel string
}
return CreateTargetPaths(pathDescriptor).RelPermalink(d.PathSpec)
-
}
}
lastChunk := chunks[4]
c.Assert(lastChunk.Len(), qt.Equals, 1)
-
}
func TestSplitPageGroups(t *testing.T) {
} else {
t.Fatal("Excepted PageGroup")
}
-
}
func TestPager(t *testing.T) {
first = pag.Pagers()[0].First()
c.Assert(first.PageGroups(), qt.Not(qt.HasLen), 0)
c.Assert(first.Pages(), qt.HasLen, 0)
-
}
func doTestPages(t *testing.T, paginator *Paginator) {
first = paginator.Pagers()[0].First()
c.Assert(first.PageGroups(), qt.HasLen, 0)
c.Assert(first.Pages(), qt.HasLen, 0)
-
}
func doTestPagerNoPages(t *testing.T, paginator *Paginator) {
c.Assert(pageOne.TotalPages(), qt.Equals, 0)
c.Assert(pageOne.PageNumber(), qt.Equals, 1)
c.Assert(pageOne.PageSize(), qt.Equals, 5)
-
}
func TestPaginationURLFactory(t *testing.T) {
for _, uglyURLs := range []bool{false, true} {
c.Run(fmt.Sprintf("uglyURLs=%t", uglyURLs), func(c *qt.C) {
-
tests := []struct {
name string
d TargetPathDescriptor
expected string
expectedUgly string
}{
- {"HTML home page 32",
- TargetPathDescriptor{Kind: KindHome, Type: output.HTMLFormat}, "http://example.com/", 32, "/zoo/32/", "/zoo/32.html"},
- {"JSON home page 42",
- TargetPathDescriptor{Kind: KindHome, Type: output.JSONFormat}, "http://example.com/", 42, "/zoo/42/index.json", "/zoo/42.json"},
+ {
+ "HTML home page 32",
+ TargetPathDescriptor{Kind: KindHome, Type: output.HTMLFormat},
+ "http://example.com/", 32, "/zoo/32/", "/zoo/32.html",
+ },
+ {
+ "JSON home page 42",
+ TargetPathDescriptor{Kind: KindHome, Type: output.JSONFormat},
+ "http://example.com/", 42, "/zoo/42/index.json", "/zoo/42.json",
+ },
}
for _, test := range tests {
}
})
-
}
}
if result != this.expect {
t.Errorf("[%d] got %t but expected %t", i, result, this.expect)
-
}
}
}
// NewPermalinkExpander creates a new PermalinkExpander configured by the given
// PathSpec.
func NewPermalinkExpander(ps *helpers.PathSpec) (PermalinkExpander, error) {
-
p := PermalinkExpander{ps: ps}
p.knownPermalinkAttributes = map[string]pageToPermaAttribute{
}
return expand(p)
-
}
func (l PermalinkExpander) parse(patterns map[string]string) (map[string]func(Page) (string, error), error) {
-
expanders := make(map[string]func(Page) (string, error))
// Allow " " and / to represent the root section.
}
expanders[k] = func(p Page) (string, error) {
-
if matches == nil {
return pattern, nil
}
attr := replacement[1:]
callback := callbacks[i]
newAttr, err := callback(p, attr)
-
if err != nil {
return "", &permalinkExpandError{pattern: pattern, err: err}
}
}
return newField, nil
-
}
}
// validate determines if a PathPattern is well-formed
func (l PermalinkExpander) validate(pp string) bool {
fragments := strings.Split(pp[1:], "/")
- var bail = false
+ bail := false
for i := range fragments {
if bail {
return false
expanded, err = expander.Expand("blog", page)
c.Assert(err, qt.IsNil)
c.Assert(expanded, qt.Equals, "/blue/2012")
-
}
func TestPermalinkExpansionConcurrent(t *testing.T) {
func (p *testPage) Author() Author {
return Author{}
-
}
+
func (p *testPage) Authors() AuthorList {
return nil
}
func (p *testPage) Layout() string {
return ""
}
+
func (p *testPage) Date() time.Time {
return p.date
}
"github.com/gohugoio/hugo/common/collections"
)
-var (
- _ collections.Slicer = WeightedPage{}
-)
+var _ collections.Slicer = WeightedPage{}
// WeightedPages is a list of Pages with their corresponding (and relative) weight
// [{Weight: 30, Page: *1}, {Weight: 40, Page: *2}]
z.log.Println(".File.Path on zero object. Wrap it in if or with: {{ with .File }}{{ .Path }}{{ end }}")
return
}
+
func (z zeroFile) Section() (o0 string) {
z.log.Println(".File.Section on zero object. Wrap it in if or with: {{ with .File }}{{ .Section }}{{ end }}")
return
}
+
func (z zeroFile) Lang() (o0 string) {
z.log.Println(".File.Lang on zero object. Wrap it in if or with: {{ with .File }}{{ .Lang }}{{ end }}")
return
}
+
func (z zeroFile) Filename() (o0 string) {
z.log.Println(".File.Filename on zero object. Wrap it in if or with: {{ with .File }}{{ .Filename }}{{ end }}")
return
}
+
func (z zeroFile) Dir() (o0 string) {
z.log.Println(".File.Dir on zero object. Wrap it in if or with: {{ with .File }}{{ .Dir }}{{ end }}")
return
}
+
func (z zeroFile) Extension() (o0 string) {
z.log.Println(".File.Extension on zero object. Wrap it in if or with: {{ with .File }}{{ .Extension }}{{ end }}")
return
}
+
func (z zeroFile) Ext() (o0 string) {
z.log.Println(".File.Ext on zero object. Wrap it in if or with: {{ with .File }}{{ .Ext }}{{ end }}")
return
}
+
func (z zeroFile) LogicalName() (o0 string) {
z.log.Println(".File.LogicalName on zero object. Wrap it in if or with: {{ with .File }}{{ .LogicalName }}{{ end }}")
return
}
+
func (z zeroFile) BaseFileName() (o0 string) {
z.log.Println(".File.BaseFileName on zero object. Wrap it in if or with: {{ with .File }}{{ .BaseFileName }}{{ end }}")
return
}
+
func (z zeroFile) TranslationBaseName() (o0 string) {
z.log.Println(".File.TranslationBaseName on zero object. Wrap it in if or with: {{ with .File }}{{ .TranslationBaseName }}{{ end }}")
return
}
+
func (z zeroFile) ContentBaseName() (o0 string) {
z.log.Println(".File.ContentBaseName on zero object. Wrap it in if or with: {{ with .File }}{{ .ContentBaseName }}{{ end }}")
return
}
+
func (z zeroFile) UniqueID() (o0 string) {
z.log.Println(".File.UniqueID on zero object. Wrap it in if or with: {{ with .File }}{{ .UniqueID }}{{ end }}")
return
}
+
func (z zeroFile) FileInfo() (o0 hugofs.FileMetaInfo) {
z.log.Println(".File.FileInfo on zero object. Wrap it in if or with: {{ with .File }}{{ .FileInfo }}{{ end }}")
return
// insert placeholder for the templates. Do it very shallow for now.
func insertFieldPlaceholders(root string, m map[string]interface{}, createPlaceholder func(s string) string) {
- for k, _ := range m {
+ for k := range m {
m[k] = createPlaceholder(root + "." + k)
}
}
"SubType": "pre_foo.SubType_post",
"Suffixes": "pre_foo.Suffixes_post",
})
-
}
default:
panic(fmt.Sprintf("unknown field accessor %q", fieldAccessor))
}
-
}
func (r *PostPublishResource) fieldToString(receiver interface{}, path string) string {
defer fw.Close()
_, err = io.Copy(fw, fr)
-
})
return err
// returns an opened file or nil if nothing to write (it may already be published).
func (l *genericResource) openDestinationsForWriting() (w io.WriteCloser, err error) {
-
l.publishInit.Do(func() {
targetFilenames := l.getTargetFilenames()
var changedFilenames []string
}
w, err = helpers.OpenFilesForWriting(l.getSpec().BaseFs.PublishFs, changedFilenames...)
-
})
return
-
}
func (r *genericResource) openPublishFileForWriting(relTargetPath string) (io.WriteCloser, error) {
}
return maps.GetNestedParam(keyStr, ".", r.Params(), fallback)
-
}
// Commonly used aliases and directory names used for some types.
var extAliasKeywords = map[string][]string{
- "sass": []string{"scss"},
- "scss": []string{"sass"},
+ "sass": {"scss"},
+ "scss": {"sass"},
}
// ResourceKeyPartitions resolves a ordered slice of partitions that is
c.set(key, r)
return r, nil
-
}
func (c *ResourceCache) getFilenames(key string) (string, string) {
fi, rc, _ := c.fileCache.Get(filenameContent)
return fi, rc, meta, rc != nil
-
}
// writeMeta writes the metadata to file and returns a writer for the content part.
fi, fc, err := c.fileCache.WriteCloser(filenameContent)
return fi, fc, err
-
}
func (c *ResourceCache) set(key string, r interface{}) {
delete(c.cache, k)
}
}
-
}
func (c *ResourceCache) DeleteMatches(re *regexp.Regexp) {
if re.MatchString(k) {
delete(c.cache, k)
}
-
}
-
}
}
return newMultiReadSeekCloser(rcsources...), nil
-
}
composite, err := c.rs.New(
Fs: c.rs.FileCaches.AssetsCache().Fs,
LazyPublish: true,
OpenReadSeekCloser: concatr,
- RelTargetFilename: filepath.Clean(targetPath)})
-
+ RelTargetFilename: filepath.Clean(targetPath),
+ })
if err != nil {
return nil, err
}
return composite, nil
})
-
}
_, err := rc.Seek(0, 0)
c.Assert(err, qt.IsNil)
}
-
}
return c.rs.New(resources.ResourceSourceDescriptor{
Fs: c.rs.BaseFs.Assets.Fs,
LazyPublish: true,
- SourceFilename: filename})
+ SourceFilename: filename,
+ })
})
-
}
// Match gets the resources matching the given pattern from the assets filesystem.
OpenReadSeekCloser: func() (hugio.ReadSeekCloser, error) {
return meta.Open()
},
- RelTargetFilename: meta.Path()})
-
+ RelTargetFilename: meta.Path(),
+ })
if err != nil {
return true, err
}
res = append(res, r)
return firstOnly, nil
-
}
if err := hugofs.Glob(c.rs.BaseFs.Assets.Fs, pattern, handle); err != nil {
}
return res, nil
-
})
}
OpenReadSeekCloser: func() (hugio.ReadSeekCloser, error) {
return hugio.NewReadSeekerNoOpCloserFromString(content), nil
},
- RelTargetFilename: filepath.Clean(targetPath)})
-
+ RelTargetFilename: filepath.Clean(targetPath),
+ })
})
-
}
import (
"fmt"
"strconv"
+ "strings"
"github.com/gohugoio/hugo/hugofs/glob"
"github.com/gohugoio/hugo/media"
"github.com/pkg/errors"
"github.com/spf13/cast"
- "strings"
-
"github.com/gohugoio/hugo/common/maps"
)
c.Assert(logo1.Title(), qt.Equals, "My Resource")
c.Assert(logo1.Name(), qt.Equals, "My Name")
c.Assert(foo2.Name(), qt.Equals, "My Name")
-
}},
{[]map[string]interface{}{
{
c.Assert(foo2.Name(), qt.Equals, "My Name")
c.Assert(foo3.Name(), qt.Equals, "My Name")
c.Assert(foo3.Title(), qt.Equals, "My Resource")
-
}},
{[]map[string]interface{}{
{
c.Assert(icon1, qt.Equals, "logo")
c.Assert(icon2, qt.Equals, "resource")
-
}},
{[]map[string]interface{}{
{
c.Assert(foo3.Title(), qt.Equals, "Resource #5")
c.Assert(resources.GetMatch("logo name #1*"), qt.Equals, logo2)
-
}},
{[]map[string]interface{}{
{
c.Assert(logo2.Name(), qt.Equals, "Name #1")
c.Assert(logo1.Title(), qt.Equals, "Other Logo #2")
c.Assert(logo1.Name(), qt.Equals, "Name #2")
-
}},
{[]map[string]interface{}{
{
c.Assert(logo2.Name(), qt.Equals, "Name #1")
c.Assert(logo1.Title(), qt.Equals, "Other Logo #2")
c.Assert(logo1.Name(), qt.Equals, "Name #2")
-
}},
{[]map[string]interface{}{
{
c.Assert(logo2.Name(), qt.Equals, "Name #1")
c.Assert(logo1.Title(), qt.Equals, "Logo #2")
c.Assert(logo1.Name(), qt.Equals, "Name #2")
-
}},
{[]map[string]interface{}{
{
}, func(err error) {
// Missing src
c.Assert(err, qt.Not(qt.IsNil))
-
}},
{[]map[string]interface{}{
{
}, func(err error) {
// Invalid pattern
c.Assert(err, qt.Not(qt.IsNil))
-
}},
} {
this.assertFunc(AssignMetadata(this.metaData, resources...))
}
-
}
errorHandler herrors.ErrorSender,
outputFormats output.Formats,
mimeTypes media.Types) (*Spec, error) {
-
imgConfig, err := images.DecodeConfig(s.Cfg.GetStringMap("imaging"))
if err != nil {
return nil, err
fileCaches.ImageCache(),
s,
- )}
+ ),
+ }
rs.ResourceCache = newResourceCache(rs)
return rs, nil
-
}
type Spec struct {
baseFilename,
mediaType,
)
-
}
func (r *Spec) newGenericResourceWithBase(
sourceFilename,
baseFilename string,
mediaType media.Type) *genericResource {
-
if osFileInfo != nil && osFileInfo.IsDir() {
panic(fmt.Sprintf("dirs not supported resource types: %v", osFileInfo))
}
}
return g
-
}
func (r *Spec) newResource(sourceFs afero.Fs, fd ResourceSourceDescriptor) (resource.Resource, error) {
}
return newResourceAdapter(gr.spec, fd.LazyPublish, gr), nil
-
}
func (r *Spec) newResourceFor(fd ResourceSourceDescriptor) (resource.Resource, error) {
c.Assert(r.Permalink(), qt.Equals, "https://example.com/foo.css")
c.Assert(r.RelPermalink(), qt.Equals, "/foo.css")
c.Assert(r.ResourceType(), qt.Equals, "css")
-
}
func TestGenericResourceWithLinkFacory(t *testing.T) {
c.Assert(err, qt.IsNil)
c.Assert(r, qt.Not(qt.IsNil))
c.Assert(r.ResourceType(), qt.Equals, "json")
-
}
func TestNewResourceFromFilenameSubPathInBaseURL(t *testing.T) {
c.Assert(r.ResourceType(), qt.Equals, "image")
c.Assert(r.RelPermalink(), qt.Equals, "/docs/a/b/logo.png")
c.Assert(r.Permalink(), qt.Equals, "https://example.com/docs/a/b/logo.png")
-
}
var pngType, _ = media.FromStringAndExt("image/png", "png")
spec.newGenericResource(nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType),
spec.newGenericResource(nil, nil, nil, "/a/logo.png", "logo.css", pngType),
spec.newGenericResource(nil, nil, nil, "/a/foo2.css", "foo2.css", media.CSSType),
- spec.newGenericResource(nil, nil, nil, "/a/foo3.css", "foo3.css", media.CSSType)}
+ spec.newGenericResource(nil, nil, nil, "/a/foo3.css", "foo3.css", media.CSSType),
+ }
c.Assert(len(resources.ByType("css")), qt.Equals, 3)
c.Assert(len(resources.ByType("image")), qt.Equals, 1)
-
}
func TestResourcesGetByPrefix(t *testing.T) {
spec.newGenericResource(nil, nil, nil, "/a/logo1.png", "logo1.png", pngType),
spec.newGenericResource(nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType),
spec.newGenericResource(nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType),
- spec.newGenericResource(nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType)}
+ spec.newGenericResource(nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType),
+ }
c.Assert(resources.GetMatch("asdf*"), qt.IsNil)
c.Assert(resources.GetMatch("logo*").RelPermalink(), qt.Equals, "/logo1.png")
c.Assert(logo.Params(), qt.Not(qt.IsNil))
c.Assert(logo.Name(), qt.Equals, "logo1.png")
c.Assert(logo.Title(), qt.Equals, "logo1.png")
-
}
func TestResourcesGetMatch(t *testing.T) {
// (it is possible for users to do a rename)
// This is analogous to standing in a directory and doing "ls *.*".
c.Assert(len(resources.Match("/c/**.css")), qt.Equals, 0)
-
}
func BenchmarkResourcesMatch(b *testing.B) {
for i := 0; i < b.N; i++ {
resources.Match(pattern)
}
-
}
func benchResources(b *testing.B) resource.Resources {
}
return resources
-
}
func BenchmarkAssignMetadata(b *testing.B) {
for i := 0; i < b.N; i++ {
b.StopTimer()
var resources resource.Resources
- var meta = []map[string]interface{}{
+ meta := []map[string]interface{}{
{
"title": "Foo #:counter",
"name": "Foo Name #:counter",
err = mapstructure.WeakDecode(m, &opts)
return
}
+
func (opts Options) toArgs() []string {
var args []string
// Try PATH
binary = binaryName
if _, err := exec.LookPath(binary); err != nil {
-
// This may be on a CI server etc. Will fall back to pre-built assets.
return herrors.ErrFeatureNotAvailable
}
// Transform creates a MD5 hash of the Resource content and inserts that hash before
// the extension in the filename.
func (t *fingerprintTransformation) Transform(ctx *resources.ResourceTransformationCtx) error {
-
h, err := newHash(t.algo)
if err != nil {
return err
)
func TestHashFromAlgo(t *testing.T) {
-
for _, algo := range []struct {
name string
bits int
{"sha512", 512},
{"shaman", -1},
} {
-
t.Run(algo.name, func(t *testing.T) {
c := qt.New(t)
h, err := newHash(algo.name)
c.Assert(err, qt.Not(qt.IsNil))
c.Assert(err.Error(), qt.Contains, "use either md5, sha256, sha384 or sha512")
}
-
})
}
}
build.OnResolve(api.OnResolveOptions{Filter: `.*`},
func(args api.OnResolveArgs) (api.OnResolveResult, error) {
return resolveImport(args)
-
})
build.OnLoad(api.OnLoadOptions{Filter: `.*`, Namespace: nsImportHugo},
func(args api.OnLoadArgs) (api.OnLoadResult, error) {
b, err := ioutil.ReadFile(args.Path)
-
if err != nil {
return api.OnLoadResult{}, errors.Wrapf(err, "failed to read %q", args.Path)
}
}
return []api.Plugin{importResolver, paramsPlugin}, nil
-
}
func toBuildOptions(opts Options) (buildOptions api.BuildOptions, err error) {
-
var target api.Target
switch opts.Target {
case "", "esnext":
}
// By default we only need to specify outDir and no outFile
- var outDir = opts.outDir
- var outFile = ""
+ outDir := opts.outDir
+ outFile := ""
var sourceMap api.SourceMap
switch opts.SourceMap {
case "inline":
},
}
return
-
}
opts, err = toBuildOptions(Options{
Target: "es2018", Format: "cjs", Minify: true, mediaType: media.JavascriptType,
- SourceMap: "inline"})
+ SourceMap: "inline",
+ })
c.Assert(err, qt.IsNil)
c.Assert(opts, qt.DeepEquals, api.BuildOptions{
Bundle: true,
opts, err = toBuildOptions(Options{
Target: "es2018", Format: "cjs", Minify: true, mediaType: media.JavascriptType,
- SourceMap: "inline"})
+ SourceMap: "inline",
+ })
c.Assert(err, qt.IsNil)
c.Assert(opts, qt.DeepEquals, api.BuildOptions{
Bundle: true,
Loader: api.LoaderJS,
},
})
-
}
content, err := transformed.(resource.ContentProvider).Content()
c.Assert(err, qt.IsNil)
c.Assert(content, qt.Equals, "<h1>Hugo Rocks!</h1>")
-
}
"encoding/hex"
"io"
"io/ioutil"
+ "os/exec"
"path"
"path/filepath"
"regexp"
"github.com/gohugoio/hugo/hugofs"
"github.com/pkg/errors"
- "os/exec"
-
"github.com/mitchellh/mapstructure"
"github.com/gohugoio/hugo/common/herrors"
// npm install -g postcss-cli
// npm install -g autoprefixer
func (t *postcssTransformation) Transform(ctx *resources.ResourceTransformationCtx) error {
-
const localPostCSSPath = "node_modules/.bin/"
const binaryName = "postcss"
if configFile == "" && t.options.Config != "" {
// Only fail if the user specificed config file is not found.
return errors.Errorf("postcss config %q not found:", configFile)
-
}
}
lineNum int,
content string,
inPath string) (int, string, error) {
-
basePath := path.Dir(inPath)
var replacements []string
}
return strings.NewReader(newContent), nil
-
}
// See https://www.w3schools.com/cssref/pr_import_rule.asp
c.Assert(err, qt.IsNil)
c.Assert(opts2.NoMap, qt.Equals, true)
-
}
func TestShouldImport(t *testing.T) {
Offset: 1,
Filename: "d.css",
})
-
}
func BenchmarkImportResolver(b *testing.B) {
reverted := replaceRegularImportsOut(res)
c.Assert(reverted, qt.Equals, scssWithImport)
-
}
// more correct for the main entry path (main.scss typically), but
// it will mess up the import mappings. As a workaround, we do a replacement
// in the source map itself (see below).
- //options.InputPath = inputPath
+ // options.InputPath = inputPath
options.to.SourceMapOptions.OutputPath = outName
options.to.SourceMapOptions.Contents = true
options.to.SourceMapOptions.OmitURL = false
package resources
import (
- "path/filepath"
- "testing"
-
"image"
"io"
"io/ioutil"
"os"
+ "path/filepath"
"runtime"
"strings"
+ "testing"
"github.com/gohugoio/hugo/langs"
"github.com/gohugoio/hugo/modules"
cfg.Set("allModules", modules.Modules{mod})
return cfg
-
}
func newTestResourceSpec(desc specDescriptor) *Spec {
-
baseURL := desc.baseURL
if baseURL == "" {
baseURL = "https://example.com/"
c.Assert(err, qt.IsNil)
return spec, workDir
-
}
func fetchSunset(c *qt.C) resource.Image {
r.spec.Logger.Errorf("Failed to publish Resource: %s", r.publisherErr)
}
})
-
}
func (r *resourceAdapter) TransformationKey() string {
}
newErr := func(err error) error {
-
msg := fmt.Sprintf("%s: failed to transform %q (%s)", strings.ToUpper(tr.Key().Name), tctx.InPath, tctx.InMediaType.Type())
if err == herrors.ErrFeatureNotAvailable {
}
return errors.Wrap(err, msg)
-
}
var tryFileCache bool
resizedNotPublished, err := img.Resize("50x50")
c.Assert(err, qt.IsNil)
c.Assert(resizedNotPublished.Height(), qt.Equals, 50)
- //c.Assert(resized.RelPermalink(), qt.Equals, "/gopher.changed_hu2e827f5a78333ebc04166dd643235dea_1462_50x50_resize_linear_2.png")
+ // c.Assert(resized.RelPermalink(), qt.Equals, "/gopher.changed_hu2e827f5a78333ebc04166dd643235dea_1462_50x50_resize_linear_2.png")
assertShouldExist(c, spec, "public/gopher.changed_hu2e827f5a78333ebc04166dd643235dea_1462_50x50_resize_linear_2.png", false)
assertNoDuplicateWrites(c, spec)
-
})
c.Run("Concurrent", func(c *qt.C) {
goimports(htmlRoot)
gofmt(forkRoot)
-
}
const (
}
return content
-
}
var goPackages = []goPackage{
- goPackage{srcPkg: "text/template", dstPkg: "texttemplate",
- replacer: func(name, content string) string { return textTemplateReplacers.Replace(commonReplace(name, content)) }},
- goPackage{srcPkg: "html/template", dstPkg: "htmltemplate", replacer: func(name, content string) string {
- if strings.HasSuffix(name, "content.go") {
- // Remove template.HTML types. We need to use the Go types.
- content = removeAll(`(?s)// Strings of content.*?\)\n`, content)
- }
+ {
+ srcPkg: "text/template", dstPkg: "texttemplate",
+ replacer: func(name, content string) string { return textTemplateReplacers.Replace(commonReplace(name, content)) },
+ },
+ {
+ srcPkg: "html/template", dstPkg: "htmltemplate", replacer: func(name, content string) string {
+ if strings.HasSuffix(name, "content.go") {
+ // Remove template.HTML types. We need to use the Go types.
+ content = removeAll(`(?s)// Strings of content.*?\)\n`, content)
+ }
- content = commonReplace(name, content)
+ content = commonReplace(name, content)
- return htmlTemplateReplacers.Replace(content)
- },
+ return htmlTemplateReplacers.Replace(content)
+ },
rewriter: func(name string) {
for _, s := range []string{"CSS", "HTML", "HTMLAttr", "JS", "JSStr", "URL", "Srcset"} {
rewrite(name, fmt.Sprintf("%s -> htmltemplate.%s", s, s))
}
rewrite(name, `"text/template/parse" -> "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate/parse"`)
- }},
- goPackage{srcPkg: "internal/fmtsort", dstPkg: "fmtsort", rewriter: func(name string) {
+ },
+ },
+ {srcPkg: "internal/fmtsort", dstPkg: "fmtsort", rewriter: func(name string) {
rewrite(name, `"internal/fmtsort" -> "github.com/gohugoio/hugo/tpl/internal/go_templates/fmtsort"`)
}},
- goPackage{srcPkg: "internal/testenv", dstPkg: "testenv",
+ {
+ srcPkg: "internal/testenv", dstPkg: "testenv",
replacer: func(name, content string) string { return testEnvReplacers.Replace(content) }, rewriter: func(name string) {
rewrite(name, `"internal/testenv" -> "github.com/gohugoio/hugo/tpl/internal/go_templates/testenv"`)
- }},
- goPackage{srcPkg: "internal/cfg", dstPkg: "cfg", rewriter: func(name string) {
+ },
+ },
+ {srcPkg: "internal/cfg", dstPkg: "cfg", rewriter: func(name string) {
rewrite(name, `"internal/cfg" -> "github.com/gohugoio/hugo/tpl/internal/go_templates/cfg"`)
}},
}
func removeAll(expression, content string) string {
re := regexp.MustCompile(expression)
return re.ReplaceAllString(content, "")
-
}
func rewrite(filename, rule string) {
}
func (sp *SourceSpec) NewFileInfo(fi hugofs.FileMetaInfo) (*FileInfo, error) {
-
m := fi.Meta()
filename := m.Filename()
}
return f, nil
-
}
c.Assert(f.Section(), qt.Equals, "b")
c.Assert(f.TranslationBaseName(), qt.Equals, filepath.FromSlash("page"))
c.Assert(f.BaseFileName(), qt.Equals, filepath.FromSlash("page"))
-
}},
{filepath.FromSlash("/a/"), filepath.FromSlash("/a/b/c/d/page.md"), func(f *FileInfo) {
c.Assert(f.Section(), qt.Equals, "b")
-
}},
{filepath.FromSlash("/a/"), filepath.FromSlash("/a/b/page.en.MD"), func(f *FileInfo) {
c.Assert(f.Section(), qt.Equals, "b")
c.Assert(f.Path(), qt.Equals, filepath.FromSlash("b/page.en.MD"))
c.Assert(f.TranslationBaseName(), qt.Equals, filepath.FromSlash("page"))
c.Assert(f.BaseFileName(), qt.Equals, filepath.FromSlash("page.en"))
-
}},
} {
path := strings.TrimPrefix(this.filename, this.base)
c.Assert(err, qt.IsNil)
this.assert(f)
}
-
}
})
return w.Walk()
-
}
func (f *Filesystem) shouldRead(filename string, fi hugofs.FileMetaInfo) (bool, error) {
-
ignore := f.SourceSpec.IgnoreFile(fi.Meta().Filename())
if fi.IsDir() {
t.Fatalf("file %q name in NFD form should be normalized (%s)", f.BaseFileName(), path.NFC)
}
}
-
}
func newTestConfig() *viper.Viper {
}
return &SourceSpec{ignoreFilesRe: regexps, PathSpec: ps, SourceFs: fs, Languages: languages, DefaultContentLanguage: defaultLang, DisabledLanguages: disabledLangsSet}
-
}
// IgnoreFile returns whether a given file should be ignored.
import (
"html/template"
-
"testing"
qt "github.com/frankban/quicktest"
}
return docshelper.DocProvider{"tpl": map[string]interface{}{"funcs": namespaces}}
-
}
docshelper.AddDocProviderFunc(docsProvider)
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
c.Assert(found, qt.Equals, true)
c.Assert(ns.Context(), hqt.IsSameType, &Namespace{})
-
}
from := args[:len(args)-1]
return collections.Append(to, from...)
-
}
{"", []interface{}{[]string{"a", "b"}}, false},
{[]string{"a", "b"}, []interface{}{}, false},
// No string concatenation.
- {"ab",
+ {
+ "ab",
[]interface{}{"c"},
- false},
+ false,
+ },
} {
errMsg := qt.Commentf("[%d]", i)
t.Fatalf("%s got\n%T: %v\nexpected\n%T: %v", errMsg, result, result, test.expected, test.expected)
}
}
-
}
vv := seqv.Index(i)
vvv, err := applyFnToThis(fnv, vv, args...)
-
if err != nil {
return nil, err
}
package collections
import (
+ "fmt"
"io"
"reflect"
"testing"
- "fmt"
-
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/output"
}
return reflect.ValueOf(fmt.Sprint), true
-
}
func TestApply(t *testing.T) {
if err == nil {
t.Errorf("apply with unknown func should fail")
}
-
}
import (
"fmt"
"html/template"
-
"math/rand"
"net/url"
"reflect"
return nil, errors.New("invalid arguments to Seq")
}
- var inc = 1
+ inc := 1
var last int
- var first = intArgs[0]
+ first := intArgs[0]
if len(intArgs) == 1 {
last = first
}
func (i *intersector) appendIfNotSeen(v reflect.Value) {
-
vi := v.Interface()
if !i.seen[vi] {
i.r = reflect.Append(i.r, v)
}
return slice.Interface(), nil
-
}
// KeyVals creates a key and values wrapper.
"errors"
"fmt"
"html/template"
-
"math/rand"
"reflect"
"testing"
}{
{[]interface{}{"a", "b"}, map[string]interface{}{"a": "b"}},
{[]interface{}{[]string{"a", "b"}, "c"}, map[string]interface{}{"a": map[string]interface{}{"b": "c"}}},
- {[]interface{}{[]string{"a", "b"}, "c", []string{"a", "b2"}, "c2", "b", "c"},
- map[string]interface{}{"a": map[string]interface{}{"b": "c", "b2": "c2"}, "b": "c"}},
+ {
+ []interface{}{[]string{"a", "b"}, "c", []string{"a", "b2"}, "c2", "b", "c"},
+ map[string]interface{}{"a": map[string]interface{}{"b": "c", "b2": "c2"}, "b": "c"},
+ },
{[]interface{}{"a", 12, "b", []int{4}}, map[string]interface{}{"a": 12, "b": []int{4}}},
// errors
{[]interface{}{5, "b"}, false},
c.Assert(reversed, qt.IsNil)
_, err = ns.Reverse(43)
c.Assert(err, qt.Not(qt.IsNil))
-
}
func TestEchoParam(t *testing.T) {
return "p-" + p.Title
}
-type pagesPtr []*testPage
-type pagesVals []testPage
+type (
+ pagesPtr []*testPage
+ pagesVals []testPage
+)
var (
p1 = &testPage{"A"}
c.Assert(result, qt.DeepEquals, test.expected, errMsg)
}
-
}
func TestUnion(t *testing.T) {
func (x TstParams) Params() maps.Params {
return x.params
-
}
type TstXIHolder struct {
{"error", []interface{}{[]string{"c", "d"}, []string{"a", "b"}}, false},
{[]string{"a", "b", "c"}, []interface{}{[][]string{{"c", "d"}}}, false},
{
- []interface{}{[][]string{{"c", "d"}}}, []interface{}{[]string{"c", "d"}, []string{"a", "b"}},
+ []interface{}{[][]string{{"c", "d"}}},
+ []interface{}{[]string{"c", "d"}, []string{"a", "b"}},
[]interface{}{[][]string{{"c", "d"}}},
},
} {
c.Assert(err, qt.Not(qt.IsNil))
_, err = ns.Complement([]string{"a", "b"})
c.Assert(err, qt.Not(qt.IsNil))
-
}
{[]int{0, 1}, []interface{}{nil}, nil, true},
{tstNoStringer{}, []interface{}{0}, nil, true},
} {
-
c.Run(fmt.Sprint(i), func(c *qt.C) {
errMsg := qt.Commentf("[%d] %v", i, test)
map[string]interface{}{"a": 42, "c": 3},
map[string]interface{}{"a": 1, "b": 2},
},
- map[string]interface{}{"a": 1, "b": 2, "c": 3}, false,
+ map[string]interface{}{"a": 1, "b": 2, "c": 3},
+ false,
},
{
"multi",
map[string]interface{}{"a": 1, "b": 2},
map[string]interface{}{"a": 9, "c": 4, "d": 7},
},
- map[string]interface{}{"a": 9, "b": 2, "c": 4, "d": 7, "e": 11}, false,
+ map[string]interface{}{"a": 9, "b": 2, "c": 4, "d": 7, "e": 11},
+ false,
},
{
"basic case insensitive",
map[string]interface{}{"A": 42, "c": 3},
map[string]interface{}{"a": 1, "b": 2},
},
- map[string]interface{}{"a": 1, "b": 2, "c": 3}, false,
+ map[string]interface{}{"a": 1, "b": 2, "c": 3},
+ false,
},
{
"nested",
map[string]interface{}{"a": 42, "c": 3, "b": map[string]interface{}{"d": 55, "e": 66, "f": 3}},
map[string]interface{}{"a": 1, "b": map[string]interface{}{"d": 1, "e": 2}},
},
- map[string]interface{}{"a": 1, "b": map[string]interface{}{"d": 1, "e": 2, "f": 3}, "c": 3}, false,
+ map[string]interface{}{"a": 1, "b": map[string]interface{}{"d": 1, "e": 2, "f": 3}, "c": 3},
+ false,
},
{
// https://github.com/gohugoio/hugo/issues/6633
map[string]interface{}{"a": 42, "c": 3},
maps.Params{"a": 1, "b": 2},
},
- maps.Params{"a": int(1), "b": int(2), "c": int(3)}, false,
+ maps.Params{"a": int(1), "b": int(2), "c": int(3)},
+ false,
},
{
"params dst, upper case src",
map[string]interface{}{"a": 42, "C": 3},
maps.Params{"a": 1, "b": 2},
},
- maps.Params{"a": int(1), "b": int(2), "c": int(3)}, false,
+ maps.Params{"a": int(1), "b": int(2), "c": int(3)},
+ false,
},
{
"params src",
maps.Params{"a": 42, "c": 3},
map[string]interface{}{"a": 1, "c": 2},
},
- map[string]interface{}{"a": int(1), "c": int(2)}, false,
+ map[string]interface{}{"a": int(1), "c": int(2)},
+ false,
},
{
"params src, upper case dst",
maps.Params{"a": 42, "c": 3},
map[string]interface{}{"a": 1, "C": 2},
},
- map[string]interface{}{"a": int(1), "C": int(2)}, false,
+ map[string]interface{}{"a": int(1), "C": int(2)},
+ false,
},
{
"nested, params dst",
map[string]interface{}{"a": 42, "c": 3, "b": map[string]interface{}{"d": 55, "e": 66, "f": 3}},
maps.Params{"a": 1, "b": maps.Params{"d": 1, "e": 2}},
},
- maps.Params{"a": 1, "b": maps.Params{"d": 1, "e": 2, "f": 3}, "c": 3}, false,
+ maps.Params{"a": 1, "b": maps.Params{"d": 1, "e": 2, "f": 3}, "c": 3},
+ false,
},
{
// https://github.com/gohugoio/hugo/issues/7899
map[string]interface{}{"k": "v"},
map[string]interface{}{"k": map[string]interface{}{"k2": "v2"}},
},
- map[string]interface{}{"k": map[string]interface{}{"k2": "v2"}}, false,
+ map[string]interface{}{"k": map[string]interface{}{"k2": "v2"}},
+ false,
},
{"src nil", []interface{}{nil, simpleMap}, simpleMap, false},
// Error cases.
}
return n, nil
-
}
func newSliceElement(items interface{}) interface{} {
},
{nil, nil, "asc", false},
} {
-
t.Run(fmt.Sprintf("test%d", i), func(t *testing.T) {
var result interface{}
var err error
}
}
})
-
}
}
}
return slice.Interface(), nil
-
}
c.Assert(err, qt.Not(qt.IsNil))
_, err = ns.Complement([]string{"a", "b"})
c.Assert(err, qt.Not(qt.IsNil))
-
}
}
return testVariants
-
}
for i, test := range []testt{
},
key: "B", match: "b2",
expect: []maps.Params{
- maps.Params{"a": "a2", "b": "b2"},
+ {"a": "a2", "b": "b2"},
},
},
{
seq: []maps.Params{
- maps.Params{
+ {
"a": map[string]interface{}{
"b": "b1",
},
},
- maps.Params{
+ {
"a": map[string]interface{}{
"b": "b2",
},
},
key: "A.B", match: "b2",
expect: []maps.Params{
- maps.Params{
+ {
"a": map[string]interface{}{
"b": "b2",
},
NonEmptyInterfaceTypedNil: (*T)(nil),
}
-type tstEqerType1 string
-type tstEqerType2 string
+type (
+ tstEqerType1 string
+ tstEqerType2 string
+)
func (t tstEqerType2) Eq(other interface{}) bool {
return cast.ToString(t) == cast.ToString(other)
c.Assert(n.Eq("az", "az"), qt.Equals, true)
c.Assert(n.Eq("az", stringType("az")), qt.Equals, true)
-
}
func TestStringType(t *testing.T) {
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
// New returns a new instance of the data-namespaced template functions.
func New(deps *deps.Deps) *Namespace {
-
return &Namespace{
deps: deps,
cacheGetCSV: deps.FileCaches.GetCSVCache(),
if _, ok := test.expect.(bool); ok {
c.Assert(int(ns.deps.Log.LogCounters().ErrorCounter.Count()), qt.Equals, 1)
- //c.Assert(err, msg, qt.Not(qt.IsNil))
+ // c.Assert(err, msg, qt.Not(qt.IsNil))
c.Assert(got, qt.IsNil)
continue
}
if _, ok := test.expect.(bool); ok {
c.Assert(int(ns.deps.Log.LogCounters().ErrorCounter.Count()), qt.Equals, 1)
- //c.Assert(err, msg, qt.Not(qt.IsNil))
+ // c.Assert(err, msg, qt.Not(qt.IsNil))
continue
}
}
return nil, err
-
})
if !handled {
}
return afero.ReadFile(fs, filename)
-
}
// getResource loads the content of a local or remote file and returns its content and the
t.Errorf("\nExpected: %s\nActual: %s\n", string(test.content), string(c))
}
}
-
}
func getTestServer(handler func(w http.ResponseWriter, r *http.Request)) (*httptest.Server, *http.Client) {
// Printf returns a formatted string representation of the passed arguments.
func (ns *Namespace) Printf(format string, a ...interface{}) string {
return _fmt.Sprintf(format, a...)
-
}
// Println returns string representation of the passed arguments ending with a newline.
func init() {
f := func(d *deps.Deps) *internal.TemplateFuncsNamespace {
-
h := d.Site.Hugo()
ns := &internal.TemplateFuncsNamespace{
// We just add the Hugo struct as the namespace here. No method mappings.
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
import (
"fmt"
- "github.com/gohugoio/hugo/tpl/internal/go_templates/fmtsort"
"math"
"reflect"
"strings"
"testing"
+
+ "github.com/gohugoio/hugo/tpl/internal/go_templates/fmtsort"
)
var compareTests = [][]reflect.Value{
if err := tmpl.Execute(b, s); err != nil {
t.Fatal(err)
}
- var expect = "string=3"
+ expect := "string=3"
if b.String() != expect {
t.Errorf("expected %q got %q", expect, b.String())
}
'}': `\7d`,
}
-var expressionBytes = []byte("expression")
-var mozBindingBytes = []byte("mozbinding")
+var (
+ expressionBytes = []byte("expression")
+ mozBindingBytes = []byte("mozbinding")
+)
// cssValueFilter allows innocuous CSS values in the output including CSS
// quantities (10px or 25%), ID or class literals (#foo, .bar), keyword values
t.Errorf("want\n\t%q\ngot\n\t%q", test.want, got)
}
}
-
}
func TestErrors(t *testing.T) {
// Check that we get the same error if we call Execute again.
if err := tmpl.Execute(buf, nil); err == nil || err.Error() != got {
t.Errorf("input=%q: unexpected error on second call %q", test.input, err)
-
}
}
}
// <div><strong>no rows</strong></div>
// </body>
// </html>
-
}
func Example_autoescaping() {
// \"Fran \u0026 Freddie\'s Diner\" \u003Ctasty@example.com\u003E
// \"Fran \u0026 Freddie\'s Diner\"32\u003Ctasty@example.com\u003E
// %22Fran+%26+Freddie%27s+Diner%2232%3Ctasty%40example.com%3E
-
}
func ExampleTemplate_Delims() {
'<': `\u003c`,
'>': `\u003e`,
}
+
var jsRegexpReplacementTable = []string{
0: `\u0000`,
'\t': `\t`,
{"<!--", `\u003c!--`},
{"-->", `--\u003e`},
// From https://code.google.com/p/doctype/wiki/ArticleUtf7
- {"+ADw-script+AD4-alert(1)+ADw-/script+AD4-",
+ {
+ "+ADw-script+AD4-alert(1)+ADw-/script+AD4-",
`\u002bADw-script\u002bAD4-alert(1)\u002bADw-\/script\u002bAD4-`,
},
// Invalid UTF-8 sequence
stateError: tError,
}
-var commentStart = []byte("<!--")
-var commentEnd = []byte("-->")
+var (
+ commentStart = []byte("<!--")
+ commentEnd = []byte("-->")
+)
// tText is the context transition function for the text state.
func tText(c context, s []byte) (context, int) {
}
func BenchmarkTemplateSpecialTags(b *testing.B) {
-
r := struct {
Name, Gift string
}{"Aunt Mildred", "bone china tea set"}
import (
"errors"
"flag"
- "github.com/gohugoio/hugo/tpl/internal/go_templates/cfg"
"os"
"os/exec"
"path/filepath"
"strings"
"sync"
"testing"
+
+ "github.com/gohugoio/hugo/tpl/internal/go_templates/cfg"
)
// Builder reports the name of the builder running this test
"syscall"
)
-var symlinkOnce sync.Once
-var winSymlinkErr error
+var (
+ symlinkOnce sync.Once
+ winSymlinkErr error
+)
func initWinHasSymlink() {
tmpdir, err := ioutil.TempDir("", "symtest")
Name, Gift string
Attended bool
}
- var recipients = []Recipient{
+ recipients := []Recipient{
{"Aunt Mildred", "bone china tea set", true},
{"Uncle John", "moleskin pants", false},
{"Cousin Rodney", "", false},
import (
"fmt"
- "github.com/gohugoio/hugo/tpl/internal/go_templates/fmtsort"
- "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate/parse"
"io"
"reflect"
"runtime"
"strings"
+
+ "github.com/gohugoio/hugo/tpl/internal/go_templates/fmtsort"
+ "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate/parse"
)
// maxExecDepth specifies the maximum stack depth of templates within
{"$.U.V", "{{$.U.V}}", "v", tVal, true},
{"declare in action", "{{$x := $.U.V}}{{$x}}", "v", tVal, true},
{"simple assignment", "{{$x := 2}}{{$x = 3}}{{$x}}", "3", tVal, true},
- {"nested assignment",
+ {
+ "nested assignment",
"{{$x := 2}}{{if true}}{{$x = 3}}{{end}}{{$x}}",
- "3", tVal, true},
- {"nested assignment changes the last declaration",
+ "3", tVal, true,
+ },
+ {
+ "nested assignment changes the last declaration",
"{{$x := 1}}{{if true}}{{$x := 2}}{{if true}}{{$x = 3}}{{end}}{{end}}{{$x}}",
- "1", tVal, true},
+ "1", tVal, true,
+ },
// Type with String method.
{"V{6666}.String()", "-{{.V0}}-", "-<6666>-", tVal, true},
{".Method3(nil constant)", "-{{.Method3 nil}}-", "-Method3: <nil>-", tVal, true},
{".Method3(nil value)", "-{{.Method3 .MXI.unset}}-", "-Method3: <nil>-", tVal, true},
{"method on var", "{{if $x := .}}-{{$x.Method2 .U16 $x.X}}{{end}}-", "-Method2: 16 x-", tVal, true},
- {"method on chained var",
+ {
+ "method on chained var",
"{{range .MSIone}}{{if $.U.TrueFalse $.True}}{{$.U.TrueFalse $.True}}{{else}}WRONG{{end}}{{end}}",
- "true", tVal, true},
- {"chained method",
+ "true", tVal, true,
+ },
+ {
+ "chained method",
"{{range .MSIone}}{{if $.GetU.TrueFalse $.True}}{{$.U.TrueFalse $.True}}{{else}}WRONG{{end}}{{end}}",
- "true", tVal, true},
- {"chained method on variable",
+ "true", tVal, true,
+ },
+ {
+ "chained method on variable",
"{{with $x := .}}{{with .SI}}{{$.GetU.TrueFalse $.True}}{{end}}{{end}}",
- "true", tVal, true},
+ "true", tVal, true,
+ },
{".NilOKFunc not nil", "{{call .NilOKFunc .PI}}", "false", tVal, true},
{".NilOKFunc nil", "{{call .NilOKFunc nil}}", "true", tVal, true},
{"method on nil value from slice", "-{{range .}}{{.Method1 1234}}{{end}}-", "-1234-", tSliceOfNil, true},
{"printf lots", `{{printf "%d %s %g %s" 127 "hello" 7-3i .Method0}}`, "127 hello (7-3i) M0", tVal, true},
// HTML.
- {"html", `{{html "<script>alert(\"XSS\");</script>"}}`,
- "<script>alert("XSS");</script>", nil, true},
- {"html pipeline", `{{printf "<script>alert(\"XSS\");</script>" | html}}`,
- "<script>alert("XSS");</script>", nil, true},
+ {
+ "html", `{{html "<script>alert(\"XSS\");</script>"}}`,
+ "<script>alert("XSS");</script>", nil, true,
+ },
+ {
+ "html pipeline", `{{printf "<script>alert(\"XSS\");</script>" | html}}`,
+ "<script>alert("XSS");</script>", nil, true,
+ },
{"html", `{{html .PS}}`, "a string", tVal, true},
{"html typed nil", `{{html .NIL}}`, "<nil>", tVal, true},
{"html untyped nil", `{{html .Empty0}}`, "<no value>", tVal, true},
func TestDelims(t *testing.T) {
const hello = "Hello, world"
- var value = struct{ Str string }{hello}
+ value := struct{ Str string }{hello}
for i := 0; i < len(delimPairs); i += 2 {
text := ".Str"
left := delimPairs[i+0]
if err != nil {
t.Fatalf("delim %q text %q parse err %s", left, text, err)
}
- var b = new(bytes.Buffer)
+ b := new(bytes.Buffer)
err = tmpl.Execute(b, value)
if err != nil {
t.Fatalf("delim %q exec err %s", left, err)
`
func TestTree(t *testing.T) {
- var tree = &Tree{
+ tree := &Tree{
1,
&Tree{
2, &Tree{
func TestComparison(t *testing.T) {
b := new(bytes.Buffer)
- var cmpStruct = struct {
+ cmpStruct := struct {
Uthree, Ufour uint
NegOne, Three int
Ptr, NilPtr *int
}
return tmpl.executeWithState(state, value)
-
}
// Prepare returns a template ready for execution.
c.Assert(got, qt.Contains, "hello hugo")
c.Assert(got, qt.Contains, "Map: av")
c.Assert(got, qt.Contains, "Method: v2 v1")
-
}
import (
"bytes"
"fmt"
- "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate/parse"
"testing"
+
+ "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate/parse"
)
const (
}
var multiParseTests = []multiParseTest{
- {"empty", "", noError,
+ {
+ "empty", "", noError,
nil,
- nil},
- {"one", `{{define "foo"}} FOO {{end}}`, noError,
+ nil,
+ },
+ {
+ "one", `{{define "foo"}} FOO {{end}}`, noError,
[]string{"foo"},
- []string{" FOO "}},
- {"two", `{{define "foo"}} FOO {{end}}{{define "bar"}} BAR {{end}}`, noError,
+ []string{" FOO "},
+ },
+ {
+ "two", `{{define "foo"}} FOO {{end}}{{define "bar"}} BAR {{end}}`, noError,
[]string{"foo", "bar"},
- []string{" FOO ", " BAR "}},
+ []string{" FOO ", " BAR "},
+ },
// errors
- {"missing end", `{{define "foo"}} FOO `, hasError,
+ {
+ "missing end", `{{define "foo"}} FOO `, hasError,
+ nil,
+ nil,
+ },
+ {
+ "malformed name", `{{define "foo}} FOO `, hasError,
nil,
- nil},
- {"malformed name", `{{define "foo}} FOO `, hasError,
nil,
- nil},
+ },
}
func TestMultiParse(t *testing.T) {
// by the contents of "stylesheet", but if the internal map associating
// names with templates is built in the wrong order, the empty block
// looks non-empty and this doesn't happen.
- var inlined = map[string]string{
+ inlined := map[string]string{
"stylesheet": `{{define "stylesheet"}}stylesheet{{end}}`,
"xhtml": `{{block "stylesheet" .}}{{end}}`,
}
func (a *ActionNode) Copy() Node {
return a.tr.newAction(a.Pos, a.Line, a.Pipe.CopyPipe())
-
}
// CommandNode holds a command (a pipeline inside an evaluating action).
var next Node
list, next = t.itemList()
switch next.Type() {
- case nodeEnd: //done
+ case nodeEnd: // done
case nodeElse:
if allowElseIf {
// Special case for "else if". If the "else" is followed immediately by an "if",
)
var parseTests = []parseTest{
- {"empty", "", noError,
- ``},
- {"comment", "{{/*\n\n\n*/}}", noError,
- ``},
- {"spaces", " \t\n", noError,
- `" \t\n"`},
- {"text", "some text", noError,
- `"some text"`},
- {"emptyAction", "{{}}", hasError,
- `{{}}`},
- {"field", "{{.X}}", noError,
- `{{.X}}`},
- {"simple command", "{{printf}}", noError,
- `{{printf}}`},
- {"$ invocation", "{{$}}", noError,
- "{{$}}"},
- {"variable invocation", "{{with $x := 3}}{{$x 23}}{{end}}", noError,
- "{{with $x := 3}}{{$x 23}}{{end}}"},
- {"variable with fields", "{{$.I}}", noError,
- "{{$.I}}"},
- {"multi-word command", "{{printf `%d` 23}}", noError,
- "{{printf `%d` 23}}"},
- {"pipeline", "{{.X|.Y}}", noError,
- `{{.X | .Y}}`},
- {"pipeline with decl", "{{$x := .X|.Y}}", noError,
- `{{$x := .X | .Y}}`},
- {"nested pipeline", "{{.X (.Y .Z) (.A | .B .C) (.E)}}", noError,
- `{{.X (.Y .Z) (.A | .B .C) (.E)}}`},
- {"field applied to parentheses", "{{(.Y .Z).Field}}", noError,
- `{{(.Y .Z).Field}}`},
- {"simple if", "{{if .X}}hello{{end}}", noError,
- `{{if .X}}"hello"{{end}}`},
- {"if with else", "{{if .X}}true{{else}}false{{end}}", noError,
- `{{if .X}}"true"{{else}}"false"{{end}}`},
- {"if with else if", "{{if .X}}true{{else if .Y}}false{{end}}", noError,
- `{{if .X}}"true"{{else}}{{if .Y}}"false"{{end}}{{end}}`},
- {"if else chain", "+{{if .X}}X{{else if .Y}}Y{{else if .Z}}Z{{end}}+", noError,
- `"+"{{if .X}}"X"{{else}}{{if .Y}}"Y"{{else}}{{if .Z}}"Z"{{end}}{{end}}{{end}}"+"`},
- {"simple range", "{{range .X}}hello{{end}}", noError,
- `{{range .X}}"hello"{{end}}`},
- {"chained field range", "{{range .X.Y.Z}}hello{{end}}", noError,
- `{{range .X.Y.Z}}"hello"{{end}}`},
- {"nested range", "{{range .X}}hello{{range .Y}}goodbye{{end}}{{end}}", noError,
- `{{range .X}}"hello"{{range .Y}}"goodbye"{{end}}{{end}}`},
- {"range with else", "{{range .X}}true{{else}}false{{end}}", noError,
- `{{range .X}}"true"{{else}}"false"{{end}}`},
- {"range over pipeline", "{{range .X|.M}}true{{else}}false{{end}}", noError,
- `{{range .X | .M}}"true"{{else}}"false"{{end}}`},
- {"range []int", "{{range .SI}}{{.}}{{end}}", noError,
- `{{range .SI}}{{.}}{{end}}`},
- {"range 1 var", "{{range $x := .SI}}{{.}}{{end}}", noError,
- `{{range $x := .SI}}{{.}}{{end}}`},
- {"range 2 vars", "{{range $x, $y := .SI}}{{.}}{{end}}", noError,
- `{{range $x, $y := .SI}}{{.}}{{end}}`},
- {"constants", "{{range .SI 1 -3.2i true false 'a' nil}}{{end}}", noError,
- `{{range .SI 1 -3.2i true false 'a' nil}}{{end}}`},
- {"template", "{{template `x`}}", noError,
- `{{template "x"}}`},
- {"template with arg", "{{template `x` .Y}}", noError,
- `{{template "x" .Y}}`},
- {"with", "{{with .X}}hello{{end}}", noError,
- `{{with .X}}"hello"{{end}}`},
- {"with with else", "{{with .X}}hello{{else}}goodbye{{end}}", noError,
- `{{with .X}}"hello"{{else}}"goodbye"{{end}}`},
+ {
+ "empty", "", noError,
+ ``,
+ },
+ {
+ "comment", "{{/*\n\n\n*/}}", noError,
+ ``,
+ },
+ {
+ "spaces", " \t\n", noError,
+ `" \t\n"`,
+ },
+ {
+ "text", "some text", noError,
+ `"some text"`,
+ },
+ {
+ "emptyAction", "{{}}", hasError,
+ `{{}}`,
+ },
+ {
+ "field", "{{.X}}", noError,
+ `{{.X}}`,
+ },
+ {
+ "simple command", "{{printf}}", noError,
+ `{{printf}}`,
+ },
+ {
+ "$ invocation", "{{$}}", noError,
+ "{{$}}",
+ },
+ {
+ "variable invocation", "{{with $x := 3}}{{$x 23}}{{end}}", noError,
+ "{{with $x := 3}}{{$x 23}}{{end}}",
+ },
+ {
+ "variable with fields", "{{$.I}}", noError,
+ "{{$.I}}",
+ },
+ {
+ "multi-word command", "{{printf `%d` 23}}", noError,
+ "{{printf `%d` 23}}",
+ },
+ {
+ "pipeline", "{{.X|.Y}}", noError,
+ `{{.X | .Y}}`,
+ },
+ {
+ "pipeline with decl", "{{$x := .X|.Y}}", noError,
+ `{{$x := .X | .Y}}`,
+ },
+ {
+ "nested pipeline", "{{.X (.Y .Z) (.A | .B .C) (.E)}}", noError,
+ `{{.X (.Y .Z) (.A | .B .C) (.E)}}`,
+ },
+ {
+ "field applied to parentheses", "{{(.Y .Z).Field}}", noError,
+ `{{(.Y .Z).Field}}`,
+ },
+ {
+ "simple if", "{{if .X}}hello{{end}}", noError,
+ `{{if .X}}"hello"{{end}}`,
+ },
+ {
+ "if with else", "{{if .X}}true{{else}}false{{end}}", noError,
+ `{{if .X}}"true"{{else}}"false"{{end}}`,
+ },
+ {
+ "if with else if", "{{if .X}}true{{else if .Y}}false{{end}}", noError,
+ `{{if .X}}"true"{{else}}{{if .Y}}"false"{{end}}{{end}}`,
+ },
+ {
+ "if else chain", "+{{if .X}}X{{else if .Y}}Y{{else if .Z}}Z{{end}}+", noError,
+ `"+"{{if .X}}"X"{{else}}{{if .Y}}"Y"{{else}}{{if .Z}}"Z"{{end}}{{end}}{{end}}"+"`,
+ },
+ {
+ "simple range", "{{range .X}}hello{{end}}", noError,
+ `{{range .X}}"hello"{{end}}`,
+ },
+ {
+ "chained field range", "{{range .X.Y.Z}}hello{{end}}", noError,
+ `{{range .X.Y.Z}}"hello"{{end}}`,
+ },
+ {
+ "nested range", "{{range .X}}hello{{range .Y}}goodbye{{end}}{{end}}", noError,
+ `{{range .X}}"hello"{{range .Y}}"goodbye"{{end}}{{end}}`,
+ },
+ {
+ "range with else", "{{range .X}}true{{else}}false{{end}}", noError,
+ `{{range .X}}"true"{{else}}"false"{{end}}`,
+ },
+ {
+ "range over pipeline", "{{range .X|.M}}true{{else}}false{{end}}", noError,
+ `{{range .X | .M}}"true"{{else}}"false"{{end}}`,
+ },
+ {
+ "range []int", "{{range .SI}}{{.}}{{end}}", noError,
+ `{{range .SI}}{{.}}{{end}}`,
+ },
+ {
+ "range 1 var", "{{range $x := .SI}}{{.}}{{end}}", noError,
+ `{{range $x := .SI}}{{.}}{{end}}`,
+ },
+ {
+ "range 2 vars", "{{range $x, $y := .SI}}{{.}}{{end}}", noError,
+ `{{range $x, $y := .SI}}{{.}}{{end}}`,
+ },
+ {
+ "constants", "{{range .SI 1 -3.2i true false 'a' nil}}{{end}}", noError,
+ `{{range .SI 1 -3.2i true false 'a' nil}}{{end}}`,
+ },
+ {
+ "template", "{{template `x`}}", noError,
+ `{{template "x"}}`,
+ },
+ {
+ "template with arg", "{{template `x` .Y}}", noError,
+ `{{template "x" .Y}}`,
+ },
+ {
+ "with", "{{with .X}}hello{{end}}", noError,
+ `{{with .X}}"hello"{{end}}`,
+ },
+ {
+ "with with else", "{{with .X}}hello{{else}}goodbye{{end}}", noError,
+ `{{with .X}}"hello"{{else}}"goodbye"{{end}}`,
+ },
// Trimming spaces.
{"trim left", "x \r\n\t{{- 3}}", noError, `"x"{{3}}`},
{"trim right", "{{3 -}}\n\n\ty", noError, `{{3}}"y"`},
{"comment trim left", "x \r\n\t{{- /* hi */}}", noError, `"x"`},
{"comment trim right", "{{/* hi */ -}}\n\n\ty", noError, `"y"`},
{"comment trim left and right", "x \r\n\t{{- /* */ -}}\n\n\ty", noError, `"x""y"`},
- {"block definition", `{{block "foo" .}}hello{{end}}`, noError,
- `{{template "foo" .}}`},
+ {
+ "block definition", `{{block "foo" .}}hello{{end}}`, noError,
+ `{{template "foo" .}}`,
+ },
// Errors.
{"unclosed action", "hello{{range", hasError, ""},
{"unmatched end", "{{end}}", hasError, ""},
// All failures, and the result is a string that must appear in the error message.
var errorTests = []parseTest{
// Check line numbers are accurate.
- {"unclosed1",
+ {
+ "unclosed1",
"line1\n{{",
- hasError, `unclosed1:2: unexpected unclosed action in command`},
- {"unclosed2",
+ hasError, `unclosed1:2: unexpected unclosed action in command`,
+ },
+ {
+ "unclosed2",
"line1\n{{define `x`}}line2\n{{",
- hasError, `unclosed2:3: unexpected unclosed action in command`},
+ hasError, `unclosed2:3: unexpected unclosed action in command`,
+ },
// Specific errors.
- {"function",
+ {
+ "function",
"{{foo}}",
- hasError, `function "foo" not defined`},
- {"comment",
+ hasError, `function "foo" not defined`,
+ },
+ {
+ "comment",
"{{/*}}",
- hasError, `unclosed comment`},
- {"lparen",
+ hasError, `unclosed comment`,
+ },
+ {
+ "lparen",
"{{.X (1 2 3}}",
- hasError, `unclosed left paren`},
- {"rparen",
+ hasError, `unclosed left paren`,
+ },
+ {
+ "rparen",
"{{.X 1 2 3)}}",
- hasError, `unexpected ")"`},
- {"space",
+ hasError, `unexpected ")"`,
+ },
+ {
+ "space",
"{{`x`3}}",
- hasError, `in operand`},
- {"idchar",
+ hasError, `in operand`,
+ },
+ {
+ "idchar",
"{{a#}}",
- hasError, `'#'`},
- {"charconst",
+ hasError, `'#'`,
+ },
+ {
+ "charconst",
"{{'a}}",
- hasError, `unterminated character constant`},
- {"stringconst",
+ hasError, `unterminated character constant`,
+ },
+ {
+ "stringconst",
`{{"a}}`,
- hasError, `unterminated quoted string`},
- {"rawstringconst",
+ hasError, `unterminated quoted string`,
+ },
+ {
+ "rawstringconst",
"{{`a}}",
- hasError, `unterminated raw quoted string`},
- {"number",
+ hasError, `unterminated raw quoted string`,
+ },
+ {
+ "number",
"{{0xi}}",
- hasError, `number syntax`},
- {"multidefine",
+ hasError, `number syntax`,
+ },
+ {
+ "multidefine",
"{{define `a`}}a{{end}}{{define `a`}}b{{end}}",
- hasError, `multiple definition of template`},
- {"eof",
+ hasError, `multiple definition of template`,
+ },
+ {
+ "eof",
"{{range .X}}",
- hasError, `unexpected EOF`},
- {"variable",
+ hasError, `unexpected EOF`,
+ },
+ {
+ "variable",
// Declare $x so it's defined, to avoid that error, and then check we don't parse a declaration.
"{{$x := 23}}{{with $x.y := 3}}{{$x 23}}{{end}}",
- hasError, `unexpected ":="`},
- {"multidecl",
+ hasError, `unexpected ":="`,
+ },
+ {
+ "multidecl",
"{{$a,$b,$c := 23}}",
- hasError, `too many declarations`},
- {"undefvar",
+ hasError, `too many declarations`,
+ },
+ {
+ "undefvar",
"{{$a}}",
- hasError, `undefined variable`},
- {"wrongdot",
+ hasError, `undefined variable`,
+ },
+ {
+ "wrongdot",
"{{true.any}}",
- hasError, `unexpected . after term`},
- {"wrongpipeline",
+ hasError, `unexpected . after term`,
+ },
+ {
+ "wrongpipeline",
"{{12|false}}",
- hasError, `non executable command in pipeline`},
- {"emptypipeline",
+ hasError, `non executable command in pipeline`,
+ },
+ {
+ "emptypipeline",
`{{ ( ) }}`,
- hasError, `missing value for parenthesized pipeline`},
- {"multilinerawstring",
+ hasError, `missing value for parenthesized pipeline`,
+ },
+ {
+ "multilinerawstring",
"{{ $v := `\n` }} {{",
- hasError, `multilinerawstring:2: unexpected unclosed action`},
- {"rangeundefvar",
+ hasError, `multilinerawstring:2: unexpected unclosed action`,
+ },
+ {
+ "rangeundefvar",
"{{range $k}}{{end}}",
- hasError, `undefined variable`},
- {"rangeundefvars",
+ hasError, `undefined variable`,
+ },
+ {
+ "rangeundefvars",
"{{range $k, $v}}{{end}}",
- hasError, `undefined variable`},
- {"rangemissingvalue1",
+ hasError, `undefined variable`,
+ },
+ {
+ "rangemissingvalue1",
"{{range $k,}}{{end}}",
- hasError, `missing value for range`},
- {"rangemissingvalue2",
+ hasError, `missing value for range`,
+ },
+ {
+ "rangemissingvalue2",
"{{range $k, $v := }}{{end}}",
- hasError, `missing value for range`},
- {"rangenotvariable1",
+ hasError, `missing value for range`,
+ },
+ {
+ "rangenotvariable1",
"{{range $k, .}}{{end}}",
- hasError, `range can only initialize variables`},
- {"rangenotvariable2",
+ hasError, `range can only initialize variables`,
+ },
+ {
+ "rangenotvariable2",
"{{range $k, 123 := .}}{{end}}",
- hasError, `range can only initialize variables`},
+ hasError, `range can only initialize variables`,
+ },
}
func TestErrors(t *testing.T) {
package template
import (
- "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate/parse"
"reflect"
"sync"
+
+ "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate/parse"
)
// common holds the information shared by related templates.
Aliases: aliases,
Examples: examples,
}
-
}
// TemplateFuncMethodMapping represents a mapping of functions to methods for a
}
func (t *TemplateFuncsNamespace) toJSON() ([]byte, error) {
-
var buf bytes.Buffer
godoc := getGetTplPackagesGoDoc()[t.Name]
}
return ns.client.Process(r, m)
-
}
},
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
// Log returns the natural logarithm of a number.
func (ns *Namespace) Log(a interface{}) (float64, error) {
af, err := cast.ToFloat64E(a)
-
if err != nil {
return 0, errors.New("Log operator can't be used with non integer or float value")
}
// NOTE: will return for NaN for negative values of a
func (ns *Namespace) Sqrt(a interface{}) (float64, error) {
af, err := cast.ToFloat64E(a)
-
if err != nil {
return 0, errors.New("Sqrt operator can't be used with non integer or float value")
}
result, err := ns.Sqrt(-1)
c.Assert(err, qt.IsNil)
c.Assert(result, qt.Satisfies, math.IsNaN)
-
}
func TestMod(t *testing.T) {
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
}
func (ns *Namespace) Unmarshal(r resource.UnmarshableResource) (*kopenapi3.Swagger, error) {
-
key := r.Key()
if key == "" {
return nil, errors.New("no Key set in Resource")
return s, err
})
-
if err != nil {
return nil, err
}
return v.(*kopenapi3.Swagger), nil
-
}
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
// New returns a new instance of the os-namespaced template functions.
func New(d *deps.Deps) *Namespace {
-
var rfs afero.Fs
if d.Fs != nil {
rfs = d.Fs.WorkingDir
return "", err
}
b, err := afero.ReadFile(fs, filename)
-
if err != nil {
return "", err
}
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
}
return result, nil
-
}
// IncludeCached executes and caches partial templates. The cache is created with name+variants as the key.
c.Assert(create("a", map[string]string{"a": "av"}), qt.Equals, partialCacheKey{name: "a", variant: "4809626101226749924"})
c.Assert(create("a", []string{"a", "b"}), qt.Equals, partialCacheKey{name: "a", variant: "2712570657419664240"})
}
-
}
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
}
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
filenamestr = filepath.Clean(filenamestr)
return ns.createClient.Get(filenamestr)
-
}
// GetMatch finds the first Resource matching the given pattern, or nil if none found.
}
return ns.createClient.GetMatch(patternStr)
-
}
// Match gets all resources matching the given base path prefix, e.g
func (ns *Namespace) PostProcess(r resource.Resource) (postpub.PostPublishedResource, error) {
return ns.deps.ResourceSpec.PostProcess(r)
-
}
// Babel processes the given Resource with Babel.
}
return ns.babelClient.Process(r, options)
-
}
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
import (
"html/template"
-
"testing"
qt "github.com/frankban/quicktest"
func init() {
f := func(d *deps.Deps) *internal.TemplateFuncsNamespace {
-
s := d.Site
ns := &internal.TemplateFuncsNamespace{
Name: name,
// We just add the Site as the namespace here. No method mappings.
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
"errors"
"html"
"html/template"
-
"regexp"
"unicode"
"unicode/utf8"
import (
"html/template"
-
"reflect"
"strings"
"testing"
if err == nil {
t.Errorf("Should have errored")
}
-
}
package tpl
import (
- "reflect"
-
"io"
+ "reflect"
"regexp"
"github.com/gohugoio/hugo/output"
ns.AddMethodMapping(ctx.Exists,
nil,
- [][2]string{{`{{ if (templates.Exists "partials/header.html") }}Yes!{{ end }}`, `Yes!`},
+ [][2]string{
+ {`{{ if (templates.Exists "partials/header.html") }}Yes!{{ end }}`, `Yes!`},
{`{{ if not (templates.Exists "partials/doesnotexist.html") }}No!{{ end }}`, `No!`},
},
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
func (ns *Namespace) Exists(name string) bool {
_, found := ns.deps.Tmpl().Lookup(name)
return found
-
}
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
)
func main() {
-
templateFolder := filepath.Join("..", "templates")
temlatePath := filepath.Join(".", templateFolder)
fmt.Fprint(file, " ", v, ",\n")
}
fmt.Fprint(file, "}\n")
-
}
func nameValue(name, value string) string {
// calculate a weight for two string slices of same length.
// higher value means "better match".
func (s *shortcodeTemplates) compareVariants(a, b []string) int {
-
weight := 0
k := len(a)
for i, av := range a {
}
func templateNameAndVariants(name string) (string, []string) {
-
variants := make([]string, numTemplateVariants)
parts := strings.Split(name, ".")
)
func TestShortcodesTemplate(t *testing.T) {
-
t.Run("isShortcode", func(t *testing.T) {
c := qt.New(t)
c.Assert(isShortcode("shortcodes/figures.html"), qt.Equals, true)
c.Assert(isShortcode("_internal/shortcodes/figures.html"), qt.Equals, true)
c.Assert(isShortcode("shortcodes\\figures.html"), qt.Equals, false)
c.Assert(isShortcode("myshortcodes"), qt.Equals, false)
-
})
t.Run("variantsFromName", func(t *testing.T) {
name, variants := templateNameAndVariants("figure.html")
c.Assert(name, qt.Equals, "figure")
c.Assert(variants, qt.DeepEquals, []string{"", "html", "html"})
-
})
t.Run("compareVariants", func(t *testing.T) {
w := s.compareVariants(templateVariants(test.name1), templateVariants(test.name2))
c.Assert(w, qt.Equals, test.expected)
}
-
})
t.Run("indexOf", func(t *testing.T) {
c.Assert(s.indexOf([]string{"a", "b", "c"}), qt.Equals, 0)
c.Assert(s.indexOf([]string{"a", "b", "d"}), qt.Equals, 1)
c.Assert(s.indexOf([]string{"a", "b", "x"}), qt.Equals, -1)
-
})
t.Run("Name", func(t *testing.T) {
c.Assert(templateBaseName(templateShortcode, "shortcodes/test/foo.html"), qt.Equals, "test/foo.html")
c.Assert(true, qt.Equals, true)
-
})
}
if d.WithTemplate != nil {
if err := d.WithTemplate(e); err != nil {
return nil, err
-
}
}
})
return err
-
}
type templateHandler struct {
more := len(s.variants) > 1
return sv.ts, true, more
-
}
// LookupVariants returns all variants of name, nil if none found.
}
return variants
-
}
func (t *templateHandler) HasTemplate(name string) bool {
-
if _, found := t.baseof[name]; found {
return true
}
err, _ := checkFilename(ts.baseInfo, inerr)
return err
-
}
func (t *templateHandler) addShortcodeVariant(ts *templateState) {
t.applyTemplateTransformers(t.main, templ)
return nil
-
}
func (t *templateHandler) addTemplateTo(info templateInfo, to *templateNamespace) (*templateState, error) {
}
return nil
-
}
func (t *templateHandler) nameIsText(name string) (string, bool) {
}
return nil
-
}
func (t *templateHandler) postTransform() error {
return newTemplateState(templ, templateInfo{name: templ.Name()})
}
return nil
-
}
}
func isText(templ tpl.Template) bool {
_, isText := templ.(*texttemplate.Template)
return isText
-
}
type templateStateMap struct {
}
return s
-
}
// resolves _internal/shortcodes/param.html => param.html etc.
default:
panic("not implemented")
}
-
}
func unwrap(templ tpl.Template) tpl.Template {
}
return templs
-
}
func newTemplateContext(
t *templateState,
lookupFn func(name string) *templateState) *templateContext {
-
return &templateContext{
t: t,
lookupFn: lookupFn,
func applyTemplateTransformers(
t *templateState,
lookupFn func(name string) *templateState) (*templateContext, error) {
-
if t == nil {
return nil, errors.New("expected template, but none provided")
}
partialReturnWrapperTempl = `{{ $_hugo_dot := $ }}{{ $ := .Arg }}{{ with .Arg }}{{ $_hugo_dot.Set ("PLACEHOLDER") }}{{ end }}`
)
-var (
- partialReturnWrapper *parse.ListNode
-)
+var partialReturnWrapper *parse.ListNode
func init() {
templ, err := texttemplate.New("").Parse(partialReturnWrapperTempl)
panic(err)
}
partialReturnWrapper = templ.Tree.Root
-
}
func (c *templateContext) wrapInPartialReturnWrapper(n *parse.ListNode) *parse.ListNode {
withNode.List.Nodes = append(n.Nodes, retn)
return wrapper
-
}
// applyTransformations do 2 things:
break
}
}
-
}
var partialRe = regexp.MustCompile(`^partial(Cached)?$|^partials\.Include(Cached)?$`)
c.returnNode.Args = c.returnNode.Args[1:]
return false
-
}
func findTemplateIn(name string, in tpl.Template) (tpl.Template, bool) {
return templ, true
}
return nil, false
-
}
newTestTemplateLookup(ts),
)
ctx.applyTransformations(templ.Tree.Root)
-
}
func newTestTemplate(templ tpl.Template) *templateState {
}
func TestCollectInfo(t *testing.T) {
-
configStr := `{ "version": 42 }`
tests := []struct {
c.Assert(ctx.t.parseInfo, qt.DeepEquals, test.expected)
})
}
-
}
func TestPartialReturn(t *testing.T) {
-
tests := []struct {
name string
tplString string
// Just check that it doesn't fail in this test. We have functional tests
// in hugoblib.
c.Assert(err, qt.IsNil)
-
})
}
-
}
_ "github.com/gohugoio/hugo/tpl/urls"
)
-var _ texttemplate.ExecHelper = (*templateExecHelper)(nil)
-var zero reflect.Value
+var (
+ _ texttemplate.ExecHelper = (*templateExecHelper)(nil)
+ zero reflect.Value
+)
type templateExecHelper struct {
running bool // whether we're in server mode.
}
func createFuncMap(d *deps.Deps) map[string]interface{} {
-
funcMap := template.FuncMap{}
// Merge the namespace funcs
}
return funcMap
-
}
"github.com/spf13/viper"
)
-var (
- logger = loggers.NewErrorLogger()
-)
+var logger = loggers.NewErrorLogger()
func newTestConfig() config.Provider {
v := viper.New()
t.Fatalf("cache mismatch")
}
}
-
}
func BenchmarkPartial(b *testing.B) {
tti, ok := tt.(tpl.Info)
c.Assert(ok, qt.Equals, true)
c.Assert(tti.ParseInfo().IsInner, qt.Equals, true)
-
}
// TODO(bep) move and use in other places
provider.Update(d)
return d
-
}
[][2]string{
{
`{{ htmlEscape "Cathal Garvey & The Sunshine Band <cathal@foo.bar>" | safeHTML}}`,
- `Cathal Garvey & The Sunshine Band <cathal@foo.bar>`},
+ `Cathal Garvey & The Sunshine Band <cathal@foo.bar>`,
+ },
{
`{{ htmlEscape "Cathal Garvey & The Sunshine Band <cathal@foo.bar>"}}`,
- `Cathal Garvey &amp; The Sunshine Band &lt;cathal@foo.bar&gt;`},
+ `Cathal Garvey &amp; The Sunshine Band &lt;cathal@foo.bar&gt;`,
+ },
{
`{{ htmlEscape "Cathal Garvey & The Sunshine Band <cathal@foo.bar>" | htmlUnescape | safeHTML }}`,
- `Cathal Garvey & The Sunshine Band <cathal@foo.bar>`},
+ `Cathal Garvey & The Sunshine Band <cathal@foo.bar>`,
+ },
},
)
[][2]string{
{
`{{ htmlUnescape "Cathal Garvey & The Sunshine Band <cathal@foo.bar>" | safeHTML}}`,
- `Cathal Garvey & The Sunshine Band <cathal@foo.bar>`},
+ `Cathal Garvey & The Sunshine Band <cathal@foo.bar>`,
+ },
{
`{{"Cathal Garvey &amp; The Sunshine Band &lt;cathal@foo.bar&gt;" | htmlUnescape | htmlUnescape | safeHTML}}`,
- `Cathal Garvey & The Sunshine Band <cathal@foo.bar>`},
+ `Cathal Garvey & The Sunshine Band <cathal@foo.bar>`,
+ },
{
`{{"Cathal Garvey &amp; The Sunshine Band &lt;cathal@foo.bar&gt;" | htmlUnescape | htmlUnescape }}`,
- `Cathal Garvey & The Sunshine Band <cathal@foo.bar>`},
+ `Cathal Garvey & The Sunshine Band <cathal@foo.bar>`,
+ },
{
`{{ htmlUnescape "Cathal Garvey & The Sunshine Band <cathal@foo.bar>" | htmlEscape | safeHTML }}`,
- `Cathal Garvey & The Sunshine Band <cathal@foo.bar>`},
+ `Cathal Garvey & The Sunshine Band <cathal@foo.bar>`,
+ },
},
)
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
}
}
-
}
func TestRemarshalComments(t *testing.T) {
_, err = ns.Remarshal("json", "asdf")
c.Assert(err, qt.Not(qt.IsNil))
-
}
func TestTestRemarshalMapInput(t *testing.T) {
}
b, err := ns.deps.ContentSpec.RenderMarkdown([]byte(ss))
-
if err != nil {
return "", err
}
import (
"html/template"
-
"testing"
"github.com/gohugoio/hugo/common/loggers"
c.Assert(err, qt.IsNil)
c.Assert(result, qt.Equals, template.HTML(
"<p>#First</p>\n<p>This is some <em>bold</em> text.</p>\n<h2 id=\"second\">Second</h2>\n<p>This is some more text.</p>\n<p>And then some.</p>\n"))
-
}
func TestPlainify(t *testing.T) {
}
var data interface{}
- var decoder = metadecoders.Default
+ decoder := metadecoders.Default
if len(args) == 1 {
data = args[0]
}
func TestUnmarshal(t *testing.T) {
-
v := viper.New()
ns := New(newDeps(v))
c := qt.New(t)
}},
{testContentResource{key: "r1", content: `a;b;c`, mime: media.CSVType}, map[string]interface{}{"delimiter": ";"}, func(r [][]string) {
c.Assert([][]string{{"a", "b", "c"}}, qt.DeepEquals, r)
-
}},
{"a,b,c", nil, func(r [][]string) {
c.Assert([][]string{{"a", "b", "c"}}, qt.DeepEquals, r)
-
}},
{"a;b;c", map[string]interface{}{"delimiter": ";"}, func(r [][]string) {
c.Assert([][]string{{"a", "b", "c"}}, qt.DeepEquals, r)
-
}},
{testContentResource{key: "r1", content: `
% This is a comment
a;b;c`, mime: media.CSVType}, map[string]interface{}{"DElimiter": ";", "Comment": "%"}, func(r [][]string) {
c.Assert([][]string{{"a", "b", "c"}}, qt.DeepEquals, r)
-
}},
// errors
{"thisisnotavaliddataformat", nil, false},
)
return ns
-
}
internal.AddTemplateFuncsNamespace(f)
import (
"errors"
"fmt"
-
"html/template"
-
"net/url"
"github.com/gohugoio/hugo/common/urls"
}
var tags = []tag{
- tag{markup: []byte("<head>"), appendScript: true},
- tag{markup: []byte("<HEAD>"), appendScript: true},
- tag{markup: []byte("</body>")},
- tag{markup: []byte("</BODY>")},
+ {markup: []byte("<head>"), appendScript: true},
+ {markup: []byte("<HEAD>"), appendScript: true},
+ {markup: []byte("</body>")},
+ {markup: []byte("</BODY>")},
}
// New creates a function that can be used
// to inject a script tag for the livereload JavaScript in a HTML document.
func New(baseURL url.URL) transform.Transformer {
-
return func(ft transform.FromTo) error {
b := ft.From().Bytes()
- var idx = -1
+ idx := -1
var match tag
// We used to insert the livereload script right before the closing body.
// This does not work when combined with tools such as Turbolinks.
c.Run("No match", func(c *qt.C) {
c.Assert(apply("<h1>No match</h1>"), qt.Equals, "<h1>No match</h1>")
})
-
}
"github.com/gohugoio/hugo/transform"
)
-var metaTagsCheck = regexp.MustCompile(`(?i)<meta\s+name=['|"]?generator['|"]?`)
-var hugoGeneratorTag = fmt.Sprintf(`<meta name="generator" content="Hugo %s" />`, hugo.CurrentVersion)
+var (
+ metaTagsCheck = regexp.MustCompile(`(?i)<meta\s+name=['|"]?generator['|"]?`)
+ hugoGeneratorTag = fmt.Sprintf(`<meta name="generator" content="Hugo %s" />`, hugo.CurrentVersion)
+)
// HugoGenerator injects a meta generator tag for Hugo if none present.
func HugoGenerator(ft transform.FromTo) error {
}
return nil
-
}
t.Errorf("[%d] Expected \n%q got \n%q", i, this.expect, out.String())
}
}
-
}
return bytes.IndexFunc(l.content[l.pos:], func(r rune) bool {
return r == '>' || unicode.IsSpace(r)
})
-
}
// handle URLs in srcset.
l.pos += len(section)
l.start = l.pos
-
}
// main loop
}
func doReplace(path string, ct transform.FromTo, quotes [][]byte) {
-
lexer := &absurllexer{
content: ct.From().Bytes(),
w: ct.To(),
path: []byte(path),
- quotes: quotes}
+ quotes: quotes,
+ }
lexer.replace()
}
func newAbsURLReplacer() *absURLReplacer {
return &absURLReplacer{
htmlQuotes: [][]byte{[]byte("\""), []byte("'")},
- xmlQuotes: [][]byte{[]byte("""), []byte("'")}}
+ xmlQuotes: [][]byte{[]byte("""), []byte("'")},
+ }
}
func (au *absURLReplacer) replaceInHTML(path string, ct transform.FromTo) {
srcsetXMLTests = []test{
{srcsetXMLBasic, srcsetXMLBasicCorrect},
{srcsetXMLSingleQuote, srcsetXMLSingleQuoteCorrect},
- {srcsetXMLVariations, srcsetXMLVariationsCorrect}}
+ {srcsetXMLVariations, srcsetXMLVariationsCorrect},
+ }
relurlTests = []test{{relPathVariations, relPathVariationsCorrect}}
)
tr := transform.New(NewAbsURLTransformer(testBaseURL))
apply(t.Errorf, tr, absURLTests)
-
}
func TestAbsURLUnqoted(t *testing.T) {
tr := transform.New(NewAbsURLTransformer(helpers.GetDottedRelativePath(filepath.FromSlash("/post/sub/"))))
applyWithPath(t.Errorf, tr, relurlTests)
-
}
func TestAbsURLSrcSet(t *testing.T) {
projects / brevno-suite / hugo / commitdiff