}
func benchmark(cmd *cobra.Command, args []string) error {
- var err error
- if err = InitializeConfig(benchmarkCmd); err != nil {
+ cfg, err := InitializeConfig(benchmarkCmd)
+ if err != nil {
return err
}
t := time.Now()
for i := 0; i < benchmarkTimes; i++ {
- if err = resetAndBuildSites(false); err != nil {
+ if err = resetAndBuildSites(cfg, false); err != nil {
return err
}
}
convertCmd.PersistentFlags().SetAnnotation("source", cobra.BashCompSubdirsInDir, []string{})
}
-func convertContents(mark rune) (err error) {
- if err := InitializeConfig(); err != nil {
+func convertContents(mark rune) error {
+ cfg, err := InitializeConfig()
+ if err != nil {
return err
}
- h, err := hugolib.NewHugoSitesFromConfiguration()
-
+ h, err := hugolib.NewHugoSitesFromConfiguration(cfg)
if err != nil {
return err
}
jww.FEEDBACK.Println("processing", len(site.Source.Files()), "content files")
for _, file := range site.Source.Files() {
jww.INFO.Println("Attempting to convert", file.LogicalName())
- page, err := hugolib.NewPage(file.LogicalName())
+ page, err := site.NewPage(file.LogicalName())
if err != nil {
return err
}
}
}
}
- return
+ return nil
}
import (
"fmt"
"io/ioutil"
+ "log"
"net/http"
"os"
"path/filepath"
Complete documentation is available at http://gohugo.io/.`,
RunE: func(cmd *cobra.Command, args []string) error {
- if err := InitializeConfig(); err != nil {
+ cfg, err := InitializeConfig()
+ if err != nil {
return err
}
if buildWatch {
viper.Set("disableLiveReload", true)
- watchConfig()
+ watchConfig(cfg)
}
- return build()
+ return build(cfg)
},
}
}
// InitializeConfig initializes a config file with sensible default configuration flags.
-func InitializeConfig(subCmdVs ...*cobra.Command) error {
+func InitializeConfig(subCmdVs ...*cobra.Command) (hugolib.DepsCfg, error) {
+
+ var cfg hugolib.DepsCfg
+
if err := hugolib.LoadGlobalConfig(source, cfgFile); err != nil {
- return err
+ return cfg, err
}
for _, cmdV := range append([]*cobra.Command{hugoCmdV}, subCmdVs...) {
viper.Set("cacheDir", helpers.GetTempDir("hugo_cache", hugofs.Source()))
}
- logFile := ioutil.Discard
-
- if verboseLog || logging || (viper.IsSet("logFile") && viper.GetString("logFile") != "") {
-
- var err error
- if viper.IsSet("logFile") && viper.GetString("logFile") != "" {
- path := viper.GetString("logFile")
- logFile, err = os.OpenFile(path, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666)
- if err != nil {
- return newSystemError("Failed to open log file:", path, err)
- }
- } else {
- logFile, err = ioutil.TempFile(os.TempDir(), "hugo")
- if err != nil {
- return newSystemError(err)
- }
- }
- }
-
- jww.SetLogOutput(logFile)
-
- if quiet {
- jww.SetStdoutThreshold(jww.LevelError)
- } else if viper.GetBool("verbose") {
- jww.SetStdoutThreshold(jww.LevelInfo)
- }
-
- if verboseLog {
- jww.SetLogThreshold(jww.LevelInfo)
- }
-
jww.INFO.Println("Using config file:", viper.ConfigFileUsed())
// Init file systems. This may be changed at a later point.
themeDir := helpers.GetThemeDir()
if themeDir != "" {
if _, err := hugofs.Source().Stat(themeDir); os.IsNotExist(err) {
- return newSystemError("Unable to find theme Directory:", themeDir)
+ return cfg, newSystemError("Unable to find theme Directory:", themeDir)
}
}
helpers.HugoReleaseVersion(), minVersion)
}
- return nil
+ logger, err := createLogger()
+ if err != nil {
+ return cfg, err
+ }
+
+ cfg.Logger = logger
+
+ return cfg, nil
+
+}
+
+func createLogger() (*jww.Notepad, error) {
+ var (
+ logHandle = ioutil.Discard
+ outHandle = os.Stdout
+ stdoutThreshold = jww.LevelError
+ logThreshold = jww.LevelWarn
+ )
+
+ if verboseLog || logging || (viper.IsSet("logFile") && viper.GetString("logFile") != "") {
+
+ var err error
+ if viper.IsSet("logFile") && viper.GetString("logFile") != "" {
+ path := viper.GetString("logFile")
+ logHandle, err = os.OpenFile(path, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666)
+ if err != nil {
+ return nil, newSystemError("Failed to open log file:", path, err)
+ }
+ } else {
+ logHandle, err = ioutil.TempFile(os.TempDir(), "hugo")
+ if err != nil {
+ return nil, newSystemError(err)
+ }
+ }
+ } else if !quiet && viper.GetBool("verbose") {
+ stdoutThreshold = jww.LevelInfo
+ }
+
+ if verboseLog {
+ logThreshold = jww.LevelInfo
+ }
+ return jww.NewNotepad(stdoutThreshold, logThreshold, outHandle, logHandle, "", log.Ldate|log.Ltime), nil
}
func initializeFlags(cmd *cobra.Command) {
return flag.Changed
}
-func watchConfig() {
+func watchConfig(cfg hugolib.DepsCfg) {
viper.WatchConfig()
viper.OnConfigChange(func(e fsnotify.Event) {
jww.FEEDBACK.Println("Config file changed:", e.Name)
// Force a full rebuild
- utils.CheckErr(recreateAndBuildSites(true))
+ utils.CheckErr(recreateAndBuildSites(cfg, true))
if !viper.GetBool("disableLiveReload") {
// Will block forever trying to write to a channel that nobody is reading if livereload isn't initialized
livereload.ForceRefresh()
})
}
-func build(watches ...bool) error {
+func build(cfg hugolib.DepsCfg, watches ...bool) error {
// Hugo writes the output to memory instead of the disk.
// This is only used for benchmark testing. Cause the content is only visible
// in memory.
if len(watches) > 0 && watches[0] {
watch = true
}
- if err := buildSites(buildWatch || watch); err != nil {
+ if err := buildSites(cfg, buildWatch || watch); err != nil {
return fmt.Errorf("Error building site: %s", err)
}
if buildWatch {
jww.FEEDBACK.Println("Watching for changes in", helpers.AbsPathify(viper.GetString("contentDir")))
jww.FEEDBACK.Println("Press Ctrl+C to stop")
- utils.CheckErr(NewWatcher(0))
+ utils.CheckErr(newWatcher(cfg, 0))
}
return nil
return a
}
-func recreateAndBuildSites(watching bool) (err error) {
- if err := initSites(); err != nil {
+func recreateAndBuildSites(cfg hugolib.DepsCfg, watching bool) (err error) {
+ if err := initSites(cfg); err != nil {
return err
}
if !quiet {
return Hugo.Build(hugolib.BuildCfg{CreateSitesFromConfig: true, Watching: watching, PrintStats: !quiet})
}
-func resetAndBuildSites(watching bool) (err error) {
- if err := initSites(); err != nil {
+func resetAndBuildSites(cfg hugolib.DepsCfg, watching bool) (err error) {
+ if err := initSites(cfg); err != nil {
return err
}
if !quiet {
return Hugo.Build(hugolib.BuildCfg{ResetState: true, Watching: watching, PrintStats: !quiet})
}
-func initSites() error {
+func initSites(cfg hugolib.DepsCfg) error {
if Hugo != nil {
return nil
}
- h, err := hugolib.NewHugoSitesFromConfiguration()
+ h, err := hugolib.NewHugoSitesFromConfiguration(cfg)
if err != nil {
return err
return nil
}
-func buildSites(watching bool) (err error) {
- if err := initSites(); err != nil {
+func buildSites(cfg hugolib.DepsCfg, watching bool) (err error) {
+ if err := initSites(cfg); err != nil {
return err
}
if !quiet {
return Hugo.Build(hugolib.BuildCfg{Watching: watching, PrintStats: !quiet})
}
-func rebuildSites(events []fsnotify.Event) error {
- if err := initSites(); err != nil {
+func rebuildSites(cfg hugolib.DepsCfg, events []fsnotify.Event) error {
+ if err := initSites(cfg); err != nil {
return err
}
return Hugo.Build(hugolib.BuildCfg{PrintStats: !quiet, Watching: true}, events...)
}
-// NewWatcher creates a new watcher to watch filesystem events.
-func NewWatcher(port int) error {
+// newWatcher creates a new watcher to watch filesystem events.
+func newWatcher(cfg hugolib.DepsCfg, port int) error {
if runtime.GOOS == "darwin" {
tweakLimit()
}
const layout = "2006-01-02 15:04 -0700"
jww.FEEDBACK.Println(time.Now().Format(layout))
- rebuildSites(dynamicEvents)
+ rebuildSites(cfg, dynamicEvents)
if !buildWatch && !viper.GetBool("disableLiveReload") {
// Will block forever trying to write to a channel that nobody is reading if livereload isn't initialized
}
forceImport, _ := cmd.Flags().GetBool("force")
- if err := createSiteFromJekyll(jekyllRoot, targetDir, forceImport); err != nil {
- return newUserError(err)
+ site, err := createSiteFromJekyll(jekyllRoot, targetDir, forceImport)
+ if err != nil {
+ return err
}
jww.FEEDBACK.Println("Importing...")
}
fileCount++
- return convertJekyllPost(path, relPath, targetDir, draft)
+ return convertJekyllPost(site, path, relPath, targetDir, draft)
}
err = helpers.SymbolicWalk(hugofs.Os(), jekyllRoot, callback)
}
// TODO: Consider calling doNewSite() instead?
-func createSiteFromJekyll(jekyllRoot, targetDir string, force bool) error {
+func createSiteFromJekyll(jekyllRoot, targetDir string, force bool) (*hugolib.Site, error) {
fs := hugofs.Source()
if exists, _ := helpers.Exists(targetDir, fs); exists {
if isDir, _ := helpers.IsDir(targetDir, fs); !isDir {
- return errors.New("Target path \"" + targetDir + "\" already exists but not a directory")
+ return nil, errors.New("Target path \"" + targetDir + "\" already exists but not a directory")
}
isEmpty, _ := helpers.IsEmpty(targetDir, fs)
if !isEmpty && !force {
- return errors.New("Target path \"" + targetDir + "\" already exists and is not empty")
+ return nil, errors.New("Target path \"" + targetDir + "\" already exists and is not empty")
}
}
}
}
if !hasPostsOrDrafts {
- return errors.New("Your Jekyll root contains neither posts nor drafts, aborting.")
+ return nil, errors.New("Your Jekyll root contains neither posts nor drafts, aborting.")
}
mkdir(targetDir, "layouts")
createConfigFromJekyll(targetDir, "yaml", jekyllConfig)
copyJekyllFilesAndFolders(jekyllRoot, filepath.Join(targetDir, "static"))
+ site := hugolib.NewSiteDefaultLang()
- return nil
+ return site, nil
}
func loadJekyllConfig(jekyllRoot string) map[string]interface{} {
return postDate, postName, nil
}
-func convertJekyllPost(path, relPath, targetDir string, draft bool) error {
+func convertJekyllPost(s *hugolib.Site, path, relPath, targetDir string, draft bool) error {
jww.TRACE.Println("Converting", path)
filename := filepath.Base(path)
jww.TRACE.Println(newmetadata)
content := convertJekyllContent(newmetadata, string(psr.Content()))
- page, err := hugolib.NewPage(filename)
+ page, err := s.NewPage(filename)
if err != nil {
jww.ERROR.Println("New page error", filename)
return err
Long: `List all of the drafts in your content directory.`,
RunE: func(cmd *cobra.Command, args []string) error {
- if err := InitializeConfig(); err != nil {
+ cfg, err := InitializeConfig()
+ if err != nil {
return err
}
viper.Set("buildDrafts", true)
- sites, err := hugolib.NewHugoSitesFromConfiguration()
+ sites, err := hugolib.NewHugoSitesFromConfiguration(cfg)
if err != nil {
return newSystemError("Error creating sites", err)
posted in the future.`,
RunE: func(cmd *cobra.Command, args []string) error {
- if err := InitializeConfig(); err != nil {
+ cfg, err := InitializeConfig()
+ if err != nil {
return err
}
viper.Set("buildFuture", true)
- sites, err := hugolib.NewHugoSitesFromConfiguration()
+ sites, err := hugolib.NewHugoSitesFromConfiguration(cfg)
if err != nil {
return newSystemError("Error creating sites", err)
expired.`,
RunE: func(cmd *cobra.Command, args []string) error {
- if err := InitializeConfig(); err != nil {
+ cfg, err := InitializeConfig()
+ if err != nil {
return err
}
viper.Set("buildExpired", true)
- sites, err := hugolib.NewHugoSitesFromConfiguration()
+ sites, err := hugolib.NewHugoSitesFromConfiguration(cfg)
if err != nil {
return newSystemError("Error creating sites", err)
}
func config(cmd *cobra.Command, args []string) error {
- if err := InitializeConfig(configCmd); err != nil {
+ if _, err := InitializeConfig(configCmd); err != nil {
return err
}
// NewContent adds new content to a Hugo site.
func NewContent(cmd *cobra.Command, args []string) error {
- if err := InitializeConfig(); err != nil {
+ if _, err := InitializeConfig(); err != nil {
return err
}
// NewTheme creates a new Hugo theme.
func NewTheme(cmd *cobra.Command, args []string) error {
- if err := InitializeConfig(); err != nil {
+ if _, err := InitializeConfig(); err != nil {
return err
}
}
func server(cmd *cobra.Command, args []string) error {
- if err := InitializeConfig(serverCmd); err != nil {
+ cfg, err := InitializeConfig()
+ if err != nil {
return err
}
if viper.GetBool("watch") {
serverWatch = true
- watchConfig()
+ watchConfig(cfg)
}
l, err := net.Listen("tcp", net.JoinHostPort(serverInterface, strconv.Itoa(serverPort)))
viper.Set("publishDir", "/")
}
- if err := build(serverWatch); err != nil {
+ if err := build(cfg, serverWatch); err != nil {
return err
}
rootWatchDirs := strings.Join(helpers.UniqueStrings(helpers.ExtractRootPaths(watchDirs)), ",")
jww.FEEDBACK.Printf("Watching for changes in %s%s{%s}\n", baseWatchDir, helpers.FilePathSeparator, rootWatchDirs)
- err := NewWatcher(serverPort)
+ err := newWatcher(cfg, serverPort)
if err != nil {
return err
// to false and setting its publish date to now. If the specified content is
// not a draft, it will log an error.
func Undraft(cmd *cobra.Command, args []string) error {
- if err := InitializeConfig(); err != nil {
+ if _, err := InitializeConfig(); err != nil {
return err
}
return err
}
- page, err := hugolib.NewPage(name)
+ site := hugolib.NewSiteDefaultLang()
+
+ page, err := site.NewPage(name)
if err != nil {
return err
}
writeSource(t, filepath.Join("content", "page.md"), pageWithAlias)
writeSource(t, filepath.Join("layouts", "_default", "single.html"), basicTemplate)
- if err := buildAndRenderSite(newSiteDefaultLang()); err != nil {
+ if err := buildAndRenderSite(NewSiteDefaultLang()); err != nil {
t.Fatalf("Failed to build site: %s", err)
}
writeSource(t, filepath.Join("layouts", "_default", "single.html"), basicTemplate)
writeSource(t, filepath.Join("layouts", "alias.html"), aliasTemplate)
- if err := buildAndRenderSite(newSiteDefaultLang()); err != nil {
+ if err := buildAndRenderSite(NewSiteDefaultLang()); err != nil {
t.Fatalf("Failed to build site: %s", err)
}
t.Fatalf("Failed to load config: %s", err)
}
- sites, err := NewHugoSitesFromConfiguration()
+ sites, err := NewHugoSitesFromConfiguration(DepsCfg{})
if err != nil {
t.Fatalf("Failed to create sites: %s", err)
t.Fatalf("Failed to load config: %s", err)
}
- sites, err := NewHugoSitesFromConfiguration()
+ sites, err := NewHugoSitesFromConfiguration(DepsCfg{})
if err != nil {
t.Fatalf("Failed to create sites: %s", err)
sources := []source.ByteSource{
{Name: filepath.FromSlash("test.roml"), Content: []byte("boo")},
}
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
err := s.loadData([]source.Input{&source.InMemorySource{ByteSource: sources}})
if err != nil {
t.Fatalf("Should not return an error")
}
func doTestDataDir(t *testing.T, expected interface{}, sources []source.Input) {
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
err := s.loadData(sources)
if err != nil {
t.Fatalf("Error loading data: %s", err)
"strings"
"testing"
+ "io/ioutil"
+ "log"
+
"github.com/spf13/hugo/helpers"
"github.com/spf13/hugo/tpl"
+ 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)
+
const (
baseURL = "http://foo/bar"
)
"(?s)^\n<div class=\"highlight\" style=\"background: #f0f0f0\"><pre style=\"line-height: 125%\">.*?void</span>.*?do</span>.*?().*?</pre></div>\n$",
},
} {
- templ := tpl.New()
+ templ := tpl.New(logger)
p, _ := pageFromString(simplePage, "simple.md")
output, err := HandleShortcodes(this.in, p, templ)
"(?s)^\n<figure >.*?<img src=\"/img/hugo-logo.png\" />.*?<figcaption>.*?<p>.*?<a href=\"/img/hugo-logo.png\">.*?Hugo logo.*?</a>.*?</p>.*?</figcaption>.*?</figure>\n$",
},
} {
- templ := tpl.New()
+ templ := tpl.New(logger)
p, _ := pageFromString(simplePage, "simple.md")
output, err := HandleShortcodes(this.in, p, templ)
"(?s)^<script async class='speakerdeck-embed' data-id='4e8126e72d853c0060001f97'.*?>.*?</script>$",
},
} {
- templ := tpl.New()
+ templ := tpl.New(logger)
p, _ := pageFromString(simplePage, "simple.md")
output, err := HandleShortcodes(this.in, p, templ)
"(?s)^\n<div class=\"video\">.*?<iframe src=\"//www.youtube.com/embed/w7Ft2ymGmfc\\?autoplay=1\".*?allowfullscreen frameborder=\"0\">.*?</iframe>.*?</div>$",
},
} {
- templ := tpl.New()
+ templ := tpl.New(logger)
p, _ := pageFromString(simplePage, "simple.md")
output, err := HandleShortcodes(this.in, p, templ)
"(?s)^<div class=\"video\">.*?<iframe src=\"//player.vimeo.com/video/146022717\" webkitallowfullscreen mozallowfullscreen allowfullscreen>.*?</iframe>.*?</div>$",
},
} {
- templ := tpl.New()
+ templ := tpl.New(logger)
p, _ := pageFromString(simplePage, "simple.md")
output, err := HandleShortcodes(this.in, p, templ)
"(?s)^<script src=\"//gist.github.com/spf13/7896402.js\\?file=img.html\"></script>$",
},
} {
- templ := tpl.New()
+ templ := tpl.New(logger)
p, _ := pageFromString(simplePage, "simple.md")
output, err := HandleShortcodes(this.in, p, templ)
},
}
- templ := tpl.New()
+ templ := tpl.New(logger)
templ.Lookup("").Funcs(tweetFuncMap)
p, _ := pageFromString(simplePage, "simple.md")
},
}
- templ := tpl.New()
+ templ := tpl.New(logger)
templ.Lookup("").Funcs(tweetFuncMap)
p, _ := pageFromString(simplePage, "simple.md")
type basicPageHandler Handle
func (b basicPageHandler) Read(f *source.File, s *Site) HandledResult {
- page, err := NewPage(f.Path())
+ page, err := s.NewPage(f.Path())
if err != nil {
return HandledResult{file: f, err: err}
return HandledResult{file: f, err: err}
}
- page.Site = &s.Info
-
return HandledResult{file: f, page: page, err: err}
}
import (
"fmt"
+ "io/ioutil"
+ "log"
+ "os"
"strings"
"sync"
runMode runmode
multilingual *Multilingual
+
+ *deps
+}
+
+// deps holds dependencies used by many.
+// TODO(bep) globals a better name.
+// There will be normally be only one instance of deps in play
+// at a given time.
+type deps struct {
+ // The logger to use.
+ log *jww.Notepad
+
+ // TODO(bep) next in line: Viper, hugofs, template
+}
+
+func newDeps(cfg DepsCfg) *deps {
+ logger := cfg.Logger
+
+ if logger == nil {
+ // TODO(bep) globals default log level
+ //logger = jww.NewNotepad(jww.LevelError, jww.LevelWarn, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+ logger = jww.NewNotepad(jww.LevelFatal, jww.LevelFatal, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+ }
+
+ return &deps{
+ log: logger,
+ }
}
// NewHugoSites creates a new collection of sites given the input sites, building
// a language configuration based on those.
-func newHugoSites(sites ...*Site) (*HugoSites, error) {
+func newHugoSites(cfg DepsCfg, sites ...*Site) (*HugoSites, error) {
langConfig, err := newMultiLingualFromSites(sites...)
if err != nil {
return nil, err
}
- h := &HugoSites{multilingual: langConfig, Sites: sites}
+ h := &HugoSites{
+ deps: newDeps(cfg),
+ multilingual: langConfig,
+ Sites: sites}
for _, s := range sites {
s.owner = h
+ s.deps = h.deps
}
return h, nil
}
// NewHugoSitesFromConfiguration creates HugoSites from the global Viper config.
-func NewHugoSitesFromConfiguration() (*HugoSites, error) {
+// TODO(bep) globals rename this when all the globals are gone.
+func NewHugoSitesFromConfiguration(cfg DepsCfg) (*HugoSites, error) {
sites, err := createSitesFromConfig()
if err != nil {
return nil, err
}
- return newHugoSites(sites...)
+ return newHugoSites(cfg, sites...)
}
func createSitesFromConfig() ([]*Site, error) {
whatChanged *whatChanged
}
+// DepsCfg contains configuration options that can be used to configure Hugo
+// on a global level, i.e. logging etc.
+// Nil values will be given default values.
+type DepsCfg struct {
+
+ // The Logger to use.
+ Logger *jww.Notepad
+}
+
func (h *HugoSites) renderCrossSitesArtifacts() error {
if !h.multilingual.enabled() {
if s.PageCollections == nil {
s.PageCollections = newPageCollections()
}
- sites, err := newHugoSites(s)
+ sites, err := newHugoSites(DepsCfg{}, s)
if err != nil {
return err
}
if len(languages) == 0 {
panic("Must provide at least one language")
}
+
+ cfg := DepsCfg{}
+
first := &Site{
Source: &source.InMemorySource{ByteSource: input},
Language: languages[0],
}
if len(languages) == 1 {
- return newHugoSites(first)
+ return newHugoSites(cfg, first)
}
sites := make([]*Site, len(languages))
sites[i] = &Site{Language: languages[i]}
}
- return newHugoSites(sites...)
+ return newHugoSites(cfg, sites...)
}
"github.com/fsnotify/fsnotify"
"github.com/spf13/hugo/helpers"
- jww "github.com/spf13/jwalterweatherman"
)
// Build builds all sites. If filesystem events are provided,
}
if config.PrintStats {
- jww.FEEDBACK.Printf("total in %v ms\n", int(1000*time.Since(t0).Seconds()))
+ h.log.FEEDBACK.Printf("total in %v ms\n", int(1000*time.Since(t0).Seconds()))
}
return nil
}
func TestMultiSitesMainLangInRoot(t *testing.T) {
- //jww.SetStdoutThreshold(jww.LevelDebug)
for _, b := range []bool{true, false} {
doTestMultiSitesMainLangInRoot(t, b)
// Add some data
writeSource(t, "data/hugo.toml", "slogan = \"Hugo Rocks!\"")
- sites, err := NewHugoSitesFromConfiguration()
+ sites, err := NewHugoSitesFromConfiguration(DepsCfg{})
if err != nil {
t.Fatalf("Failed to create sites: %s", err)
// Add some data
writeSource(t, "data/hugo.toml", "slogan = \"Hugo Rocks!\"")
- sites, err := NewHugoSitesFromConfiguration()
+ sites, err := NewHugoSitesFromConfiguration(DepsCfg{})
if err != nil {
t.Fatalf("Failed to create sites: %s", err)
hugofs.InitMemFs()
return &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: pageSources},
Language: helpers.NewDefaultLanguage(),
}
"testing"
"time"
- jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
)
}
func doTestNodeAsPage(t *testing.T, ugly, preserveTaxonomyNames bool) {
- //jww.SetStdoutThreshold(jww.LevelDebug)
- jww.SetStdoutThreshold(jww.LevelFatal)
/* Will have to decide what to name the node content files, but:
viper.Set("title", "Hugo Rocks")
viper.Set("rssURI", "customrss.xml")
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
if err := buildAndRenderSite(s); err != nil {
t.Fatalf("Failed to build site: %s", err)
}
func doTestNodesWithNoContentFile(t *testing.T, ugly bool) {
- //jww.SetStdoutThreshold(jww.LevelDebug)
- jww.SetStdoutThreshold(jww.LevelFatal)
-
testCommonResetState()
writeLayoutsForNodeAsPageTests(t)
viper.Set("title", "Hugo Rocks!")
viper.Set("rssURI", "customrss.xml")
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
if err := buildAndRenderSite(s); err != nil {
t.Fatalf("Failed to build site: %s", err)
t.Fatalf("Failed to load config: %s", err)
}
- sites, err := NewHugoSitesFromConfiguration()
+ sites, err := NewHugoSitesFromConfiguration(DepsCfg{})
if err != nil {
t.Fatalf("Failed to create sites: %s", err)
viper.Set("paginate", 1)
viper.Set("title", "Hugo Rocks!")
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
if err := buildAndRenderSite(s); err != nil {
t.Fatalf("Failed to build site: %s", err)
viper.Set("paginate", 1)
viper.Set("title", "Hugo Rocks!")
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
if err := buildAndRenderSite(s); err != nil {
t.Fatalf("Failed to build site: %s", err)
viper.Set("baseURL", "http://base/")
viper.Set("title", "Hugo Rocks!")
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
if err := buildAndRenderSite(s); err != nil {
t.Fatalf("Failed to build site: %s", err)
viper.Set("paginate", 1)
viper.Set("title", "Hugo Rocks!")
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
if err := buildAndRenderSite(s); err != nil {
t.Fatalf("Failed to build site: %s", err)
viper.Set("title", "Hugo Rocks!")
viper.Set("baseURL", "http://bep.is/base/")
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
if err := buildAndRenderSite(s); err != nil {
t.Fatalf("Failed to build site: %s", err)
"github.com/spf13/hugo/hugofs"
"github.com/spf13/hugo/source"
"github.com/spf13/hugo/tpl"
- jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
)
// isn't accomanied by one.
sections []string
- site *Site
+ s *Site
// Pulled over from old Node. TODO(bep) reorg and group (embed)
p.renderingConfig = helpers.NewBlackfriday(p.Language())
if err := mapstructure.Decode(pageParam, p.renderingConfig); err != nil {
- jww.FATAL.Printf("Failed to get rendering config for %s:\n%s", p.BaseFileName(), err.Error())
+ p.s.log.FATAL.Printf("Failed to get rendering config for %s:\n%s", p.BaseFileName(), err.Error())
}
})
return p.renderingConfig
}
-func newPage(filename string) *Page {
+func (s *Site) newPage(filename string) *Page {
page := Page{
pageInit: &pageInit{},
Kind: kindFromFilename(filename),
sections: sectionsFromFilename(filename),
}
- jww.DEBUG.Println("Reading from", page.File.Path())
+ s.log.DEBUG.Println("Reading from", page.File.Path())
return &page
}
switch p.Kind {
case KindHome:
- return p.site.appendThemeTemplates([]string{"index.html", "_default/list.html"})
+ return p.s.appendThemeTemplates([]string{"index.html", "_default/list.html"})
case KindSection:
section := p.sections[0]
- return p.site.appendThemeTemplates([]string{"section/" + section + ".html", "_default/section.html", "_default/list.html", "indexes/" + section + ".html", "_default/indexes.html"})
+ return p.s.appendThemeTemplates([]string{"section/" + section + ".html", "_default/section.html", "_default/list.html", "indexes/" + section + ".html", "_default/indexes.html"})
case KindTaxonomy:
- singular := p.site.taxonomiesPluralSingular[p.sections[0]]
- return p.site.appendThemeTemplates([]string{"taxonomy/" + singular + ".html", "indexes/" + singular + ".html", "_default/taxonomy.html", "_default/list.html"})
+ singular := p.s.taxonomiesPluralSingular[p.sections[0]]
+ return p.s.appendThemeTemplates([]string{"taxonomy/" + singular + ".html", "indexes/" + singular + ".html", "_default/taxonomy.html", "_default/list.html"})
case KindTaxonomyTerm:
- singular := p.site.taxonomiesPluralSingular[p.sections[0]]
- return p.site.appendThemeTemplates([]string{"taxonomy/" + singular + ".terms.html", "_default/terms.html", "indexes/indexes.html"})
+ singular := p.s.taxonomiesPluralSingular[p.sections[0]]
+ return p.s.appendThemeTemplates([]string{"taxonomy/" + singular + ".terms.html", "_default/terms.html", "indexes/indexes.html"})
}
// Regular Page handled below
section := p.sections[0]
return []string{"section/" + section + ".rss.xml", "_default/rss.xml", "rss.xml", "_internal/_default/rss.xml"}
case KindTaxonomy:
- singular := p.site.taxonomiesPluralSingular[p.sections[0]]
+ singular := p.s.taxonomiesPluralSingular[p.sections[0]]
return []string{"taxonomy/" + singular + ".rss.xml", "_default/rss.xml", "rss.xml", "_internal/_default/rss.xml"}
case KindTaxonomyTerm:
// No RSS for taxonomy terms
return
}
-func NewPageFrom(buf io.Reader, name string) (*Page, error) {
- p, err := NewPage(name)
+func (s *Site) NewPageFrom(buf io.Reader, name string) (*Page, error) {
+ p, err := s.NewPage(name)
if err != nil {
return p, err
}
return p, err
}
-func NewPage(name string) (*Page, error) {
+func (s *Site) NewPage(name string) (*Page, error) {
if len(name) == 0 {
return nil, errors.New("Zero length page name")
}
// Create new page
- p := newPage(name)
+ p := s.newPage(name)
+ p.s = s
+ p.Site = &s.Info
return p, nil
}
func (p *Page) ReadFrom(buf io.Reader) (int64, error) {
// Parse for metadata & body
if err := p.parse(buf); err != nil {
- jww.ERROR.Print(err)
+ p.s.log.ERROR.Print(err)
return 0, err
}
p.pageURLInit.Do(func() {
u, err := p.createPermalink()
if err != nil {
- jww.ERROR.Printf("Failed to create permalink for page %q: %s", p.FullFilePath(), err)
+ p.s.log.ERROR.Printf("Failed to create permalink for page %q: %s", p.FullFilePath(), err)
p.permalink = new(url.URL)
return
}
case "date":
p.Date, err = cast.ToTimeE(v)
if err != nil {
- jww.ERROR.Printf("Failed to parse date '%v' in page %s", v, p.File.Path())
+ p.s.log.ERROR.Printf("Failed to parse date '%v' in page %s", v, p.File.Path())
}
case "lastmod":
p.Lastmod, err = cast.ToTimeE(v)
if err != nil {
- jww.ERROR.Printf("Failed to parse lastmod '%v' in page %s", v, p.File.Path())
+ p.s.log.ERROR.Printf("Failed to parse lastmod '%v' in page %s", v, p.File.Path())
}
case "publishdate", "pubdate":
p.PublishDate, err = cast.ToTimeE(v)
if err != nil {
- jww.ERROR.Printf("Failed to parse publishdate '%v' in page %s", v, p.File.Path())
+ p.s.log.ERROR.Printf("Failed to parse publishdate '%v' in page %s", v, p.File.Path())
}
case "expirydate", "unpublishdate":
p.ExpiryDate, err = cast.ToTimeE(v)
if err != nil {
- jww.ERROR.Printf("Failed to parse expirydate '%v' in page %s", v, p.File.Path())
+ p.s.log.ERROR.Printf("Failed to parse expirydate '%v' in page %s", v, p.File.Path())
}
case "draft":
draft = new(bool)
if draft != nil && published != nil {
p.Draft = *draft
- jww.ERROR.Printf("page %s has both draft and published settings in its frontmatter. Using draft.", p.File.Path())
+ p.s.log.ERROR.Printf("page %s has both draft and published settings in its frontmatter. Using draft.", p.File.Path())
return ErrHasDraftAndPublished
} else if draft != nil {
p.Draft = *draft
return v
}
- jww.ERROR.Printf("GetParam(\"%s\"): Unknown type %s\n", key, reflect.TypeOf(v))
+ p.s.log.ERROR.Printf("GetParam(\"%s\"): Unknown type %s\n", key, reflect.TypeOf(v))
return nil
}
menus, err := cast.ToStringMapE(ms)
if err != nil {
- jww.ERROR.Printf("unable to process menus for %q\n", p.Title)
+ p.s.log.ERROR.Printf("unable to process menus for %q\n", p.Title)
}
for name, menu := range menus {
menuEntry := MenuEntry{Name: p.LinkTitle(), URL: link, Weight: p.Weight, Menu: name}
if menu != nil {
- jww.DEBUG.Printf("found menu: %q, in %q\n", name, p.Title)
+ p.s.log.DEBUG.Printf("found menu: %q, in %q\n", name, p.Title)
ime, err := cast.ToStringMapE(menu)
if err != nil {
- jww.ERROR.Printf("unable to process menus for %q: %s", p.Title, err)
+ p.s.log.ERROR.Printf("unable to process menus for %q: %s", p.Title, err)
}
menuEntry.marshallMap(ime)
meta, err := psr.Metadata()
if meta != nil {
if err != nil {
- jww.ERROR.Printf("Error parsing page meta data for %s", p.File.Path())
- jww.ERROR.Println(err)
+ p.s.log.ERROR.Printf("Error parsing page meta data for %s", p.File.Path())
+ p.s.log.ERROR.Println(err)
return err
}
if err = p.update(meta); err != nil {
if !filepath.IsAbs(inpath) {
inpath = helpers.AbsPathify(inpath)
}
- jww.INFO.Println("creating", inpath)
+ p.s.log.INFO.Println("creating", inpath)
if safe {
err = helpers.SafeWriteToDisk(inpath, bytes.NewReader(by), hugofs.Source())
if language == nil {
// It can be a file named stefano.chiodino.md.
- jww.WARN.Printf("Page language (if it is that) not found in multilang setup: %s.", pageLang)
+ p.s.log.WARN.Printf("Page language (if it is that) not found in multilang setup: %s.", pageLang)
language = ml.DefaultLang
}
p.URLPath.URL = "/" + path.Join(p.sections...) + "/"
}
- p.site = s
+ p.s = s
}
func preparePageGroupTestPages(t *testing.T) Pages {
var pages Pages
for _, s := range pageGroupTestSources {
- p, err := NewPage(filepath.FromSlash(s.path))
+ p, err := pageTestSite.NewPage(filepath.FromSlash(s.path))
if err != nil {
t.Fatalf("failed to prepare test page %s", s.path)
}
func TestGroupByParamCalledWithCapitalLetterString(t *testing.T) {
testStr := "TestString"
f := "/section1/test_capital.md"
- p, err := NewPage(filepath.FromSlash(f))
+ p, err := pageTestSite.NewPage(filepath.FromSlash(f))
if err != nil {
t.Fatalf("failed to prepare test page %s", f)
}
pageYamlWithTaxonomiesC,
} {
- p, _ := NewPage("page/with/taxonomy")
+ p, _ := pageTestSite.NewPage("page/with/taxonomy")
_, err := p.ReadFrom(strings.NewReader(test))
if err != nil {
t.Fatalf("Failed parsing %q: %s", test, err)
Hi.
`
+var pageTestSite = NewSiteDefaultLang()
+
func checkError(t *testing.T, err error, expected string) {
if err == nil {
t.Fatalf("err is nil. Expected: %s", expected)
func TestDegenerateEmptyPageZeroLengthName(t *testing.T) {
- _, err := NewPage("")
+ _, err := pageTestSite.NewPage("")
if err == nil {
t.Fatalf("A zero length page name must return an error")
}
}
func TestDegenerateEmptyPage(t *testing.T) {
- _, err := NewPageFrom(strings.NewReader(emptyPage), "test")
+ _, err := pageTestSite.NewPageFrom(strings.NewReader(emptyPage), "test")
if err != nil {
t.Fatalf("Empty files should not trigger an error. Should be able to touch a file while watching without erroring out.")
}
writeSource(t, filepath.Join(contentDir, fileSourcePairs[i]), fileSourcePairs[i+1])
}
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
if err := buildSiteSkipRender(s); err != nil {
t.Fatalf("Failed to build site: %s", err)
}
for _, test := range tests {
- p, _ := NewPage("page")
+ p, _ := pageTestSite.NewPage("page")
if _, err := p.ReadFrom(strings.NewReader(test.r)); err != nil {
t.Errorf("Unable to parse page: %s", err)
}
}
for _, test := range tests {
- p, _ := NewPage("invalid/front/matter/short/delim")
+ p, _ := pageTestSite.NewPage("invalid/front/matter/short/delim")
_, err := p.ReadFrom(strings.NewReader(test.r))
checkError(t, err, test.err)
}
for _, test := range tests {
- p, _ := NewPage("render/front/matter")
+ p, _ := pageTestSite.NewPage("render/front/matter")
_, err := p.ReadFrom(strings.NewReader(test.text))
p = pageMust(p, err)
if p.IsRenderable() != test.render {
// Issue #768
func TestCalendarParamsVariants(t *testing.T) {
- pageJSON, _ := NewPage("test/fileJSON.md")
+ pageJSON, _ := pageTestSite.NewPage("test/fileJSON.md")
_, _ = pageJSON.ReadFrom(strings.NewReader(pageWithCalendarJSONFrontmatter))
- pageYAML, _ := NewPage("test/fileYAML.md")
+ pageYAML, _ := pageTestSite.NewPage("test/fileYAML.md")
_, _ = pageYAML.ReadFrom(strings.NewReader(pageWithCalendarYAMLFrontmatter))
- pageTOML, _ := NewPage("test/fileTOML.md")
+ pageTOML, _ := pageTestSite.NewPage("test/fileTOML.md")
_, _ = pageTOML.ReadFrom(strings.NewReader(pageWithCalendarTOMLFrontmatter))
assert.True(t, compareObjects(pageJSON.Params, pageYAML.Params))
}
func TestDifferentFrontMatterVarTypes(t *testing.T) {
- page, _ := NewPage("test/file1.md")
+ page, _ := pageTestSite.NewPage("test/file1.md")
_, _ = page.ReadFrom(strings.NewReader(pageWithVariousFrontmatterTypes))
dateval, _ := time.Parse(time.RFC3339, "1979-05-27T07:32:00Z")
}
func TestDegenerateInvalidFrontMatterLeadingWhitespace(t *testing.T) {
- p, _ := NewPage("invalid/front/matter/leading/ws")
+ p, _ := pageTestSite.NewPage("invalid/front/matter/leading/ws")
_, err := p.ReadFrom(strings.NewReader(invalidFrontmatterLadingWs))
if err != nil {
t.Fatalf("Unable to parse front matter given leading whitespace: %s", err)
}
func TestSectionEvaluation(t *testing.T) {
- page, _ := NewPage(filepath.FromSlash("blue/file1.md"))
+ page, _ := pageTestSite.NewPage(filepath.FromSlash("blue/file1.md"))
page.ReadFrom(strings.NewReader(simplePage))
if page.Section() != "blue" {
t.Errorf("Section should be %s, got: %s", "blue", page.Section())
{simplePageTypeLayout, pathNoDirectory, L("barfoo/buzfoo.html", "_default/buzfoo.html")},
}
for _, test := range tests {
- p, _ := NewPage(test.path)
+ p, _ := pageTestSite.NewPage(test.path)
_, err := p.ReadFrom(strings.NewReader(test.content))
if err != nil {
t.Fatalf("Unable to parse content:\n%s\n", test.content)
}
for _, test := range tests {
- p, _ := NewPageFrom(strings.NewReader(test.content), filepath.FromSlash(test.path))
+ p, _ := pageTestSite.NewPageFrom(strings.NewReader(test.content), filepath.FromSlash(test.path))
info := newSiteInfo(siteBuilderCfg{language: helpers.NewDefaultLanguage()})
p.Site = &info
`
func TestDraftAndPublishedFrontMatterError(t *testing.T) {
- _, err := NewPageFrom(strings.NewReader(pageWithDraftAndPublished), "content/post/broken.md")
+ _, err := pageTestSite.NewPageFrom(strings.NewReader(pageWithDraftAndPublished), "content/post/broken.md")
if err != ErrHasDraftAndPublished {
t.Errorf("expected ErrHasDraftAndPublished, was %#v", err)
}
`
func TestPublishedFrontMatter(t *testing.T) {
- p, err := NewPageFrom(strings.NewReader(pagesWithPublishedFalse), "content/post/broken.md")
+ p, err := pageTestSite.NewPageFrom(strings.NewReader(pagesWithPublishedFalse), "content/post/broken.md")
if err != nil {
t.Fatalf("err during parse: %s", err)
}
if !p.Draft {
t.Errorf("expected true, got %t", p.Draft)
}
- p, err = NewPageFrom(strings.NewReader(pageWithPublishedTrue), "content/post/broken.md")
+ p, err = pageTestSite.NewPageFrom(strings.NewReader(pageWithPublishedTrue), "content/post/broken.md")
if err != nil {
t.Fatalf("err during parse: %s", err)
}
for _, draft := range []bool{true, false} {
for i, templ := range pagesDraftTemplate {
pageContent := fmt.Sprintf(templ, draft)
- p, err := NewPageFrom(strings.NewReader(pageContent), "content/post/broken.md")
+ p, err := pageTestSite.NewPageFrom(strings.NewReader(pageContent), "content/post/broken.md")
if err != nil {
t.Fatalf("err during parse: %s", err)
}
}
for i, c := range pagesParamsTemplate {
- p, err := NewPageFrom(strings.NewReader(c), "content/post/params.md")
+ p, err := pageTestSite.NewPageFrom(strings.NewReader(c), "content/post/params.md")
require.NoError(t, err, "err during parse", "#%d", i)
assert.Equal(t, want, p.Params, "#%d", i)
}
{func(p *Page) bool { return strings.Join(p.PlainWords(), " ") == "Do Be Do Be Do" }},
} {
- p, _ := NewPage("Test")
+ p, _ := pageTestSite.NewPage("Test")
p.Content = "<h1>Do Be Do Be Do</h1>"
if !this.assertFunc(p) {
t.Errorf("[%d] Page method error", i)
buf.ReadFrom(f)
b.ResetTimer()
for i := 0; i < b.N; i++ {
- page, _ := NewPage("bench")
+ page, _ := pageTestSite.NewPage("bench")
page.ReadFrom(bytes.NewReader(buf.Bytes()))
}
}
)
func TestDegenerateDateFrontMatter(t *testing.T) {
- p, _ := NewPageFrom(strings.NewReader(pageWithInvalidDate), "page/with/invalid/date")
+ p, _ := pageTestSite.NewPageFrom(strings.NewReader(pageWithInvalidDate), "page/with/invalid/date")
if p.Date != *new(time.Time) {
t.Fatalf("Date should be set to time.Time zero value. Got: %s", p.Date)
}
if e != nil {
t.Fatalf("Unable to parse date time (RFC3339) for running the test: %s", e)
}
- p, err := NewPageFrom(strings.NewReader(test.buf), "page/with/date")
+ p, err := pageTestSite.NewPageFrom(strings.NewReader(test.buf), "page/with/date")
if err != nil {
t.Fatalf("Expected to be able to parse page.")
}
w := WeightedPages{}
for _, s := range pagePNTestSources {
- p, err := NewPage(s.path)
+ p, err := pageTestSite.NewPage(s.path)
if err != nil {
t.Fatalf("failed to prepare test page %s", s.path)
}
viper.Set("paginate", -1)
}
pages := createTestPages(12)
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
n1 := s.newHomePage()
n2 := s.newHomePage()
n1.Data["Pages"] = pages
samePaginator, _ := n1.Paginator()
assert.Equal(t, paginator1, samePaginator)
- p, _ := NewPage("test")
+ p, _ := pageTestSite.NewPage("test")
_, err = p.Paginator()
assert.NotNil(t, err)
}
testCommonResetState()
viper.Set("paginate", -1)
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
_, err := s.newHomePage().Paginator()
assert.NotNil(t, err)
}
}
pages := createTestPages(6)
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
n1 := s.newHomePage()
n2 := s.newHomePage()
assert.Nil(t, err)
assert.Equal(t, paginator2, paginator1.Next())
- p, _ := NewPage("test")
+ p, _ := pageTestSite.NewPage("test")
_, err = p.Paginate(pages)
assert.NotNil(t, err)
}
func TestInvalidOptions(t *testing.T) {
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
n1 := s.newHomePage()
_, err := n1.Paginate(createTestPages(1), 1, 2)
assert.NotNil(t, err)
testCommonResetState()
viper.Set("paginate", -1)
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
_, err := s.newHomePage().Paginate(createTestPages(2))
assert.NotNil(t, err)
}
testCommonResetState()
viper.Set("paginate", 10)
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
n1 := s.newHomePage()
n2 := s.newHomePage()
testCommonResetState()
viper.Set("paginate", 10)
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
n1 := s.newHomePage()
n2 := s.newHomePage()
`
func TestDegenerateMissingFolderInPageFilename(t *testing.T) {
- p, err := NewPageFrom(strings.NewReader(simplePageYAML), filepath.Join("foobar"))
+ p, err := pageTestSite.NewPageFrom(strings.NewReader(simplePageYAML), filepath.Join("foobar"))
if err != nil {
t.Fatalf("Error in NewPageFrom")
}
}
for i, el := range toCheck {
- p, err := NewPageFrom(strings.NewReader(simplePageYAML), el.input)
+ p, err := pageTestSite.NewPageFrom(strings.NewReader(simplePageYAML), el.input)
if err != nil {
t.Errorf("[%d] Reading from simplePageYAML resulted in an error: %s", i, err)
}
}
func TestPermalinkExpansion(t *testing.T) {
- page, err := NewPageFrom(strings.NewReader(simplePageJSON), "blue/test-page.md")
+ page, err := pageTestSite.NewPageFrom(strings.NewReader(simplePageJSON), "blue/test-page.md")
info := newSiteInfo(siteBuilderCfg{language: helpers.NewDefaultLanguage()})
page.Site = &info
if err != nil {
writeSource(t, filepath.Join("content", "sect", s.Name), string(s.Content))
}
- if err := buildAndRenderSite(newSiteDefaultLang()); err != nil {
+ if err := buildAndRenderSite(NewSiteDefaultLang()); err != nil {
t.Fatalf("Failed to build site: %s", err)
}
bp "github.com/spf13/hugo/bufferpool"
"github.com/spf13/hugo/helpers"
"github.com/spf13/hugo/tpl"
- jww "github.com/spf13/jwalterweatherman"
)
// ShortcodeWithPage is the "." context in a shortcode template.
tmpl := getShortcodeTemplate(sc.name, t)
if tmpl == nil {
- jww.ERROR.Printf("Unable to locate template for shortcode '%s' in page %s", sc.name, p.BaseFileName())
+ p.s.log.ERROR.Printf("Unable to locate template for shortcode '%s' in page %s", sc.name, p.BaseFileName())
return ""
}
case shortcode:
inner += renderShortcode(innerData.(shortcode), data, p, t)
default:
- jww.ERROR.Printf("Illegal state on shortcode rendering of '%s' in page %s. Illegal type in inner data: %s ",
+ p.s.log.ERROR.Printf("Illegal state on shortcode rendering of '%s' in page %s. Illegal type in inner data: %s ",
sc.name, p.BaseFileName(), reflect.TypeOf(innerData))
return ""
}
if err != nil {
// try to render what we have whilst logging the error
- jww.ERROR.Println(err.Error())
+ p.s.log.ERROR.Println(err.Error())
}
// Save for reuse
err := tmpl.Execute(buffer, data)
isInnerShortcodeCache.RUnlock()
if err != nil {
- jww.ERROR.Println("error processing shortcode", tmpl.Name(), "\n ERR:", err)
- jww.WARN.Println(data)
+ // TODO(bep) globals
+ data.Page.s.log.ERROR.Println("error processing shortcode", tmpl.Name(), "\n ERR:", err)
+ data.Page.s.log.WARN.Println(data)
}
return buffer.String()
}
// TODO(bep) remove
func pageFromString(in, filename string) (*Page, error) {
- return NewPageFrom(strings.NewReader(in), filename)
+ return pageTestSite.NewPageFrom(strings.NewReader(in), filename)
}
func CheckShortCodeMatch(t *testing.T, input, expected string, withTemplate func(templ tpl.Template) error) {
}
func TestShortcodeGoFuzzReports(t *testing.T) {
- tem := tpl.New()
+ tem := tpl.New(logger)
tem.AddInternalShortcode("sc.html", `foo`)
p, _ := pageFromString(simplePage, "simple.md")
viper.Set("pygmentsStyle", "bw")
viper.Set("pygmentsUseClasses", false)
- templ := tpl.New()
+ templ := tpl.New(logger)
code := `
{{< highlight java >}}
} {
p, _ := pageFromString(simplePage, "simple.md")
- tem := tpl.New()
+ tem := tpl.New(logger)
tem.AddInternalShortcode("tag.html", `tag`)
tem.AddInternalShortcode("sc1.html", `sc1`)
tem.AddInternalShortcode("sc2.html", `sc2`)
}
- sites, err := newHugoSites(s)
+ sites, err := newHugoSites(DepsCfg{}, s)
if err != nil {
t.Fatalf("Failed to build site: %s", err)
"github.com/spf13/hugo/target"
"github.com/spf13/hugo/tpl"
"github.com/spf13/hugo/transform"
- jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/nitro"
"github.com/spf13/viper"
)
expiredCount int
Data map[string]interface{}
Language *helpers.Language
+
+ // Logger etc.
+ *deps
}
// reset returns a new Site prepared for rebuild.
func (s *Site) reset() *Site {
- return &Site{Language: s.Language, owner: s.owner, PageCollections: newPageCollections()}
+ return &Site{deps: s.deps, Language: s.Language, owner: s.owner, PageCollections: newPageCollections()}
}
// newSite creates a new site in the given language.
func newSite(lang *helpers.Language) *Site {
c := newPageCollections()
- return &Site{Language: lang, PageCollections: c, Info: newSiteInfo(siteBuilderCfg{pageCollections: c, language: lang})}
+ // TODO(bep) globals (also see other Site creation places)
+ deps := newDeps(DepsCfg{})
+ // TODO(bep) globals
+ viper.Set("currentContentLanguage", lang)
+ return &Site{deps: deps, Language: lang, PageCollections: c, Info: newSiteInfo(siteBuilderCfg{pageCollections: c, language: lang})}
}
-// newSite creates a new site in the default language.
-func newSiteDefaultLang() *Site {
+// NewSiteDefaultLang creates a new site in the default language.
+func NewSiteDefaultLang() *Site {
return newSite(helpers.NewDefaultLanguage())
}
lang := helpers.NewDefaultLanguage()
return &Site{
+ deps: newDeps(DepsCfg{}),
PageCollections: newPageCollections(),
Source: &source.InMemorySource{ByteSource: sources},
Language: lang,
// It returns whetever the content source was changed.
func (s *Site) reProcess(events []fsnotify.Event) (whatChanged, error) {
- jww.DEBUG.Printf("Rebuild for events %q", events)
+ s.log.DEBUG.Printf("Rebuild for events %q", events)
s.timerStep("initialize rebuild")
if len(i18nChanged) > 0 {
if err := s.readI18nSources(); err != nil {
- jww.ERROR.Println(err)
+ s.log.ERROR.Println(err)
}
}
file, err := s.reReadFile(ev.Name)
if err != nil {
- jww.ERROR.Println("Error reading file", ev.Name, ";", err)
+ s.log.ERROR.Println("Error reading file", ev.Name, ";", err)
}
if file != nil {
for i := 0; i < 2; i++ {
err := <-errs
if err != nil {
- jww.ERROR.Println(err)
+ s.log.ERROR.Println(err)
}
}
}
func (s *Site) loadTemplates() {
- s.owner.tmpl = tpl.InitializeT()
+ s.owner.tmpl = tpl.InitializeT(s.log)
s.owner.tmpl.LoadTemplates(s.absLayoutDir())
if s.hasTheme() {
s.owner.tmpl.LoadTemplatesWithPrefix(s.absThemeDir()+"/layouts", "theme")
}
func (s *Site) loadData(sources []source.Input) (err error) {
- jww.DEBUG.Printf("Load Data from %q", sources)
+ s.log.DEBUG.Printf("Load Data from %q", sources)
s.Data = make(map[string]interface{})
var current map[string]interface{}
for _, currentSource := range sources {
}
}
- data, err := readData(r)
+ data, err := s.readData(r)
if err != nil {
return fmt.Errorf("Failed to read data from %s: %s", filepath.Join(r.Path(), r.LogicalName()), err)
}
// this warning could happen if
// 1. A theme uses the same key; the main data folder wins
// 2. A sub folder uses the same key: the sub folder wins
- jww.WARN.Printf("Data for key '%s' in path '%s' is overridden in subfolder", key, r.Path())
+ s.log.WARN.Printf("Data for key '%s' in path '%s' is overridden in subfolder", key, r.Path())
}
data[key] = value
}
return
}
-func readData(f *source.File) (interface{}, error) {
+func (s *Site) readData(f *source.File) (interface{}, error) {
switch f.Extension() {
case "yaml", "yml":
return parser.HandleYAMLMetaData(f.Bytes())
case "toml":
return parser.HandleTOMLMetaData(f.Bytes())
default:
- jww.WARN.Printf("Data not supported for extension '%s'", f.Extension())
+ s.log.WARN.Printf("Data not supported for extension '%s'", f.Extension())
return nil, nil
}
}
// May be supplied in tests.
if s.Source != nil && len(s.Source.Files()) > 0 {
- jww.DEBUG.Println("initialize: Source is already set")
+ s.log.DEBUG.Println("initialize: Source is already set")
return
}
}
func (s *Site) getI18nDir(path string) string {
- return getRealDir(s.absI18nDir(), path)
+ return s.getRealDir(s.absI18nDir(), path)
}
func (s *Site) getThemeI18nDir(path string) string {
if !s.hasTheme() {
return ""
}
- return getRealDir(helpers.AbsPathify(filepath.Join(s.themeDir(), s.i18nDir())), path)
+ return s.getRealDir(helpers.AbsPathify(filepath.Join(s.themeDir(), s.i18nDir())), path)
}
func (s *Site) isDataDirEvent(e fsnotify.Event) bool {
}
func (s *Site) getDataDir(path string) string {
- return getRealDir(s.absDataDir(), path)
+ return s.getRealDir(s.absDataDir(), path)
}
func (s *Site) getThemeDataDir(path string) string {
if !s.hasTheme() {
return ""
}
- return getRealDir(helpers.AbsPathify(filepath.Join(s.themeDir(), s.dataDir())), path)
+ return s.getRealDir(helpers.AbsPathify(filepath.Join(s.themeDir(), s.dataDir())), path)
}
func (s *Site) themeDir() string {
}
func (s *Site) getLayoutDir(path string) string {
- return getRealDir(s.absLayoutDir(), path)
+ return s.getRealDir(s.absLayoutDir(), path)
}
func (s *Site) getThemeLayoutDir(path string) string {
if !s.hasTheme() {
return ""
}
- return getRealDir(helpers.AbsPathify(filepath.Join(s.themeDir(), s.layoutDir())), path)
+ return s.getRealDir(helpers.AbsPathify(filepath.Join(s.themeDir(), s.layoutDir())), path)
}
func (s *Site) absContentDir() string {
}
func (s *Site) getContentDir(path string) string {
- return getRealDir(s.absContentDir(), path)
+ return s.getRealDir(s.absContentDir(), path)
}
// getRealDir gets the base path of the given path, also handling the case where
// base is a symlinked folder.
-func getRealDir(base, path string) string {
+func (s *Site) getRealDir(base, path string) string {
if strings.HasPrefix(path, base) {
return base
if err != nil {
if !os.IsNotExist(err) {
- jww.ERROR.Printf("Failed to get real path for %s: %s", path, err)
+ s.log.ERROR.Printf("Failed to get real path for %s: %s", path, err)
}
return ""
}
// reReadFile resets file to be read from disk again
func (s *Site) reReadFile(absFilePath string) (*source.File, error) {
- jww.INFO.Println("rereading", absFilePath)
+ s.log.INFO.Println("rereading", absFilePath)
var file *source.File
reader, err := source.NewLazyFileReader(hugofs.Source(), absFilePath)
panic(fmt.Sprintf("s.Source not set %s", s.absContentDir()))
}
- jww.DEBUG.Printf("Read %d pages from source", len(s.Source.Files()))
+ s.log.DEBUG.Printf("Read %d pages from source", len(s.Source.Files()))
errs := make(chan error)
if len(s.Source.Files()) < 1 {
if h != nil {
h.Read(file, s, results)
} else {
- jww.ERROR.Println("Unsupported File Type", file.Path())
+ s.log.ERROR.Println("Unsupported File Type", file.Path())
}
}
for name, menu := range menus {
m, err := cast.ToSliceE(menu)
if err != nil {
- jww.ERROR.Printf("unable to process menus in site config\n")
- jww.ERROR.Println(err)
+ s.log.ERROR.Printf("unable to process menus in site config\n")
+ s.log.ERROR.Println(err)
} else {
for _, entry := range m {
- jww.DEBUG.Printf("found menu: %q, in site config\n", name)
+ s.log.DEBUG.Printf("found menu: %q, in site config\n", name)
menuEntry := MenuEntry{Menu: name}
ime, err := cast.ToStringMapE(entry)
if err != nil {
- jww.ERROR.Printf("unable to process menus in site config\n")
- jww.ERROR.Println(err)
+ s.log.ERROR.Printf("unable to process menus in site config\n")
+ s.log.ERROR.Println(err)
}
menuEntry.marshallMap(ime)
for name, me := range p.Menus() {
if _, ok := flat[twoD{name, me.KeyName()}]; ok {
- jww.ERROR.Printf("Two or more menu items have the same name/identifier in Menu %q: %q.\nRename or set an unique identifier.\n", name, me.KeyName())
+ s.log.ERROR.Printf("Two or more menu items have the same name/identifier in Menu %q: %q.\nRename or set an unique identifier.\n", name, me.KeyName())
continue
}
flat[twoD{name, me.KeyName()}] = me
taxonomies := s.Language.GetStringMapString("taxonomies")
- jww.INFO.Printf("found taxonomies: %#v\n", taxonomies)
+ s.log.INFO.Printf("found taxonomies: %#v\n", taxonomies)
for singular, plural := range taxonomies {
s.Taxonomies[plural] = make(Taxonomy)
s.taxonomiesOrigKey[fmt.Sprintf("%s-%s", plural, kp(v))] = v
}
} else {
- jww.ERROR.Printf("Invalid %s in %s\n", plural, p.File.Path())
+ s.log.ERROR.Printf("Invalid %s in %s\n", plural, p.File.Path())
}
}
}
// Stats prints Hugo builds stats to the console.
// This is what you see after a successful hugo build.
func (s *Site) Stats() {
- jww.FEEDBACK.Printf("Built site for language %s:\n", s.Language.Lang)
- jww.FEEDBACK.Println(s.draftStats())
- jww.FEEDBACK.Println(s.futureStats())
- jww.FEEDBACK.Println(s.expiredStats())
- jww.FEEDBACK.Printf("%d regular pages created\n", len(s.RegularPages))
- jww.FEEDBACK.Printf("%d other pages created\n", (len(s.Pages) - len(s.RegularPages)))
- jww.FEEDBACK.Printf("%d non-page files copied\n", len(s.Files))
- jww.FEEDBACK.Printf("%d paginator pages created\n", s.Info.paginationPageCount)
+ s.log.FEEDBACK.Printf("Built site for language %s:\n", s.Language.Lang)
+ s.log.FEEDBACK.Println(s.draftStats())
+ s.log.FEEDBACK.Println(s.futureStats())
+ s.log.FEEDBACK.Println(s.expiredStats())
+ s.log.FEEDBACK.Printf("%d regular pages created\n", len(s.RegularPages))
+ s.log.FEEDBACK.Printf("%d other pages created\n", (len(s.Pages) - len(s.RegularPages)))
+ s.log.FEEDBACK.Printf("%d non-page files copied\n", len(s.Files))
+ s.log.FEEDBACK.Printf("%d paginator pages created\n", s.Info.paginationPageCount)
taxonomies := s.Language.GetStringMapString("taxonomies")
for _, pl := range taxonomies {
- jww.FEEDBACK.Printf("%d %s created\n", len(s.Taxonomies[pl]), pl)
+ s.log.FEEDBACK.Printf("%d %s created\n", len(s.Taxonomies[pl]), pl)
}
}
}
func (s *Site) renderAndWriteXML(name string, dest string, d interface{}, layouts ...string) error {
- jww.DEBUG.Printf("Render XML for %q to %q", name, dest)
+ s.log.DEBUG.Printf("Render XML for %q to %q", name, dest)
renderBuffer := bp.GetBuffer()
defer bp.PutBuffer(renderBuffer)
renderBuffer.WriteString("<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\" ?>\n")
if outBuffer.Len() == 0 {
- jww.WARN.Printf("%s is rendered empty\n", dest)
+ s.log.WARN.Printf("%s is rendered empty\n", dest)
if dest == "/" {
debugAddend := ""
if !viper.GetBool("verbose") {
func (s *Site) renderForLayouts(name string, d interface{}, w io.Writer, layouts ...string) error {
layout, found := s.findFirstLayout(layouts...)
if !found {
- jww.WARN.Printf("Unable to locate layout for %s: %s\n", name, layouts)
+ s.log.WARN.Printf("Unable to locate layout for %s: %s\n", name, layouts)
return nil
}
}
func (s *Site) writeDestFile(path string, reader io.Reader) (err error) {
- jww.DEBUG.Println("creating file:", path)
+ s.log.DEBUG.Println("creating file:", path)
return s.fileTarget().Publish(path, reader)
}
func (s *Site) writeDestPage(path string, publisher target.Publisher, reader io.Reader) (err error) {
- jww.DEBUG.Println("creating page:", path)
+ s.log.DEBUG.Println("creating page:", path)
return publisher.Publish(path, reader)
}
}
permalink, err = helpers.GetRelativePath(permalink, path)
if err != nil {
- jww.ERROR.Println("Failed to make a RelativeURL alias:", path, "redirecting to", permalink)
+ s.log.ERROR.Println("Failed to make a RelativeURL alias:", path, "redirecting to", permalink)
}
permalink = filepath.ToSlash(permalink)
}
- jww.DEBUG.Println("creating alias:", path, "redirecting to", permalink)
+ s.log.DEBUG.Println("creating alias:", path, "redirecting to", permalink)
return aliasPublisher.Publish(path, permalink, p)
}
Data: make(map[string]interface{}),
Site: &s.Info,
language: s.Language,
- site: s}
+ s: s}
}
func (s *Site) newHomePage() *Page {
bp "github.com/spf13/hugo/bufferpool"
"github.com/spf13/hugo/helpers"
"github.com/spf13/viper"
-
- jww "github.com/spf13/jwalterweatherman"
)
// renderPages renders pages each corresponding to a markdown file.
for p := range pages {
targetPath := p.TargetPath()
layouts := p.layouts()
- jww.DEBUG.Printf("Render %s to %q with layouts %q", p.Kind, targetPath, layouts)
+ s.log.DEBUG.Printf("Render %s to %q with layouts %q", p.Kind, targetPath, layouts)
if err := s.renderAndWritePage("page "+p.FullFilePath(), targetPath, p, s.appendThemeTemplates(layouts)...); err != nil {
results <- err
// renderPaginator must be run after the owning Page has been rendered.
func (s *Site) renderPaginator(p *Page) error {
if p.paginator != nil {
- jww.DEBUG.Printf("Render paginator for page %q", p.Path())
+ s.log.DEBUG.Printf("Render paginator for page %q", p.Path())
paginatePath := helpers.Config().GetString("paginatePath")
// write alias for page 1
mainLang := s.owner.multilingual.DefaultLang.Lang
if s.Info.defaultContentLanguageInSubdir {
mainLangURL := s.Info.pathSpec.AbsURL(mainLang, false)
- jww.DEBUG.Printf("Write redirect to main language %s: %s", mainLang, mainLangURL)
+ s.log.DEBUG.Printf("Write redirect to main language %s: %s", mainLang, mainLangURL)
if err := s.publishDestAlias(s.languageAliasTarget(), "/", mainLangURL, nil); err != nil {
return err
}
} else {
mainLangURL := s.Info.pathSpec.AbsURL("", false)
- jww.DEBUG.Printf("Write redirect to main language %s: %s", mainLang, mainLangURL)
+ s.log.DEBUG.Printf("Write redirect to main language %s: %s", mainLang, mainLangURL)
if err := s.publishDestAlias(s.languageAliasTarget(), mainLang, mainLangURL, nil); err != nil {
return err
}
sources := []source.ByteSource{}
s := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: sources},
targets: targetList{page: &target.PagePub{UglyURLs: true}},
}
}
func TestRenderWithInvalidTemplate(t *testing.T) {
- jww.ResetLogCounters()
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
if err := buildAndRenderSite(s, "missing", templateMissingFunc); err != nil {
t.Fatalf("Got build error: %s", err)
}
- if jww.LogCountForLevelsGreaterThanorEqualTo(jww.LevelError) != 1 {
+ if s.log.LogCountForLevelsGreaterThanorEqualTo(jww.LevelError) != 1 {
t.Fatalf("Expecting the template to log an ERROR")
}
}
siteSetup := func(t *testing.T) *Site {
s := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: sources},
Language: helpers.NewDefaultLanguage(),
}
siteSetup := func(t *testing.T) *Site {
s := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: sources},
Language: helpers.NewDefaultLanguage(),
}
}
s := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: sources},
targets: targetList{page: &target.PagePub{UglyURLs: uglyURLs}},
Language: helpers.NewDefaultLanguage(),
}
s := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: sources},
targets: targetList{page: &target.PagePub{UglyURLs: uglyURLs, PublishDir: "public"}},
Language: helpers.NewDefaultLanguage(),
// Issue #1176
func TestSectionNaming(t *testing.T) {
- //jww.SetStdoutThreshold(jww.LevelDebug)
for _, canonify := range []bool{true, false} {
for _, uglify := range []bool{true, false} {
writeSource(t, filepath.Join("content", source.Name), string(source.Content))
}
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
if err := buildAndRenderSite(s,
"_default/single.html", "{{.Content}}",
viper.Set("canonifyURLs", true)
viper.Set("baseURL", "http://auth/bub")
s := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: sources},
targets: targetList{page: &target.PagePub{UglyURLs: true}},
Language: helpers.NewDefaultLanguage(),
viper.Set("canonifyURLs", canonify)
viper.Set("baseURL", baseURL)
s := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: sources},
targets: targetList{page: &target.PagePub{UglyURLs: true}},
Language: helpers.NewDefaultLanguage(),
viper.Set("baseURL", "http://auth/bub")
s := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: weightedSources},
Language: helpers.NewDefaultLanguage(),
}
viper.Set("baseURL", "http://auth/bub")
s := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: groupedSources},
Language: helpers.NewDefaultLanguage(),
}
viper.Set("baseURL", "http://auth/bub")
viper.Set("taxonomies", taxonomies)
s := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: sources},
Language: helpers.NewDefaultLanguage(),
}
"sourceRelativeLinksProjectFolder": "/docs"})
site := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: sources},
Language: helpers.NewDefaultLanguage(),
}
{"http://base.com", "http://base.com"}} {
viper.Set("baseURL", this.in)
- s := newSiteDefaultLang()
+ s := NewSiteDefaultLang()
s.initializeSiteInfo()
if s.Info.BaseURL != template.URL(this.expected) {
viper.Set("uglyURLs", false)
viper.Set("paginate", 10)
s := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: urlFakeSource},
Language: helpers.NewDefaultLanguage(),
}
viper.Set("baseURL", "http://auth/bub/")
s := &Site{
+ deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: weightedSources},
Language: helpers.NewDefaultLanguage(),
}
writeSource(t, filepath.Join("content", "page.md"), pageYamlWithTaxonomiesA)
- site := newSiteDefaultLang()
+ site := NewSiteDefaultLang()
if err := buildSiteSkipRender(site); err != nil {
t.Fatalf("Failed to build site: %s", err)
`)
this.setup(t)
- if err := buildAndRenderSite(newSiteDefaultLang()); err != nil {
+ if err := buildAndRenderSite(NewSiteDefaultLang()); err != nil {
t.Fatalf("[%d] Failed to build site: %s", i, err)
}
)
var localTemplates *template.Template
-var tmpl Template
+
+// TODO(bep) globals get rid of the reset of the jww.ERR etc.
+var tmpl *GoHTMLTemplate
// TODO(bep) an interface with hundreds of methods ... remove it.
// And unexport most of these methods.
overlays map[string]*template.Template
errors []*templateErr
-}
-// T is the "global" template system
-func T() Template {
- if tmpl == nil {
- tmpl = New()
- }
-
- return tmpl
+ // TODO(bep) globals template
+ log *jww.Notepad
}
// InitializeT resets the internal template state to its initial state
-func InitializeT() Template {
- tmpl = New()
+func InitializeT(logger *jww.Notepad) *GoHTMLTemplate {
+ tmpl = New(logger)
return tmpl
}
// New returns a new Hugo Template System
// with all the additional features, templates & functions
-func New() Template {
+func New(logger *jww.Notepad) *GoHTMLTemplate {
var templates = &GoHTMLTemplate{
Template: *template.New(""),
overlays: make(map[string]*template.Template),
errors: make([]*templateErr, 0),
+ log: logger,
}
localTemplates = &templates.Template
}
}
if !worked {
- jww.ERROR.Println("Unable to render", layouts)
- jww.ERROR.Println("Expecting to find a template in either the theme/layouts or /layouts in one of the following relative locations", layouts)
+ tmpl.log.ERROR.Println("Unable to render", layouts)
+ tmpl.log.ERROR.Println("Expecting to find a template in either the theme/layouts or /layouts in one of the following relative locations", layouts)
}
}
}
func Lookup(name string) *template.Template {
- return (tmpl.(*GoHTMLTemplate)).Lookup(name)
+ return tmpl.Lookup(name)
}
func (t *GoHTMLTemplate) Lookup(name string) *template.Template {
return err
}
- jww.DEBUG.Printf("Add template file from path %s", path)
+ t.log.DEBUG.Printf("Add template file from path %s", path)
return t.AddTemplate(name, string(b))
}
}
func (t *GoHTMLTemplate) loadTemplates(absPath string, prefix string) {
- jww.DEBUG.Printf("Load templates from path %q prefix %q", absPath, prefix)
+ t.log.DEBUG.Printf("Load templates from path %q prefix %q", absPath, prefix)
walker := func(path string, fi os.FileInfo, err error) error {
if err != nil {
return nil
}
- jww.DEBUG.Println("Template path", path)
+ t.log.DEBUG.Println("Template path", path)
if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
link, err := filepath.EvalSymlinks(absPath)
if err != nil {
- jww.ERROR.Printf("Cannot read symbolic link '%s', error was: %s", absPath, err)
+ t.log.ERROR.Printf("Cannot read symbolic link '%s', error was: %s", absPath, err)
return nil
}
linkfi, err := hugofs.Source().Stat(link)
if err != nil {
- jww.ERROR.Printf("Cannot stat '%s', error was: %s", link, err)
+ t.log.ERROR.Printf("Cannot stat '%s', error was: %s", link, err)
return nil
}
if !linkfi.Mode().IsRegular() {
- jww.ERROR.Printf("Symbolic links for directories not supported, skipping '%s'", absPath)
+ t.log.ERROR.Printf("Symbolic links for directories not supported, skipping '%s'", absPath)
}
return nil
}
}
if err := t.AddTemplateFile(tplName, baseTemplatePath, path); err != nil {
- jww.ERROR.Printf("Failed to add template %s in path %s: %s", tplName, path, err)
+ t.log.ERROR.Printf("Failed to add template %s in path %s: %s", tplName, path, err)
}
}
return nil
}
if err := helpers.SymbolicWalk(hugofs.Source(), absPath, walker); err != nil {
- jww.ERROR.Printf("Failed to load templates: %s", err)
+ t.log.ERROR.Printf("Failed to load templates: %s", err)
}
}
func (t *GoHTMLTemplate) PrintErrors() {
for _, e := range t.errors {
- jww.ERROR.Println(e.err)
+ t.log.ERROR.Println(e.err)
}
}
"github.com/spf13/hugo/helpers"
+ "io/ioutil"
+ "log"
+ "os"
+
"github.com/spf13/afero"
"github.com/spf13/cast"
"github.com/spf13/hugo/hugofs"
+ jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
"github.com/stretchr/testify/assert"
)
+var logger = jww.NewNotepad(jww.LevelFatal, jww.LevelFatal, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+
type tstNoStringer struct {
}
`
var b bytes.Buffer
- templ, err := New().New("test").Parse(in)
+ templ, err := New(logger).New("test").Parse(in)
var data struct {
Title string
Section string
{map[string]string{"foo": "dog"}, `{{ default "nope" .foo "extra" }}`, ``, false},
{map[string]interface{}{"images": []string{}}, `{{ default "default.jpg" (index .images 0) }}`, `default.jpg`, true},
} {
- tmpl, err := New().New("test").Parse(this.tpl)
+ tmpl, err := New(logger).New("test").Parse(this.tpl)
if err != nil {
t.Errorf("[%d] unable to create new html template %q: %s", i, this.tpl, err)
continue
data.Params = map[string]interface{}{"langCode": "en"}
tstInitTemplates()
- InitializeT()
+ InitializeT(logger)
for i, tc := range testCases {
var tmp string
if tc.variant != "" {
tmp = tc.tmpl
}
- tmpl, err := New().New("testroot").Parse(tmp)
+ tmpl, err := New(logger).New("testroot").Parse(tmp)
if err != nil {
t.Fatalf("[%d] unable to create new html template: %s", i, err)
}
}
func BenchmarkPartial(b *testing.B) {
- InitializeT()
- tmpl, err := New().New("testroot").Parse(`{{ partial "bench1" . }}`)
+ InitializeT(logger)
+ tmpl, err := New(logger).New("testroot").Parse(`{{ partial "bench1" . }}`)
if err != nil {
b.Fatalf("unable to create new html template: %s", err)
}
}
func BenchmarkPartialCached(b *testing.B) {
- InitializeT()
- tmpl, err := New().New("testroot").Parse(`{{ partialCached "bench1" . }}`)
+ InitializeT(logger)
+ tmpl, err := New(logger).New("testroot").Parse(`{{ partialCached "bench1" . }}`)
if err != nil {
b.Fatalf("unable to create new html template: %s", err)
}
}
func BenchmarkPartialCachedVariants(b *testing.B) {
- InitializeT()
- tmpl, err := New().New("testroot").Parse(`{{ partialCached "bench1" . "header" }}`)
+ InitializeT(logger)
+ tmpl, err := New(logger).New("testroot").Parse(`{{ partialCached "bench1" . "header" }}`)
if err != nil {
b.Fatalf("unable to create new html template: %s", err)
}
for _, root := range []string{"", os.TempDir()} {
- templ := New()
+ templ := New(logger)
basePath := this.basePath
innerPath := this.innerPath
} {
hugofs.InitMemFs()
- templ := New()
+ templ := New(logger)
overlayTplName := "ot"
masterTplName := "mt"
finalTplName := "tp"
// Issue #1095
{"{{apply .C \"urlize\" " +
"\".\"}}", 2}} {
- templ := New()
+ templ := New(logger)
d := &Data{
A: 42,
projects / brevno-suite / hugo / commitdiff