The main item in this commit is showing of errors with a file context when running `hugo server`.
This can be turned off: `hugo server --disableBrowserError` (can also be set in `config.toml`).
But to get there, the error handling in Hugo needed a revision. There are some items left TODO for commits soon to follow, most notable errors in content and config files.
Fixes #5284
Fixes #5290
See #5325
See #5324
package commands
import (
+ "bytes"
+ "errors"
+
+ "github.com/gohugoio/hugo/common/herrors"
+
+ "io/ioutil"
+
+ jww "github.com/spf13/jwalterweatherman"
+
"os"
"path/filepath"
"regexp"
"sync"
"time"
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/config"
"github.com/spf13/cobra"
- "github.com/spf13/afero"
-
"github.com/gohugoio/hugo/hugolib"
+ "github.com/spf13/afero"
"github.com/bep/debounce"
"github.com/gohugoio/hugo/common/types"
type commandeer struct {
*commandeerHugoState
+ logger *loggers.Logger
+
// Currently only set when in "fast render mode". But it seems to
// be fast enough that we could maybe just add it for all server modes.
changeDetector *fileChangeDetector
serverPorts []int
languagesConfigured bool
languages langs.Languages
+ doLiveReload bool
+ fastRenderMode bool
+ showErrorInBrowser bool
configured bool
paused bool
+
+ // Any error from the last build.
+ buildErr error
+}
+
+func (c *commandeer) errCount() int {
+ return int(c.logger.ErrorCounter.Count())
+}
+
+func (c *commandeer) getErrorWithContext() interface{} {
+ errCount := c.errCount()
+
+ if errCount == 0 {
+ return nil
+ }
+
+ m := make(map[string]interface{})
+
+ m["Error"] = errors.New(removeErrorPrefixFromLog(c.logger.Errors.String()))
+ m["Version"] = hugoVersionString()
+
+ fe := herrors.UnwrapErrorWithFileContext(c.buildErr)
+ if fe != nil {
+ m["File"] = fe
+ }
+
+ if c.h.verbose {
+ var b bytes.Buffer
+ herrors.FprintStackTrace(&b, c.buildErr)
+ m["StackTrace"] = b.String()
+ }
+
+ return m
}
func (c *commandeer) Set(key string, value interface{}) {
doWithCommandeer: doWithCommandeer,
visitedURLs: types.NewEvictingStringQueue(10),
debounce: rebuildDebouncer,
+ // This will be replaced later, but we need something to log to before the configuration is read.
+ logger: loggers.NewLogger(jww.LevelError, jww.LevelError, os.Stdout, ioutil.Discard, running),
}
return c, c.loadConfig(mustHaveConfigFile, running)
c.languages = l
}
+ // Set some commonly used flags
+ c.doLiveReload = !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload")
+ c.fastRenderMode = c.doLiveReload && !c.Cfg.GetBool("disableFastRender")
+ c.showErrorInBrowser = c.doLiveReload && !c.Cfg.GetBool("disableBrowserError")
+
// This is potentially double work, but we need to do this one more time now
// that all the languages have been configured.
if c.doWithCommandeer != nil {
}
}
- logger, err := c.createLogger(config)
+ logger, err := c.createLogger(config, running)
if err != nil {
return err
}
cfg.Logger = logger
+ c.logger = logger
createMemFs := config.GetBool("renderToMemory")
package commands
import (
- "os"
-
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/helpers"
"github.com/spf13/cobra"
- jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/nitro"
)
_ = cmd.Flags().SetAnnotation("theme", cobra.BashCompSubdirsInDir, []string{"themes"})
}
-func checkErr(logger *jww.Notepad, err error, s ...string) {
+func checkErr(logger *loggers.Logger, err error, s ...string) {
if err == nil {
return
}
}
logger.ERROR.Println(err)
}
-
-func stopOnErr(logger *jww.Notepad, err error, s ...string) {
- if err == nil {
- return
- }
-
- defer os.Exit(-1)
-
- if len(s) == 0 {
- newMessage := err.Error()
- // Printing an empty string results in a error with
- // no message, no bueno.
- if newMessage != "" {
- logger.CRITICAL.Println(newMessage)
- }
- }
- for _, message := range s {
- if message != "" {
- logger.CRITICAL.Println(message)
- }
- }
-}
package commands
import (
- "fmt"
"time"
src "github.com/gohugoio/hugo/source"
+ "github.com/pkg/errors"
"github.com/gohugoio/hugo/hugolib"
}
if err = newPage.SaveSourceAs(newFilename); err != nil {
- return fmt.Errorf("Failed to save file %q: %s", newFilename, err)
+ return errors.Wrapf(err, "Failed to save file %q:", newFilename)
}
return nil
import (
"fmt"
"io/ioutil"
+
"os/signal"
"sort"
"sync/atomic"
+
+ "github.com/pkg/errors"
+
+ "github.com/gohugoio/hugo/common/herrors"
+ "github.com/gohugoio/hugo/common/loggers"
+
"syscall"
"github.com/gohugoio/hugo/hugolib/filesystems"
"golang.org/x/sync/errgroup"
- "log"
"os"
"path/filepath"
"runtime"
}
if err == nil {
- errCount := int(jww.LogCountForLevelsGreaterThanorEqualTo(jww.LevelError))
+ errCount := int(loggers.GlobalErrorCounter.Count())
if errCount > 0 {
err = fmt.Errorf("logged %d errors", errCount)
} else if resp.Result != nil {
}
-func (c *commandeer) createLogger(cfg config.Provider) (*jww.Notepad, error) {
+func (c *commandeer) createLogger(cfg config.Provider, running bool) (*loggers.Logger, error) {
var (
logHandle = ioutil.Discard
logThreshold = jww.LevelWarn
jww.SetStdoutThreshold(stdoutThreshold)
helpers.InitLoggers()
- return jww.NewNotepad(stdoutThreshold, logThreshold, outHandle, logHandle, "", log.Ldate|log.Ltime), nil
+ return loggers.NewLogger(stdoutThreshold, logThreshold, outHandle, logHandle, running), nil
}
func initializeFlags(cmd *cobra.Command, cfg config.Provider) {
cnt, err := c.copyStatic()
if err != nil {
if !os.IsNotExist(err) {
- return fmt.Errorf("Error copying static files: %s", err)
+ return errors.Wrap(err, "Error copying static files")
}
- c.Logger.WARN.Println("No Static directory found")
+ c.logger.WARN.Println("No Static directory found")
}
langCount = cnt
langCount = cnt
}
buildSitesFunc := func() error {
if err := c.buildSites(); err != nil {
- return fmt.Errorf("Error building site: %s", err)
+ return errors.Wrap(err, "Error building site")
}
return nil
}
if err != nil {
return err
}
- c.Logger.FEEDBACK.Println("Watching for changes in", c.hugo.PathSpec.AbsPathify(c.Cfg.GetString("contentDir")))
- c.Logger.FEEDBACK.Println("Press Ctrl+C to stop")
+ c.logger.FEEDBACK.Println("Watching for changes in", c.hugo.PathSpec.AbsPathify(c.Cfg.GetString("contentDir")))
+ c.logger.FEEDBACK.Println("Press Ctrl+C to stop")
watcher, err := c.newWatcher(watchDirs...)
checkErr(c.Logger, err)
defer watcher.Close()
staticFilesystems := c.hugo.BaseFs.SourceFilesystems.Static
if len(staticFilesystems) == 0 {
- c.Logger.WARN.Println("No static directories found to sync")
+ c.logger.WARN.Println("No static directories found to sync")
return langCount, nil
}
syncer.Delete = c.Cfg.GetBool("cleanDestinationDir")
if syncer.Delete {
- c.Logger.INFO.Println("removing all files from destination that don't exist in static dirs")
+ c.logger.INFO.Println("removing all files from destination that don't exist in static dirs")
syncer.DeleteFilter = func(f os.FileInfo) bool {
return f.IsDir() && strings.HasPrefix(f.Name(), ".")
}
}
- c.Logger.INFO.Println("syncing static files to", publishDir)
+ c.logger.INFO.Println("syncing static files to", publishDir)
var err error
return
}
elapsed := time.Since(start)
- c.Logger.FEEDBACK.Printf("%s in %v ms", name, int(1000*elapsed.Seconds()))
+ c.logger.FEEDBACK.Printf("%s in %v ms", name, int(1000*elapsed.Seconds()))
}
// getDirList provides NewWatcher() with a list of directories to watch for changes.
return nil
}
- c.Logger.ERROR.Println("Walker: ", err)
+ c.logger.ERROR.Println("Walker: ", err)
return nil
}
if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
link, err := filepath.EvalSymlinks(path)
if err != nil {
- c.Logger.ERROR.Printf("Cannot read symbolic link '%s', error was: %s", path, err)
+ c.logger.ERROR.Printf("Cannot read symbolic link '%s', error was: %s", path, err)
return nil
}
linkfi, err := helpers.LstatIfPossible(c.Fs.Source, link)
if err != nil {
- c.Logger.ERROR.Printf("Cannot stat %q: %s", link, err)
+ c.logger.ERROR.Printf("Cannot stat %q: %s", link, err)
return nil
}
if !allowSymbolicDirs && !linkfi.Mode().IsRegular() {
- c.Logger.ERROR.Printf("Symbolic links for directories not supported, skipping %q", path)
+ c.logger.ERROR.Printf("Symbolic links for directories not supported, skipping %q", path)
return nil
}
func (c *commandeer) resetAndBuildSites() (err error) {
if !c.h.quiet {
- c.Logger.FEEDBACK.Println("Started building sites ...")
+ c.logger.FEEDBACK.Println("Started building sites ...")
}
return c.hugo.Build(hugolib.BuildCfg{ResetState: true})
}
func (c *commandeer) rebuildSites(events []fsnotify.Event) error {
defer c.timeTrack(time.Now(), "Total")
+ c.buildErr = nil
visited := c.visitedURLs.PeekAllSet()
doLiveReload := !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload")
if doLiveReload && !c.Cfg.GetBool("disableFastRender") {
c.commandeerHugoState = &commandeerHugoState{}
err := c.loadConfig(true, true)
if err != nil {
- jww.ERROR.Println("Failed to reload config:", err)
+ c.logger.ERROR.Println("Failed to reload config:", err)
// Set the processing on pause until the state is recovered.
c.paused = true
} else {
}
if !c.paused {
- if err := c.buildSites(); err != nil {
- jww.ERROR.Println(err)
+ err := c.buildSites()
+ if err != nil {
+ c.logger.ERROR.Println(err)
} else if !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload") {
livereload.ForceRefresh()
}
configSet := make(map[string]bool)
for _, configFile := range c.configFiles {
- c.Logger.FEEDBACK.Println("Watching for config changes in", configFile)
+ c.logger.FEEDBACK.Println("Watching for config changes in", configFile)
watcher.Add(configFile)
configSet[configFile] = true
}
for {
select {
case evs := <-watcher.Events:
- for _, ev := range evs {
- if configSet[ev.Name] {
- if ev.Op&fsnotify.Chmod == fsnotify.Chmod {
- continue
- }
- if ev.Op&fsnotify.Remove == fsnotify.Remove {
- for _, configFile := range c.configFiles {
- counter := 0
- for watcher.Add(configFile) != nil {
- counter++
- if counter >= 100 {
- break
- }
- time.Sleep(100 * time.Millisecond)
- }
- }
- }
- // Config file changed. Need full rebuild.
- c.fullRebuild()
- break
- }
+ c.handleEvents(watcher, staticSyncer, evs, configSet)
+ if c.showErrorInBrowser && c.errCount() > 0 {
+ // Need to reload browser to show the error
+ livereload.ForceRefresh()
}
-
- if c.paused {
- // Wait for the server to get into a consistent state before
- // we continue with processing.
- continue
- }
-
- if len(evs) > 50 {
- // This is probably a mass edit of the content dir.
- // Schedule a full rebuild for when it slows down.
- c.debounce(c.fullRebuild)
- continue
+ case err := <-watcher.Errors:
+ if err != nil {
+ c.logger.ERROR.Println("Error while watching:", err)
}
+ }
+ }
+ }()
- c.Logger.INFO.Println("Received System Events:", evs)
+ return watcher, nil
+}
- staticEvents := []fsnotify.Event{}
- dynamicEvents := []fsnotify.Event{}
+func (c *commandeer) handleEvents(watcher *watcher.Batcher,
+ staticSyncer *staticSyncer,
+ evs []fsnotify.Event,
+ configSet map[string]bool) {
- // Special handling for symbolic links inside /content.
- filtered := []fsnotify.Event{}
- for _, ev := range evs {
- // Check the most specific first, i.e. files.
- contentMapped := c.hugo.ContentChanges.GetSymbolicLinkMappings(ev.Name)
- if len(contentMapped) > 0 {
- for _, mapped := range contentMapped {
- filtered = append(filtered, fsnotify.Event{Name: mapped, Op: ev.Op})
+ for _, ev := range evs {
+ if configSet[ev.Name] {
+ if ev.Op&fsnotify.Chmod == fsnotify.Chmod {
+ continue
+ }
+ if ev.Op&fsnotify.Remove == fsnotify.Remove {
+ for _, configFile := range c.configFiles {
+ counter := 0
+ for watcher.Add(configFile) != nil {
+ counter++
+ if counter >= 100 {
+ break
}
- continue
+ time.Sleep(100 * time.Millisecond)
}
+ }
+ }
+ // Config file changed. Need full rebuild.
+ c.fullRebuild()
+ break
+ }
+ }
- // Check for any symbolic directory mapping.
+ if c.paused {
+ // Wait for the server to get into a consistent state before
+ // we continue with processing.
+ return
+ }
- dir, name := filepath.Split(ev.Name)
+ if len(evs) > 50 {
+ // This is probably a mass edit of the content dir.
+ // Schedule a full rebuild for when it slows down.
+ c.debounce(c.fullRebuild)
+ return
+ }
- contentMapped = c.hugo.ContentChanges.GetSymbolicLinkMappings(dir)
+ c.logger.INFO.Println("Received System Events:", evs)
- if len(contentMapped) == 0 {
- filtered = append(filtered, ev)
- continue
- }
+ staticEvents := []fsnotify.Event{}
+ dynamicEvents := []fsnotify.Event{}
- for _, mapped := range contentMapped {
- mappedFilename := filepath.Join(mapped, name)
- filtered = append(filtered, fsnotify.Event{Name: mappedFilename, Op: ev.Op})
- }
- }
+ // Special handling for symbolic links inside /content.
+ filtered := []fsnotify.Event{}
+ for _, ev := range evs {
+ // Check the most specific first, i.e. files.
+ contentMapped := c.hugo.ContentChanges.GetSymbolicLinkMappings(ev.Name)
+ if len(contentMapped) > 0 {
+ for _, mapped := range contentMapped {
+ filtered = append(filtered, fsnotify.Event{Name: mapped, Op: ev.Op})
+ }
+ continue
+ }
- evs = filtered
-
- for _, ev := range evs {
- ext := filepath.Ext(ev.Name)
- baseName := filepath.Base(ev.Name)
- istemp := strings.HasSuffix(ext, "~") ||
- (ext == ".swp") || // vim
- (ext == ".swx") || // vim
- (ext == ".tmp") || // generic temp file
- (ext == ".DS_Store") || // OSX Thumbnail
- baseName == "4913" || // vim
- strings.HasPrefix(ext, ".goutputstream") || // gnome
- strings.HasSuffix(ext, "jb_old___") || // intelliJ
- strings.HasSuffix(ext, "jb_tmp___") || // intelliJ
- strings.HasSuffix(ext, "jb_bak___") || // intelliJ
- strings.HasPrefix(ext, ".sb-") || // byword
- strings.HasPrefix(baseName, ".#") || // emacs
- strings.HasPrefix(baseName, "#") // emacs
- if istemp {
- continue
- }
- // Sometimes during rm -rf operations a '"": REMOVE' is triggered. Just ignore these
- if ev.Name == "" {
- continue
- }
+ // Check for any symbolic directory mapping.
- // Write and rename operations are often followed by CHMOD.
- // There may be valid use cases for rebuilding the site on CHMOD,
- // but that will require more complex logic than this simple conditional.
- // On OS X this seems to be related to Spotlight, see:
- // https://github.com/go-fsnotify/fsnotify/issues/15
- // A workaround is to put your site(s) on the Spotlight exception list,
- // but that may be a little mysterious for most end users.
- // So, for now, we skip reload on CHMOD.
- // We do have to check for WRITE though. On slower laptops a Chmod
- // could be aggregated with other important events, and we still want
- // to rebuild on those
- if ev.Op&(fsnotify.Chmod|fsnotify.Write|fsnotify.Create) == fsnotify.Chmod {
- continue
- }
+ dir, name := filepath.Split(ev.Name)
- walkAdder := func(path string, f os.FileInfo, err error) error {
- if f.IsDir() {
- c.Logger.FEEDBACK.Println("adding created directory to watchlist", path)
- if err := watcher.Add(path); err != nil {
- return err
- }
- } else if !staticSyncer.isStatic(path) {
- // Hugo's rebuilding logic is entirely file based. When you drop a new folder into
- // /content on OSX, the above logic will handle future watching of those files,
- // but the initial CREATE is lost.
- dynamicEvents = append(dynamicEvents, fsnotify.Event{Name: path, Op: fsnotify.Create})
- }
- return nil
- }
+ contentMapped = c.hugo.ContentChanges.GetSymbolicLinkMappings(dir)
- // recursively add new directories to watch list
- // When mkdir -p is used, only the top directory triggers an event (at least on OSX)
- if ev.Op&fsnotify.Create == fsnotify.Create {
- if s, err := c.Fs.Source.Stat(ev.Name); err == nil && s.Mode().IsDir() {
- _ = helpers.SymbolicWalk(c.Fs.Source, ev.Name, walkAdder)
- }
- }
+ if len(contentMapped) == 0 {
+ filtered = append(filtered, ev)
+ continue
+ }
- if staticSyncer.isStatic(ev.Name) {
- staticEvents = append(staticEvents, ev)
- } else {
- dynamicEvents = append(dynamicEvents, ev)
- }
- }
+ for _, mapped := range contentMapped {
+ mappedFilename := filepath.Join(mapped, name)
+ filtered = append(filtered, fsnotify.Event{Name: mappedFilename, Op: ev.Op})
+ }
+ }
- if len(staticEvents) > 0 {
- c.Logger.FEEDBACK.Println("\nStatic file changes detected")
- const layout = "2006-01-02 15:04:05.000 -0700"
- c.Logger.FEEDBACK.Println(time.Now().Format(layout))
+ evs = filtered
+
+ for _, ev := range evs {
+ ext := filepath.Ext(ev.Name)
+ baseName := filepath.Base(ev.Name)
+ istemp := strings.HasSuffix(ext, "~") ||
+ (ext == ".swp") || // vim
+ (ext == ".swx") || // vim
+ (ext == ".tmp") || // generic temp file
+ (ext == ".DS_Store") || // OSX Thumbnail
+ baseName == "4913" || // vim
+ strings.HasPrefix(ext, ".goutputstream") || // gnome
+ strings.HasSuffix(ext, "jb_old___") || // intelliJ
+ strings.HasSuffix(ext, "jb_tmp___") || // intelliJ
+ strings.HasSuffix(ext, "jb_bak___") || // intelliJ
+ strings.HasPrefix(ext, ".sb-") || // byword
+ strings.HasPrefix(baseName, ".#") || // emacs
+ strings.HasPrefix(baseName, "#") // emacs
+ if istemp {
+ continue
+ }
+ // Sometimes during rm -rf operations a '"": REMOVE' is triggered. Just ignore these
+ if ev.Name == "" {
+ continue
+ }
- if c.Cfg.GetBool("forceSyncStatic") {
- c.Logger.FEEDBACK.Printf("Syncing all static files\n")
- _, err := c.copyStatic()
- if err != nil {
- stopOnErr(c.Logger, err, "Error copying static files to publish dir")
- }
- } else {
- if err := staticSyncer.syncsStaticEvents(staticEvents); err != nil {
- c.Logger.ERROR.Println(err)
- continue
- }
- }
+ // Write and rename operations are often followed by CHMOD.
+ // There may be valid use cases for rebuilding the site on CHMOD,
+ // but that will require more complex logic than this simple conditional.
+ // On OS X this seems to be related to Spotlight, see:
+ // https://github.com/go-fsnotify/fsnotify/issues/15
+ // A workaround is to put your site(s) on the Spotlight exception list,
+ // but that may be a little mysterious for most end users.
+ // So, for now, we skip reload on CHMOD.
+ // We do have to check for WRITE though. On slower laptops a Chmod
+ // could be aggregated with other important events, and we still want
+ // to rebuild on those
+ if ev.Op&(fsnotify.Chmod|fsnotify.Write|fsnotify.Create) == fsnotify.Chmod {
+ continue
+ }
- if !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload") {
- // Will block forever trying to write to a channel that nobody is reading if livereload isn't initialized
-
- // force refresh when more than one file
- if len(staticEvents) == 1 {
- ev := staticEvents[0]
- path := c.hugo.BaseFs.SourceFilesystems.MakeStaticPathRelative(ev.Name)
- path = c.firstPathSpec().RelURL(helpers.ToSlashTrimLeading(path), false)
- livereload.RefreshPath(path)
- } else {
- livereload.ForceRefresh()
- }
- }
+ walkAdder := func(path string, f os.FileInfo, err error) error {
+ if f.IsDir() {
+ c.logger.FEEDBACK.Println("adding created directory to watchlist", path)
+ if err := watcher.Add(path); err != nil {
+ return err
}
+ } else if !staticSyncer.isStatic(path) {
+ // Hugo's rebuilding logic is entirely file based. When you drop a new folder into
+ // /content on OSX, the above logic will handle future watching of those files,
+ // but the initial CREATE is lost.
+ dynamicEvents = append(dynamicEvents, fsnotify.Event{Name: path, Op: fsnotify.Create})
+ }
+ return nil
+ }
- if len(dynamicEvents) > 0 {
- partitionedEvents := partitionDynamicEvents(
- c.firstPathSpec().BaseFs.SourceFilesystems,
- dynamicEvents)
+ // recursively add new directories to watch list
+ // When mkdir -p is used, only the top directory triggers an event (at least on OSX)
+ if ev.Op&fsnotify.Create == fsnotify.Create {
+ if s, err := c.Fs.Source.Stat(ev.Name); err == nil && s.Mode().IsDir() {
+ _ = helpers.SymbolicWalk(c.Fs.Source, ev.Name, walkAdder)
+ }
+ }
- doLiveReload := !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload")
- onePageName := pickOneWriteOrCreatePath(partitionedEvents.ContentEvents)
+ if staticSyncer.isStatic(ev.Name) {
+ staticEvents = append(staticEvents, ev)
+ } else {
+ dynamicEvents = append(dynamicEvents, ev)
+ }
+ }
- c.Logger.FEEDBACK.Println("\nChange detected, rebuilding site")
- const layout = "2006-01-02 15:04:05.000 -0700"
- c.Logger.FEEDBACK.Println(time.Now().Format(layout))
+ if len(staticEvents) > 0 {
+ c.logger.FEEDBACK.Println("\nStatic file changes detected")
+ const layout = "2006-01-02 15:04:05.000 -0700"
+ c.logger.FEEDBACK.Println(time.Now().Format(layout))
- c.changeDetector.PrepareNew()
- if err := c.rebuildSites(dynamicEvents); err != nil {
- c.Logger.ERROR.Println("Failed to rebuild site:", err)
- }
+ if c.Cfg.GetBool("forceSyncStatic") {
+ c.logger.FEEDBACK.Printf("Syncing all static files\n")
+ _, err := c.copyStatic()
+ if err != nil {
+ c.logger.ERROR.Println("Error copying static files to publish dir:", err)
+ return
+ }
+ } else {
+ if err := staticSyncer.syncsStaticEvents(staticEvents); err != nil {
+ c.logger.ERROR.Println("Error syncing static files to publish dir:", err)
+ return
+ }
+ }
- if doLiveReload {
- if len(partitionedEvents.ContentEvents) == 0 && len(partitionedEvents.AssetEvents) > 0 {
- changed := c.changeDetector.changed()
- if c.changeDetector != nil && len(changed) == 0 {
- // Nothing has changed.
- continue
- } else if len(changed) == 1 {
- pathToRefresh := c.firstPathSpec().RelURL(helpers.ToSlashTrimLeading(changed[0]), false)
- livereload.RefreshPath(pathToRefresh)
- } else {
- livereload.ForceRefresh()
- }
- }
+ if !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload") {
+ // Will block forever trying to write to a channel that nobody is reading if livereload isn't initialized
+
+ // force refresh when more than one file
+ if len(staticEvents) == 1 {
+ ev := staticEvents[0]
+ path := c.hugo.BaseFs.SourceFilesystems.MakeStaticPathRelative(ev.Name)
+ path = c.firstPathSpec().RelURL(helpers.ToSlashTrimLeading(path), false)
+ livereload.RefreshPath(path)
+ } else {
+ livereload.ForceRefresh()
+ }
+ }
+ }
- if len(partitionedEvents.ContentEvents) > 0 {
+ if len(dynamicEvents) > 0 {
+ partitionedEvents := partitionDynamicEvents(
+ c.firstPathSpec().BaseFs.SourceFilesystems,
+ dynamicEvents)
- navigate := c.Cfg.GetBool("navigateToChanged")
- // We have fetched the same page above, but it may have
- // changed.
- var p *hugolib.Page
+ doLiveReload := !c.h.buildWatch && !c.Cfg.GetBool("disableLiveReload")
+ onePageName := pickOneWriteOrCreatePath(partitionedEvents.ContentEvents)
- if navigate {
- if onePageName != "" {
- p = c.hugo.GetContentPage(onePageName)
- }
- }
+ c.logger.FEEDBACK.Println("\nChange detected, rebuilding site")
+ const layout = "2006-01-02 15:04:05.000 -0700"
+ c.logger.FEEDBACK.Println(time.Now().Format(layout))
- if p != nil {
- livereload.NavigateToPathForPort(p.RelPermalink(), p.Site.ServerPort())
- } else {
- livereload.ForceRefresh()
- }
- }
+ c.changeDetector.PrepareNew()
+ if err := c.rebuildSites(dynamicEvents); err != nil {
+ c.buildErr = err
+ c.logger.ERROR.Printf("Rebuild failed: %s", err)
+ if !c.h.quiet && c.h.verbose {
+ herrors.PrintStackTrace(err)
+ }
+ }
+
+ if doLiveReload {
+
+ if len(partitionedEvents.ContentEvents) == 0 && len(partitionedEvents.AssetEvents) > 0 {
+ changed := c.changeDetector.changed()
+ if c.changeDetector != nil && len(changed) == 0 {
+ // Nothing has changed.
+ return
+ } else if len(changed) == 1 {
+ pathToRefresh := c.firstPathSpec().RelURL(helpers.ToSlashTrimLeading(changed[0]), false)
+ livereload.RefreshPath(pathToRefresh)
+ } else {
+ livereload.ForceRefresh()
+ }
+ }
+
+ if len(partitionedEvents.ContentEvents) > 0 {
+
+ navigate := c.Cfg.GetBool("navigateToChanged")
+ // We have fetched the same page above, but it may have
+ // changed.
+ var p *hugolib.Page
+
+ if navigate {
+ if onePageName != "" {
+ p = c.hugo.GetContentPage(onePageName)
}
}
- case err := <-watcher.Errors:
- if err != nil {
- c.Logger.ERROR.Println(err)
+
+ if p != nil {
+ livereload.NavigateToPathForPort(p.RelPermalink(), p.Site.ServerPort())
+ } else {
+ livereload.ForceRefresh()
}
}
}
- }()
-
- return watcher, nil
+ }
}
// dynamicEvents contains events that is considered dynamic, as in "not static".
import (
"bytes"
"errors"
- "fmt"
"path/filepath"
"strings"
+ _errors "github.com/pkg/errors"
+
"github.com/gohugoio/hugo/create"
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/hugofs"
for _, dir := range dirs {
if err := fs.Source.MkdirAll(dir, 0777); err != nil {
- return fmt.Errorf("Failed to create dir: %s", err)
+ return _errors.Wrap(err, "Failed to create dir")
}
}
package commands
import (
+ "bytes"
"fmt"
"net"
"net/http"
"os"
"os/signal"
"path/filepath"
+ "regexp"
"runtime"
"strconv"
"strings"
"syscall"
"time"
+ "github.com/pkg/errors"
+
"github.com/gohugoio/hugo/livereload"
+ "github.com/gohugoio/hugo/tpl"
"github.com/gohugoio/hugo/config"
serverWatch bool
noHTTPCache bool
- disableFastRender bool
+ disableFastRender bool
+ disableBrowserError bool
*baseBuilderCmd
}
cc.cmd.Flags().BoolVar(&cc.navigateToChanged, "navigateToChanged", false, "navigate to changed content file on live browser reload")
cc.cmd.Flags().BoolVar(&cc.renderToDisk, "renderToDisk", false, "render to Destination path (default is render to memory & serve from there)")
cc.cmd.Flags().BoolVar(&cc.disableFastRender, "disableFastRender", false, "enables full re-renders on changes")
+ cc.cmd.Flags().BoolVar(&cc.disableBrowserError, "disableBrowserError", false, "do not show build errors in the browser")
cc.cmd.Flags().String("memstats", "", "log memory usage to this file")
cc.cmd.Flags().String("meminterval", "100ms", "interval to poll memory usage (requires --memstats), valid time units are \"ns\", \"us\" (or \"µs\"), \"ms\", \"s\", \"m\", \"h\".")
if cmd.Flags().Changed("disableFastRender") {
c.Set("disableFastRender", sc.disableFastRender)
}
+ if cmd.Flags().Changed("disableBrowserError") {
+ c.Set("disableBrowserError", sc.disableBrowserError)
+ }
if sc.serverWatch {
c.Set("watch", true)
}
// port set explicitly by user -- he/she probably meant it!
err = newSystemErrorF("Server startup failed: %s", err)
}
- jww.ERROR.Println("port", sc.serverPort, "already in use, attempting to use an available port")
+ c.logger.FEEDBACK.Println("port", sc.serverPort, "already in use, attempting to use an available port")
sp, err := helpers.FindAvailablePort()
if err != nil {
err = newSystemError("Unable to find alternative port to use:", err)
}
if err := memStats(); err != nil {
- jww.ERROR.Println("memstats error:", err)
+ jww.WARN.Println("memstats error:", err)
}
c, err := initializeConfig(true, true, &sc.hugoBuilderCommon, sc, cfgInit)
}
type fileServer struct {
- baseURLs []string
- roots []string
- c *commandeer
- s *serverCmd
+ baseURLs []string
+ roots []string
+ errorTemplate tpl.Template
+ c *commandeer
+ s *serverCmd
}
func (f *fileServer) createEndpoint(i int) (*http.ServeMux, string, string, error) {
httpFs := afero.NewHttpFs(f.c.destinationFs)
fs := filesOnlyFs{httpFs.Dir(absPublishDir)}
- doLiveReload := !f.s.buildWatch && !f.c.Cfg.GetBool("disableLiveReload")
- fastRenderMode := doLiveReload && !f.c.Cfg.GetBool("disableFastRender")
-
- if i == 0 && fastRenderMode {
+ if i == 0 && f.c.fastRenderMode {
jww.FEEDBACK.Println("Running in Fast Render Mode. For full rebuilds on change: hugo server --disableFastRender")
}
// We're only interested in the path
u, err := url.Parse(baseURL)
if err != nil {
- return nil, "", "", fmt.Errorf("Invalid baseURL: %s", err)
+ return nil, "", "", errors.Wrap(err, "Invalid baseURL")
}
decorate := func(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if f.c.showErrorInBrowser {
+ // First check the error state
+ err := f.c.getErrorWithContext()
+ if err != nil {
+ w.WriteHeader(500)
+ var b bytes.Buffer
+ err := f.errorTemplate.Execute(&b, err)
+ if err != nil {
+ f.c.logger.ERROR.Println(err)
+ }
+ fmt.Fprint(w, injectLiveReloadScript(&b, f.c.Cfg.GetInt("liveReloadPort")))
+
+ return
+ }
+ }
+
if f.s.noHTTPCache {
w.Header().Set("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0")
w.Header().Set("Pragma", "no-cache")
}
- if fastRenderMode {
+ if f.c.fastRenderMode {
p := r.RequestURI
if strings.HasSuffix(p, "/") || strings.HasSuffix(p, "html") || strings.HasSuffix(p, "htm") {
f.c.visitedURLs.Add(p)
return mu, u.String(), endpoint, nil
}
+var logErrorRe = regexp.MustCompile("(?s)ERROR \\d{4}/\\d{2}/\\d{2} \\d{2}:\\d{2}:\\d{2} ")
+
+func removeErrorPrefixFromLog(content string) string {
+ return logErrorRe.ReplaceAllLiteralString(content, "")
+}
func (c *commandeer) serve(s *serverCmd) error {
isMultiHost := c.hugo.IsMultihost()
roots = []string{""}
}
+ templ, err := c.hugo.TextTmpl.Parse("__default_server_error", buildErrorTemplate)
+ if err != nil {
+ return err
+ }
+
srv := &fileServer{
- baseURLs: baseURLs,
- roots: roots,
- c: c,
- s: s,
+ baseURLs: baseURLs,
+ roots: roots,
+ c: c,
+ s: s,
+ errorTemplate: templ,
}
doLiveReload := !c.Cfg.GetBool("disableLiveReload")
go func() {
err = http.ListenAndServe(endpoint, mu)
if err != nil {
- jww.ERROR.Printf("Error: %s\n", err.Error())
+ c.logger.ERROR.Printf("Error: %s\n", err.Error())
os.Exit(1)
}
}()
if strings.Contains(u.Host, ":") {
u.Host, _, err = net.SplitHostPort(u.Host)
if err != nil {
- return "", fmt.Errorf("Failed to split baseURL hostpost: %s", err)
+ return "", errors.Wrap(err, "Failed to split baseURL hostpost")
}
}
u.Host += fmt.Sprintf(":%d", port)
--- /dev/null
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package commands
+
+import (
+ "bytes"
+ "io"
+
+ "github.com/gohugoio/hugo/transform"
+ "github.com/gohugoio/hugo/transform/livereloadinject"
+)
+
+var buildErrorTemplate = `<!doctype html>
+<html class="no-js" lang="">
+ <head>
+ <meta charset="utf-8">
+ <title>Hugo Server: Error</title>
+ <style type="text/css">
+ body {
+ font-family: "Muli",avenir, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+ font-size: 16px;
+ background-color: black;
+ color: rgba(255, 255, 255, 0.9);
+ }
+ main {
+ margin: auto;
+ width: 95%;
+ padding: 1rem;
+ }
+ .version {
+ color: #ccc;
+ padding: 1rem 0;
+ }
+ .stack {
+ margin-top: 6rem;
+ }
+ pre {
+ white-space: pre-wrap;
+ white-space: -moz-pre-wrap;
+ white-space: -pre-wrap;
+ white-space: -o-pre-wrap;
+ word-wrap: break-word;
+ }
+ .highlight {
+ overflow-x: scroll;
+ padding: 0.75rem;
+ margin-bottom: 1rem;
+ background-color: #272822;
+ border: 1px solid black;
+ }
+ a {
+ color: #0594cb;
+ text-decoration: none;
+ }
+ a:hover {
+ color: #ccc;
+ }
+ </style>
+ </head>
+ <body>
+ <main>
+ {{ highlight .Error "apl" "noclasses=true,style=monokai" }}
+ {{ with .File }}
+ {{ $params := printf "noclasses=true,style=monokai,linenos=table,hl_lines=%d,linenostart=%d" (add .Pos 1) .LineNumber }}
+ {{ $lexer := .ChromaLexer | default "go-html-template" }}
+ {{ highlight (delimit .Lines "\n") $lexer $params }}
+ {{ end }}
+ {{ with .StackTrace }}
+ {{ highlight . "apl" "noclasses=true,style=monokai" }}
+ {{ end }}
+ <p class="version">{{ .Version }}</p>
+ <a href="">Reload Page</a>
+ </main>
+</body>
+</html>
+`
+
+func injectLiveReloadScript(src io.Reader, port int) string {
+ var b bytes.Buffer
+ chain := transform.Chain{livereloadinject.New(port)}
+ chain.Apply(&b, src)
+
+ return b.String()
+}
"net/http"
"os"
"runtime"
+ "strings"
"testing"
"time"
}
}
+func TestRemoveErrorPrefixFromLog(t *testing.T) {
+ assert := require.New(t)
+ content := `ERROR 2018/10/07 13:11:12 Error while rendering "home": template: _default/baseof.html:4:3: executing "main" at <partial "logo" .>: error calling partial: template: partials/logo.html:5:84: executing "partials/logo.html" at <$resized.AHeight>: can't evaluate field AHeight in type *resource.Image
+ERROR 2018/10/07 13:11:12 Rebuild failed: logged 1 error(s)
+`
+
+ withoutError := removeErrorPrefixFromLog(content)
+
+ assert.False(strings.Contains(withoutError, "ERROR"), withoutError)
+
+}
+
func isWindowsCI() bool {
return runtime.GOOS == "windows" && os.Getenv("CI") != ""
}
logger.Println("Syncing", relPath, "to", publishDir)
if err := syncer.Sync(filepath.Join(publishDir, relPath), relPath); err != nil {
- c.Logger.ERROR.Println(err)
+ c.logger.ERROR.Println(err)
}
} else {
- c.Logger.ERROR.Println(err)
+ c.logger.ERROR.Println(err)
}
continue
// For all other event operations Hugo will sync static.
logger.Println("Syncing", relPath, "to", publishDir)
if err := syncer.Sync(filepath.Join(publishDir, relPath), relPath); err != nil {
- c.Logger.ERROR.Println(err)
+ c.logger.ERROR.Println(err)
}
}
package commands
import (
+ "fmt"
"runtime"
"strings"
+ jww "github.com/spf13/jwalterweatherman"
+
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/hugolib"
"github.com/gohugoio/hugo/resource/tocss/scss"
"github.com/spf13/cobra"
- jww "github.com/spf13/jwalterweatherman"
)
var _ cmder = (*versionCmd)(nil)
}
func printHugoVersion() {
+ jww.FEEDBACK.Println(hugoVersionString())
+}
+
+func hugoVersionString() string {
program := "Hugo Static Site Generator"
version := "v" + helpers.CurrentHugoVersion.String()
buildDate = "unknown"
}
- jww.FEEDBACK.Println(program, version, osArch, "BuildDate:", buildDate)
+ return fmt.Sprintf("%s %s %s BuildDate: %s", program, version, osArch, buildDate)
+
}
+++ /dev/null
-// Copyright 2018 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package errors contains common Hugo errors and error related utilities.
-package errors
-
-import (
- "errors"
-)
-
-// ErrFeatureNotAvailable denotes that a feature is unavailable.
-//
-// We will, at least to begin with, make some Hugo features (SCSS with libsass) optional,
-// and this error is used to signal those situations.
-var ErrFeatureNotAvailable = errors.New("this feature is not available in your current Hugo version")
--- /dev/null
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package errors contains common Hugo errors and error related utilities.
+package herrors
+
+import (
+ "bufio"
+ "io"
+ "strings"
+
+ "github.com/spf13/afero"
+)
+
+// LineMatcher is used to match a line with an error.
+type LineMatcher func(le FileError, lineNumber int, line string) bool
+
+// SimpleLineMatcher matches if the current line number matches the line number
+// in the error.
+var SimpleLineMatcher = func(le FileError, lineNumber int, line string) bool {
+ return le.LineNumber() == lineNumber
+}
+
+// ErrorContext contains contextual information about an error. This will
+// typically be the lines surrounding some problem in a file.
+type ErrorContext struct {
+
+ // If a match will contain the matched line and up to 2 lines before and after.
+ // Will be empty if no match.
+ Lines []string
+
+ // The position of the error in the Lines above. 0 based.
+ Pos int
+
+ // The linenumber in the source file from where the Lines start. Starting at 1.
+ LineNumber int
+
+ // The lexer to use for syntax highlighting.
+ // https://gohugo.io/content-management/syntax-highlighting/#list-of-chroma-highlighting-languages
+ ChromaLexer string
+}
+
+var _ causer = (*ErrorWithFileContext)(nil)
+
+// ErrorWithFileContext is an error with some additional file context related
+// to that error.
+type ErrorWithFileContext struct {
+ cause error
+ ErrorContext
+}
+
+func (e *ErrorWithFileContext) Error() string {
+ return e.cause.Error()
+}
+
+func (e *ErrorWithFileContext) Cause() error {
+ return e.cause
+}
+
+// WithFileContextForFile will try to add a file context with lines matching the given matcher.
+// If no match could be found, the original error is returned with false as the second return value.
+func WithFileContextForFile(e error, filename string, fs afero.Fs, chromaLexer string, matcher LineMatcher) (error, bool) {
+ f, err := fs.Open(filename)
+ if err != nil {
+ return e, false
+ }
+ defer f.Close()
+ return WithFileContext(e, f, chromaLexer, matcher)
+}
+
+// WithFileContextForFile will try to add a file context with lines matching the given matcher.
+// If no match could be found, the original error is returned with false as the second return value.
+func WithFileContext(e error, r io.Reader, chromaLexer string, matcher LineMatcher) (error, bool) {
+ if e == nil {
+ panic("error missing")
+ }
+ le := UnwrapFileError(e)
+ if le == nil {
+ var ok bool
+ if le, ok = ToFileError("bash", e).(FileError); !ok {
+ return e, false
+ }
+ }
+
+ errCtx := locateError(r, le, matcher)
+
+ if errCtx.LineNumber == -1 {
+ return e, false
+ }
+
+ if chromaLexer != "" {
+ errCtx.ChromaLexer = chromaLexer
+ } else {
+ errCtx.ChromaLexer = chromaLexerFromType(le.Type())
+ }
+
+ return &ErrorWithFileContext{cause: e, ErrorContext: errCtx}, true
+}
+
+// UnwrapErrorWithFileContext tries to unwrap an ErrorWithFileContext from err.
+// It returns nil if this is not possible.
+func UnwrapErrorWithFileContext(err error) *ErrorWithFileContext {
+ for err != nil {
+ switch v := err.(type) {
+ case *ErrorWithFileContext:
+ return v
+ case causer:
+ err = v.Cause()
+ default:
+ return nil
+ }
+ }
+ return nil
+}
+
+func chromaLexerFromType(fileType string) string {
+ return fileType
+}
+
+func locateErrorInString(le FileError, src string, matcher LineMatcher) ErrorContext {
+ return locateError(strings.NewReader(src), nil, matcher)
+}
+
+func locateError(r io.Reader, le FileError, matches LineMatcher) ErrorContext {
+ var errCtx ErrorContext
+ s := bufio.NewScanner(r)
+
+ lineNo := 0
+
+ var buff [6]string
+ i := 0
+ errCtx.Pos = -1
+
+ for s.Scan() {
+ lineNo++
+ txt := s.Text()
+ buff[i] = txt
+
+ if errCtx.Pos != -1 && i >= 5 {
+ break
+ }
+
+ if errCtx.Pos == -1 && matches(le, lineNo, txt) {
+ errCtx.Pos = i
+ errCtx.LineNumber = lineNo - i
+ }
+
+ if errCtx.Pos == -1 && i == 2 {
+ // Shift left
+ buff[0], buff[1] = buff[i-1], buff[i]
+ } else {
+ i++
+ }
+ }
+
+ // Go's template parser will typically report "unexpected EOF" errors on the
+ // empty last line that is supressed by the scanner.
+ // Do an explicit check for that.
+ if errCtx.Pos == -1 {
+ lineNo++
+ if matches(le, lineNo, "") {
+ buff[i] = ""
+ errCtx.Pos = i
+ errCtx.LineNumber = lineNo - 1
+
+ i++
+ }
+ }
+
+ if errCtx.Pos != -1 {
+ low := errCtx.Pos - 2
+ if low < 0 {
+ low = 0
+ }
+ high := i
+ errCtx.Lines = buff[low:high]
+
+ } else {
+ errCtx.Pos = -1
+ errCtx.LineNumber = -1
+ }
+
+ return errCtx
+}
--- /dev/null
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package errors contains common Hugo errors and error related utilities.
+package herrors
+
+import (
+ "strings"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestErrorLocator(t *testing.T) {
+ assert := require.New(t)
+
+ lineMatcher := func(le FileError, lineno int, line string) bool {
+ return strings.Contains(line, "THEONE")
+ }
+
+ lines := `LINE 1
+LINE 2
+LINE 3
+LINE 4
+This is THEONE
+LINE 6
+LINE 7
+LINE 8
+`
+
+ location := locateErrorInString(nil, lines, lineMatcher)
+ assert.Equal([]string{"LINE 3", "LINE 4", "This is THEONE", "LINE 6", "LINE 7"}, location.Lines)
+
+ assert.Equal(3, location.LineNumber)
+ assert.Equal(2, location.Pos)
+
+ assert.Equal([]string{"This is THEONE"}, locateErrorInString(nil, `This is THEONE`, lineMatcher).Lines)
+
+ location = locateErrorInString(nil, `L1
+This is THEONE
+L2
+`, lineMatcher)
+ assert.Equal(1, location.Pos)
+ assert.Equal([]string{"L1", "This is THEONE", "L2"}, location.Lines)
+
+ location = locateErrorInString(nil, `This is THEONE
+L2
+`, lineMatcher)
+ assert.Equal(0, location.Pos)
+ assert.Equal([]string{"This is THEONE", "L2"}, location.Lines)
+
+ location = locateErrorInString(nil, `L1
+This THEONE
+`, lineMatcher)
+ assert.Equal([]string{"L1", "This THEONE"}, location.Lines)
+ assert.Equal(1, location.Pos)
+
+ location = locateErrorInString(nil, `L1
+L2
+This THEONE
+`, lineMatcher)
+ assert.Equal([]string{"L1", "L2", "This THEONE"}, location.Lines)
+ assert.Equal(2, location.Pos)
+
+ location = locateErrorInString(nil, "NO MATCH", lineMatcher)
+ assert.Equal(-1, location.LineNumber)
+ assert.Equal(-1, location.Pos)
+ assert.Equal(0, len(location.Lines))
+
+ lineMatcher = func(le FileError, lineno int, line string) bool {
+ return lineno == 6
+ }
+ location = locateErrorInString(nil, `A
+B
+C
+D
+E
+F
+G
+H
+I
+J`, lineMatcher)
+
+ assert.Equal([]string{"D", "E", "F", "G", "H"}, location.Lines)
+ assert.Equal(4, location.LineNumber)
+ assert.Equal(2, location.Pos)
+
+ // Test match EOF
+ lineMatcher = func(le FileError, lineno int, line string) bool {
+ return lineno == 4
+ }
+
+ location = locateErrorInString(nil, `A
+B
+C
+`, lineMatcher)
+
+ assert.Equal([]string{"B", "C", ""}, location.Lines)
+ assert.Equal(3, location.LineNumber)
+ assert.Equal(2, location.Pos)
+
+}
--- /dev/null
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package herrors contains common Hugo errors and error related utilities.
+package herrors
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "os"
+
+ _errors "github.com/pkg/errors"
+)
+
+// As defined in https://godoc.org/github.com/pkg/errors
+type causer interface {
+ Cause() error
+}
+
+type stackTracer interface {
+ StackTrace() _errors.StackTrace
+}
+
+// PrintStackTrace prints the error's stack trace to stdoud.
+func PrintStackTrace(err error) {
+ FprintStackTrace(os.Stdout, err)
+}
+
+// FprintStackTrace prints the error's stack trace to w.
+func FprintStackTrace(w io.Writer, err error) {
+ if err, ok := err.(stackTracer); ok {
+ for _, f := range err.StackTrace() {
+ fmt.Fprintf(w, "%+s:%d\n", f, f)
+ }
+ }
+}
+
+// ErrFeatureNotAvailable denotes that a feature is unavailable.
+//
+// We will, at least to begin with, make some Hugo features (SCSS with libsass) optional,
+// and this error is used to signal those situations.
+var ErrFeatureNotAvailable = errors.New("this feature is not available in your current Hugo version")
--- /dev/null
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitatio ns under the License.
+
+package herrors
+
+import (
+ "fmt"
+)
+
+var _ causer = (*fileError)(nil)
+
+// FileError represents an error when handling a file: Parsing a config file,
+// execute a template etc.
+type FileError interface {
+ error
+
+ // LineNumber gets the error location, starting at line 1.
+ LineNumber() int
+
+ // A string identifying the type of file, e.g. JSON, TOML, markdown etc.
+ Type() string
+}
+
+var _ FileError = (*fileError)(nil)
+
+type fileError struct {
+ lineNumber int
+ fileType string
+ msg string
+
+ cause error
+}
+
+func (e *fileError) LineNumber() int {
+ return e.lineNumber
+}
+
+func (e *fileError) Type() string {
+ return e.fileType
+}
+
+func (e *fileError) Error() string {
+ return e.msg
+}
+
+func (f *fileError) Cause() error {
+ return f.cause
+}
+
+func (e *fileError) Format(s fmt.State, verb rune) {
+ switch verb {
+ case 'v':
+ fallthrough
+ case 's':
+ fmt.Fprintf(s, "%s:%d: %s:%s", e.fileType, e.lineNumber, e.msg, e.cause)
+ case 'q':
+ fmt.Fprintf(s, "%q:%d: %q:%q", e.fileType, e.lineNumber, e.msg, e.cause)
+ }
+}
+
+// NewFileError creates a new FileError.
+func NewFileError(fileType string, lineNumber int, msg string, err error) FileError {
+ return &fileError{cause: err, fileType: fileType, lineNumber: lineNumber, msg: msg}
+}
+
+// UnwrapFileError tries to unwrap a FileError from err.
+// It returns nil if this is not possible.
+func UnwrapFileError(err error) FileError {
+ for err != nil {
+ switch v := err.(type) {
+ case FileError:
+ return v
+ case causer:
+ err = v.Cause()
+ default:
+ return nil
+ }
+ }
+ return nil
+}
+
+// ToFileError will try to convert the given error to an error supporting
+// the FileError interface.
+// If will fall back to returning the original error if a line number cannot be extracted.
+func ToFileError(fileType string, err error) error {
+ return ToFileErrorWithOffset(fileType, err, 0)
+}
+
+// ToFileErrorWithOffset will try to convert the given error to an error supporting
+// the FileError interface. It will take any line number offset given into account.
+// If will fall back to returning the original error if a line number cannot be extracted.
+func ToFileErrorWithOffset(fileType string, err error, offset int) error {
+ for _, handle := range lineNumberExtractors {
+ lno, msg := handle(err, offset)
+ if lno > 0 {
+ return NewFileError(fileType, lno, msg, err)
+ }
+ }
+ // Fall back to the original.
+ return err
+}
--- /dev/null
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package herrors
+
+import (
+ "errors"
+ "fmt"
+ "strconv"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestToLineNumberError(t *testing.T) {
+ t.Parallel()
+
+ assert := require.New(t)
+
+ for i, test := range []struct {
+ in error
+ offset int
+ lineNumber int
+ }{
+ {errors.New("no line number for you"), 0, -1},
+ {errors.New(`template: _default/single.html:2:15: executing "_default/single.html" at <.Titles>: can't evaluate field`), 0, 2},
+ {errors.New("parse failed: template: _default/bundle-resource-meta.html:11: unexpected in operand"), 0, 11},
+ {errors.New(`failed:: template: _default/bundle-resource-meta.html:2:7: executing "main" at <.Titles>`), 0, 2},
+ {errors.New("error in front matter: Near line 32 (last key parsed 'title')"), 0, 32},
+ {errors.New("error in front matter: Near line 32 (last key parsed 'title')"), 2, 34},
+ } {
+
+ got := ToFileErrorWithOffset("template", test.in, test.offset)
+
+ errMsg := fmt.Sprintf("[%d][%T]", i, got)
+ le, ok := got.(FileError)
+
+ if test.lineNumber > 0 {
+ assert.True(ok)
+ assert.Equal(test.lineNumber, le.LineNumber(), errMsg)
+ assert.Contains(got.Error(), strconv.Itoa(le.LineNumber()))
+ } else {
+ assert.False(ok)
+ }
+ }
+}
--- /dev/null
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitatio ns under the License.
+
+package herrors
+
+import (
+ "fmt"
+ "regexp"
+ "strconv"
+)
+
+var lineNumberExtractors = []lineNumberExtractor{
+ // Template/shortcode parse errors
+ newLineNumberErrHandlerFromRegexp("(.*?:)(\\d+)(:.*)"),
+
+ // TOML parse errors
+ newLineNumberErrHandlerFromRegexp("(.*Near line )(\\d+)(\\s.*)"),
+
+ // YAML parse errors
+ newLineNumberErrHandlerFromRegexp("(line )(\\d+)(:)"),
+}
+
+type lineNumberExtractor func(e error, offset int) (int, string)
+
+func newLineNumberErrHandlerFromRegexp(expression string) lineNumberExtractor {
+ re := regexp.MustCompile(expression)
+ return extractLineNo(re)
+}
+
+func extractLineNo(re *regexp.Regexp) lineNumberExtractor {
+ return func(e error, offset int) (int, string) {
+ if e == nil {
+ panic("no error")
+ }
+ s := e.Error()
+ m := re.FindStringSubmatch(s)
+ if len(m) == 4 {
+ i, _ := strconv.Atoi(m[2])
+ msg := e.Error()
+ if offset != 0 {
+ i = i + offset
+ msg = re.ReplaceAllString(s, fmt.Sprintf("${1}%d${3}", i))
+ }
+ return i, msg
+ }
+
+ return -1, ""
+ }
+}
package loggers
import (
+ "bytes"
+ "io"
"io/ioutil"
"log"
"os"
jww "github.com/spf13/jwalterweatherman"
)
+var (
+ // Counts ERROR logs to the global jww logger.
+ GlobalErrorCounter *jww.Counter
+)
+
+func init() {
+ GlobalErrorCounter = &jww.Counter{}
+ jww.SetLogListeners(jww.LogCounter(GlobalErrorCounter, jww.LevelError))
+}
+
+// Logger wraps a *loggers.Logger and some other related logging state.
+type Logger struct {
+ *jww.Notepad
+ ErrorCounter *jww.Counter
+
+ // This is only set in server mode.
+ Errors *bytes.Buffer
+}
+
+// Reset resets the logger's internal state.
+func (l *Logger) Reset() {
+ l.ErrorCounter.Reset()
+ if l.Errors != nil {
+ l.Errors.Reset()
+ }
+}
+
+// NewLogger creates a new Logger for the given thresholds
+func NewLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer, saveErrors bool) *Logger {
+ return newLogger(stdoutThreshold, logThreshold, outHandle, logHandle, saveErrors)
+}
+
// NewDebugLogger is a convenience function to create a debug logger.
-func NewDebugLogger() *jww.Notepad {
- return jww.NewNotepad(jww.LevelDebug, jww.LevelError, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+func NewDebugLogger() *Logger {
+ return newBasicLogger(jww.LevelDebug)
}
// NewWarningLogger is a convenience function to create a warning logger.
-func NewWarningLogger() *jww.Notepad {
- return jww.NewNotepad(jww.LevelWarn, jww.LevelError, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+func NewWarningLogger() *Logger {
+ return newBasicLogger(jww.LevelWarn)
}
// NewErrorLogger is a convenience function to create an error logger.
-func NewErrorLogger() *jww.Notepad {
- return jww.NewNotepad(jww.LevelError, jww.LevelError, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+func NewErrorLogger() *Logger {
+ return newBasicLogger(jww.LevelError)
+}
+
+func newLogger(stdoutThreshold, logThreshold jww.Threshold, outHandle, logHandle io.Writer, saveErrors bool) *Logger {
+ errorCounter := &jww.Counter{}
+ listeners := []jww.LogListener{jww.LogCounter(errorCounter, jww.LevelError)}
+ var errorBuff *bytes.Buffer
+ if saveErrors {
+ errorBuff = new(bytes.Buffer)
+ errorCapture := func(t jww.Threshold) io.Writer {
+ if t != jww.LevelError {
+ // Only interested in ERROR
+ return nil
+ }
+
+ return errorBuff
+ }
+
+ listeners = append(listeners, errorCapture)
+ }
+
+ return &Logger{
+ Notepad: jww.NewNotepad(stdoutThreshold, logThreshold, outHandle, logHandle, "", log.Ldate|log.Ltime, listeners...),
+ ErrorCounter: errorCounter,
+ Errors: errorBuff,
+ }
+}
+
+func newBasicLogger(t jww.Threshold) *Logger {
+ return newLogger(t, jww.LevelError, os.Stdout, ioutil.Discard, false)
}
import (
"bytes"
- "fmt"
+
+ "github.com/pkg/errors"
+
"io"
"os"
"os/exec"
targetDir := filepath.Dir(targetFilename)
if err := targetFs.MkdirAll(targetDir, 0777); err != nil && !os.IsExist(err) {
- return fmt.Errorf("failed to create target directory for %s: %s", targetDir, err)
+ return errors.Wrapf(err, "failed to create target directory for %s:", targetDir)
}
out, err := targetFs.Create(targetFilename)
func usesSiteVar(fs afero.Fs, filename string) (bool, error) {
f, err := fs.Open(filename)
if err != nil {
- return false, fmt.Errorf("failed to open archetype file: %s", err)
+ return false, errors.Wrap(err, "failed to open archetype file")
}
defer f.Close()
return helpers.ReaderContains(f, []byte(".Site")), nil
"strings"
"time"
+ "github.com/pkg/errors"
+
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/source"
templateHandler := s.Deps.Tmpl.(tpl.TemplateHandler)
templateName := "_text/" + helpers.Filename(archetypeFilename)
if err := templateHandler.AddTemplate(templateName, string(archetypeTemplate)); err != nil {
- return nil, fmt.Errorf("Failed to parse archetype file %q: %s", archetypeFilename, err)
+ return nil, errors.Wrapf(err, "Failed to parse archetype file %q:", archetypeFilename)
}
templ, _ := templateHandler.Lookup(templateName)
var buff bytes.Buffer
if err := templ.Execute(&buff, data); err != nil {
- return nil, fmt.Errorf("Failed to process archetype file %q: %s", archetypeFilename, err)
+ return nil, errors.Wrapf(err, "Failed to process archetype file %q:", archetypeFilename)
}
archetypeContent = []byte(archetypeShortcodeReplacementsPost.Replace(buff.String()))
"github.com/gohugoio/hugo/resource"
"github.com/gohugoio/hugo/source"
"github.com/gohugoio/hugo/tpl"
- jww "github.com/spf13/jwalterweatherman"
)
// Deps holds dependencies used by many.
type Deps struct {
// The logger to use.
- Log *jww.Notepad `json:"-"`
+ Log *loggers.Logger `json:"-"`
// Used to log errors that may repeat itself many times.
DistinctErrorLog *helpers.DistinctLogger
return err
}
- if th, ok := d.Tmpl.(tpl.TemplateHandler); ok {
- th.PrintErrors()
- }
-
return nil
}
type DepsCfg struct {
// The Logger to use.
- Logger *jww.Notepad
+ Logger *loggers.Logger
// The file systems to use
Fs *hugofs.Fs
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect
github.com/nicksnyder/go-i18n v1.10.0
github.com/olekukonko/tablewriter v0.0.0-20180506121414-d4647c9c7a84
- github.com/pmezard/go-difflib v1.0.0 // indirect
+ github.com/pkg/errors v0.8.0
github.com/russross/blackfriday v0.0.0-20180804101149-46c73eb196ba
github.com/sanity-io/litter v1.1.0
github.com/sergi/go-diff v1.0.0 // indirect
github.com/spf13/cast v1.2.0
github.com/spf13/cobra v0.0.3
github.com/spf13/fsync v0.0.0-20170320142552-12a01e648f05
- github.com/spf13/jwalterweatherman v1.0.0
+ github.com/spf13/jwalterweatherman v1.0.1-0.20181005085228-103a6da826d0
github.com/spf13/nitro v0.0.0-20131003134307-24d7ef30a12d
github.com/spf13/pflag v1.0.2
github.com/spf13/viper v1.2.0
golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81
golang.org/x/net v0.0.0-20180906233101-161cd47e91fd // indirect
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f
+ golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e // indirect
golang.org/x/text v0.3.0
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
gopkg.in/yaml.v2 v2.2.1
github.com/olekukonko/tablewriter v0.0.0-20180506121414-d4647c9c7a84/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/russross/blackfriday v0.0.0-20180804101149-46c73eb196ba h1:8Vzt8HxRjy7hp1eqPKVoAEPK9npQFW2510qlobGzvi0=
github.com/spf13/fsync v0.0.0-20170320142552-12a01e648f05/go.mod h1:jdsEoy1w+v0NpuwXZEaRAH6ADTDmzfRnE2eVwshwFrM=
github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9Gc1vn7yk=
github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/jwalterweatherman v1.0.1-0.20181005085228-103a6da826d0 h1:kPJPXmEs6V1YyXfHFbp1NCpdqhvFVssh2FGx7+OoJLM=
+github.com/spf13/jwalterweatherman v1.0.1-0.20181005085228-103a6da826d0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
github.com/spf13/nitro v0.0.0-20131003134307-24d7ef30a12d h1:ihvj2nmx8eqWjlgNgdW6h0DyGJuq5GiwHadJkG0wXtQ=
github.com/spf13/nitro v0.0.0-20131003134307-24d7ef30a12d/go.mod h1:jU8A+8xL+6n1OX4XaZtCj4B3mIa64tULUsD6YegdpFo=
github.com/spf13/pflag v1.0.2 h1:Fy0orTDgHdbnzHcsOgfCN4LtHf0ec3wwtiwJqwvf3Gc=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20180906133057-8cf3aee42992 h1:BH3eQWeGbwRU2+wxxuuPOdFBmaiBH81O8BugSjHeTFg=
golang.org/x/sys v0.0.0-20180906133057-8cf3aee42992/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e h1:o3PsSEY8E4eXWkXrIP9YJALUkVZqzHJT5DOasTyn8Vs=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
"unicode"
"github.com/gohugoio/hugo/common/hugio"
+ _errors "github.com/pkg/errors"
"github.com/spf13/afero"
"golang.org/x/text/transform"
"golang.org/x/text/unicode/norm"
if fileInfo.Mode()&os.ModeSymlink == os.ModeSymlink {
link, err := filepath.EvalSymlinks(path)
if err != nil {
- return nil, "", fmt.Errorf("Cannot read symbolic link '%s', error was: %s", path, err)
+ return nil, "", _errors.Wrapf(err, "Cannot read symbolic link %q", path)
}
fileInfo, err = LstatIfPossible(fs, link)
if err != nil {
- return nil, "", fmt.Errorf("Cannot stat '%s', error was: %s", link, err)
+ return nil, "", _errors.Wrapf(err, "Cannot stat %q", link)
}
realPath = link
}
"runtime"
"strings"
+ "github.com/gohugoio/hugo/common/loggers"
+
"github.com/gohugoio/hugo/output"
"github.com/gohugoio/hugo/publisher"
"github.com/gohugoio/hugo/tpl"
- jww "github.com/spf13/jwalterweatherman"
-
"github.com/gohugoio/hugo/helpers"
)
type aliasHandler struct {
t tpl.TemplateFinder
- log *jww.Notepad
+ log *loggers.Logger
allowRoot bool
}
-func newAliasHandler(t tpl.TemplateFinder, l *jww.Notepad, allowRoot bool) aliasHandler {
+func newAliasHandler(t tpl.TemplateFinder, l *loggers.Logger, allowRoot bool) aliasHandler {
return aliasHandler{t, l, allowRoot}
}
"errors"
"fmt"
- "github.com/gohugoio/hugo/hugolib/paths"
-
"io"
"strings"
+ "github.com/gohugoio/hugo/hugolib/paths"
+ _errors "github.com/pkg/errors"
+
"github.com/gohugoio/hugo/langs"
"github.com/gohugoio/hugo/config"
} else {
languages2, err = toSortedLanguages(cfg, languages)
if err != nil {
- return fmt.Errorf("Failed to parse multilingual config: %s", err)
+ return _errors.Wrap(err, "Failed to parse multilingual config")
}
}
}
}()
- s := buildSingleSiteExpected(t, expectBuildError, depsCfg, BuildCfg{SkipRender: true})
+ s := buildSingleSiteExpected(t, false, expectBuildError, depsCfg, BuildCfg{SkipRender: true})
if !expectBuildError && !reflect.DeepEqual(expected, s.Data) {
// This disabled code detects the situation described in the WARNING message below.
}
func (fi *fileInfo) Filename() string {
+ if fi == nil || fi.basePather == nil {
+ return ""
+ }
return fi.basePather.Filename()
}
"strings"
"sync"
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/langs"
"github.com/gohugoio/hugo/i18n"
"github.com/gohugoio/hugo/tpl"
"github.com/gohugoio/hugo/tpl/tplimpl"
- jww "github.com/spf13/jwalterweatherman"
)
// HugoSites represents the sites to build. Each site represents a language.
if h == nil {
return 0
}
- return int(h.Log.LogCountForLevelsGreaterThanorEqualTo(jww.LevelError))
+ return int(h.Log.ErrorCounter.Count())
}
func (h *HugoSites) PrintProcessingStats(w io.Writer) {
func (s *Site) withSiteTemplates(withTemplates ...func(templ tpl.TemplateHandler) error) func(templ tpl.TemplateHandler) error {
return func(templ tpl.TemplateHandler) error {
- templ.LoadTemplates("")
+ if err := templ.LoadTemplates(""); err != nil {
+ return err
+ }
for _, wt := range withTemplates {
if wt == nil {
// resetLogs resets the log counters etc. Used to do a new build on the same sites.
func (h *HugoSites) resetLogs() {
- h.Log.ResetLogCounters()
+ h.Log.Reset()
+ loggers.GlobalErrorCounter.Reset()
for _, s := range h.Sites {
s.Deps.DistinctErrorLog = helpers.NewDistinctLogger(h.Log.ERROR)
}
"errors"
- jww "github.com/spf13/jwalterweatherman"
-
"github.com/fsnotify/fsnotify"
"github.com/gohugoio/hugo/helpers"
)
h.Log.FEEDBACK.Println()
}
- errorCount := h.Log.LogCountForLevel(jww.LevelError)
+ errorCount := h.Log.ErrorCounter.Count()
if errorCount > 0 {
return fmt.Errorf("logged %d error(s)", errorCount)
}
--- /dev/null
+package hugolib
+
+import (
+ "fmt"
+ "strings"
+ "testing"
+
+ "github.com/gohugoio/hugo/common/herrors"
+ "github.com/stretchr/testify/require"
+)
+
+type testSiteBuildErrorAsserter struct {
+ name string
+ assert *require.Assertions
+}
+
+func (t testSiteBuildErrorAsserter) getFileError(err error) *herrors.ErrorWithFileContext {
+ t.assert.NotNil(err, t.name)
+ ferr := herrors.UnwrapErrorWithFileContext(err)
+ t.assert.NotNil(ferr, fmt.Sprintf("[%s] got %T: %+v", t.name, err, err))
+ return ferr
+}
+
+func (t testSiteBuildErrorAsserter) assertLineNumber(lineNumber int, err error) {
+ fe := t.getFileError(err)
+ t.assert.Equal(lineNumber, fe.LineNumber, fmt.Sprintf("[%s] got => %s", t.name, fe))
+}
+
+func TestSiteBuildErrors(t *testing.T) {
+ t.Parallel()
+ assert := require.New(t)
+
+ const (
+ yamlcontent = "yamlcontent"
+ shortcode = "shortcode"
+ base = "base"
+ single = "single"
+ )
+
+ // TODO(bep) add content tests after https://github.com/gohugoio/hugo/issues/5324
+ // is implemented.
+
+ tests := []struct {
+ name string
+ fileType string
+ fileFixer func(content string) string
+ assertCreateError func(a testSiteBuildErrorAsserter, err error)
+ assertBuildError func(a testSiteBuildErrorAsserter, err error)
+ }{
+
+ {
+ name: "Base template parse failed",
+ fileType: base,
+ fileFixer: func(content string) string {
+ return strings.Replace(content, ".Title }}", ".Title }", 1)
+ },
+ assertCreateError: func(a testSiteBuildErrorAsserter, err error) {
+ a.assertLineNumber(2, err)
+ },
+ },
+ {
+ name: "Base template execute failed",
+ fileType: base,
+ fileFixer: func(content string) string {
+ return strings.Replace(content, ".Title", ".Titles", 1)
+ },
+ assertBuildError: func(a testSiteBuildErrorAsserter, err error) {
+ a.assertLineNumber(2, err)
+ },
+ },
+ {
+ name: "Single template parse failed",
+ fileType: single,
+ fileFixer: func(content string) string {
+ return strings.Replace(content, ".Title }}", ".Title }", 1)
+ },
+ assertCreateError: func(a testSiteBuildErrorAsserter, err error) {
+ a.assertLineNumber(3, err)
+ },
+ },
+ {
+ name: "Single template execute failed",
+ fileType: single,
+ fileFixer: func(content string) string {
+ return strings.Replace(content, ".Title", ".Titles", 1)
+ },
+ assertBuildError: func(a testSiteBuildErrorAsserter, err error) {
+ a.assertLineNumber(3, err)
+ },
+ },
+ {
+ name: "Shortcode parse failed",
+ fileType: shortcode,
+ fileFixer: func(content string) string {
+ return strings.Replace(content, ".Title }}", ".Title }", 1)
+ },
+ assertCreateError: func(a testSiteBuildErrorAsserter, err error) {
+ a.assertLineNumber(2, err)
+ },
+ },
+ // TODO(bep) 2errors
+ /* {
+ name: "Shortode execute failed",
+ fileType: shortcode,
+ fileFixer: func(content string) string {
+ return strings.Replace(content, ".Title", ".Titles", 1)
+ },
+ assertBuildError: func(a testSiteBuildErrorAsserter, err error) {
+ a.assertLineNumber(2, err)
+ },
+ },*/
+ }
+
+ for _, test := range tests {
+
+ errorAsserter := testSiteBuildErrorAsserter{
+ assert: assert,
+ name: test.name,
+ }
+
+ b := newTestSitesBuilder(t).WithSimpleConfigFile()
+
+ f := func(fileType, content string) string {
+ if fileType != test.fileType {
+ return content
+ }
+ return test.fileFixer(content)
+
+ }
+
+ b.WithTemplatesAdded("layouts/shortcodes/sc.html", f(shortcode, `SHORTCODE L1
+SHORTCODE L2
+SHORTCODE L3:
+SHORTCODE L4: {{ .Page.Title }}
+`))
+ b.WithTemplatesAdded("layouts/_default/baseof.html", f(base, `BASEOF L1
+BASEOF L2
+BASEOF L3
+BASEOF L4{{ if .Title }}{{ end }}
+{{block "main" .}}This is the main content.{{end}}
+BASEOF L6
+`))
+
+ b.WithTemplatesAdded("layouts/_default/single.html", f(single, `{{ define "main" }}
+SINGLE L2:
+SINGLE L3:
+SINGLE L4:
+SINGLE L5: {{ .Title }} {{ .Content }}
+{{ end }}
+`))
+
+ b.WithContent("myyaml.md", f(yamlcontent, `---
+title: "The YAML"
+---
+
+Some content.
+
+{{< sc >}}
+
+Some more text.
+
+The end.
+
+`))
+
+ createErr := b.CreateSitesE()
+ if test.assertCreateError != nil {
+ test.assertCreateError(errorAsserter, createErr)
+ } else {
+ assert.NoError(createErr)
+ }
+
+ if createErr == nil {
+ buildErr := b.BuildE(BuildCfg{})
+ if test.assertBuildError != nil {
+ test.assertBuildError(errorAsserter, buildErr)
+ } else {
+ assert.NoError(buildErr)
+ }
+ }
+ }
+}
+++ /dev/null
-package hugolib
-
-import (
- "fmt"
- "testing"
-)
-
-// https://github.com/gohugoio/hugo/issues/4526
-func TestSiteBuildFailureInvalidPageMetadata(t *testing.T) {
- t.Parallel()
-
- validContentFile := `
----
-title = "This is good"
----
-
-Some content.
-`
-
- invalidContentFile := `
----
-title = "PDF EPUB: Anne Bradstreet: Poems "The Prologue Summary And Analysis EBook Full Text "
----
-
-Some content.
-`
-
- var contentFiles []string
- for i := 0; i <= 30; i++ {
- name := fmt.Sprintf("valid%d.md", i)
- contentFiles = append(contentFiles, name, validContentFile)
- if i%5 == 0 {
- name = fmt.Sprintf("invalid%d.md", i)
- contentFiles = append(contentFiles, name, invalidContentFile)
- }
- }
-
- b := newTestSitesBuilder(t)
- b.WithSimpleConfigFile().WithContent(contentFiles...)
- b.CreateSites().BuildFail(BuildCfg{})
-
-}
"unicode"
"github.com/gohugoio/hugo/media"
+ _errors "github.com/pkg/errors"
"github.com/gohugoio/hugo/common/maps"
err = p.prepareForRender()
if err != nil {
- p.s.Log.ERROR.Printf("Failed to prepare page %q for render: %s", p.Path(), err)
+ c <- err
return
}
if len(p.summary) == 0 {
if err = p.setAutoSummary(); err != nil {
- err = fmt.Errorf("Failed to set user auto summary for page %q: %s", p.pathOrTitle(), err)
+ err = _errors.Wrapf(err, "Failed to set user auto summary for page %q:", p.pathOrTitle())
}
}
c <- err
p.s.Log.WARN.Printf("WARNING: Timed out creating content for page %q (.Content will be empty). This is most likely a circular shortcode content loop that should be fixed. If this is just a shortcode calling a slow remote service, try to set \"timeout=20000\" (or higher, value is in milliseconds) in config.toml.\n", p.pathOrTitle())
case err := <-c:
if err != nil {
+ // TODO(bep) 2errors needs to be transported to the caller.
p.s.Log.ERROR.Println(err)
}
}
})
-
}
// This is sent to the shortcodes for this page. Not doing that will create an infinite regress. So,
return p, nil
}
+func (p *Page) errorf(err error, format string, a ...interface{}) error {
+ args := append([]interface{}{p.Lang(), p.pathOrTitle()}, a...)
+ format = "[%s] Page %q: " + format
+ if err == nil {
+ return fmt.Errorf(format, args...)
+ }
+ return _errors.Wrapf(err, format, args...)
+}
+
func (p *Page) ReadFrom(buf io.Reader) (int64, error) {
// Parse for metadata & body
if err := p.parse(buf); err != nil {
- p.s.Log.ERROR.Printf("%s for %s", err, p.File.Path())
- return 0, err
+ return 0, p.errorf(err, "parse failed")
+
}
return int64(len(p.rawContent)), nil
pageOutput, err := newPageOutput(p, false, false, outFormat)
if err != nil {
- return fmt.Errorf("Failed to create output page for type %q for page %q: %s", outFormat.Name, p.pathOrTitle(), err)
+ return _errors.Wrapf(err, "Failed to create output page for type %q for page %q:", outFormat.Name, p.pathOrTitle())
}
p.mainPageOutput = pageOutput
// Note: The shortcodes in a page cannot access the page content it lives in,
// hence the withoutContent().
if workContentCopy, err = handleShortcodes(p.withoutContent(), workContentCopy); err != nil {
- s.Log.ERROR.Printf("Failed to handle shortcodes for page %s: %s", p.BaseFileName(), err)
+ return err
}
if p.Markup != "html" {
return nil
}
-var ErrHasDraftAndPublished = errors.New("both draft and published parameters were found in page's frontmatter")
-
func (p *Page) update(frontmatter map[string]interface{}) error {
if frontmatter == nil {
return errors.New("missing frontmatter data")
if draft != nil && published != nil {
p.Draft = *draft
- p.s.Log.ERROR.Printf("page %s has both draft and published settings in its frontmatter. Using draft.", p.File.Path())
- return ErrHasDraftAndPublished
+ p.s.Log.WARN.Printf("page %q has both draft and published settings in its frontmatter. Using draft.", p.File.Path())
} else if draft != nil {
p.Draft = *draft
} else if published != nil {
func (p *Page) parse(reader io.Reader) error {
psr, err := parser.ReadFrom(reader)
+
if err != nil {
return err
}
meta, err := psr.Metadata()
if err != nil {
- return fmt.Errorf("failed to parse page metadata for %q: %s", p.File.Path(), err)
+ return _errors.Wrap(err, "error in front matter")
}
if meta == nil {
// missing frontmatter equivalent to empty frontmatter
func (p *Page) Ref(argsm map[string]interface{}) (string, error) {
args, s, err := p.decodeRefArgs(argsm)
if err != nil {
- return "", fmt.Errorf("invalid arguments to Ref: %s", err)
+ return "", _errors.Wrap(err, "invalid arguments to Ref")
}
if s == nil {
func (p *Page) RelRef(argsm map[string]interface{}) (string, error) {
args, s, err := p.decodeRefArgs(argsm)
if err != nil {
- return "", fmt.Errorf("invalid arguments to Ref: %s", err)
+ return "", _errors.Wrap(err, "invalid arguments to Ref")
}
if s == nil {
// Used in error logs.
func (p *Page) pathOrTitle() string {
- if p.Path() != "" {
- return p.Path()
+ if p.Filename() != "" {
+ // Make a path relative to the working dir if possible.
+ filename := strings.TrimPrefix(p.Filename(), p.s.WorkingDir)
+ if filename != p.Filename() {
+ filename = strings.TrimPrefix(filename, helpers.FilePathSeparator)
+ }
+ return filename
}
return p.title
}
"math"
"runtime"
+ _errors "github.com/pkg/errors"
+
"golang.org/x/sync/errgroup"
)
for _, file := range files {
f, err := s.site.BaseFs.Content.Fs.Open(file.Filename())
if err != nil {
- return fmt.Errorf("failed to open assets file: %s", err)
+ return _errors.Wrap(err, "failed to open assets file")
}
err = s.site.publish(&s.site.PathSpec.ProcessingStats.Files, file.Path(), f)
f.Close()
"path"
"path/filepath"
"runtime"
+
+ "github.com/gohugoio/hugo/common/loggers"
+ _errors "github.com/pkg/errors"
+
"sort"
"strings"
"sync"
"golang.org/x/sync/errgroup"
"github.com/gohugoio/hugo/source"
- jww "github.com/spf13/jwalterweatherman"
)
var errSkipCyclicDir = errors.New("skip potential cyclic dir")
sourceSpec *source.SourceSpec
fs afero.Fs
- logger *jww.Notepad
+ logger *loggers.Logger
// Filenames limits the content to process to a list of filenames/directories.
// This is used for partial building in server mode.
}
func newCapturer(
- logger *jww.Notepad,
+ logger *loggers.Logger,
sourceSpec *source.SourceSpec,
handler captureResultHandler,
contentChanges *contentChangeMap,
if fileInfo.Mode()&os.ModeSymlink == os.ModeSymlink {
link, err := filepath.EvalSymlinks(path)
if err != nil {
- return fmt.Errorf("Cannot read symbolic link %q, error was: %s", path, err)
+ return _errors.Wrapf(err, "Cannot read symbolic link %q, error was:", path)
}
// This is a file on the outside of any base fs, so we have to use the os package.
sfi, err := os.Stat(link)
if err != nil {
- return fmt.Errorf("Cannot stat %q, error was: %s", link, err)
+ return _errors.Wrapf(err, "Cannot stat %q, error was:", link)
}
// TODO(bep) improve all of this.
"github.com/gohugoio/hugo/common/loggers"
- jww "github.com/spf13/jwalterweatherman"
-
"runtime"
"strings"
"sync"
assert.NoError(c.capture())
- // Symlink back to content skipped to prevent infinite recursion.
- assert.Equal(uint64(3), logger.LogCountForLevelsGreaterThanorEqualTo(jww.LevelWarn))
-
expected := `
F:
/base/a/page_s.md
assert.Len(pageResources, 2)
firstPage := pageResources[0].(*Page)
secondPage := pageResources[1].(*Page)
- assert.Equal(filepath.FromSlash("b/my-bundle/1.md"), firstPage.pathOrTitle(), secondPage.pathOrTitle())
+ assert.Equal(filepath.FromSlash("base/b/my-bundle/1.md"), firstPage.pathOrTitle(), secondPage.pathOrTitle())
assert.Contains(firstPage.content(), "TheContent")
assert.Equal(6, len(leafBundle1.Resources))
}
}
-var pageWithDraftAndPublished = `---
-title: broken
-published: false
-draft: true
----
-some content
-`
-
-func TestDraftAndPublishedFrontMatterError(t *testing.T) {
- t.Parallel()
- s := newTestSite(t)
- _, err := s.NewPageFrom(strings.NewReader(pageWithDraftAndPublished), "content/post/broken.md")
- if err != ErrHasDraftAndPublished {
- t.Errorf("expected ErrHasDraftAndPublished, was %#v", err)
- }
-}
-
var pagesWithPublishedFalse = `---
title: okay
published: false
package pagemeta
import (
- "io/ioutil"
- "log"
- "os"
"strings"
"time"
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/config"
"github.com/spf13/cast"
- jww "github.com/spf13/jwalterweatherman"
)
// FrontMatterHandler maps front matter into Page fields and .Params.
// A map of all date keys configured, including any custom.
allDateKeys map[string]bool
- logger *jww.Notepad
+ logger *loggers.Logger
}
// FrontMatterDescriptor describes how to handle front matter for a given Page.
// NewFrontmatterHandler creates a new FrontMatterHandler with the given logger and configuration.
// If no logger is provided, one will be created.
-func NewFrontmatterHandler(logger *jww.Notepad, cfg config.Provider) (FrontMatterHandler, error) {
+func NewFrontmatterHandler(logger *loggers.Logger, cfg config.Provider) (FrontMatterHandler, error) {
if logger == nil {
- logger = jww.NewNotepad(jww.LevelWarn, jww.LevelWarn, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+ logger = loggers.NewWarningLogger()
}
frontMatterConfig, err := newFrontmatterConfig(cfg)
"github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/langs"
+ "github.com/pkg/errors"
"github.com/gohugoio/hugo/hugofs"
)
baseURL, err := newBaseURLFromString(baseURLstr)
if err != nil {
- return nil, fmt.Errorf("Failed to create baseURL from %q: %s", baseURLstr, err)
+ return nil, errors.Wrapf(err, "Failed to create baseURL from %q:", baseURLstr)
}
- contentDir := cfg.GetString("contentDir")
- workingDir := cfg.GetString("workingDir")
- resourceDir := cfg.GetString("resourceDir")
- publishDir := cfg.GetString("publishDir")
+ contentDir := filepath.Clean(cfg.GetString("contentDir"))
+ workingDir := filepath.Clean(cfg.GetString("workingDir"))
+ resourceDir := filepath.Clean(cfg.GetString("resourceDir"))
+ publishDir := filepath.Clean(cfg.GetString("publishDir"))
if contentDir == "" {
return nil, fmt.Errorf("contentDir not set")
"reflect"
"regexp"
"sort"
+
+ _errors "github.com/pkg/errors"
+
"strings"
"sync"
// The most specific template will win.
key := newScKeyFromLangAndOutputFormat(lang, f, placeholder)
m[key] = func() (string, error) {
- return renderShortcode(key, sc, nil, p), nil
+ return renderShortcode(key, sc, nil, p)
}
}
tmplKey scKey,
sc *shortcode,
parent *ShortcodeWithPage,
- p *PageWithoutContent) string {
+ p *PageWithoutContent) (string, error) {
tmpl := getShortcodeTemplateForTemplateKey(tmplKey, sc.name, p.s.Tmpl)
if tmpl == nil {
p.s.Log.ERROR.Printf("Unable to locate template for shortcode %q in page %q", sc.name, p.Path())
- return ""
+ return "", nil
}
data := &ShortcodeWithPage{Ordinal: sc.ordinal, Params: sc.params, Page: p, Parent: parent}
case string:
inner += innerData.(string)
case *shortcode:
- inner += renderShortcode(tmplKey, innerData.(*shortcode), data, p)
+ s, err := renderShortcode(tmplKey, innerData.(*shortcode), data, p)
+ if err != nil {
+ return "", err
+ }
+ inner += s
default:
p.s.Log.ERROR.Printf("Illegal state on shortcode rendering of %q in page %q. Illegal type in inner data: %s ",
sc.name, p.Path(), reflect.TypeOf(innerData))
- return ""
+ return "", nil
}
}
render := s.contentShortcodesDelta.getShortcodeRenderer(k)
renderedShortcode, err := render()
if err != nil {
- return fmt.Errorf("Failed to execute shortcode in page %q: %s", p.Path(), err)
+ return _errors.Wrapf(err, "Failed to execute shortcode in page %q:", p.Path())
}
s.renderedShortcodes[k.(scKey).ShortcodePlaceholder] = renderedShortcode
var cnt = 0
var nestedOrdinal = 0
+ // TODO(bep) 2errors revisit after https://github.com/gohugoio/hugo/issues/5324
+ msgf := func(i item, format string, args ...interface{}) string {
+ format = format + ":%d:"
+ c1 := strings.Count(pt.lexer.input[:i.pos], "\n") + 1
+ c2 := bytes.Count(p.frontmatter, []byte{'\n'})
+ args = append(args, c1+c2)
+ return fmt.Sprintf(format, args...)
+
+ }
+
Loop:
for {
currItem = pt.next()
// return that error, more specific
continue
}
- return sc, fmt.Errorf("Shortcode '%s' in page '%s' has no .Inner, yet a closing tag was provided", next.val, p.FullFilePath())
+ return sc, errors.New(msgf(next, "shortcode %q has no .Inner, yet a closing tag was provided", next.val))
}
if next.typ == tRightDelimScWithMarkup || next.typ == tRightDelimScNoMarkup {
// self-closing
// if more than one. It is "all inner or no inner".
tmpl := getShortcodeTemplateForTemplateKey(scKey{}, sc.name, p.s.Tmpl)
if tmpl == nil {
- return sc, fmt.Errorf("Unable to locate template for shortcode %q in page %q", sc.name, p.Path())
+ return sc, errors.New(msgf(currItem, "unable to locate template for shortcode %q", sc.name))
}
var err error
isInner, err = isInnerShortcode(tmpl.(tpl.TemplateExecutor))
if err != nil {
- return sc, fmt.Errorf("Failed to handle template for shortcode %q for page %q: %s", sc.name, p.Path(), err)
+ return sc, _errors.Wrap(err, msgf(currItem, "failed to handle template for shortcode %q", sc.name))
}
case tScParam:
case tEOF:
break Loop
case tError:
- err := fmt.Errorf("%s:%d: %s",
- p.FullFilePath(), (p.lineNumRawContentStart() + pt.lexer.lineNum() - 1), currItem)
+ err := fmt.Errorf("%s:shortcode:%d: %s",
+ p.pathOrTitle(), (p.lineNumRawContentStart() + pt.lexer.lineNum() - 1), currItem)
currShortcode.err = err
return result.String(), err
}
return nil
}
-func renderShortcodeWithPage(tmpl tpl.Template, data *ShortcodeWithPage) string {
+func renderShortcodeWithPage(tmpl tpl.Template, data *ShortcodeWithPage) (string, error) {
buffer := bp.GetBuffer()
defer bp.PutBuffer(buffer)
err := tmpl.Execute(buffer, data)
isInnerShortcodeCache.RUnlock()
if err != nil {
- data.Page.s.Log.ERROR.Printf("error processing shortcode %q for page %q: %s", tmpl.Name(), data.Page.Path(), err)
+ return "", data.Page.errorf(err, "failed to process shortcode")
}
- return buffer.String()
+ return buffer.String(), nil
}
"github.com/spf13/viper"
- jww "github.com/spf13/jwalterweatherman"
-
"github.com/spf13/afero"
"github.com/gohugoio/hugo/output"
expectErrorMsg string
}{
{"text", "Some text.", "map[]", "Some text.", ""},
- {"invalid right delim", "{{< tag }}", "", false, "simple.md:4:.*unrecognized character.*}"},
- {"invalid close", "\n{{< /tag >}}", "", false, "simple.md:5:.*got closing shortcode, but none is open"},
- {"invalid close2", "\n\n{{< tag >}}{{< /anotherTag >}}", "", false, "simple.md:6: closing tag for shortcode 'anotherTag' does not match start tag"},
- {"unterminated quote 1", `{{< figure src="im caption="S" >}}`, "", false, "simple.md:4:.got pos.*"},
- {"unterminated quote 1", `{{< figure src="im" caption="S >}}`, "", false, "simple.md:4:.*unterm.*}"},
+ {"invalid right delim", "{{< tag }}", "", false, ":4:.*unrecognized character.*}"},
+ {"invalid close", "\n{{< /tag >}}", "", false, ":5:.*got closing shortcode, but none is open"},
+ {"invalid close2", "\n\n{{< tag >}}{{< /anotherTag >}}", "", false, ":6: closing tag for shortcode 'anotherTag' does not match start tag"},
+ {"unterminated quote 1", `{{< figure src="im caption="S" >}}`, "", false, ":4:.got pos.*"},
+ {"unterminated quote 1", `{{< figure src="im" caption="S >}}`, "", false, ":4:.*unterm.*}"},
{"one shortcode, no markup", "{{< tag >}}", "", testScPlaceholderRegexp, ""},
{"one shortcode, markup", "{{% tag %}}", "", testScPlaceholderRegexp, ""},
{"one pos param", "{{% tag param1 %}}", `tag([\"param1\"], true){[]}"]`, testScPlaceholderRegexp, ""},
// issue #934
{"inner self-closing", `Some text. {{< inner />}}. Some more text.`, `inner([], false){[]}`,
fmt.Sprintf("Some text. %s. Some more text.", testScPlaceholderRegexp), ""},
- {"close, but not inner", "{{< tag >}}foo{{< /tag >}}", "", false, "Shortcode 'tag' in page 'simple.md' has no .Inner.*"},
+ {"close, but not inner", "{{< tag >}}foo{{< /tag >}}", "", false, `shortcode "tag" has no .Inner, yet a closing tag was provided`},
{"nested inner", `Inner->{{< inner >}}Inner Content->{{% inner2 param1 %}}inner2txt{{% /inner2 %}}Inner close->{{< / inner >}}<-done`,
`inner([], false){[Inner Content-> inner2([\"param1\"], true){[inner2txt]} Inner close->]}`,
fmt.Sprintf("Inner->%s<-done", testScPlaceholderRegexp), ""},
} else {
r, _ := regexp.Compile(this.expectErrorMsg)
if !r.MatchString(err.Error()) {
- t.Fatalf("[%d] %s: ExtractShortcodes didn't return an expected error message, got %s but expected %s",
+ t.Fatalf("[%d] %s: ExtractShortcodes didn't return an expected error message, got\n%s but expected\n%s",
i, this.name, err.Error(), this.expectErrorMsg)
}
}
"thisDoesNotExist",
)
- require.Equal(t, uint64(1), s.Log.LogCountForLevel(jww.LevelError))
+ require.Equal(t, uint64(1), s.Log.ErrorCounter.Count())
}
import (
"context"
- "errors"
"fmt"
"html/template"
"io"
"strings"
"time"
+ _errors "github.com/pkg/errors"
+
+ "github.com/gohugoio/hugo/common/herrors"
"github.com/gohugoio/hugo/common/maps"
"github.com/gohugoio/hugo/publisher"
"github.com/gohugoio/hugo/resource"
return whatChanged{}, err
}
- s.TemplateHandler().PrintErrors()
-
for i := 1; i < len(sites); i++ {
site := sites[i]
var err error
f, err := r.Open()
if err != nil {
- return fmt.Errorf("Failed to open data file %q: %s", r.LogicalName(), err)
+ return _errors.Wrapf(err, "Failed to open data file %q:", r.LogicalName())
}
defer f.Close()
func (s *Site) readData(f source.ReadableFile) (interface{}, error) {
file, err := f.Open()
if err != nil {
- return nil, fmt.Errorf("readData: failed to open data file: %s", err)
+ return nil, _errors.Wrap(err, "readData: failed to open data file")
}
defer file.Close()
content := helpers.ReaderToBytes(file)
}
}
- if len(errors) != 0 {
- return fmt.Errorf("Prepare pages failed: %.100q…", errors)
+ return s.pickOneAndLogTheRest(errors)
+}
+
+func (s *Site) errorCollator(results <-chan error, errs chan<- error) {
+ var errors []error
+ for e := range results {
+ errors = append(errors, e)
}
- return nil
+ errs <- s.pickOneAndLogTheRest(errors)
+
+ close(errs)
}
-func errorCollator(results <-chan error, errs chan<- error) {
- errMsgs := []string{}
- for err := range results {
- if err != nil {
- errMsgs = append(errMsgs, err.Error())
+func (s *Site) pickOneAndLogTheRest(errors []error) error {
+ if len(errors) == 0 {
+ return nil
+ }
+
+ var i int
+
+ for j, err := range errors {
+ // If this is in server mode, we want to return an error to the client
+ // with a file context, if possible.
+ if herrors.UnwrapErrorWithFileContext(err) != nil {
+ i = j
+ break
}
}
- if len(errMsgs) == 0 {
- errs <- nil
- } else {
- errs <- errors.New(strings.Join(errMsgs, "\n"))
+
+ // Log the rest, but add a threshold to avoid flooding the log.
+ const errLogThreshold = 5
+
+ for j, err := range errors {
+ if j == i {
+ continue
+ }
+
+ if j >= errLogThreshold {
+ break
+ }
+
+ s.Log.ERROR.Println(err)
}
- close(errs)
+
+ return errors[i]
}
func (s *Site) appendThemeTemplates(in []string) []string {
renderBuffer.WriteString("<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\" ?>\n")
if err := s.renderForLayouts(name, d, renderBuffer, layouts...); err != nil {
- helpers.DistinctWarnLog.Println(err)
- return nil
+ return err
}
var path string
defer bp.PutBuffer(renderBuffer)
if err := s.renderForLayouts(p.Kind, p, renderBuffer, layouts...); err != nil {
- helpers.DistinctWarnLog.Println(err)
- return nil
+
+ return err
}
if renderBuffer.Len() == 0 {
func (s *Site) renderForLayouts(name string, d interface{}, w io.Writer, layouts ...string) (err error) {
var templ tpl.Template
- defer func() {
- if r := recover(); r != nil {
- templName := ""
- if templ != nil {
- templName = templ.Name()
- }
- s.DistinctErrorLog.Printf("Failed to render %q: %s", templName, r)
- s.DistinctErrorLog.Printf("Stack Trace:\n%s", stackTrace(1200))
-
- // TOD(bep) we really need to fix this. Also see below.
- if !s.running() && !testMode {
- os.Exit(-1)
- }
- }
- }()
-
templ = s.findFirstTemplate(layouts...)
if templ == nil {
- return fmt.Errorf("[%s] Unable to locate layout for %q: %s\n", s.Language.Lang, name, layouts)
+ s.Log.WARN.Printf("[%s] Unable to locate layout for %q: %s\n", s.Language.Lang, name, layouts)
+ return nil
}
if err = templ.Execute(w, d); err != nil {
- // Behavior here should be dependent on if running in server or watch mode.
if p, ok := d.(*PageOutput); ok {
- if p.File != nil {
- s.DistinctErrorLog.Printf("Error while rendering %q in %q: %s", name, p.File.Dir(), err)
- } else {
- s.DistinctErrorLog.Printf("Error while rendering %q: %s", name, err)
- }
- } else {
- s.DistinctErrorLog.Printf("Error while rendering %q: %s", name, err)
- }
- if !s.running() && !testMode {
- // TODO(bep) check if this can be propagated
- os.Exit(-1)
- } else if testMode {
- return
+ return p.errorf(err, "render of %q failed", name)
}
+ return _errors.Wrapf(err, "render of %q failed", name)
}
-
return
}
"strings"
"sync"
+ "github.com/pkg/errors"
+
"github.com/gohugoio/hugo/output"
)
pages := make(chan *Page)
errs := make(chan error)
- go errorCollator(results, errs)
+ go s.errorCollator(results, errs)
numWorkers := getGoMaxProcs() * 4
err := <-errs
if err != nil {
- return fmt.Errorf("Error(s) rendering pages: %s", err)
+ return errors.Wrap(err, "failed to render pages")
}
return nil
}
if shouldRender {
if err := pageOutput.renderResources(); err != nil {
+ // TODO(bep) 2errors
s.Log.ERROR.Printf("Failed to render resources for page %q: %s", page, err)
continue
}
withTemplate := createWithTemplateFromNameValues("missing", templateMissingFunc)
- buildSingleSiteExpected(t, true, deps.DepsCfg{Fs: fs, Cfg: cfg, WithTemplate: withTemplate}, BuildCfg{})
+ buildSingleSiteExpected(t, true, false, deps.DepsCfg{Fs: fs, Cfg: cfg, WithTemplate: withTemplate}, BuildCfg{})
}
"github.com/gohugoio/hugo/langs"
"github.com/sanity-io/litter"
- jww "github.com/spf13/jwalterweatherman"
"github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/deps"
"os"
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/hugofs"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
Fs *hugofs.Fs
T testing.TB
- logger *jww.Notepad
+ logger *loggers.Logger
dumper litter.Options
return s
}
-func (s *sitesBuilder) WithLogger(logger *jww.Notepad) *sitesBuilder {
+func (s *sitesBuilder) WithLogger(logger *loggers.Logger) *sitesBuilder {
s.logger = logger
return s
}
}
func (s *sitesBuilder) CreateSites() *sitesBuilder {
+ if err := s.CreateSitesE(); err != nil {
+ s.Fatalf("Failed to create sites: %s", err)
+ }
+
+ return s
+}
+
+func (s *sitesBuilder) CreateSitesE() error {
s.addDefaults()
s.writeFilePairs("content", s.contentFilePairs)
s.writeFilePairs("content", s.contentFilePairsAdded)
if s.Cfg == nil {
cfg, _, err := LoadConfig(ConfigSourceDescriptor{Fs: s.Fs.Source, Filename: "config." + s.configFormat})
if err != nil {
- s.Fatalf("Failed to load config: %s", err)
+ return err
}
// TODO(bep)
/* expectedConfigs := 1
sites, err := NewHugoSites(deps.DepsCfg{Fs: s.Fs, Cfg: s.Cfg, Logger: s.logger, Running: s.running})
if err != nil {
- s.Fatalf("Failed to create sites: %s", err)
+ return err
}
s.H = sites
- return s
+ return nil
+}
+
+func (s *sitesBuilder) BuildE(cfg BuildCfg) error {
+ if s.H == nil {
+ s.CreateSites()
+ }
+
+ return s.H.Build(cfg)
}
func (s *sitesBuilder) Build(cfg BuildCfg) *sitesBuilder {
}
err := s.H.Build(cfg)
+
if err == nil {
logErrorCount := s.H.NumLogErrors()
if logErrorCount > 0 {
}
func buildSingleSite(t testing.TB, depsCfg deps.DepsCfg, buildCfg BuildCfg) *Site {
- return buildSingleSiteExpected(t, false, depsCfg, buildCfg)
+ return buildSingleSiteExpected(t, false, false, depsCfg, buildCfg)
}
-func buildSingleSiteExpected(t testing.TB, expectBuildError bool, depsCfg deps.DepsCfg, buildCfg BuildCfg) *Site {
+func buildSingleSiteExpected(t testing.TB, expectSiteInitEror, expectBuildError bool, depsCfg deps.DepsCfg, buildCfg BuildCfg) *Site {
h, err := NewHugoSites(depsCfg)
- require.NoError(t, err)
+ if expectSiteInitEror {
+ require.Error(t, err)
+ return nil
+ } else {
+ require.NoError(t, err)
+ }
+
require.Len(t, h.Sites, 1)
if expectBuildError {
package i18n
import (
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/helpers"
+
"github.com/nicksnyder/go-i18n/i18n/bundle"
jww "github.com/spf13/jwalterweatherman"
)
type Translator struct {
translateFuncs map[string]bundle.TranslateFunc
cfg config.Provider
- logger *jww.Notepad
+ logger *loggers.Logger
}
// NewTranslator creates a new Translator for the given language bundle and configuration.
-func NewTranslator(b *bundle.Bundle, cfg config.Provider, logger *jww.Notepad) Translator {
+func NewTranslator(b *bundle.Bundle, cfg config.Provider, logger *loggers.Logger) Translator {
t := Translator{cfg: cfg, logger: logger, translateFuncs: make(map[string]bundle.TranslateFunc)}
t.initFuncs(b)
return t
"github.com/gohugoio/hugo/tpl/tplimpl"
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/langs"
"github.com/spf13/afero"
"github.com/gohugoio/hugo/deps"
- "io/ioutil"
- "os"
-
- "log"
-
"github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/hugofs"
- jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
)
-var logger = jww.NewNotepad(jww.LevelError, jww.LevelError, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+var logger = loggers.NewErrorLogger()
type i18nTest struct {
data map[string][]byte
import (
"errors"
- "fmt"
-
- "github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/deps"
+ "github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/source"
"github.com/nicksnyder/go-i18n/i18n/bundle"
"github.com/nicksnyder/go-i18n/i18n/language"
+ _errors "github.com/pkg/errors"
)
// TranslationProvider provides translation handling, i.e. loading
func addTranslationFile(bundle *bundle.Bundle, r source.ReadableFile) error {
f, err := r.Open()
if err != nil {
- return fmt.Errorf("Failed to open translations file %q: %s", r.LogicalName(), err)
+ return _errors.Wrapf(err, "Failed to open translations file %q:", r.LogicalName())
}
defer f.Close()
err = bundle.ParseTranslationFileBytes(r.LogicalName(), helpers.ReaderToBytes(f))
if err != nil {
- return fmt.Errorf("Failed to load translations in file %q: %s", r.LogicalName(), err)
+ return _errors.Wrapf(err, "Failed to load translations in file %q:", r.LogicalName())
}
return nil
}
package releaser
import (
- "errors"
"fmt"
"io/ioutil"
"log"
"regexp"
"strings"
+ "github.com/pkg/errors"
+
"github.com/gohugoio/hugo/helpers"
)
cmd.Stderr = os.Stderr
err := cmd.Run()
if err != nil {
- return fmt.Errorf("goreleaser failed: %s", err)
+ return errors.Wrap(err, "goreleaser failed")
}
return nil
}
"strings"
"sync"
+ _errors "github.com/pkg/errors"
+
"github.com/disintegration/imaging"
"github.com/gohugoio/hugo/common/hugio"
"github.com/gohugoio/hugo/helpers"
})
if err != nil {
- return fmt.Errorf("failed to load image config: %s", err)
+ return _errors.Wrap(err, "failed to load image config")
}
return nil
func (i *Image) decodeSource() (image.Image, error) {
f, err := i.ReadSeekCloser()
if err != nil {
- return nil, fmt.Errorf("failed to open image for decode: %s", err)
+ return nil, _errors.Wrap(err, "failed to open image for decode")
}
defer f.Close()
img, _, err := image.Decode(f)
package postcss
import (
- "fmt"
"io"
"path/filepath"
"github.com/gohugoio/hugo/hugofs"
+ "github.com/pkg/errors"
- "github.com/mitchellh/mapstructure"
- // "io/ioutil"
"os"
"os/exec"
- "github.com/gohugoio/hugo/common/errors"
+ "github.com/mitchellh/mapstructure"
+ "github.com/gohugoio/hugo/common/herrors"
"github.com/gohugoio/hugo/resource"
)
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 errors.ErrFeatureNotAvailable
+ return herrors.ErrFeatureNotAvailable
}
}
if err != nil {
if t.options.Config != "" {
// Only fail if the user specificed config file is not found.
- return fmt.Errorf("postcss config %q not found: %s", configFile, err)
+ return errors.Wrapf(err, "postcss config %q not found:", configFile)
}
configFile = ""
} else {
package resource
import (
- "errors"
"fmt"
"io"
"io/ioutil"
"github.com/gohugoio/hugo/output"
"github.com/gohugoio/hugo/tpl"
+ "github.com/pkg/errors"
"github.com/gohugoio/hugo/common/collections"
"github.com/gohugoio/hugo/common/hugio"
"github.com/gohugoio/hugo/common/loggers"
- jww "github.com/spf13/jwalterweatherman"
-
"github.com/spf13/afero"
"github.com/gobwas/glob"
MediaTypes media.Types
OutputFormats output.Formats
- Logger *jww.Notepad
+ Logger *loggers.Logger
TextTemplates tpl.TemplateParseFinder
GenAssetsPath string
}
-func NewSpec(s *helpers.PathSpec, logger *jww.Notepad, outputFormats output.Formats, mimeTypes media.Types) (*Spec, error) {
+func NewSpec(s *helpers.PathSpec, logger *loggers.Logger, outputFormats output.Formats, mimeTypes media.Types) (*Spec, error) {
imaging, err := decodeImaging(s.Cfg.GetStringMap("imaging"))
if err != nil {
type publishOnce struct {
publisherInit sync.Once
publisherErr error
- logger *jww.Notepad
+ logger *loggers.Logger
}
func (l *publishOnce) publish(s Source) error {
var f hugio.ReadSeekCloser
f, err = l.ReadSeekCloser()
if err != nil {
- err = fmt.Errorf("failed to open source file: %s", err)
+ err = errors.Wrap(err, "failed to open source file")
return
}
defer f.Close()
"fmt"
"strconv"
+ "github.com/pkg/errors"
"github.com/spf13/cast"
"strings"
glob, err := getGlob(srcKey)
if err != nil {
- return fmt.Errorf("failed to match resource with metadata: %s", err)
+ return errors.Wrap(err, "failed to match resource with metadata")
}
match := glob.Match(resourceSrcKey)
package templates
import (
- "fmt"
-
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/resource"
"github.com/gohugoio/hugo/tpl"
+ "github.com/pkg/errors"
)
// Client contains methods to perform template processing of Resource objects.
tplStr := helpers.ReaderToString(ctx.From)
templ, err := t.textTemplate.Parse(ctx.InPath, tplStr)
if err != nil {
- return fmt.Errorf("failed to parse Resource %q as Template: %s", ctx.InPath, err)
+ return errors.Wrapf(err, "failed to parse Resource %q as Template:", ctx.InPath)
}
ctx.OutPath = t.targetPath
"github.com/gohugoio/hugo/hugofs"
"github.com/gohugoio/hugo/media"
"github.com/gohugoio/hugo/resource"
+ "github.com/pkg/errors"
)
// Used in tests. This feature requires Hugo to be built with the extended tag.
res, err = transpiler.Execute(dst, src)
if err != nil {
- return res, fmt.Errorf("SCSS processing failed: %s", err)
+ return res, errors.Wrap(err, "SCSS processing failed")
}
return res, nil
package scss
import (
- "github.com/gohugoio/hugo/common/errors"
+ "github.com/gohugoio/hugo/common/herrors"
"github.com/gohugoio/hugo/resource"
)
}
func (t *toCSSTransformation) Transform(ctx *resource.ResourceTransformationCtx) error {
- return errors.ErrFeatureNotAvailable
+ return herrors.ErrFeatureNotAvailable
}
"strings"
"github.com/gohugoio/hugo/common/collections"
- "github.com/gohugoio/hugo/common/errors"
+ "github.com/gohugoio/hugo/common/herrors"
"github.com/gohugoio/hugo/common/hugio"
"github.com/gohugoio/hugo/helpers"
"github.com/mitchellh/hashstructure"
}
if err := tr.transformation.Transform(tctx); err != nil {
- if err == errors.ErrFeatureNotAvailable {
+ if err == herrors.ErrFeatureNotAvailable {
// This transformation is not available in this
// Hugo installation (scss not compiled in, PostCSS not available etc.)
// If a prepared bundle for this transformation chain is available, use that.
"errors"
"fmt"
"html/template"
- "io/ioutil"
- "log"
"math/rand"
- "os"
"reflect"
"testing"
"time"
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/hugofs"
"github.com/gohugoio/hugo/langs"
- jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
Cfg: cfg,
Fs: hugofs.NewMem(l),
ContentSpec: cs,
- Log: jww.NewNotepad(jww.LevelError, jww.LevelError, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime),
+ Log: loggers.NewErrorLogger(),
}
}
"encoding/csv"
"encoding/json"
"errors"
- "fmt"
"net/http"
"strings"
"time"
"github.com/gohugoio/hugo/deps"
+ _errors "github.com/pkg/errors"
)
// New returns a new instance of the data-namespaced template functions.
var req *http.Request
req, err = http.NewRequest("GET", url, nil)
if err != nil {
- return nil, fmt.Errorf("Failed to create request for getCSV for resource %s: %s", url, err)
+ return nil, _errors.Wrapf(err, "Failed to create request for getCSV for resource %s:", url)
}
req.Header.Add("Accept", "text/csv")
var req *http.Request
req, err = http.NewRequest("GET", url, nil)
if err != nil {
- return nil, fmt.Errorf("Failed to create request for getJSON resource %s: %s", url, err)
+ return nil, _errors.Wrapf(err, "Failed to create request for getJSON resource %s:", url)
}
req.Header.Add("Accept", "application/json")
require.NoError(t, err, msg)
if _, ok := test.expect.(bool); ok {
- require.Equal(t, 1, int(ns.deps.Log.LogCountForLevelsGreaterThanorEqualTo(jww.LevelError)))
+ require.Equal(t, 1, int(ns.deps.Log.ErrorCounter.Count()))
require.Nil(t, got)
continue
}
- require.Equal(t, 0, int(ns.deps.Log.LogCountForLevelsGreaterThanorEqualTo(jww.LevelError)))
+ require.Equal(t, 0, int(ns.deps.Log.ErrorCounter.Count()))
require.NotNil(t, got, msg)
assert.EqualValues(t, test.expect, got, msg)
continue
}
- if errLevel, ok := test.expect.(jww.Threshold); ok {
- logCount := ns.deps.Log.LogCountForLevelsGreaterThanorEqualTo(errLevel)
+ if errLevel, ok := test.expect.(jww.Threshold); ok && errLevel >= jww.LevelError {
+ logCount := ns.deps.Log.ErrorCounter.Count()
require.True(t, logCount >= 1, fmt.Sprintf("got log count %d", logCount))
continue
}
require.NoError(t, err, msg)
- require.Equal(t, 0, int(ns.deps.Log.LogCountForLevelsGreaterThanorEqualTo(jww.LevelError)), msg)
+ require.Equal(t, 0, int(ns.deps.Log.ErrorCounter.Count()), msg)
require.NotNil(t, got, msg)
assert.EqualValues(t, test.expect, got, msg)
import (
_fmt "fmt"
+ "github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/helpers"
)
// New returns a new instance of the fmt-namespaced template functions.
-func New() *Namespace {
- return &Namespace{helpers.NewDistinctErrorLogger()}
+func New(d *deps.Deps) *Namespace {
+ return &Namespace{helpers.NewDistinctLogger(d.Log.ERROR)}
}
// Namespace provides template functions for the "fmt" namespace.
func init() {
f := func(d *deps.Deps) *internal.TemplateFuncsNamespace {
- ctx := New()
+ ctx := New(d)
ns := &internal.TemplateFuncsNamespace{
Name: name,
import (
"testing"
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/tpl/internal"
"github.com/stretchr/testify/require"
var ns *internal.TemplateFuncsNamespace
for _, nsf := range internal.TemplateFuncsNamespaceRegistry {
- ns = nsf(&deps.Deps{})
+ ns = nsf(&deps.Deps{Log: loggers.NewErrorLogger()})
if ns.Name == name {
found = true
break
import (
"testing"
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/tpl/internal"
"github.com/stretchr/testify/require"
for _, nsf := range internal.TemplateFuncsNamespaceRegistry {
ns = nsf(&deps.Deps{
BuildStartListeners: &deps.Listeners{},
+ Log: loggers.NewErrorLogger(),
})
if ns.Name == name {
found = true
"fmt"
"path/filepath"
+ _errors "github.com/pkg/errors"
+
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/resource"
"github.com/gohugoio/hugo/resource/bundler"
m, err := cast.ToStringMapE(args[0])
if err != nil {
- return nil, nil, fmt.Errorf("invalid options type: %s", err)
+ return nil, nil, _errors.Wrap(err, "invalid options type")
}
return r, m, nil
_strings "strings"
"unicode/utf8"
+ _errors "github.com/pkg/errors"
+
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/helpers"
"github.com/spf13/cast"
func (ns *Namespace) CountRunes(s interface{}) (int, error) {
ss, err := cast.ToStringE(s)
if err != nil {
- return 0, fmt.Errorf("Failed to convert content to string: %s", err)
+ return 0, _errors.Wrap(err, "Failed to convert content to string")
}
counter := 0
func (ns *Namespace) RuneCount(s interface{}) (int, error) {
ss, err := cast.ToStringE(s)
if err != nil {
- return 0, fmt.Errorf("Failed to convert content to string: %s", err)
+ return 0, _errors.Wrap(err, "Failed to convert content to string")
}
return utf8.RuneCountInString(ss), nil
}
func (ns *Namespace) CountWords(s interface{}) (int, error) {
ss, err := cast.ToStringE(s)
if err != nil {
- return 0, fmt.Errorf("Failed to convert content to string: %s", err)
+ return 0, _errors.Wrap(err, "Failed to convert content to string")
}
counter := 0
-// Copyright 2017-present The Hugo Authors. All rights reserved.
+// Copyright 2018 The Hugo Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
package tpl
import (
+ "fmt"
"io"
+ "path/filepath"
+ "regexp"
+ "strings"
"time"
- "text/template/parse"
+ "github.com/gohugoio/hugo/common/herrors"
+
+ "github.com/gohugoio/hugo/hugofs"
+
+ "github.com/spf13/afero"
"html/template"
texttemplate "text/template"
+ "text/template/parse"
bp "github.com/gohugoio/hugo/bufferpool"
"github.com/gohugoio/hugo/metrics"
+ "github.com/pkg/errors"
)
var (
TemplateFinder
AddTemplate(name, tpl string) error
AddLateTemplate(name, tpl string) error
- LoadTemplates(prefix string)
- PrintErrors()
+ LoadTemplates(prefix string) error
NewTextTemplate() TemplateParseFinder
type TemplateAdapter struct {
Template
Metrics metrics.Provider
+
+ // The filesystem where the templates are stored.
+ Fs afero.Fs
+
+ // Maps to base template if relevant.
+ NameBaseTemplateName map[string]string
+}
+
+var baseOfRe = regexp.MustCompile("template: (.*?):")
+
+func extractBaseOf(err string) string {
+ m := baseOfRe.FindStringSubmatch(err)
+ if len(m) == 2 {
+ return m[1]
+ }
+ return ""
}
// Execute executes the current template. The actual execution is performed
// by the embedded text or html template, but we add an implementation here so
// we can add a timer for some metrics.
-func (t *TemplateAdapter) Execute(w io.Writer, data interface{}) error {
+func (t *TemplateAdapter) Execute(w io.Writer, data interface{}) (execErr error) {
+ defer func() {
+ // Panics in templates are a little bit too common (nil pointers etc.)
+ if r := recover(); r != nil {
+ execErr = t.addFileContext(t.Name(), fmt.Errorf("panic in Execute: %s", r))
+ }
+ }()
+
if t.Metrics != nil {
defer t.Metrics.MeasureSince(t.Name(), time.Now())
}
- return t.Template.Execute(w, data)
+
+ execErr = t.Template.Execute(w, data)
+ if execErr != nil {
+ execErr = t.addFileContext(t.Name(), execErr)
+ }
+
+ return
+}
+
+var identifiersRe = regexp.MustCompile("at \\<(.*?)\\>:")
+
+func (t *TemplateAdapter) extractIdentifiers(line string) []string {
+ m := identifiersRe.FindAllStringSubmatch(line, -1)
+ identifiers := make([]string, len(m))
+ for i := 0; i < len(m); i++ {
+ identifiers[i] = m[i][1]
+ }
+ return identifiers
+}
+
+func (t *TemplateAdapter) addFileContext(name string, inerr error) error {
+ f, realFilename, err := t.fileAndFilename(t.Name())
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+
+ master, hasMaster := t.NameBaseTemplateName[name]
+
+ ferr := errors.Wrapf(inerr, "execute of template %q failed", realFilename)
+
+ // Since this can be a composite of multiple template files (single.html + baseof.html etc.)
+ // we potentially need to look in both -- and cannot rely on line number alone.
+ lineMatcher := func(le herrors.FileError, lineNumber int, line string) bool {
+ if le.LineNumber() != lineNumber {
+ return false
+ }
+ if !hasMaster {
+ return true
+ }
+
+ identifiers := t.extractIdentifiers(le.Error())
+
+ for _, id := range identifiers {
+ if strings.Contains(line, id) {
+ return true
+ }
+ }
+ return false
+ }
+
+ // TODO(bep) 2errors text vs HTML
+ fe, ok := herrors.WithFileContext(ferr, f, "go-html-template", lineMatcher)
+ if ok || !hasMaster {
+ return fe
+ }
+
+ // Try the base template if relevant
+ f, realFilename, err = t.fileAndFilename(master)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+
+ ferr = errors.Wrapf(inerr, "execute of template %q failed", realFilename)
+ fe, _ = herrors.WithFileContext(ferr, f, "go-html-template", lineMatcher)
+ return fe
+
+}
+
+func (t *TemplateAdapter) fileAndFilename(name string) (afero.File, string, error) {
+ fs := t.Fs
+ filename := filepath.FromSlash(name)
+
+ fi, err := fs.Stat(filename)
+ if err != nil {
+ return nil, "", errors.Wrapf(err, "failed to Stat %q", filename)
+ }
+ f, err := fs.Open(filename)
+ if err != nil {
+ return nil, "", errors.Wrapf(err, "failed to open template file %q:", filename)
+ }
+
+ return f, fi.(hugofs.RealFilenameInfo).RealFilename(), nil
}
// ExecuteToString executes the current template and returns the result as a
--- /dev/null
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package tpl
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestExtractBaseof(t *testing.T) {
+ assert := require.New(t)
+
+ replaced := extractBaseOf(`failed: template: _default/baseof.html:37:11: executing "_default/baseof.html" at <.Parents>: can't evaluate field Parents in type *hugolib.PageOutput`)
+
+ assert.Equal("_default/baseof.html", replaced)
+ assert.Equal("", extractBaseOf("not baseof for you"))
+ assert.Equal("blog/baseof.html", extractBaseOf("template: blog/baseof.html:23:11:"))
+ assert.Equal("blog/baseof.ace", extractBaseOf("template: blog/baseof.ace:23:11:"))
+}
-// Copyright 2017-present The Hugo Authors. All rights reserved.
+// Copyright 2018 The Hugo Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
"strings"
texttemplate "text/template"
+ "github.com/gohugoio/hugo/hugofs"
"github.com/gohugoio/hugo/tpl/tplimpl/embedded"
+ "github.com/pkg/errors"
"github.com/eknkc/amber"
}
type templateLoader interface {
- handleMaster(name, overlayFilename, masterFilename string, onMissing func(filename string) (string, error)) error
+ handleMaster(name, overlayFilename, masterFilename string, onMissing func(filename string) (templateInfo, error)) error
addTemplate(name, tpl string) error
addLateTemplate(name, tpl string) error
}
}
-func (t *templateHandler) addError(name string, err error) {
- t.errors = append(t.errors, &templateErr{name, err})
-}
-
func (t *templateHandler) Debug() {
fmt.Println("HTML templates:\n", t.html.t.DefinedTemplates())
fmt.Println("\n\nText templates:\n", t.text.t.DefinedTemplates())
}
-// PrintErrors prints the accumulated errors as ERROR to the log.
-func (t *templateHandler) PrintErrors() {
- for _, e := range t.errors {
- t.Log.ERROR.Println(e.name, ":", e.err)
- }
-}
-
// Lookup tries to find a template with the given name in both template
// collections: First HTML, then the plain text template collection.
func (t *templateHandler) Lookup(name string) (tpl.Template, bool) {
c := &templateHandler{
Deps: d,
layoutsFs: d.BaseFs.Layouts.Fs,
- html: &htmlTemplates{t: template.Must(t.html.t.Clone()), overlays: make(map[string]*template.Template)},
- text: &textTemplates{textTemplate: &textTemplate{t: texttemplate.Must(t.text.t.Clone())}, overlays: make(map[string]*texttemplate.Template)},
+ html: &htmlTemplates{t: template.Must(t.html.t.Clone()), overlays: make(map[string]*template.Template), templatesCommon: t.html.templatesCommon},
+ text: &textTemplates{textTemplate: &textTemplate{t: texttemplate.Must(t.text.t.Clone())}, overlays: make(map[string]*texttemplate.Template), templatesCommon: t.text.templatesCommon},
errors: make([]*templateErr, 0),
}
}
func newTemplateAdapter(deps *deps.Deps) *templateHandler {
+ common := &templatesCommon{
+ nameBaseTemplateName: make(map[string]string),
+ }
+
htmlT := &htmlTemplates{
- t: template.New(""),
- overlays: make(map[string]*template.Template),
+ t: template.New(""),
+ overlays: make(map[string]*template.Template),
+ templatesCommon: common,
}
textT := &textTemplates{
- textTemplate: &textTemplate{t: texttemplate.New("")},
- overlays: make(map[string]*texttemplate.Template),
+ textTemplate: &textTemplate{t: texttemplate.New("")},
+ overlays: make(map[string]*texttemplate.Template),
+ templatesCommon: common,
}
- return &templateHandler{
+ h := &templateHandler{
Deps: deps,
layoutsFs: deps.BaseFs.Layouts.Fs,
html: htmlT,
errors: make([]*templateErr, 0),
}
+ common.handler = h
+
+ return h
+
}
-type htmlTemplates struct {
+// Shared by both HTML and text templates.
+type templatesCommon struct {
+ handler *templateHandler
funcster *templateFuncster
+ // Used to get proper filenames in errors
+ nameBaseTemplateName map[string]string
+}
+type htmlTemplates struct {
+ *templatesCommon
+
t *template.Template
// This looks, and is, strange.
if templ == nil {
return nil, false
}
- return &tpl.TemplateAdapter{Template: templ, Metrics: t.funcster.Deps.Metrics}, true
+
+ return &tpl.TemplateAdapter{Template: templ, Metrics: t.funcster.Deps.Metrics, Fs: t.handler.layoutsFs, NameBaseTemplateName: t.nameBaseTemplateName}, true
}
func (t *htmlTemplates) lookup(name string) *template.Template {
}
type textTemplates struct {
+ *templatesCommon
*textTemplate
- funcster *templateFuncster
clone *texttemplate.Template
cloneClone *texttemplate.Template
if templ == nil {
return nil, false
}
- return &tpl.TemplateAdapter{Template: templ, Metrics: t.funcster.Deps.Metrics}, true
+ return &tpl.TemplateAdapter{Template: templ, Metrics: t.funcster.Deps.Metrics, Fs: t.handler.layoutsFs, NameBaseTemplateName: t.nameBaseTemplateName}, true
}
func (t *textTemplates) lookup(name string) *texttemplate.Template {
// LoadTemplates loads the templates from the layouts filesystem.
// A prefix can be given to indicate a template namespace to load the templates
// into, i.e. "_internal" etc.
-func (t *templateHandler) LoadTemplates(prefix string) {
- t.loadTemplates(prefix)
+func (t *templateHandler) LoadTemplates(prefix string) error {
+ return t.loadTemplates(prefix)
}
func (t *templateHandler) AddLateTemplate(name, tpl string) error {
h := t.getTemplateHandler(name)
if err := h.addLateTemplate(name, tpl); err != nil {
- t.addError(name, err)
return err
}
return nil
func (t *templateHandler) AddTemplate(name, tpl string) error {
h := t.getTemplateHandler(name)
if err := h.addTemplate(name, tpl); err != nil {
- t.addError(name, err)
return err
}
return nil
// RebuildClone rebuilds the cloned templates. Used for live-reloads.
func (t *templateHandler) RebuildClone() {
- t.html.clone = template.Must(t.html.cloneClone.Clone())
- t.text.clone = texttemplate.Must(t.text.cloneClone.Clone())
+ if t.html != nil && t.html.cloneClone != nil {
+ t.html.clone = template.Must(t.html.cloneClone.Clone())
+ }
+ if t.text != nil && t.text.cloneClone != nil {
+ t.text.clone = texttemplate.Must(t.text.cloneClone.Clone())
+ }
}
-func (t *templateHandler) loadTemplates(prefix string) {
+func (t *templateHandler) loadTemplates(prefix string) error {
+
walker := func(path string, fi os.FileInfo, err error) error {
if err != nil || fi.IsDir() {
- return nil
+ return err
}
if isDotFile(path) || isBackupFile(path) || isBaseTemplate(path) {
tplID, err := output.CreateTemplateNames(descriptor)
if err != nil {
t.Log.ERROR.Printf("Failed to resolve template in path %q: %s", path, err)
-
return nil
}
if err := t.addTemplateFile(tplID.Name, tplID.MasterFilename, tplID.OverlayFilename); err != nil {
- t.Log.ERROR.Printf("Failed to add template %q in path %q: %s", tplID.Name, path, err)
+ return err
}
return nil
}
if err := helpers.SymbolicWalk(t.Layouts.Fs, "", walker); err != nil {
- t.Log.ERROR.Printf("Failed to load templates: %s", err)
+ if !os.IsNotExist(err) {
+ return err
+ }
+ return nil
}
+ return nil
+
}
func (t *templateHandler) initFuncs() {
return t.html
}
-func (t *templateHandler) handleMaster(name, overlayFilename, masterFilename string, onMissing func(filename string) (string, error)) error {
+func (t *templateHandler) handleMaster(name, overlayFilename, masterFilename string, onMissing func(filename string) (templateInfo, error)) error {
h := t.getTemplateHandler(name)
return h.handleMaster(name, overlayFilename, masterFilename, onMissing)
}
-func (t *htmlTemplates) handleMaster(name, overlayFilename, masterFilename string, onMissing func(filename string) (string, error)) error {
+func (t *htmlTemplates) handleMaster(name, overlayFilename, masterFilename string, onMissing func(filename string) (templateInfo, error)) error {
masterTpl := t.lookup(masterFilename)
return err
}
- masterTpl, err = t.t.New(overlayFilename).Parse(templ)
+ masterTpl, err = t.t.New(overlayFilename).Parse(templ.template)
if err != nil {
- return err
+ return templ.errWithFileContext("parse master failed", err)
}
}
return err
}
- overlayTpl, err := template.Must(masterTpl.Clone()).Parse(templ)
+ overlayTpl, err := template.Must(masterTpl.Clone()).Parse(templ.template)
if err != nil {
- return err
+ return templ.errWithFileContext("parse failed", err)
}
// The extra lookup is a workaround, see
}
t.overlays[name] = overlayTpl
+ t.nameBaseTemplateName[name] = masterFilename
return err
}
-func (t *textTemplates) handleMaster(name, overlayFilename, masterFilename string, onMissing func(filename string) (string, error)) error {
+func (t *textTemplates) handleMaster(name, overlayFilename, masterFilename string, onMissing func(filename string) (templateInfo, error)) error {
name = strings.TrimPrefix(name, textTmplNamePrefix)
masterTpl := t.lookup(masterFilename)
return err
}
- masterTpl, err = t.t.New(overlayFilename).Parse(templ)
+ masterTpl, err = t.t.New(masterFilename).Parse(templ.template)
if err != nil {
- return err
+ return errors.Wrapf(err, "failed to parse %q:", templ.filename)
}
+ t.nameBaseTemplateName[masterFilename] = templ.filename
}
templ, err := onMissing(overlayFilename)
return err
}
- overlayTpl, err := texttemplate.Must(masterTpl.Clone()).Parse(templ)
+ overlayTpl, err := texttemplate.Must(masterTpl.Clone()).Parse(templ.template)
if err != nil {
- return err
+ return errors.Wrapf(err, "failed to parse %q:", templ.filename)
}
overlayTpl = overlayTpl.Lookup(overlayTpl.Name())
return err
}
t.overlays[name] = overlayTpl
+ t.nameBaseTemplateName[name] = templ.filename
return err
t.Log.DEBUG.Printf("Add template file: name %q, baseTemplatePath %q, path %q", name, baseTemplatePath, path)
- getTemplate := func(filename string) (string, error) {
- b, err := afero.ReadFile(t.Layouts.Fs, filename)
+ getTemplate := func(filename string) (templateInfo, error) {
+ fs := t.Layouts.Fs
+ b, err := afero.ReadFile(fs, filename)
if err != nil {
- return "", err
+ return templateInfo{filename: filename, fs: fs}, err
}
s := string(b)
- return s, nil
+ realFilename := filename
+ if fi, err := fs.Stat(filename); err == nil {
+ if fir, ok := fi.(hugofs.RealFilenameInfo); ok {
+ realFilename = fir.RealFilename()
+ }
+ }
+
+ return templateInfo{template: s, filename: filename, realFilename: realFilename, fs: fs}, nil
}
// get the suffix and switch on that
return err
}
- return t.AddTemplate(name, templ)
+ err = t.AddTemplate(name, templ.template)
+ if err != nil {
+ return templ.errWithFileContext("parse failed", err)
+ }
+ return nil
}
}
"shortcodes/twitter.html": []string{"shortcodes/tweet.html"},
}
-func (t *templateHandler) loadEmbedded() {
+func (t *templateHandler) loadEmbedded() error {
for _, kv := range embedded.EmbeddedTemplates {
- // TODO(bep) error handling
name, templ := kv[0], kv[1]
- t.addInternalTemplate(name, templ)
+ if err := t.addInternalTemplate(name, templ); err != nil {
+ return err
+ }
if aliases, found := embeddedTemplatesAliases[name]; found {
for _, alias := range aliases {
- t.addInternalTemplate(alias, templ)
+ if err := t.addInternalTemplate(alias, templ); err != nil {
+ return err
+ }
}
}
}
+ return nil
+
}
func (t *templateHandler) addInternalTemplate(name, tpl string) error {
deps.TextTmpl = newTmpl.NewTextTemplate()
newTmpl.initFuncs()
- newTmpl.loadEmbedded()
+
+ if err := newTmpl.loadEmbedded(); err != nil {
+ return err
+ }
if deps.WithTemplate != nil {
err := deps.WithTemplate(newTmpl)
if err != nil {
- newTmpl.addError("init", err)
+ return err
}
}
--- /dev/null
+// Copyright 2018 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package tplimpl
+
+import (
+ "github.com/gohugoio/hugo/common/herrors"
+ "github.com/pkg/errors"
+ "github.com/spf13/afero"
+)
+
+type templateInfo struct {
+ template string
+
+ // Used to create some error context in error situations
+ fs afero.Fs
+
+ // The filename relative to the fs above.
+ filename string
+
+ // The real filename (if possible). Used for logging.
+ realFilename string
+}
+
+func (info templateInfo) errWithFileContext(what string, err error) error {
+ err = errors.Wrapf(err, "file %q: %s:", info.realFilename, what)
+
+ err, _ = herrors.WithFileContextForFile(
+ err,
+ info.filename,
+ info.fs,
+ "go-html-template",
+ herrors.SimpleLineMatcher)
+
+ return err
+}
"testing"
"time"
- "io/ioutil"
- "log"
- "os"
-
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/config"
"github.com/gohugoio/hugo/deps"
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/tpl/internal"
"github.com/gohugoio/hugo/tpl/partials"
"github.com/spf13/afero"
- jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
)
var (
- logger = jww.NewNotepad(jww.LevelFatal, jww.LevelFatal, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+ logger = loggers.NewErrorLogger()
)
func newTestConfig() config.Provider {
"errors"
"fmt"
- "github.com/russross/blackfriday"
-
"html/template"
"net/url"
+ _errors "github.com/pkg/errors"
+ "github.com/russross/blackfriday"
+
"github.com/gohugoio/hugo/deps"
"github.com/spf13/cast"
)
func (ns *Namespace) Parse(rawurl interface{}) (*url.URL, error) {
s, err := cast.ToStringE(rawurl)
if err != nil {
- return nil, fmt.Errorf("Error in Parse: %s", err)
+ return nil, _errors.Wrap(err, "Error in Parse")
}
return url.Parse(s)
projects / brevno-suite / hugo / commitdiff