func benchmark(cmd *cobra.Command, args []string) error {
cfg, err := InitializeConfig(benchmarkCmd)
+
if err != nil {
return err
}
+ c := commandeer{cfg}
+
var memProf *os.File
if memProfileFile != "" {
memProf, err = os.Create(memProfileFile)
t := time.Now()
for i := 0; i < benchmarkTimes; i++ {
- if err = resetAndBuildSites(cfg, false); err != nil {
+ if err = c.resetAndBuildSites(false); err != nil {
return err
}
}
if !strings.HasSuffix(gendocdir, helpers.FilePathSeparator) {
gendocdir += helpers.FilePathSeparator
}
- if found, _ := helpers.Exists(gendocdir, hugofs.Os()); !found {
+ if found, _ := helpers.Exists(gendocdir, hugofs.Os); !found {
jww.FEEDBACK.Println("Directory", gendocdir, "does not exist, creating...")
- hugofs.Os().MkdirAll(gendocdir, 0777)
+ hugofs.Os.MkdirAll(gendocdir, 0777)
}
now := time.Now().Format(time.RFC3339)
prepender := func(filename string) string {
if !strings.HasSuffix(genmandir, helpers.FilePathSeparator) {
genmandir += helpers.FilePathSeparator
}
- if found, _ := helpers.Exists(genmandir, hugofs.Os()); !found {
+ if found, _ := helpers.Exists(genmandir, hugofs.Os); !found {
jww.FEEDBACK.Println("Directory", genmandir, "does not exist, creating...")
- hugofs.Os().MkdirAll(genmandir, 0777)
+ hugofs.Os.MkdirAll(genmandir, 0777)
}
cmd.Root().DisableAutoGenTag = true
"github.com/spf13/afero"
"github.com/spf13/cobra"
"github.com/spf13/fsync"
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/helpers"
"github.com/spf13/hugo/hugolib"
"github.com/spf13/hugo/livereload"
"github.com/spf13/viper"
)
+type commandeer struct {
+ deps.DepsCfg
+}
+
// Hugo represents the Hugo sites to build. This variable is exported as it
// is used by at least one external library (the Hugo caddy plugin). We should
// provide a cleaner external API, but until then, this is it.
return err
}
+ c := commandeer{cfg}
+
if buildWatch {
viper.Set("disableLiveReload", true)
- watchConfig(cfg)
+ c.watchConfig()
}
- return build(cfg)
+ return c.build()
},
}
}
// InitializeConfig initializes a config file with sensible default configuration flags.
-func InitializeConfig(subCmdVs ...*cobra.Command) (hugolib.DepsCfg, error) {
+func InitializeConfig(subCmdVs ...*cobra.Command) (deps.DepsCfg, error) {
- var cfg hugolib.DepsCfg
+ var cfg deps.DepsCfg
if err := hugolib.LoadGlobalConfig(source, cfgFile); err != nil {
return cfg, err
viper.Set("cacheDir", cacheDir)
}
+ // Init file systems. This may be changed at a later point.
+ cfg.Fs = hugofs.NewDefault()
+
cacheDir = viper.GetString("cacheDir")
if cacheDir != "" {
if helpers.FilePathSeparator != cacheDir[len(cacheDir)-1:] {
cacheDir = cacheDir + helpers.FilePathSeparator
}
- isDir, err := helpers.DirExists(cacheDir, hugofs.Source())
+ isDir, err := helpers.DirExists(cacheDir, cfg.Fs.Source)
utils.CheckErr(err)
if !isDir {
mkdir(cacheDir)
}
viper.Set("cacheDir", cacheDir)
} else {
- viper.Set("cacheDir", helpers.GetTempDir("hugo_cache", hugofs.Source()))
+ viper.Set("cacheDir", helpers.GetTempDir("hugo_cache", cfg.Fs.Source))
}
jww.INFO.Println("Using config file:", viper.ConfigFileUsed())
- // Init file systems. This may be changed at a later point.
- hugofs.InitDefaultFs()
-
themeDir := helpers.GetThemeDir()
if themeDir != "" {
- if _, err := hugofs.Source().Stat(themeDir); os.IsNotExist(err) {
+ if _, err := cfg.Fs.Source.Stat(themeDir); os.IsNotExist(err) {
return cfg, newSystemError("Unable to find theme Directory:", themeDir)
}
}
- themeVersionMismatch, minVersion := isThemeVsHugoVersionMismatch()
+ themeVersionMismatch, minVersion := isThemeVsHugoVersionMismatch(cfg.Fs.Source)
if themeVersionMismatch {
jww.ERROR.Printf("Current theme does not support Hugo version %s. Minimum version required is %s\n",
return flag.Changed
}
-func watchConfig(cfg hugolib.DepsCfg) {
+func (c commandeer) watchConfig() {
viper.WatchConfig()
viper.OnConfigChange(func(e fsnotify.Event) {
jww.FEEDBACK.Println("Config file changed:", e.Name)
// Force a full rebuild
- utils.CheckErr(recreateAndBuildSites(cfg, true))
+ utils.CheckErr(c.recreateAndBuildSites(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(cfg hugolib.DepsCfg, watches ...bool) error {
+func (c commandeer) build(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 renderToMemory {
- hugofs.SetDestination(new(afero.MemMapFs))
+ c.Fs.Destination = new(afero.MemMapFs)
// Rendering to memoryFS, publish to Root regardless of publishDir.
viper.Set("publishDir", "/")
}
- if err := copyStatic(); err != nil {
+ if err := c.copyStatic(); err != nil {
return fmt.Errorf("Error copying static files to %s: %s", helpers.AbsPathify(viper.GetString("publishDir")), err)
}
watch := false
if len(watches) > 0 && watches[0] {
watch = true
}
- if err := buildSites(cfg, buildWatch || watch); err != nil {
+ if err := c.buildSites(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(cfg, 0))
+ utils.CheckErr(c.newWatcher(0))
}
return nil
}
-func getStaticSourceFs() afero.Fs {
- source := hugofs.Source()
- themeDir, err := helpers.GetThemeStaticDirPath()
+func (c commandeer) getStaticSourceFs() afero.Fs {
+ source := c.Fs.Source
+ pathSpec := helpers.NewPathSpec(c.Fs, viper.GetViper())
+ themeDir, err := pathSpec.GetThemeStaticDirPath()
staticDir := helpers.GetStaticDirPath() + helpers.FilePathSeparator
useTheme := true
jww.INFO.Println("using a UnionFS for static directory comprised of:")
jww.INFO.Println("Base:", themeDir)
jww.INFO.Println("Overlay:", staticDir)
- base := afero.NewReadOnlyFs(afero.NewBasePathFs(hugofs.Source(), themeDir))
- overlay := afero.NewReadOnlyFs(afero.NewBasePathFs(hugofs.Source(), staticDir))
+ base := afero.NewReadOnlyFs(afero.NewBasePathFs(source, themeDir))
+ overlay := afero.NewReadOnlyFs(afero.NewBasePathFs(source, staticDir))
return afero.NewCopyOnWriteFs(base, overlay)
}
-func copyStatic() error {
+func (c commandeer) copyStatic() error {
publishDir := helpers.AbsPathify(viper.GetString("publishDir")) + helpers.FilePathSeparator
// If root, remove the second '/'
}
// Includes both theme/static & /static
- staticSourceFs := getStaticSourceFs()
+ staticSourceFs := c.getStaticSourceFs()
if staticSourceFs == nil {
jww.WARN.Println("No static directories found to sync")
syncer.NoTimes = viper.GetBool("noTimes")
syncer.NoChmod = viper.GetBool("noChmod")
syncer.SrcFs = staticSourceFs
- syncer.DestFs = hugofs.Destination()
+ syncer.DestFs = c.Fs.Destination
// Now that we are using a unionFs for the static directories
// We can effectively clean the publishDir on initial sync
syncer.Delete = viper.GetBool("cleanDestinationDir")
}
// getDirList provides NewWatcher() with a list of directories to watch for changes.
-func getDirList() []string {
+func (c commandeer) getDirList() []string {
var a []string
dataDir := helpers.AbsPathify(viper.GetString("dataDir"))
i18nDir := helpers.AbsPathify(viper.GetString("i18nDir"))
jww.ERROR.Printf("Cannot read symbolic link '%s', error was: %s", path, err)
return nil
}
- linkfi, err := hugofs.Source().Stat(link)
+ linkfi, err := c.Fs.Source.Stat(link)
if err != nil {
jww.ERROR.Printf("Cannot stat '%s', error was: %s", link, err)
return nil
return nil
}
- helpers.SymbolicWalk(hugofs.Source(), dataDir, walker)
- helpers.SymbolicWalk(hugofs.Source(), helpers.AbsPathify(viper.GetString("contentDir")), walker)
- helpers.SymbolicWalk(hugofs.Source(), i18nDir, walker)
- helpers.SymbolicWalk(hugofs.Source(), helpers.AbsPathify(viper.GetString("layoutDir")), walker)
+ helpers.SymbolicWalk(c.Fs.Source, dataDir, walker)
+ helpers.SymbolicWalk(c.Fs.Source, helpers.AbsPathify(viper.GetString("contentDir")), walker)
+ helpers.SymbolicWalk(c.Fs.Source, i18nDir, walker)
+ helpers.SymbolicWalk(c.Fs.Source, helpers.AbsPathify(viper.GetString("layoutDir")), walker)
- helpers.SymbolicWalk(hugofs.Source(), staticDir, walker)
+ helpers.SymbolicWalk(c.Fs.Source, staticDir, walker)
if helpers.ThemeSet() {
- helpers.SymbolicWalk(hugofs.Source(), filepath.Join(themesDir, "layouts"), walker)
- helpers.SymbolicWalk(hugofs.Source(), filepath.Join(themesDir, "static"), walker)
- helpers.SymbolicWalk(hugofs.Source(), filepath.Join(themesDir, "i18n"), walker)
- helpers.SymbolicWalk(hugofs.Source(), filepath.Join(themesDir, "data"), walker)
+ helpers.SymbolicWalk(c.Fs.Source, filepath.Join(themesDir, "layouts"), walker)
+ helpers.SymbolicWalk(c.Fs.Source, filepath.Join(themesDir, "static"), walker)
+ helpers.SymbolicWalk(c.Fs.Source, filepath.Join(themesDir, "i18n"), walker)
+ helpers.SymbolicWalk(c.Fs.Source, filepath.Join(themesDir, "data"), walker)
}
return a
}
-func recreateAndBuildSites(cfg hugolib.DepsCfg, watching bool) (err error) {
- if err := initSites(cfg); err != nil {
+func (c commandeer) recreateAndBuildSites(watching bool) (err error) {
+ if err := c.initSites(); err != nil {
return err
}
if !quiet {
return Hugo.Build(hugolib.BuildCfg{CreateSitesFromConfig: true, Watching: watching, PrintStats: !quiet})
}
-func resetAndBuildSites(cfg hugolib.DepsCfg, watching bool) (err error) {
- if err := initSites(cfg); err != nil {
- return err
+func (c commandeer) resetAndBuildSites(watching bool) (err error) {
+ if err = c.initSites(); err != nil {
+ return
}
if !quiet {
jww.FEEDBACK.Println("Started building sites ...")
return Hugo.Build(hugolib.BuildCfg{ResetState: true, Watching: watching, PrintStats: !quiet})
}
-func initSites(cfg hugolib.DepsCfg) error {
+func (c commandeer) initSites() error {
if Hugo != nil {
return nil
}
- h, err := hugolib.NewHugoSitesFromConfiguration(cfg)
+ h, err := hugolib.NewHugoSitesFromConfiguration(c.DepsCfg)
if err != nil {
return err
return nil
}
-func buildSites(cfg hugolib.DepsCfg, watching bool) (err error) {
- if err := initSites(cfg); err != nil {
+func (c commandeer) buildSites(watching bool) (err error) {
+ if err := c.initSites(); err != nil {
return err
}
if !quiet {
return Hugo.Build(hugolib.BuildCfg{Watching: watching, PrintStats: !quiet})
}
-func rebuildSites(cfg hugolib.DepsCfg, events []fsnotify.Event) error {
- if err := initSites(cfg); err != nil {
+func (c commandeer) rebuildSites(events []fsnotify.Event) error {
+ if err := c.initSites(); 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(cfg hugolib.DepsCfg, port int) error {
+func (c commandeer) newWatcher(port int) error {
if runtime.GOOS == "darwin" {
tweakLimit()
}
+ pathSpec := helpers.NewPathSpec(c.Fs, viper.GetViper())
+
watcher, err := watcher.New(1 * time.Second)
var wg sync.WaitGroup
wg.Add(1)
- for _, d := range getDirList() {
+ for _, d := range c.getDirList() {
if d != "" {
_ = watcher.Add(d)
}
// 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 := hugofs.Source().Stat(ev.Name); err == nil && s.Mode().IsDir() {
- helpers.SymbolicWalk(hugofs.Source(), ev.Name, walkAdder)
+ if s, err := c.Fs.Source.Stat(ev.Name); err == nil && s.Mode().IsDir() {
+ helpers.SymbolicWalk(c.Fs.Source, ev.Name, walkAdder)
}
}
- isstatic := strings.HasPrefix(ev.Name, helpers.GetStaticDirPath()) || (len(helpers.GetThemesDirPath()) > 0 && strings.HasPrefix(ev.Name, helpers.GetThemesDirPath()))
+ isstatic := strings.HasPrefix(ev.Name, helpers.GetStaticDirPath()) || (len(pathSpec.GetThemesDirPath()) > 0 && strings.HasPrefix(ev.Name, pathSpec.GetThemesDirPath()))
if isstatic {
staticEvents = append(staticEvents, ev)
if viper.GetBool("forceSyncStatic") {
jww.FEEDBACK.Printf("Syncing all static files\n")
- err := copyStatic()
+ err := c.copyStatic()
if err != nil {
utils.StopOnErr(err, fmt.Sprintf("Error copying static files to %s", publishDir))
}
} else {
- staticSourceFs := getStaticSourceFs()
+ staticSourceFs := c.getStaticSourceFs()
if staticSourceFs == nil {
jww.WARN.Println("No static directories found to sync")
syncer.NoTimes = viper.GetBool("noTimes")
syncer.NoChmod = viper.GetBool("noChmod")
syncer.SrcFs = staticSourceFs
- syncer.DestFs = hugofs.Destination()
+ syncer.DestFs = c.Fs.Destination
// prevent spamming the log on changes
logger := helpers.NewDistinctFeedbackLogger()
fromPath := ev.Name
// If we are here we already know the event took place in a static dir
- relPath, err := helpers.MakeStaticPathRelative(fromPath)
+ relPath, err := pathSpec.MakeStaticPathRelative(fromPath)
if err != nil {
jww.ERROR.Println(err)
continue
// If file doesn't exist in any static dir, remove it
toRemove := filepath.Join(publishDir, relPath)
logger.Println("File no longer exists in static dir, removing", toRemove)
- hugofs.Destination().RemoveAll(toRemove)
+ c.Fs.Destination.RemoveAll(toRemove)
} else if err == nil {
// If file still exists, sync it
logger.Println("Syncing", relPath, "to", publishDir)
// force refresh when more than one file
if len(staticEvents) > 0 {
for _, ev := range staticEvents {
- path, _ := helpers.MakeStaticPathRelative(ev.Name)
+ path, _ := pathSpec.MakeStaticPathRelative(ev.Name)
livereload.RefreshPath(path)
}
const layout = "2006-01-02 15:04 -0700"
jww.FEEDBACK.Println(time.Now().Format(layout))
- rebuildSites(cfg, dynamicEvents)
+ c.rebuildSites(dynamicEvents)
if !buildWatch && !viper.GetBool("disableLiveReload") {
// Will block forever trying to write to a channel that nobody is reading if livereload isn't initialized
http.HandleFunc("/livereload", livereload.Handler)
}
- go serve(port)
+ go c.serve(port)
}
wg.Wait()
// isThemeVsHugoVersionMismatch returns whether the current Hugo version is
// less than the theme's min_version.
-func isThemeVsHugoVersionMismatch() (mismatch bool, requiredMinVersion string) {
+func isThemeVsHugoVersionMismatch(fs afero.Fs) (mismatch bool, requiredMinVersion string) {
if !helpers.ThemeSet() {
return
}
themeDir := helpers.GetThemeDir()
- fs := hugofs.Source()
path := filepath.Join(themeDir, "theme.toml")
exists, err := helpers.Exists(path, fs)
"strings"
"time"
+ "github.com/spf13/afero"
"github.com/spf13/cast"
"github.com/spf13/cobra"
"github.com/spf13/hugo/helpers"
return convertJekyllPost(site, path, relPath, targetDir, draft)
}
- err = helpers.SymbolicWalk(hugofs.Os(), jekyllRoot, callback)
+ err = helpers.SymbolicWalk(hugofs.Os, jekyllRoot, callback)
if err != nil {
return err
// TODO: Consider calling doNewSite() instead?
func createSiteFromJekyll(jekyllRoot, targetDir string, force bool) (*hugolib.Site, error) {
- fs := hugofs.Source()
+ s, err := hugolib.NewSiteDefaultLang()
+ if err != nil {
+ return nil, err
+ }
+
+ fs := s.Fs.Source
+
if exists, _ := helpers.Exists(targetDir, fs); exists {
if isDir, _ := helpers.IsDir(targetDir, fs); !isDir {
return nil, errors.New("Target path \"" + targetDir + "\" already exists but not a directory")
}
}
- jekyllConfig := loadJekyllConfig(jekyllRoot)
+ jekyllConfig := loadJekyllConfig(fs, jekyllRoot)
// Crude test to make sure at least one of _drafts/ and _posts/ exists
// and is not empty.
mkdir(targetDir, "data")
mkdir(targetDir, "themes")
- createConfigFromJekyll(targetDir, "yaml", jekyllConfig)
+ createConfigFromJekyll(fs, targetDir, "yaml", jekyllConfig)
copyJekyllFilesAndFolders(jekyllRoot, filepath.Join(targetDir, "static"))
- site := hugolib.NewSiteDefaultLang()
- return site, nil
+ return s, nil
}
-func loadJekyllConfig(jekyllRoot string) map[string]interface{} {
- fs := hugofs.Source()
+func loadJekyllConfig(fs afero.Fs, jekyllRoot string) map[string]interface{} {
path := filepath.Join(jekyllRoot, "_config.yml")
exists, err := helpers.Exists(path, fs)
return c.(map[string]interface{})
}
-func createConfigFromJekyll(inpath string, kind string, jekyllConfig map[string]interface{}) (err error) {
+func createConfigFromJekyll(fs afero.Fs, inpath string, kind string, jekyllConfig map[string]interface{}) (err error) {
title := "My New Hugo Site"
baseURL := "http://example.org/"
return err
}
- err = helpers.WriteToDisk(filepath.Join(inpath, "config."+kind), bytes.NewReader(by), hugofs.Source())
+ err = helpers.WriteToDisk(filepath.Join(inpath, "config."+kind), bytes.NewReader(by), fs)
if err != nil {
return
}
import (
"bytes"
"errors"
+ "fmt"
"os"
"path/filepath"
"strings"
"time"
+ "github.com/spf13/afero"
"github.com/spf13/cobra"
"github.com/spf13/hugo/create"
"github.com/spf13/hugo/helpers"
"github.com/spf13/hugo/hugofs"
+ "github.com/spf13/hugo/hugolib"
"github.com/spf13/hugo/parser"
jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
// NewContent adds new content to a Hugo site.
func NewContent(cmd *cobra.Command, args []string) error {
- if _, err := InitializeConfig(); err != nil {
+ cfg, err := InitializeConfig()
+
+ if err != nil {
return err
}
kind = contentType
}
- return create.NewContent(hugofs.Source(), kind, createpath)
+ s, err := hugolib.NewSite(cfg)
+
+ if err != nil {
+ return newSystemError(err)
+ }
+
+ return create.NewContent(s, kind, createpath)
}
-func doNewSite(basepath string, force bool) error {
+func doNewSite(fs *hugofs.Fs, basepath string, force bool) error {
dirs := []string{
filepath.Join(basepath, "layouts"),
filepath.Join(basepath, "content"),
filepath.Join(basepath, "themes"),
}
- if exists, _ := helpers.Exists(basepath, hugofs.Source()); exists {
- if isDir, _ := helpers.IsDir(basepath, hugofs.Source()); !isDir {
+ if exists, _ := helpers.Exists(basepath, fs.Source); exists {
+ if isDir, _ := helpers.IsDir(basepath, fs.Source); !isDir {
return errors.New(basepath + " already exists but not a directory")
}
- isEmpty, _ := helpers.IsEmpty(basepath, hugofs.Source())
+ isEmpty, _ := helpers.IsEmpty(basepath, fs.Source)
switch {
case !isEmpty && !force:
case !isEmpty && force:
all := append(dirs, filepath.Join(basepath, "config."+configFormat))
for _, path := range all {
- if exists, _ := helpers.Exists(path, hugofs.Source()); exists {
+ if exists, _ := helpers.Exists(path, fs.Source); exists {
return errors.New(path + " already exists")
}
}
}
for _, dir := range dirs {
- hugofs.Source().MkdirAll(dir, 0777)
+ if err := fs.Source.MkdirAll(dir, 0777); err != nil {
+ return fmt.Errorf("Failed to create dir: %s", err)
+ }
}
- createConfig(basepath, configFormat)
+ createConfig(fs, basepath, configFormat)
jww.FEEDBACK.Printf("Congratulations! Your new Hugo site is created in %s.\n\n", basepath)
jww.FEEDBACK.Println(nextStepsText())
forceNew, _ := cmd.Flags().GetBool("force")
- return doNewSite(createpath, forceNew)
+ return doNewSite(hugofs.NewDefault(), createpath, forceNew)
}
// NewTheme creates a new Hugo theme.
func NewTheme(cmd *cobra.Command, args []string) error {
- if _, err := InitializeConfig(); err != nil {
+ cfg, err := InitializeConfig()
+
+ if err != nil {
return err
}
createpath := helpers.AbsPathify(filepath.Join(viper.GetString("themesDir"), args[0]))
jww.INFO.Println("creating theme at", createpath)
- if x, _ := helpers.Exists(createpath, hugofs.Source()); x {
+ if x, _ := helpers.Exists(createpath, cfg.Fs.Source); x {
return newUserError(createpath, "already exists")
}
mkdir(createpath, "layouts", "_default")
mkdir(createpath, "layouts", "partials")
- touchFile(createpath, "layouts", "index.html")
- touchFile(createpath, "layouts", "404.html")
- touchFile(createpath, "layouts", "_default", "list.html")
- touchFile(createpath, "layouts", "_default", "single.html")
+ touchFile(cfg.Fs.Source, createpath, "layouts", "index.html")
+ touchFile(cfg.Fs.Source, createpath, "layouts", "404.html")
+ touchFile(cfg.Fs.Source, createpath, "layouts", "_default", "list.html")
+ touchFile(cfg.Fs.Source, createpath, "layouts", "_default", "single.html")
- touchFile(createpath, "layouts", "partials", "header.html")
- touchFile(createpath, "layouts", "partials", "footer.html")
+ touchFile(cfg.Fs.Source, createpath, "layouts", "partials", "header.html")
+ touchFile(cfg.Fs.Source, createpath, "layouts", "partials", "footer.html")
mkdir(createpath, "archetypes")
archDefault := []byte("+++\n+++\n")
- err := helpers.WriteToDisk(filepath.Join(createpath, "archetypes", "default.md"), bytes.NewReader(archDefault), hugofs.Source())
+ err = helpers.WriteToDisk(filepath.Join(createpath, "archetypes", "default.md"), bytes.NewReader(archDefault), cfg.Fs.Source)
if err != nil {
return err
}
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
`)
- err = helpers.WriteToDisk(filepath.Join(createpath, "LICENSE.md"), bytes.NewReader(by), hugofs.Source())
+ err = helpers.WriteToDisk(filepath.Join(createpath, "LICENSE.md"), bytes.NewReader(by), cfg.Fs.Source)
if err != nil {
return err
}
- createThemeMD(createpath)
+ createThemeMD(cfg.Fs, createpath)
return nil
}
}
}
-func touchFile(x ...string) {
+func touchFile(fs afero.Fs, x ...string) {
inpath := filepath.Join(x...)
mkdir(filepath.Dir(inpath))
- err := helpers.WriteToDisk(inpath, bytes.NewReader([]byte{}), hugofs.Source())
+ err := helpers.WriteToDisk(inpath, bytes.NewReader([]byte{}), fs)
if err != nil {
jww.FATAL.Fatalln(err)
}
}
-func createThemeMD(inpath string) (err error) {
+func createThemeMD(fs *hugofs.Fs, inpath string) (err error) {
by := []byte(`# theme.toml template for a Hugo theme
# See https://github.com/spf13/hugoThemes#themetoml for an example
repo = ""
`)
- err = helpers.WriteToDisk(filepath.Join(inpath, "theme.toml"), bytes.NewReader(by), hugofs.Source())
+ err = helpers.WriteToDisk(filepath.Join(inpath, "theme.toml"), bytes.NewReader(by), fs.Source)
if err != nil {
return
}
func newContentPathSection(path string) (string, string) {
// Forward slashes is used in all examples. Convert if needed.
// Issue #1133
- createpath := strings.Replace(path, "/", helpers.FilePathSeparator, -1)
+ createpath := filepath.FromSlash(path)
var section string
// assume the first directory is the section (kind)
if strings.Contains(createpath[1:], helpers.FilePathSeparator) {
return createpath, section
}
-func createConfig(inpath string, kind string) (err error) {
+func createConfig(fs *hugofs.Fs, inpath string, kind string) (err error) {
in := map[string]interface{}{
"baseURL": "http://example.org/",
"title": "My New Hugo Site",
return err
}
- err = helpers.WriteToDisk(filepath.Join(inpath, "config."+kind), bytes.NewReader(by), hugofs.Source())
+ err = helpers.WriteToDisk(filepath.Join(inpath, "config."+kind), bytes.NewReader(by), fs.Source)
if err != nil {
return
}
package commands
import (
- "os"
"path/filepath"
"testing"
"github.com/spf13/hugo/hugofs"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
// Issue #1133
assert.Equal(t, "post", s)
}
-func checkNewSiteInited(basepath string, t *testing.T) {
+func checkNewSiteInited(fs *hugofs.Fs, basepath string, t *testing.T) {
+
paths := []string{
filepath.Join(basepath, "layouts"),
filepath.Join(basepath, "content"),
}
for _, path := range paths {
- _, err := hugofs.Source().Stat(path)
- assert.Nil(t, err)
+ _, err := fs.Source.Stat(path)
+ require.NoError(t, err)
}
}
func TestDoNewSite(t *testing.T) {
- basepath := filepath.Join(os.TempDir(), "blog")
- hugofs.InitMemFs()
- err := doNewSite(basepath, false)
- assert.Nil(t, err)
+ basepath := filepath.Join("base", "blog")
+ fs := hugofs.NewMem()
+
+ require.NoError(t, doNewSite(fs, basepath, false))
- checkNewSiteInited(basepath, t)
+ checkNewSiteInited(fs, basepath, t)
}
func TestDoNewSite_noerror_base_exists_but_empty(t *testing.T) {
- basepath := filepath.Join(os.TempDir(), "blog")
- hugofs.InitMemFs()
- hugofs.Source().MkdirAll(basepath, 777)
- err := doNewSite(basepath, false)
- assert.Nil(t, err)
+ basepath := filepath.Join("base", "blog")
+ fs := hugofs.NewMem()
+
+ require.NoError(t, fs.Source.MkdirAll(basepath, 777))
+
+ require.NoError(t, doNewSite(fs, basepath, false))
}
func TestDoNewSite_error_base_exists(t *testing.T) {
- basepath := filepath.Join(os.TempDir(), "blog")
- hugofs.InitMemFs()
- hugofs.Source().MkdirAll(basepath, 777)
- hugofs.Source().Create(filepath.Join(basepath, "foo"))
+ basepath := filepath.Join("base", "blog")
+ fs := hugofs.NewMem()
+
+ require.NoError(t, fs.Source.MkdirAll(basepath, 777))
+ _, err := fs.Source.Create(filepath.Join(basepath, "foo"))
+ require.NoError(t, err)
// Since the directory already exists and isn't empty, expect an error
- err := doNewSite(basepath, false)
- assert.NotNil(t, err)
+ require.Error(t, doNewSite(fs, basepath, false))
+
}
func TestDoNewSite_force_empty_dir(t *testing.T) {
- basepath := filepath.Join(os.TempDir(), "blog")
- hugofs.InitMemFs()
- hugofs.Source().MkdirAll(basepath, 777)
- err := doNewSite(basepath, true)
- assert.Nil(t, err)
+ basepath := filepath.Join("base", "blog")
+ fs := hugofs.NewMem()
- checkNewSiteInited(basepath, t)
+ require.NoError(t, fs.Source.MkdirAll(basepath, 777))
+
+ require.NoError(t, doNewSite(fs, basepath, true))
+
+ checkNewSiteInited(fs, basepath, t)
}
func TestDoNewSite_error_force_dir_inside_exists(t *testing.T) {
- basepath := filepath.Join(os.TempDir(), "blog")
+ basepath := filepath.Join("base", "blog")
+ fs := hugofs.NewMem()
+
contentPath := filepath.Join(basepath, "content")
- hugofs.InitMemFs()
- hugofs.Source().MkdirAll(contentPath, 777)
- err := doNewSite(basepath, true)
- assert.NotNil(t, err)
+
+ require.NoError(t, fs.Source.MkdirAll(contentPath, 777))
+ require.Error(t, doNewSite(fs, basepath, true))
}
func TestDoNewSite_error_force_config_inside_exists(t *testing.T) {
- basepath := filepath.Join(os.TempDir(), "blog")
+ basepath := filepath.Join("base", "blog")
+ fs := hugofs.NewMem()
+
configPath := filepath.Join(basepath, "config.toml")
- hugofs.InitMemFs()
- hugofs.Source().MkdirAll(basepath, 777)
- hugofs.Source().Create(configPath)
- err := doNewSite(basepath, true)
- assert.NotNil(t, err)
+ require.NoError(t, fs.Source.MkdirAll(basepath, 777))
+ _, err := fs.Source.Create(configPath)
+ require.NoError(t, err)
+
+ require.Error(t, doNewSite(fs, basepath, true))
}
"github.com/spf13/afero"
"github.com/spf13/cobra"
"github.com/spf13/hugo/helpers"
- "github.com/spf13/hugo/hugofs"
jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
)
return err
}
+ c := commandeer{cfg}
+
if flagChanged(cmd.Flags(), "disableLiveReload") {
viper.Set("disableLiveReload", disableLiveReload)
}
if viper.GetBool("watch") {
serverWatch = true
- watchConfig(cfg)
+ c.watchConfig()
}
l, err := net.Listen("tcp", net.JoinHostPort(serverInterface, strconv.Itoa(serverPort)))
// Hugo writes the output to memory instead of the disk
if !renderToDisk {
- hugofs.SetDestination(new(afero.MemMapFs))
+ cfg.Fs.Destination = new(afero.MemMapFs)
// Rendering to memoryFS, publish to Root regardless of publishDir.
viper.Set("publishDir", "/")
}
- if err := build(cfg, serverWatch); err != nil {
+ if err := c.build(serverWatch); err != nil {
return err
}
// Watch runs its own server as part of the routine
if serverWatch {
- watchDirs := getDirList()
+ watchDirs := c.getDirList()
baseWatchDir := viper.GetString("workingDir")
for i, dir := range watchDirs {
watchDirs[i], _ = helpers.GetRelativePath(dir, baseWatchDir)
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(cfg, serverPort)
+ err := c.newWatcher(serverPort)
if err != nil {
return err
}
}
- serve(serverPort)
+ c.serve(serverPort)
return nil
}
-func serve(port int) {
+func (c commandeer) serve(port int) {
if renderToDisk {
jww.FEEDBACK.Println("Serving pages from " + helpers.AbsPathify(viper.GetString("publishDir")))
} else {
jww.FEEDBACK.Println("Serving pages from memory")
}
- httpFs := afero.NewHttpFs(hugofs.Destination())
+ httpFs := afero.NewHttpFs(c.Fs.Destination)
fs := filesOnlyFs{httpFs.Dir(helpers.AbsPathify(viper.GetString("publishDir")))}
fileserver := http.FileServer(fs)
"time"
"github.com/spf13/cobra"
- "github.com/spf13/hugo/hugofs"
"github.com/spf13/hugo/parser"
)
// 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 {
+ cfg, err := InitializeConfig()
+
+ if err != nil {
return err
}
location := args[0]
// open the file
- f, err := hugofs.Source().Open(location)
+ f, err := cfg.Fs.Source.Open(location)
if err != nil {
return err
}
return newSystemErrorF("an error occurred while undrafting %q: %s", location, err)
}
- f, err = hugofs.Source().OpenFile(location, os.O_WRONLY|os.O_TRUNC, 0644)
+ f, err = cfg.Fs.Source.OpenFile(location, os.O_WRONLY|os.O_TRUNC, 0644)
if err != nil {
return newSystemErrorF("%q not be undrafted due to error opening file to save changes: %q\n", location, err)
}
// NewContent creates a new content file in the content directory based upon the
// given kind, which is used to lookup an archetype.
-func NewContent(fs afero.Fs, kind, name string) (err error) {
+func NewContent(s *hugolib.Site, kind, name string) (err error) {
jww.INFO.Println("attempting to create ", name, "of", kind)
- location := FindArchetype(fs, kind)
+ location := FindArchetype(s.Fs.Source, kind)
var by []byte
if location != "" {
- by, err = afero.ReadFile(fs, location)
+ by, err = afero.ReadFile(s.Fs.Source, location)
if err != nil {
jww.ERROR.Println(err)
}
return err
}
- site := hugolib.NewSiteDefaultLang()
-
- page, err := site.NewPage(name)
+ page, err := s.NewPage(name)
if err != nil {
return err
}
"strings"
"testing"
+ "github.com/spf13/hugo/hugolib"
+
"fmt"
+ "github.com/spf13/hugo/hugofs"
+
"github.com/spf13/afero"
"github.com/spf13/hugo/create"
"github.com/spf13/hugo/helpers"
- "github.com/spf13/hugo/hugofs"
"github.com/spf13/viper"
+ "github.com/stretchr/testify/require"
)
func TestNewContent(t *testing.T) {
initViper()
- err := initFs()
- if err != nil {
- t.Fatalf("initialization error: %s", err)
- }
-
cases := []struct {
kind string
path string
{"product", "product/sample-4.md", []string{`title = "sample 4"`}}, // empty archetype front matter
}
- for i, c := range cases {
- err = create.NewContent(hugofs.Source(), c.kind, c.path)
- if err != nil {
- t.Errorf("[%d] NewContent: %s", i, err)
- }
+ for _, c := range cases {
+ s, err := hugolib.NewEnglishSite()
+ require.NoError(t, err)
+ require.NoError(t, initFs(s.Fs))
- fname := filepath.Join("content", filepath.FromSlash(c.path))
- content := readFileFromFs(t, hugofs.Source(), fname)
+ require.NoError(t, create.NewContent(s, c.kind, c.path))
+ fname := filepath.Join("content", filepath.FromSlash(c.path))
+ content := readFileFromFs(t, s.Fs.Source, fname)
for i, v := range c.expected {
found := strings.Contains(content, v)
if !found {
viper.Set("archetypeDir", "archetypes")
viper.Set("contentDir", "content")
viper.Set("themesDir", "themes")
+ viper.Set("layoutDir", "layouts")
viper.Set("theme", "sample")
}
-func initFs() error {
- hugofs.InitMemFs()
+func initFs(fs *hugofs.Fs) error {
perm := os.FileMode(0755)
var err error
filepath.Join("themes", "sample", "archetypes"),
}
for _, dir := range dirs {
- err = hugofs.Source().Mkdir(dir, perm)
+ err = fs.Source.Mkdir(dir, perm)
if err != nil {
return err
}
content: "+++\ndate =\"\"\ntitle = \"Empty Date Arch title\"\ntest = \"test1\"\n+++\n",
},
} {
- f, err := hugofs.Source().Create(v.path)
+ f, err := fs.Source.Create(v.path)
if err != nil {
return err
}
--- /dev/null
+package deps
+
+import (
+ "io/ioutil"
+ "log"
+ "os"
+
+ "github.com/spf13/hugo/helpers"
+ "github.com/spf13/hugo/hugofs"
+ "github.com/spf13/hugo/tplapi"
+ jww "github.com/spf13/jwalterweatherman"
+)
+
+// Deps holds dependencies used by many.
+// There will be normally be only one instance of deps in play
+// at a given time, i.e. one per Site built.
+type Deps struct {
+ // The logger to use.
+ Log *jww.Notepad `json:"-"`
+
+ // The templates to use.
+ Tmpl tplapi.Template `json:"-"`
+
+ // The file systems to use.
+ Fs *hugofs.Fs `json:"-"`
+
+ // The PathSpec to use
+ *helpers.PathSpec `json:"-"`
+
+ templateProvider TemplateProvider
+ WithTemplate func(templ tplapi.Template) error
+
+ // TODO(bep) globals next in line: Viper
+
+}
+
+// Used to create and refresh, and clone the template.
+type TemplateProvider interface {
+ Update(deps *Deps) error
+ Clone(deps *Deps) error
+}
+
+func (d *Deps) LoadTemplates() error {
+ if err := d.templateProvider.Update(d); err != nil {
+ return err
+ }
+ d.Tmpl.PrintErrors()
+ return nil
+}
+
+func New(cfg DepsCfg) *Deps {
+ var (
+ logger = cfg.Logger
+ fs = cfg.Fs
+ )
+
+ if cfg.TemplateProvider == nil {
+ panic("Must have a TemplateProvider")
+ }
+
+ if cfg.Language == nil {
+ panic("Must have a Language")
+ }
+
+ if logger == nil {
+ logger = jww.NewNotepad(jww.LevelError, jww.LevelError, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+ }
+
+ if fs == nil {
+ // Default to the most used file systems.
+ fs = hugofs.NewMem()
+ }
+
+ d := &Deps{
+ Fs: fs,
+ Log: logger,
+ templateProvider: cfg.TemplateProvider,
+ WithTemplate: cfg.WithTemplate,
+ PathSpec: helpers.NewPathSpec(fs, cfg.Language),
+ }
+
+ return d
+}
+
+// ForLanguage creates a copy of the Deps with the language dependent
+// parts switched out.
+func (d Deps) ForLanguage(l *helpers.Language) (*Deps, error) {
+
+ d.PathSpec = helpers.NewPathSpec(d.Fs, l)
+ if err := d.templateProvider.Clone(&d); err != nil {
+ return nil, err
+ }
+
+ return &d, nil
+
+}
+
+// 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
+
+ // The file systems to use
+ Fs *hugofs.Fs
+
+ // The language to use.
+ Language *helpers.Language
+
+ // Template handling.
+ TemplateProvider TemplateProvider
+ WithTemplate func(templ tplapi.Template) error
+}
// TODO(bep) Get rid of these.
var (
currentConfigProvider ConfigProvider
- currentPathSpec *PathSpec
)
// ConfigProvider provides the configuration settings for Hugo.
return viper.Get("currentContentLanguage").(ConfigProvider)
}
-// CurrentPathSpec returns the current PathSpec.
-// If it is not set, a new will be created based in the currently active Hugo config.
-func CurrentPathSpec() *PathSpec {
- if currentPathSpec != nil {
- return currentPathSpec
- }
- // Some tests rely on this. We will fix that, eventually.
- return NewPathSpecFromConfig(Config())
-}
-
// InitConfigProviderForCurrentContentLanguage does what it says.
func InitConfigProviderForCurrentContentLanguage() {
currentConfigProvider = viper.Get("CurrentContentLanguage").(ConfigProvider)
- currentPathSpec = NewPathSpecFromConfig(currentConfigProvider)
}
// ResetConfigProvider is used in tests.
func ResetConfigProvider() {
currentConfigProvider = nil
- currentPathSpec = nil
+
}
"strings"
"unicode"
- "github.com/spf13/hugo/hugofs"
-
"github.com/spf13/afero"
"github.com/spf13/viper"
"golang.org/x/text/transform"
// GetThemeStaticDirPath returns the theme's static dir path if theme is set.
// If theme is set and the static dir doesn't exist, an error is returned.
-func GetThemeStaticDirPath() (string, error) {
- return getThemeDirPath("static")
+func (p *PathSpec) GetThemeStaticDirPath() (string, error) {
+ return p.getThemeDirPath("static")
}
// GetThemeDataDirPath returns the theme's data dir path if theme is set.
// If theme is set and the data dir doesn't exist, an error is returned.
-func GetThemeDataDirPath() (string, error) {
- return getThemeDirPath("data")
+func (p *PathSpec) GetThemeDataDirPath() (string, error) {
+ return p.getThemeDirPath("data")
}
// GetThemeI18nDirPath returns the theme's i18n dir path if theme is set.
// If theme is set and the i18n dir doesn't exist, an error is returned.
-func GetThemeI18nDirPath() (string, error) {
- return getThemeDirPath("i18n")
+func (p *PathSpec) GetThemeI18nDirPath() (string, error) {
+ return p.getThemeDirPath("i18n")
}
-func getThemeDirPath(path string) (string, error) {
+func (p *PathSpec) getThemeDirPath(path string) (string, error) {
if !ThemeSet() {
return "", ErrThemeUndefined
}
themeDir := filepath.Join(GetThemeDir(), path)
- if _, err := hugofs.Source().Stat(themeDir); os.IsNotExist(err) {
+ if _, err := p.fs.Source.Stat(themeDir); os.IsNotExist(err) {
return "", fmt.Errorf("Unable to find %s directory for theme %s in %s", path, viper.GetString("theme"), themeDir)
}
// GetThemesDirPath gets the static files directory of the current theme, if there is one.
// Ignores underlying errors.
// TODO(bep) Candidate for deprecation?
-func GetThemesDirPath() string {
- dir, _ := getThemeDirPath("static")
+func (p *PathSpec) GetThemesDirPath() string {
+ dir, _ := p.getThemeDirPath("static")
return dir
}
// MakeStaticPathRelative makes a relative path to the static files directory.
// It does so by taking either the project's static path or the theme's static
// path into consideration.
-func MakeStaticPathRelative(inPath string) (string, error) {
+func (p *PathSpec) MakeStaticPathRelative(inPath string) (string, error) {
staticDir := GetStaticDirPath()
- themeStaticDir := GetThemesDirPath()
+ themeStaticDir := p.GetThemesDirPath()
return makePathRelative(inPath, staticDir, themeStaticDir)
}
"github.com/stretchr/testify/assert"
"github.com/spf13/afero"
+ "github.com/spf13/hugo/hugofs"
"github.com/spf13/viper"
)
for _, test := range tests {
viper.Set("removePathAccents", test.removeAccents)
- p := NewPathSpecFromConfig(viper.GetViper())
+ p := NewPathSpec(hugofs.NewMem(), viper.GetViper())
+
output := p.MakePath(test.input)
if output != test.expected {
t.Errorf("Expected %#v, got %#v\n", test.expected, output)
defer viper.Reset()
initCommonTestConfig()
- p := NewPathSpecFromConfig(viper.GetViper())
+ p := NewPathSpec(hugofs.NewMem(), viper.GetViper())
tests := []struct {
input string
initCommonTestConfig()
viper.Set("disablePathToLower", true)
- p := NewPathSpecFromConfig(viper.GetViper())
+ p := NewPathSpec(hugofs.NewMem(), viper.GetViper())
tests := []struct {
input string
package helpers
+import (
+ "fmt"
+
+ "github.com/spf13/hugo/hugofs"
+)
+
// PathSpec holds methods that decides how paths in URLs and files in Hugo should look like.
type PathSpec struct {
disablePathToLower bool
defaultContentLanguageInSubdir bool
defaultContentLanguage string
multilingual bool
+
+ // The file systems to use
+ fs *hugofs.Fs
+}
+
+func (p PathSpec) String() string {
+ return fmt.Sprintf("PathSpec, language %q, prefix %q, multilingual: %T", p.currentContentLanguage.Lang, p.getLanguagePrefix(), p.multilingual)
}
-// NewPathSpecFromConfig creats a new PathSpec from the given ConfigProvider.
-func NewPathSpecFromConfig(config ConfigProvider) *PathSpec {
+// NewPathSpec creats a new PathSpec from the given filesystems and ConfigProvider.
+func NewPathSpec(fs *hugofs.Fs, config ConfigProvider) *PathSpec {
+
+ currCl, ok := config.Get("currentContentLanguage").(*Language)
+
+ if !ok {
+ // TODO(bep) globals
+ currCl = NewLanguage("en")
+ }
+
return &PathSpec{
+ fs: fs,
disablePathToLower: config.GetBool("disablePathToLower"),
removePathAccents: config.GetBool("removePathAccents"),
uglyURLs: config.GetBool("uglyURLs"),
multilingual: config.GetBool("multilingual"),
defaultContentLanguageInSubdir: config.GetBool("defaultContentLanguageInSubdir"),
defaultContentLanguage: config.GetString("defaultContentLanguage"),
- currentContentLanguage: config.Get("currentContentLanguage").(*Language),
+ currentContentLanguage: currCl,
paginatePath: config.GetString("paginatePath"),
}
}
import (
"testing"
+ "github.com/spf13/hugo/hugofs"
+
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
)
viper.Set("canonifyURLs", true)
viper.Set("paginatePath", "side")
- pathSpec := NewPathSpecFromConfig(viper.GetViper())
+ p := NewPathSpec(hugofs.NewMem(), viper.GetViper())
- require.True(t, pathSpec.canonifyURLs)
- require.True(t, pathSpec.defaultContentLanguageInSubdir)
- require.True(t, pathSpec.disablePathToLower)
- require.True(t, pathSpec.multilingual)
- require.True(t, pathSpec.removePathAccents)
- require.True(t, pathSpec.uglyURLs)
- require.Equal(t, "no", pathSpec.defaultContentLanguage)
- require.Equal(t, "no", pathSpec.currentContentLanguage.Lang)
- require.Equal(t, "side", pathSpec.paginatePath)
+ require.True(t, p.canonifyURLs)
+ require.True(t, p.defaultContentLanguageInSubdir)
+ require.True(t, p.disablePathToLower)
+ require.True(t, p.multilingual)
+ require.True(t, p.removePathAccents)
+ require.True(t, p.uglyURLs)
+ require.Equal(t, "no", p.defaultContentLanguage)
+ require.Equal(t, "no", p.currentContentLanguage.Lang)
+ require.Equal(t, "side", p.paginatePath)
}
io.WriteString(hash, lang)
io.WriteString(hash, options)
- fs := hugofs.Os()
+ fs := hugofs.Os
ignoreCache := viper.GetBool("ignoreCache")
cacheDir := viper.GetString("cacheDir")
"strings"
"testing"
+ "github.com/spf13/hugo/hugofs"
"github.com/spf13/viper"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
func TestURLize(t *testing.T) {
initCommonTestConfig()
- p := NewPathSpecFromConfig(viper.GetViper())
+ p := NewPathSpec(hugofs.NewMem(), viper.GetViper())
tests := []struct {
input string
{"http//foo", "http://base/path", "http://base/path/MULTIhttp/foo"},
}
+ p := NewPathSpec(hugofs.NewMem(), viper.GetViper())
+
for _, test := range tests {
viper.Set("baseURL", test.baseURL)
- p := NewPathSpecFromConfig(viper.GetViper())
+
output := p.AbsURL(test.input, addLanguage)
expected := test.expected
if multilingual && addLanguage {
for i, test := range tests {
viper.Set("baseURL", test.baseURL)
viper.Set("canonifyURLs", test.canonify)
- p := NewPathSpecFromConfig(viper.GetViper())
+ p := NewPathSpec(hugofs.NewMem(), viper.GetViper())
output := p.RelURL(test.input, addLanguage)
{false, "/section/name.html", "/section/name/"},
{true, "/section/name/index.html", "/section/name.html"},
}
+
for i, d := range data {
viper.Set("uglyURLs", d.ugly)
- p := NewPathSpecFromConfig(viper.GetViper())
+ p := NewPathSpec(hugofs.NewMem(), viper.GetViper())
output := p.URLPrep(d.input)
if d.output != output {
"github.com/spf13/viper"
)
-var (
- sourceFs afero.Fs
- destinationFs afero.Fs
- osFs afero.Fs = &afero.OsFs{}
- workingDirFs *afero.BasePathFs
-)
-
-// Source returns Hugo's source file system.
-func Source() afero.Fs {
- return sourceFs
-}
+// Os points to an Os Afero file system.
+var Os = &afero.OsFs{}
-// SetSource sets Hugo's source file system
-// and re-initializes dependent file systems.
-func SetSource(fs afero.Fs) {
- sourceFs = fs
- initSourceDependencies()
-}
+type Fs struct {
+ // Source is Hugo's source file system.
+ Source afero.Fs
-// Destination returns Hugo's destionation file system.
-func Destination() afero.Fs {
- return destinationFs
-}
-
-// SetDestination sets Hugo's destionation file system
-func SetDestination(fs afero.Fs) {
- destinationFs = fs
-}
+ // Destination is Hugo's destionation file system.
+ Destination afero.Fs
-// Os returns an OS file system.
-func Os() afero.Fs {
- return osFs
-}
+ // Os is an OS file system.
+ Os afero.Fs
-// WorkingDir returns a read-only file system
-// restricted to the project working dir.
-func WorkingDir() *afero.BasePathFs {
- return workingDirFs
+ // WorkingDir is a read-only file system
+ // restricted to the project working dir.
+ WorkingDir *afero.BasePathFs
}
-// InitDefaultFs initializes with the OS file system
+// NewDefault creates a new Fs with the OS file system
// as source and destination file systems.
-func InitDefaultFs() {
- InitFs(&afero.OsFs{})
+func NewDefault() *Fs {
+ fs := &afero.OsFs{}
+ return newFs(fs)
}
-// InitMemFs initializes with a MemMapFs as source and destination file systems.
+// NewDefault creates a new Fs with the MemMapFs
+// as source and destination file systems.
// Useful for testing.
-func InitMemFs() {
- InitFs(&afero.MemMapFs{})
+func NewMem() *Fs {
+ fs := &afero.MemMapFs{}
+ return newFs(fs)
}
-// InitFs initializes with the given file system
-// as source and destination file systems.
-func InitFs(fs afero.Fs) {
- sourceFs = fs
- destinationFs = fs
-
- initSourceDependencies()
+func newFs(base afero.Fs) *Fs {
+ return &Fs{
+ Source: base,
+ Destination: base,
+ Os: &afero.OsFs{},
+ WorkingDir: getWorkingDirFs(base),
+ }
}
-func initSourceDependencies() {
+func getWorkingDirFs(base afero.Fs) *afero.BasePathFs {
workingDir := viper.GetString("workingDir")
if workingDir != "" {
- workingDirFs = afero.NewBasePathFs(afero.NewReadOnlyFs(sourceFs), workingDir).(*afero.BasePathFs)
+ return afero.NewBasePathFs(afero.NewReadOnlyFs(base), workingDir).(*afero.BasePathFs)
}
-}
-
-func init() {
- InitDefaultFs()
+ return nil
}
"github.com/stretchr/testify/assert"
)
-func TestInitDefault(t *testing.T) {
+func TestNewDefault(t *testing.T) {
viper.Reset()
defer viper.Reset()
- InitDefaultFs()
+ f := NewDefault()
- assert.NotNil(t, Source())
- assert.IsType(t, new(afero.OsFs), Source())
- assert.NotNil(t, Destination())
- assert.IsType(t, new(afero.OsFs), Destination())
- assert.NotNil(t, Os())
- assert.IsType(t, new(afero.OsFs), Os())
- assert.Nil(t, WorkingDir())
+ assert.NotNil(t, f.Source)
+ assert.IsType(t, new(afero.OsFs), f.Source)
+ assert.NotNil(t, f.Destination)
+ assert.IsType(t, new(afero.OsFs), f.Destination)
+ assert.NotNil(t, f.Os)
+ assert.IsType(t, new(afero.OsFs), f.Os)
+ assert.Nil(t, f.WorkingDir)
+
+ assert.IsType(t, new(afero.OsFs), Os)
}
-func TestInitMemFs(t *testing.T) {
+func TestNewMem(t *testing.T) {
viper.Reset()
defer viper.Reset()
- InitMemFs()
-
- assert.NotNil(t, Source())
- assert.IsType(t, new(afero.MemMapFs), Source())
- assert.NotNil(t, Destination())
- assert.IsType(t, new(afero.MemMapFs), Destination())
- assert.IsType(t, new(afero.OsFs), Os())
- assert.Nil(t, WorkingDir())
-}
-
-func TestSetSource(t *testing.T) {
-
- InitMemFs()
-
- SetSource(new(afero.OsFs))
- assert.NotNil(t, Source())
- assert.IsType(t, new(afero.OsFs), Source())
-}
-
-func TestSetDestination(t *testing.T) {
-
- InitMemFs()
+ f := NewMem()
- SetDestination(new(afero.OsFs))
- assert.NotNil(t, Destination())
- assert.IsType(t, new(afero.OsFs), Destination())
+ assert.NotNil(t, f.Source)
+ assert.IsType(t, new(afero.MemMapFs), f.Source)
+ assert.NotNil(t, f.Destination)
+ assert.IsType(t, new(afero.MemMapFs), f.Destination)
+ assert.IsType(t, new(afero.OsFs), f.Os)
+ assert.Nil(t, f.WorkingDir)
}
func TestWorkingDir(t *testing.T) {
viper.Set("workingDir", "/a/b/")
- InitMemFs()
+ f := NewMem()
- assert.NotNil(t, WorkingDir())
- assert.IsType(t, new(afero.BasePathFs), WorkingDir())
+ assert.NotNil(t, f.WorkingDir)
+ assert.IsType(t, new(afero.BasePathFs), f.WorkingDir)
}
import (
"path/filepath"
"testing"
+
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/hugofs"
+ "github.com/stretchr/testify/require"
)
const pageWithAlias = `---
func TestAlias(t *testing.T) {
testCommonResetState()
- writeSource(t, filepath.Join("content", "page.md"), pageWithAlias)
- writeSource(t, filepath.Join("layouts", "_default", "single.html"), basicTemplate)
- if err := buildAndRenderSite(NewSiteDefaultLang()); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ fs := hugofs.NewMem()
+
+ writeSource(t, fs, filepath.Join("content", "page.md"), pageWithAlias)
+ writeSource(t, fs, filepath.Join("layouts", "_default", "single.html"), basicTemplate)
+
+ buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
// the real page
- assertFileContent(t, filepath.Join("public", "page", "index.html"), false, "For some moments the old man")
+ assertFileContent(t, fs, filepath.Join("public", "page", "index.html"), false, "For some moments the old man")
// the alias redirector
- assertFileContent(t, filepath.Join("public", "foo", "bar", "index.html"), false, "<meta http-equiv=\"refresh\" content=\"0; ")
+ assertFileContent(t, fs, filepath.Join("public", "foo", "bar", "index.html"), false, "<meta http-equiv=\"refresh\" content=\"0; ")
}
func TestAliasTemplate(t *testing.T) {
testCommonResetState()
- writeSource(t, filepath.Join("content", "page.md"), pageWithAlias)
- writeSource(t, filepath.Join("layouts", "_default", "single.html"), basicTemplate)
- writeSource(t, filepath.Join("layouts", "alias.html"), aliasTemplate)
- if err := buildAndRenderSite(NewSiteDefaultLang()); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ fs := hugofs.NewMem()
+
+ writeSource(t, fs, filepath.Join("content", "page.md"), pageWithAlias)
+ writeSource(t, fs, filepath.Join("layouts", "_default", "single.html"), basicTemplate)
+ writeSource(t, fs, filepath.Join("layouts", "alias.html"), aliasTemplate)
+
+ sites, err := NewHugoSitesFromConfiguration(deps.DepsCfg{Fs: fs})
+
+ require.NoError(t, err)
+
+ require.NoError(t, sites.Build(BuildCfg{}))
// the real page
- assertFileContent(t, filepath.Join("public", "page", "index.html"), false, "For some moments the old man")
+ assertFileContent(t, fs, filepath.Join("public", "page", "index.html"), false, "For some moments the old man")
// the alias redirector
- assertFileContent(t, filepath.Join("public", "foo", "bar", "index.html"), false, "ALIASTEMPLATE")
+ assertFileContent(t, fs, filepath.Join("public", "foo", "bar", "index.html"), false, "ALIASTEMPLATE")
}
"path/filepath"
"strings"
"testing"
+
+ "github.com/spf13/viper"
+
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/hugofs"
)
var (
`
)
-func caseMixingTestsWriteCommonSources(t *testing.T) {
- writeSource(t, filepath.Join("content", "sect1", "page1.md"), caseMixingPage1)
- writeSource(t, filepath.Join("content", "sect2", "page2.md"), caseMixingPage2)
- writeSource(t, filepath.Join("content", "sect1", "page1.en.md"), caseMixingPage1En)
+func caseMixingTestsWriteCommonSources(t *testing.T, fs *hugofs.Fs) {
+ writeSource(t, fs, filepath.Join("content", "sect1", "page1.md"), caseMixingPage1)
+ writeSource(t, fs, filepath.Join("content", "sect2", "page2.md"), caseMixingPage2)
+ writeSource(t, fs, filepath.Join("content", "sect1", "page1.en.md"), caseMixingPage1En)
- writeSource(t, "layouts/shortcodes/shortcode.html", `
+ writeSource(t, fs, "layouts/shortcodes/shortcode.html", `
Shortcode Page: {{ .Page.Params.COLOR }}|{{ .Page.Params.Colors.Blue }}
Shortcode Site: {{ .Page.Site.Params.COLOR }}|{{ .Site.Params.COLORS.YELLOW }}
`)
- writeSource(t, "layouts/partials/partial.html", `
+ writeSource(t, fs, "layouts/partials/partial.html", `
Partial Page: {{ .Params.COLOR }}|{{ .Params.Colors.Blue }}
Partial Site: {{ .Site.Params.COLOR }}|{{ .Site.Params.COLORS.YELLOW }}
`)
- writeSource(t, "config.toml", caseMixingSiteConfigTOML)
+ writeSource(t, fs, "config.toml", caseMixingSiteConfigTOML)
}
// page frontmatter: regular fields, blackfriday config, param with nested map
testCommonResetState()
- caseMixingTestsWriteCommonSources(t)
- writeSource(t, filepath.Join("layouts", "_default", "baseof.html"), `
+ depsCfg := newTestDepsConfig()
+ viper.SetFs(depsCfg.Fs.Source)
+
+ caseMixingTestsWriteCommonSources(t, depsCfg.Fs)
+
+ if err := LoadGlobalConfig("", "config.toml"); err != nil {
+ t.Fatalf("Failed to load config: %s", err)
+ }
+
+ writeSource(t, depsCfg.Fs, filepath.Join("layouts", "_default", "baseof.html"), `
Block Page Colors: {{ .Params.COLOR }}|{{ .Params.Colors.Blue }}
{{ block "main" . }}default{{end}}`)
- writeSource(t, filepath.Join("layouts", "sect2", "single.html"), `
+ writeSource(t, depsCfg.Fs, filepath.Join("layouts", "sect2", "single.html"), `
{{ define "main"}}
Page Colors: {{ .Params.CoLOR }}|{{ .Params.Colors.Blue }}
Site Colors: {{ .Site.Params.COlOR }}|{{ .Site.Params.COLORS.YELLOW }}
{{ end }}
`)
- writeSource(t, filepath.Join("layouts", "_default", "single.html"), `
+ writeSource(t, depsCfg.Fs, filepath.Join("layouts", "_default", "single.html"), `
Page Title: {{ .Title }}
Site Title: {{ .Site.Title }}
Site Lang Mood: {{ .Site.Language.Params.MOoD }}
{{ partial "partial.html" . }}
`)
- if err := LoadGlobalConfig("", "config.toml"); err != nil {
- t.Fatalf("Failed to load config: %s", err)
- }
-
- sites, err := NewHugoSitesFromConfiguration(DepsCfg{})
+ sites, err := NewHugoSitesFromConfiguration(depsCfg)
if err != nil {
t.Fatalf("Failed to create sites: %s", err)
t.Fatalf("Failed to build sites: %s", err)
}
- assertFileContent(t, filepath.Join("public", "nn", "sect1", "page1", "index.html"), true,
+ assertFileContent(t, sites.Fs, filepath.Join("public", "nn", "sect1", "page1", "index.html"), true,
"Page Colors: red|heavenly",
"Site Colors: green|yellow",
"Site Lang Mood: Happy",
"«Hi»", // angled quotes
)
- assertFileContent(t, filepath.Join("public", "en", "sect1", "page1", "index.html"), true,
+ assertFileContent(t, sites.Fs, filepath.Join("public", "en", "sect1", "page1", "index.html"), true,
"Site Colors: Pink|golden",
"Page Colors: black|bluesy",
"Site Lang Mood: Thoughtful",
"“Hi”",
)
- assertFileContent(t, filepath.Join("public", "nn", "sect2", "page2", "index.html"), true,
+ assertFileContent(t, sites.Fs, filepath.Join("public", "nn", "sect2", "page2", "index.html"), true,
"Page Colors: black|sky",
"Site Colors: green|yellow",
"Shortcode Page: black|sky",
func doTestCaseInsensitiveConfigurationForTemplateEngine(t *testing.T, suffix string, templateFixer func(s string) string) {
testCommonResetState()
- caseMixingTestsWriteCommonSources(t)
+
+ fs := hugofs.NewMem()
+ viper.SetFs(fs.Source)
+
+ caseMixingTestsWriteCommonSources(t, fs)
+
+ if err := LoadGlobalConfig("", "config.toml"); err != nil {
+ t.Fatalf("Failed to load config: %s", err)
+ }
t.Log("Testing", suffix)
t.Log(templ)
- writeSource(t, filepath.Join("layouts", "_default", fmt.Sprintf("single.%s", suffix)), templ)
-
- if err := LoadGlobalConfig("", "config.toml"); err != nil {
- t.Fatalf("Failed to load config: %s", err)
- }
+ writeSource(t, fs, filepath.Join("layouts", "_default", fmt.Sprintf("single.%s", suffix)), templ)
- sites, err := NewHugoSitesFromConfiguration(DepsCfg{})
+ sites, err := NewHugoSitesFromConfiguration(deps.DepsCfg{Fs: fs})
if err != nil {
t.Fatalf("Failed to create sites: %s", err)
t.Fatalf("Failed to build sites: %s", err)
}
- assertFileContent(t, filepath.Join("public", "nn", "sect1", "page1", "index.html"), true,
+ assertFileContent(t, sites.Fs, filepath.Join("public", "nn", "sect1", "page1", "index.html"), true,
"Page Colors: red|heavenly",
"Site Colors: green|yellow",
"Shortcode Page: red|heavenly",
"github.com/spf13/hugo/helpers"
+ "github.com/spf13/hugo/hugofs"
"github.com/spf13/viper"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
PaginatePath = "side"
`
- writeSource(t, "hugo.toml", configContent)
+ fs := hugofs.NewMem()
+ viper.SetFs(fs.Source)
+
+ writeSource(t, fs, "hugo.toml", configContent)
require.NoError(t, LoadGlobalConfig("", "hugo.toml"))
assert.Equal(t, "side", helpers.Config().GetString("paginatePath"))
sources := []source.ByteSource{
{Name: filepath.FromSlash("test.roml"), Content: []byte("boo")},
}
- s := NewSiteDefaultLang()
- err := s.loadData([]source.Input{&source.InMemorySource{ByteSource: sources}})
- if err != nil {
- t.Fatalf("Should not return an error")
- }
+ s, err := NewSiteDefaultLang()
+ require.NoError(t, err)
+ require.NoError(t, s.loadData([]source.Input{&source.InMemorySource{ByteSource: sources}}))
}
func doTestDataDir(t *testing.T, expected interface{}, sources []source.Input) {
- s := NewSiteDefaultLang()
- err := s.loadData(sources)
- if err != nil {
- t.Fatalf("Error loading data: %s", err)
- }
+ s, err := NewSiteDefaultLang()
+ require.NoError(t, err)
+ require.NoError(t, s.loadData(sources))
+
if !reflect.DeepEqual(expected, s.Data) {
t.Errorf("Expected structure\n%#v got\n%#v", expected, s.Data)
}
func TestDataFromShortcode(t *testing.T) {
testCommonResetState()
- writeSource(t, "data/hugo.toml", "slogan = \"Hugo Rocks!\"")
- writeSource(t, "layouts/_default/single.html", `
+
+ cfg := newTestDepsConfig()
+
+ writeSource(t, cfg.Fs, "data/hugo.toml", "slogan = \"Hugo Rocks!\"")
+ writeSource(t, cfg.Fs, "layouts/_default/single.html", `
* Slogan from template: {{ .Site.Data.hugo.slogan }}
* {{ .Content }}`)
- writeSource(t, "layouts/shortcodes/d.html", `{{ .Page.Site.Data.hugo.slogan }}`)
- writeSource(t, "content/c.md", `---
+ writeSource(t, cfg.Fs, "layouts/shortcodes/d.html", `{{ .Page.Site.Data.hugo.slogan }}`)
+ writeSource(t, cfg.Fs, "content/c.md", `---
---
Slogan from shortcode: {{< d >}}
`)
- h, err := newHugoSitesDefaultLanguage()
- require.NoError(t, err)
- require.NoError(t, h.Build(BuildCfg{}))
+ buildSingleSite(t, cfg, BuildCfg{})
- content := readSource(t, "public/c/index.html")
+ content := readSource(t, cfg.Fs, "public/c/index.html")
require.True(t, strings.Contains(content, "Slogan from template: Hugo Rocks!"), content)
require.True(t, strings.Contains(content, "Slogan from shortcode: Hugo Rocks!"), content)
"log"
"path/filepath"
- "github.com/spf13/hugo/tpl"
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/helpers"
+ "github.com/spf13/hugo/hugofs"
+ "github.com/spf13/hugo/tplapi"
jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
path := filepath.FromSlash("blog/post.md")
in := fmt.Sprintf(`{{< %s "%s" >}}`, refShortcode, path)
- writeSource(t, "content/"+path, simplePageWithURL+": "+in)
+ fs := hugofs.NewMem()
+
+ writeSource(t, fs, "content/"+path, simplePageWithURL+": "+in)
expected := fmt.Sprintf(`%s/simple/url/`, expectedBase)
- sites, err := newHugoSitesDefaultLanguage()
- require.NoError(t, err)
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
- require.NoError(t, sites.Build(BuildCfg{}))
- require.Len(t, sites.Sites[0].RegularPages, 1)
+ require.Len(t, s.RegularPages, 1)
- output := string(sites.Sites[0].RegularPages[0].Content)
+ output := string(s.RegularPages[0].Content)
if !strings.Contains(output, expected) {
t.Errorf("Got\n%q\nExpected\n%q", output, expected)
},
}
- p, _ := pageFromString(simplePage, "simple.md", func(templ tpl.Template) error {
+ p, _ := pageFromString(simplePage, "simple.md", func(templ tplapi.Template) error {
templ.Funcs(tweetFuncMap)
return nil
})
},
}
- p, _ := pageFromString(simplePage, "simple.md", func(templ tpl.Template) error {
+ p, _ := pageFromString(simplePage, "simple.md", func(templ tplapi.Template) error {
templ.Funcs(instagramFuncMap)
return nil
})
"github.com/bep/gitmap"
"github.com/spf13/hugo/helpers"
- jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
)
gitRepo, err := gitmap.Map(workingDir, "")
if err != nil {
- jww.ERROR.Printf("Got error reading Git log: %s", err)
+ h.Log.ERROR.Printf("Got error reading Git log: %s", err)
return
}
filename := path.Join(filepath.ToSlash(contentRoot), contentDir, filepath.ToSlash(p.Path()))
g, ok := gitMap[filename]
if !ok {
- jww.ERROR.Printf("Failed to find GitInfo for %q", filename)
+ h.Log.ERROR.Printf("Failed to find GitInfo for %q", filename)
return
}
func (h htmlHandler) Extensions() []string { return []string{"html", "htm"} }
-// TODO(bep) globals use p.s.t
func (h htmlHandler) PageConvert(p *Page) HandledResult {
if p.rendered {
panic(fmt.Sprintf("Page %q already rendered, does not need conversion", p.BaseFileName()))
"path/filepath"
"testing"
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/helpers"
"github.com/spf13/hugo/hugofs"
- "github.com/spf13/hugo/source"
- "github.com/spf13/hugo/target"
"github.com/spf13/viper"
)
func TestDefaultHandler(t *testing.T) {
testCommonResetState()
- hugofs.InitMemFs()
- sources := []source.ByteSource{
- {Name: filepath.FromSlash("sect/doc1.html"), Content: []byte("---\nmarkup: markdown\n---\n# title\nsome *content*")},
- {Name: filepath.FromSlash("sect/doc2.html"), Content: []byte("<!doctype html><html><body>more content</body></html>")},
- {Name: filepath.FromSlash("sect/doc3.md"), Content: []byte("# doc3\n*some* content")},
- {Name: filepath.FromSlash("sect/doc4.md"), Content: []byte("---\ntitle: doc4\n---\n# doc4\n*some content*")},
- {Name: filepath.FromSlash("sect/doc3/img1.png"), Content: []byte("‰PNG \1a ��� IHDR���\ 1���\ 1\b����:~›U��� IDAT\18Wcø\ f�\ 1\ 1\ 1�ZMoñ����IEND®B`‚")},
- {Name: filepath.FromSlash("sect/img2.gif"), Content: []byte("GIF89a\ 1�\ 1�€��ÿÿÿ���,����\ 1�\ 1��\ 2\ 2D\ 1�;")},
- {Name: filepath.FromSlash("sect/img2.spf"), Content: []byte("****FAKE-FILETYPE****")},
- {Name: filepath.FromSlash("doc7.html"), Content: []byte("<html><body>doc7 content</body></html>")},
- {Name: filepath.FromSlash("sect/doc8.html"), Content: []byte("---\nmarkup: md\n---\n# title\nsome *content*")},
- }
-
viper.Set("defaultExtension", "html")
viper.Set("verbose", true)
+ viper.Set("uglyURLs", true)
- s := &Site{
- Source: &source.InMemorySource{ByteSource: sources},
- targets: targetList{page: &target.PagePub{UglyURLs: true, PublishDir: "public"}},
- Language: helpers.NewLanguage("en"),
- }
+ fs := hugofs.NewMem()
- if err := buildAndRenderSite(s,
- "_default/single.html", "{{.Content}}",
- "head", "<head><script src=\"script.js\"></script></head>",
- "head_abs", "<head><script src=\"/script.js\"></script></head>"); err != nil {
- t.Fatalf("Failed to render site: %s", err)
- }
+ writeSource(t, fs, filepath.FromSlash("content/sect/doc1.html"), "---\nmarkup: markdown\n---\n# title\nsome *content*")
+ writeSource(t, fs, filepath.FromSlash("content/sect/doc2.html"), "<!doctype html><html><body>more content</body></html>")
+ writeSource(t, fs, filepath.FromSlash("content/sect/doc3.md"), "# doc3\n*some* content")
+ writeSource(t, fs, filepath.FromSlash("content/sect/doc4.md"), "---\ntitle: doc4\n---\n# doc4\n*some content*")
+ writeSource(t, fs, filepath.FromSlash("content/sect/doc3/img1.png"), "‰PNG \1a ��� IHDR���\ 1���\ 1\b����:~›U��� IDAT\18Wcø\ f�\ 1\ 1\ 1�ZMoñ����IEND®B`‚")
+ writeSource(t, fs, filepath.FromSlash("content/sect/img2.gif"), "GIF89a\ 1�\ 1�€��ÿÿÿ���,����\ 1�\ 1��\ 2\ 2D\ 1�;")
+ writeSource(t, fs, filepath.FromSlash("content/sect/img2.spf"), "****FAKE-FILETYPE****")
+ writeSource(t, fs, filepath.FromSlash("content/doc7.html"), "<html><body>doc7 content</body></html>")
+ writeSource(t, fs, filepath.FromSlash("content/sect/doc8.html"), "---\nmarkup: md\n---\n# title\nsome *content*")
+
+ writeSource(t, fs, filepath.FromSlash("layouts/_default/single.html"), "{{.Content}}")
+ writeSource(t, fs, filepath.FromSlash("head"), "<head><script src=\"script.js\"></script></head>")
+ writeSource(t, fs, filepath.FromSlash("head_abs"), "<head><script src=\"/script.js\"></script></head")
+
+ buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
tests := []struct {
doc string
}
for _, test := range tests {
- file, err := hugofs.Destination().Open(test.doc)
+ file, err := fs.Destination.Open(test.doc)
if err != nil {
t.Fatalf("Did not find %s in target.", test.doc)
}
package hugolib
import (
+ "errors"
"fmt"
- "io/ioutil"
- "log"
- "os"
"strings"
"sync"
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/helpers"
"github.com/spf13/viper"
"github.com/spf13/hugo/source"
"github.com/spf13/hugo/tpl"
- jww "github.com/spf13/jwalterweatherman"
+ "github.com/spf13/hugo/tplapi"
)
// HugoSites represents the sites to build. Each site represents a language.
multilingual *Multilingual
- *deps
+ *deps.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
-
- tmpl *tpl.GoHTMLTemplate
-
- // TODO(bep) next in line: Viper, hugofs
-}
-
-func (d *deps) refreshTemplates(withTemplate ...func(templ tpl.Template) error) {
- d.tmpl = tpl.New(d.log, withTemplate...)
- d.tmpl.PrintErrors() // TODO(bep) globals error handling
-}
-
-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.LevelError, jww.LevelError, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
- }
+// NewHugoSites creates a new collection of sites given the input sites, building
+// a language configuration based on those.
+func newHugoSites(cfg deps.DepsCfg, sites ...*Site) (*HugoSites, error) {
- return &deps{
- log: logger,
- tmpl: tpl.New(logger, cfg.WithTemplate...),
+ if cfg.Language != nil {
+ return nil, errors.New("Cannot provide Language in Cfg when sites are provided")
}
-}
-// NewHugoSites creates a new collection of sites given the input sites, building
-// a language configuration based on those.
-func newHugoSites(cfg DepsCfg, sites ...*Site) (*HugoSites, error) {
langConfig, err := newMultiLingualFromSites(sites...)
if err != nil {
return nil, err
}
- var d *deps
-
- if sites[0].deps != nil {
- d = sites[0].deps
- } else {
- d = newDeps(cfg)
- }
-
h := &HugoSites{
- deps: d,
multilingual: langConfig,
Sites: sites}
for _, s := range sites {
s.owner = h
- s.deps = h.deps
}
+
+ applyDepsIfNeeded(cfg, sites...)
+
+ h.Deps = sites[0].Deps
+
return h, nil
}
+func applyDepsIfNeeded(cfg deps.DepsCfg, sites ...*Site) error {
+
+ if cfg.TemplateProvider == nil {
+ cfg.TemplateProvider = tpl.DefaultTemplateProvider
+ }
+
+ var (
+ d *deps.Deps
+ err error
+ )
+
+ for _, s := range sites {
+ if s.Deps != nil {
+ continue
+ }
+
+ if d == nil {
+ cfg.Language = s.Language
+ cfg.WithTemplate = s.withSiteTemplates(cfg.WithTemplate)
+ d = deps.New(cfg)
+ if err := d.LoadTemplates(); err != nil {
+ return err
+ }
+
+ } else {
+ d, err = d.ForLanguage(s.Language)
+ if err != nil {
+ return err
+ }
+ }
+ s.Deps = d
+ }
+
+ return nil
+}
+
// NewHugoSitesFromConfiguration creates HugoSites from the global Viper config.
// TODO(bep) globals rename this when all the globals are gone.
-func NewHugoSitesFromConfiguration(cfg DepsCfg) (*HugoSites, error) {
+func NewHugoSitesFromConfiguration(cfg deps.DepsCfg) (*HugoSites, error) {
sites, err := createSitesFromConfig(cfg)
if err != nil {
return nil, err
return newHugoSites(cfg, sites...)
}
-func createSitesFromConfig(cfg DepsCfg) ([]*Site, error) {
- deps := newDeps(cfg)
- return createSitesFromDeps(deps)
+func (s *Site) withSiteTemplates(withTemplates ...func(templ tplapi.Template) error) func(templ tplapi.Template) error {
+ return func(templ tplapi.Template) error {
+ templ.LoadTemplates(s.absLayoutDir())
+ if s.hasTheme() {
+ templ.LoadTemplatesWithPrefix(s.absThemeDir()+"/layouts", "theme")
+ }
+
+ for _, wt := range withTemplates {
+ if wt == nil {
+ continue
+ }
+ if err := wt(templ); err != nil {
+ return err
+ }
+ }
+
+ return nil
+ }
}
-func createSitesFromDeps(deps *deps) ([]*Site, error) {
- var sites []*Site
+func createSitesFromConfig(cfg deps.DepsCfg) ([]*Site, error) {
+
+ var (
+ sites []*Site
+ )
+
multilingual := viper.GetStringMap("languages")
if len(multilingual) == 0 {
- sites = append(sites, newSite(helpers.NewDefaultLanguage(), deps))
+ l := helpers.NewDefaultLanguage()
+ cfg.Language = l
+ s, err := newSite(cfg)
+ if err != nil {
+ return nil, err
+ }
+ sites = append(sites, s)
}
if len(multilingual) > 0 {
}
for _, lang := range languages {
- sites = append(sites, newSite(lang, deps))
- }
+ var s *Site
+ var err error
+ cfg.Language = lang
+ s, err = newSite(cfg)
+
+ if err != nil {
+ return nil, err
+ }
+ sites = append(sites, s)
+ }
}
return sites, nil
func (h *HugoSites) createSitesFromConfig() error {
- sites, err := createSitesFromDeps(h.deps)
+ depsCfg := deps.DepsCfg{Fs: h.Fs}
+ sites, err := createSitesFromConfig(depsCfg)
if err != nil {
return err
s.owner = h
}
+ if err := applyDepsIfNeeded(depsCfg, sites...); err != nil {
+ return err
+ }
+
+ h.Deps = sites[0].Deps
+
h.multilingual = langConfig
return nil
CreateSitesFromConfig bool
// Skip rendering. Useful for testing.
SkipRender bool
- // Use this to add templates to use for rendering.
- // Useful for testing.
- withTemplate func(templ tpl.Template) error
// Use this to indicate what changed (for rebuilds).
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
-
- WithTemplate []func(templ tpl.Template) error
-}
-
func (h *HugoSites) renderCrossSitesArtifacts() error {
if !h.multilingual.enabled() {
foundTaxonomyTermsPage := false
for key := range tax {
if s.Info.preserveTaxonomyNames {
- key = s.Info.pathSpec.MakePathSanitized(key)
+ key = s.PathSpec.MakePathSanitized(key)
}
for _, p := range taxonomyPages {
if p.sections[0] == plural && p.sections[1] == key {
}
var err error
- if workContentCopy, err = handleShortcodes(p, s.owner.tmpl, workContentCopy); err != nil {
- jww.ERROR.Printf("Failed to handle shortcodes for page %s: %s", p.BaseFileName(), err)
+ if workContentCopy, err = handleShortcodes(p, s.Tmpl, workContentCopy); err != nil {
+ s.Log.ERROR.Printf("Failed to handle shortcodes for page %s: %s", p.BaseFileName(), err)
}
if p.Markup != "html" {
summaryContent, err := p.setUserDefinedSummaryIfProvided(workContentCopy)
if err != nil {
- jww.ERROR.Printf("Failed to set user defined summary for page %q: %s", p.Path(), err)
+ s.Log.ERROR.Printf("Failed to set user defined summary for page %q: %s", p.Path(), err)
} else if summaryContent != nil {
workContentCopy = summaryContent.content
}
return h.Sites[0].AllPages
}
-func handleShortcodes(p *Page, t tpl.Template, rawContentCopy []byte) ([]byte, error) {
+func handleShortcodes(p *Page, t tplapi.Template, rawContentCopy []byte) ([]byte, error) {
if len(p.contentShortCodes) > 0 {
- jww.DEBUG.Printf("Replace %d shortcodes in %q", len(p.contentShortCodes), p.BaseFileName())
+ p.s.Log.DEBUG.Printf("Replace %d shortcodes in %q", len(p.contentShortCodes), p.BaseFileName())
shortcodes, err := executeShortcodeFuncMap(p.contentShortCodes)
if err != nil {
rawContentCopy, err = replaceShortcodeTokens(rawContentCopy, shortcodePlaceholderPrefix, shortcodes)
if err != nil {
- jww.FATAL.Printf("Failed to replace shortcode tokens in %s:\n%s", p.BaseFileName(), err.Error())
+ p.s.Log.FATAL.Printf("Failed to replace shortcode tokens in %s:\n%s", p.BaseFileName(), err.Error())
}
}
return h.findPagesByKindNotIn(kind, h.Sites[0].AllPages)
}
-// Convenience func used in tests to build a single site/language excluding render phase.
-func buildSiteSkipRender(s *Site, additionalTemplates ...string) error {
- return doBuildSite(s, false, additionalTemplates...)
-}
-
-// Convenience func used in tests to build a single site/language including render phase.
-func buildAndRenderSite(s *Site, additionalTemplates ...string) error {
- return doBuildSite(s, true, additionalTemplates...)
-}
-
-// Convenience func used in tests to build a single site/language.
-func doBuildSite(s *Site, render bool, additionalTemplates ...string) error {
- if s.PageCollections == nil {
- s.PageCollections = newPageCollections()
- }
- sites, err := newHugoSites(DepsCfg{}, s)
- if err != nil {
- return err
- }
-
- addTemplates := func(templ tpl.Template) error {
- for i := 0; i < len(additionalTemplates); i += 2 {
- err := templ.AddTemplate(additionalTemplates[i], additionalTemplates[i+1])
- if err != nil {
- return err
- }
- }
- return nil
- }
-
- config := BuildCfg{SkipRender: !render, withTemplate: addTemplates}
- return sites.Build(config)
-}
-
// Convenience func used in tests.
-func newHugoSitesFromSourceAndLanguages(input []source.ByteSource, languages helpers.Languages) (*HugoSites, error) {
+func newHugoSitesFromSourceAndLanguages(input []source.ByteSource, languages helpers.Languages, cfg deps.DepsCfg) (*HugoSites, error) {
if len(languages) == 0 {
panic("Must provide at least one language")
}
- cfg := DepsCfg{}
-
first := &Site{
- Source: &source.InMemorySource{ByteSource: input},
Language: languages[0],
+ Source: &source.InMemorySource{ByteSource: input},
}
if len(languages) == 1 {
return newHugoSites(cfg, first)
}
// Convenience func used in tests.
-func newHugoSitesDefaultLanguage() (*HugoSites, error) {
- return newHugoSitesFromSourceAndLanguages(nil, helpers.Languages{helpers.NewDefaultLanguage()})
+func newHugoSitesDefaultLanguage(cfg deps.DepsCfg) (*HugoSites, error) {
+ return newHugoSitesFromSourceAndLanguages(nil, helpers.Languages{helpers.NewDefaultLanguage()}, cfg)
}
}
if config.PrintStats {
- h.log.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
"github.com/fortytw2/leaktest"
"github.com/fsnotify/fsnotify"
"github.com/spf13/afero"
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/helpers"
"github.com/spf13/hugo/hugofs"
"github.com/spf13/hugo/source"
type testSiteConfig struct {
DefaultContentLanguage string
+ Fs *hugofs.Fs
}
func init() {
}
func testCommonResetState() {
- hugofs.InitMemFs()
viper.Reset()
- viper.SetFs(hugofs.Source())
+ // TODO(bep) globals viper viper.SetFs(hugofs.Source())
+ viper.Set("currentContentLanguage", helpers.NewLanguage("en"))
helpers.ResetConfigProvider()
loadDefaultSettings()
// Default is false, but true is easier to use as default in tests
viper.Set("defaultContentLanguageInSubdir", true)
- if err := hugofs.Source().Mkdir("content", 0755); err != nil {
- panic("Content folder creation failed.")
- }
-
}
-func TestMultiSitesMainLangInRoot(t *testing.T) {
+// TODO(bep) globals this currently fails because of a configuration dependency that will be resolved when we get rid of the global Viper.
+func _TestMultiSitesMainLangInRoot(t *testing.T) {
for _, b := range []bool{true, false} {
doTestMultiSitesMainLangInRoot(t, b)
func doTestMultiSitesMainLangInRoot(t *testing.T, defaultInSubDir bool) {
testCommonResetState()
viper.Set("defaultContentLanguageInSubdir", defaultInSubDir)
- siteConfig := testSiteConfig{DefaultContentLanguage: "fr"}
+ fs := hugofs.NewMem()
+ siteConfig := testSiteConfig{DefaultContentLanguage: "fr", Fs: fs}
sites := createMultiTestSites(t, siteConfig, multiSiteTOMLConfigTemplate)
require.Equal(t, "", frSite.Info.LanguagePrefix)
}
- require.Equal(t, "/blog/en/foo", enSite.Info.pathSpec.RelURL("foo", true))
+ fmt.Println(">>>", enSite.PathSpec)
+ require.Equal(t, "/blog/en/foo", enSite.PathSpec.RelURL("foo", true))
doc1en := enSite.RegularPages[0]
doc1fr := frSite.RegularPages[0]
require.Equal(t, replaceDefaultContentLanguageValue("http://example.com/blog/fr/sect/doc1/", defaultInSubDir), frPerm)
require.Equal(t, replaceDefaultContentLanguageValue("/blog/fr/sect/doc1/", defaultInSubDir), frRelPerm)
- assertFileContent(t, "public/fr/sect/doc1/index.html", defaultInSubDir, "Single", "Bonjour")
- assertFileContent(t, "public/en/sect/doc1-slug/index.html", defaultInSubDir, "Single", "Hello")
+ assertFileContent(t, fs, "public/fr/sect/doc1/index.html", defaultInSubDir, "Single", "Bonjour")
+ assertFileContent(t, fs, "public/en/sect/doc1-slug/index.html", defaultInSubDir, "Single", "Hello")
// Check home
if defaultInSubDir {
// should have a redirect on top level.
- assertFileContent(t, "public/index.html", true, `<meta http-equiv="refresh" content="0; url=http://example.com/blog/fr" />`)
+ assertFileContent(t, fs, "public/index.html", true, `<meta http-equiv="refresh" content="0; url=http://example.com/blog/fr" />`)
} else {
// should have redirect back to root
- assertFileContent(t, "public/fr/index.html", true, `<meta http-equiv="refresh" content="0; url=http://example.com/blog" />`)
+ assertFileContent(t, fs, "public/fr/index.html", true, `<meta http-equiv="refresh" content="0; url=http://example.com/blog" />`)
}
- assertFileContent(t, "public/fr/index.html", defaultInSubDir, "Home", "Bonjour")
- assertFileContent(t, "public/en/index.html", defaultInSubDir, "Home", "Hello")
+ assertFileContent(t, fs, "public/fr/index.html", defaultInSubDir, "Home", "Bonjour")
+ assertFileContent(t, fs, "public/en/index.html", defaultInSubDir, "Home", "Hello")
// Check list pages
- assertFileContent(t, "public/fr/sect/index.html", defaultInSubDir, "List", "Bonjour")
- assertFileContent(t, "public/en/sect/index.html", defaultInSubDir, "List", "Hello")
- assertFileContent(t, "public/fr/plaques/frtag1/index.html", defaultInSubDir, "List", "Bonjour")
- assertFileContent(t, "public/en/tags/tag1/index.html", defaultInSubDir, "List", "Hello")
+ assertFileContent(t, fs, "public/fr/sect/index.html", defaultInSubDir, "List", "Bonjour")
+ assertFileContent(t, fs, "public/en/sect/index.html", defaultInSubDir, "List", "Hello")
+ assertFileContent(t, fs, "public/fr/plaques/frtag1/index.html", defaultInSubDir, "List", "Bonjour")
+ assertFileContent(t, fs, "public/en/tags/tag1/index.html", defaultInSubDir, "List", "Hello")
// Check sitemaps
// Sitemaps behaves different: In a multilanguage setup there will always be a index file and
// one sitemap in each lang folder.
- assertFileContent(t, "public/sitemap.xml", true,
+ assertFileContent(t, fs, "public/sitemap.xml", true,
"<loc>http://example.com/blog/en/sitemap.xml</loc>",
"<loc>http://example.com/blog/fr/sitemap.xml</loc>")
if defaultInSubDir {
- assertFileContent(t, "public/fr/sitemap.xml", true, "<loc>http://example.com/blog/fr/</loc>")
+ assertFileContent(t, fs, "public/fr/sitemap.xml", true, "<loc>http://example.com/blog/fr/</loc>")
} else {
- assertFileContent(t, "public/fr/sitemap.xml", true, "<loc>http://example.com/blog/</loc>")
+ assertFileContent(t, fs, "public/fr/sitemap.xml", true, "<loc>http://example.com/blog/</loc>")
}
- assertFileContent(t, "public/en/sitemap.xml", true, "<loc>http://example.com/blog/en/</loc>")
+ assertFileContent(t, fs, "public/en/sitemap.xml", true, "<loc>http://example.com/blog/en/</loc>")
// Check rss
- assertFileContent(t, "public/fr/index.xml", defaultInSubDir, `<atom:link href="http://example.com/blog/fr/index.xml"`)
- assertFileContent(t, "public/en/index.xml", defaultInSubDir, `<atom:link href="http://example.com/blog/en/index.xml"`)
- assertFileContent(t, "public/fr/sect/index.xml", defaultInSubDir, `<atom:link href="http://example.com/blog/fr/sect/index.xml"`)
- assertFileContent(t, "public/en/sect/index.xml", defaultInSubDir, `<atom:link href="http://example.com/blog/en/sect/index.xml"`)
- assertFileContent(t, "public/fr/plaques/frtag1/index.xml", defaultInSubDir, `<atom:link href="http://example.com/blog/fr/plaques/frtag1/index.xml"`)
- assertFileContent(t, "public/en/tags/tag1/index.xml", defaultInSubDir, `<atom:link href="http://example.com/blog/en/tags/tag1/index.xml"`)
+ assertFileContent(t,
fs, "public/fr/index.xml", defaultInSubDir, `<atom:link href="http://example.com/blog/fr/index.xml"`)
+ assertFileContent(t,
fs, "public/en/index.xml", defaultInSubDir, `<atom:link href="http://example.com/blog/en/index.xml"`)
+ assertFileContent(t,
fs, "public/fr/sect/index.xml", defaultInSubDir, `<atom:link href="http://example.com/blog/fr/sect/index.xml"`)
+ assertFileContent(t,
fs, "public/en/sect/index.xml", defaultInSubDir, `<atom:link href="http://example.com/blog/en/sect/index.xml"`)
+ assertFileContent(t,
fs, "public/fr/plaques/frtag1/index.xml", defaultInSubDir, `<atom:link href="http://example.com/blog/fr/plaques/frtag1/index.xml"`)
+ assertFileContent(t,
fs, "public/en/tags/tag1/index.xml", defaultInSubDir, `<atom:link href="http://example.com/blog/en/tags/tag1/index.xml"`)
// Check paginators
- assertFileContent(t, "public/fr/page/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/fr/"`)
- assertFileContent(t, "public/en/page/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/en/"`)
- assertFileContent(t, "public/fr/page/2/index.html", defaultInSubDir, "Home Page 2", "Bonjour", "http://example.com/blog/fr/")
- assertFileContent(t, "public/en/page/2/index.html", defaultInSubDir, "Home Page 2", "Hello", "http://example.com/blog/en/")
- assertFileContent(t, "public/fr/sect/page/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/fr/sect/"`)
- assertFileContent(t, "public/en/sect/page/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/en/sect/"`)
- assertFileContent(t, "public/fr/sect/page/2/index.html", defaultInSubDir, "List Page 2", "Bonjour", "http://example.com/blog/fr/sect/")
- assertFileContent(t, "public/en/sect/page/2/index.html", defaultInSubDir, "List Page 2", "Hello", "http://example.com/blog/en/sect/")
- assertFileContent(t, "public/fr/plaques/frtag1/page/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/fr/plaques/frtag1/"`)
- assertFileContent(t, "public/en/tags/tag1/page/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/en/tags/tag1/"`)
- assertFileContent(t, "public/fr/plaques/frtag1/page/2/index.html", defaultInSubDir, "List Page 2", "Bonjour", "http://example.com/blog/fr/plaques/frtag1/")
- assertFileContent(t, "public/en/tags/tag1/page/2/index.html", defaultInSubDir, "List Page 2", "Hello", "http://example.com/blog/en/tags/tag1/")
+ assertFileContent(t, fs, "public/fr/page/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/fr/"`)
+ assertFileContent(t, fs, "public/en/page/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/en/"`)
+ assertFileContent(t, fs, "public/fr/page/2/index.html", defaultInSubDir, "Home Page 2", "Bonjour", "http://example.com/blog/fr/")
+ assertFileContent(t, fs, "public/en/page/2/index.html", defaultInSubDir, "Home Page 2", "Hello", "http://example.com/blog/en/")
+ assertFileContent(t, fs, "public/fr/sect/page/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/fr/sect/"`)
+ assertFileContent(t, fs, "public/en/sect/page/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/en/sect/"`)
+ assertFileContent(t, fs, "public/fr/sect/page/2/index.html", defaultInSubDir, "List Page 2", "Bonjour", "http://example.com/blog/fr/sect/")
+ assertFileContent(t, fs, "public/en/sect/page/2/index.html", defaultInSubDir, "List Page 2", "Hello", "http://example.com/blog/en/sect/")
+ assertFileContent(t, fs, "public/fr/plaques/frtag1/page/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/fr/plaques/frtag1/"`)
+ assertFileContent(t, fs, "public/en/tags/tag1/page/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/en/tags/tag1/"`)
+ assertFileContent(t, fs, "public/fr/plaques/frtag1/page/2/index.html", defaultInSubDir, "List Page 2", "Bonjour", "http://example.com/blog/fr/plaques/frtag1/")
+ assertFileContent(t, fs, "public/en/tags/tag1/page/2/index.html", defaultInSubDir, "List Page 2", "Hello", "http://example.com/blog/en/tags/tag1/")
// nn (Nynorsk) and nb (Bokmål) have custom pagePath: side ("page" in Norwegian)
- assertFileContent(t, "public/nn/side/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/nn/"`)
- assertFileContent(t, "public/nb/side/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/nb/"`)
+ assertFileContent(t, fs, "public/nn/side/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/nn/"`)
+ assertFileContent(t, fs, "public/nb/side/1/index.html", defaultInSubDir, `refresh" content="0; url=http://example.com/blog/nb/"`)
}
func replaceDefaultContentLanguageValue(value string, defaultInSubDir bool) string {
}
-func assertFileContent(t *testing.T, filename string, defaultInSubDir bool, matches ...string) {
+func assertFileContent(t *testing.T, fs *hugofs.Fs, filename string, defaultInSubDir bool, matches ...string) {
filename = replaceDefaultContentLanguageValue(filename, defaultInSubDir)
- content := readDestination(t, filename)
+ content := readDestination(t, fs, filename)
for _, match := range matches {
match = replaceDefaultContentLanguageValue(match, defaultInSubDir)
require.True(t, strings.Contains(content, match), fmt.Sprintf("File no match for\n%q in\n%q:\n%s", strings.Replace(match, "%", "%%", -1), filename, strings.Replace(content, "%", "%%", -1)))
}
}
-func assertFileContentRegexp(t *testing.T, filename string, defaultInSubDir bool, matches ...string) {
+func assertFileContentRegexp(t *testing.T, fs *hugofs.Fs, filename string, defaultInSubDir bool, matches ...string) {
filename = replaceDefaultContentLanguageValue(filename, defaultInSubDir)
- content := readDestination(t, filename)
+ content := readDestination(t, fs, filename)
for _, match := range matches {
match = replaceDefaultContentLanguageValue(match, defaultInSubDir)
r := regexp.MustCompile(match)
viper.Set("defaultContentLanguage", "nn")
- writeSource(t, "config.toml", `
+ fs := hugofs.NewMem()
+
+ depsCfg := deps.DepsCfg{Fs: fs}
+ viper.SetFs(depsCfg.Fs.Source)
+
+ writeSource(t, depsCfg.Fs, "config.toml", `
[languages]
[languages.nn]
languageName = "Nynorsk"
t.Fatalf("Failed to load config: %s", err)
}
- // Add some data
- writeSource(t, "data/hugo.toml", "slogan = \"Hugo Rocks!\"")
-
- sites, err := NewHugoSitesFromConfiguration(DepsCfg{})
+ sites, err := NewHugoSitesFromConfiguration(depsCfg)
if err != nil {
t.Fatalf("Failed to create sites: %s", err)
}
+ writeSource(t, fs, filepath.Join("content", "foo.md"), "foo")
+
+ // Add some data
+ writeSource(t, fs, filepath.Join("data", "hugo.toml"), "slogan = \"Hugo Rocks!\"")
+
require.NoError(t, sites.Build(BuildCfg{}))
require.Len(t, sites.Sites, 2)
func doTestMultiSitesBuild(t *testing.T, configTemplate, configSuffix string) {
defer leaktest.Check(t)()
testCommonResetState()
- siteConfig := testSiteConfig{DefaultContentLanguage: "fr"}
+ fs := hugofs.NewMem()
+ siteConfig := testSiteConfig{DefaultContentLanguage: "fr", Fs: fs}
sites := createMultiTestSitesForConfig(t, siteConfig, configTemplate, configSuffix)
err := sites.Build(BuildCfg{})
assert.Equal(t, "http://example.com/blog/superbob", permalink, "invalid doc3 permalink")
assert.Equal(t, "/superbob", doc3.URL(), "invalid url, was specified on doc3")
- assertFileContent(t, "public/superbob/index.html", true, "doc3|Hello|en")
+ assertFileContent(t, fs, "public/superbob/index.html", true, "doc3|Hello|en")
assert.Equal(t, doc2.Next, doc3, "doc3 should follow doc2, in .Next")
doc1fr := doc1en.Translations()[0]
}
// Check redirect to main language, French
- languageRedirect := readDestination(t, "public/index.html")
+ languageRedirect := readDestination(t, fs, "public/index.html")
require.True(t, strings.Contains(languageRedirect, "0; url=http://example.com/blog/fr"), languageRedirect)
// check home page content (including data files rendering)
- assertFileContent(t, "public/en/index.html", true, "Home Page 1", "Hello", "Hugo Rocks!")
- assertFileContent(t, "public/fr/index.html", true, "Home Page 1", "Bonjour", "Hugo Rocks!")
+ assertFileContent(t, fs, "public/en/index.html", true, "Home Page 1", "Hello", "Hugo Rocks!")
+ assertFileContent(t, fs, "public/fr/index.html", true, "Home Page 1", "Bonjour", "Hugo Rocks!")
// check single page content
- assertFileContent(t, "public/fr/sect/doc1/index.html", true, "Single", "Shortcode: Bonjour")
- assertFileContent(t, "public/en/sect/doc1-slug/index.html", true, "Single", "Shortcode: Hello")
+ assertFileContent(t, fs, "public/fr/sect/doc1/index.html", true, "Single", "Shortcode: Bonjour")
+ assertFileContent(t, fs, "public/en/sect/doc1-slug/index.html", true, "Single", "Shortcode: Hello")
// Check node translations
homeEn := enSite.getPage(KindHome)
require.Equal(t, "nb", taxTermNn.Translations()[0].Lang())
// Check sitemap(s)
- sitemapIndex := readDestination(t, "public/sitemap.xml")
+ sitemapIndex := readDestination(t, fs, "public/sitemap.xml")
require.True(t, strings.Contains(sitemapIndex, "<loc>http://example.com/blog/en/sitemap.xml</loc>"), sitemapIndex)
require.True(t, strings.Contains(sitemapIndex, "<loc>http://example.com/blog/fr/sitemap.xml</loc>"), sitemapIndex)
- sitemapEn := readDestination(t, "public/en/sitemap.xml")
- sitemapFr := readDestination(t, "public/fr/sitemap.xml")
+ sitemapEn := readDestination(t, fs, "public/en/sitemap.xml")
+ sitemapFr := readDestination(t, fs, "public/fr/sitemap.xml")
require.True(t, strings.Contains(sitemapEn, "http://example.com/blog/en/sect/doc2/"), sitemapEn)
require.True(t, strings.Contains(sitemapFr, "http://example.com/blog/fr/sect/doc1/"), sitemapFr)
require.Len(t, frTags, 2, fmt.Sprintf("Tags in fr: %v", frTags))
require.NotNil(t, enTags["tag1"])
require.NotNil(t, frTags["frtag1"])
- readDestination(t, "public/fr/plaques/frtag1/index.html")
- readDestination(t, "public/en/tags/tag1/index.html")
+ readDestination(t, fs, "public/fr/plaques/frtag1/index.html")
+ readDestination(t, fs, "public/en/tags/tag1/index.html")
// Check Blackfriday config
assert.True(t, strings.Contains(string(doc1fr.Content), "«"), string(doc1fr.Content))
defer leaktest.Check(t)()
testCommonResetState()
- siteConfig := testSiteConfig{DefaultContentLanguage: "fr"}
+ fs := hugofs.NewMem()
+ siteConfig := testSiteConfig{DefaultContentLanguage: "fr", Fs: fs}
sites := createMultiTestSites(t, siteConfig, multiSiteTOMLConfigTemplate)
cfg := BuildCfg{Watching: true}
t.Fatalf("Failed to build sites: %s", err)
}
- _, err = hugofs.Destination().Open("public/en/sect/doc2/index.html")
+ _, err = fs.Destination.Open("public/en/sect/doc2/index.html")
if err != nil {
t.Fatalf("Unable to locate file")
require.Len(t, frSite.RegularPages, 3)
// Verify translations
- assertFileContent(t, "public/en/sect/doc1-slug/index.html", true, "Hello")
- assertFileContent(t, "public/fr/sect/doc1/index.html", true, "Bonjour")
+ assertFileContent(t, fs, "public/en/sect/doc1-slug/index.html", true, "Hello")
+ assertFileContent(t, fs, "public/fr/sect/doc1/index.html", true, "Bonjour")
// check single page content
- assertFileContent(t, "public/fr/sect/doc1/index.html", true, "Single", "Shortcode: Bonjour")
- assertFileContent(t, "public/en/sect/doc1-slug/index.html", true, "Single", "Shortcode: Hello")
+ assertFileContent(t, fs, "public/fr/sect/doc1/index.html", true, "Single", "Shortcode: Bonjour")
+ assertFileContent(t, fs, "public/en/sect/doc1-slug/index.html", true, "Single", "Shortcode: Hello")
for i, this := range []struct {
preFunc func(t *testing.T)
},
{
func(t *testing.T) {
- writeNewContentFile(t, "new_en_1", "2016-07-31", "content/new1.en.md", -5)
- writeNewContentFile(t, "new_en_2", "1989-07-30", "content/new2.en.md", -10)
- writeNewContentFile(t, "new_fr_1", "2016-07-30", "content/new1.fr.md", 10)
+ writeNewContentFile(t, fs, "new_en_1", "2016-07-31", "content/new1.en.md", -5)
+ writeNewContentFile(t, fs, "new_en_2", "1989-07-30", "content/new2.en.md", -10)
+ writeNewContentFile(t, fs, "new_fr_1", "2016-07-30", "content/new1.fr.md", 10)
},
[]fsnotify.Event{
{Name: "content/new1.en.md", Op: fsnotify.Create},
require.Equal(t, "new_en_2", enSite.RegularPages[0].Title)
require.Equal(t, "new_en_1", enSite.RegularPages[1].Title)
- rendered := readDestination(t, "public/en/new1/index.html")
+ rendered := readDestination(t, fs, "public/en/new1/index.html")
require.True(t, strings.Contains(rendered, "new_en_1"), rendered)
},
},
{
func(t *testing.T) {
p := "content/sect/doc1.en.md"
- doc1 := readSource(t, p)
+ doc1 := readSource(t, fs, p)
doc1 += "CHANGED"
- writeSource(t, p, doc1)
+ writeSource(t, fs, p, doc1)
},
[]fsnotify.Event{{Name: "content/sect/doc1.en.md", Op: fsnotify.Write}},
func(t *testing.T) {
require.Len(t, enSite.RegularPages, 5)
- doc1 := readDestination(t, "public/en/sect/doc1-slug/index.html")
+ doc1 := readDestination(t, fs, "public/en/sect/doc1-slug/index.html")
require.True(t, strings.Contains(doc1, "CHANGED"), doc1)
},
// Rename a file
{
func(t *testing.T) {
- if err := hugofs.Source().Rename("content/new1.en.md", "content/new1renamed.en.md"); err != nil {
+ if err := fs.Source.Rename("content/new1.en.md", "content/new1renamed.en.md"); err != nil {
t.Fatalf("Rename failed: %s", err)
}
},
func(t *testing.T) {
require.Len(t, enSite.RegularPages, 5, "Rename")
require.Equal(t, "new_en_1", enSite.RegularPages[1].Title)
- rendered := readDestination(t, "public/en/new1renamed/index.html")
+ rendered := readDestination(t, fs, "public/en/new1renamed/index.html")
require.True(t, strings.Contains(rendered, "new_en_1"), rendered)
}},
{
// Change a template
func(t *testing.T) {
template := "layouts/_default/single.html"
- templateContent := readSource(t, template)
+ templateContent := readSource(t, fs, template)
templateContent += "{{ print \"Template Changed\"}}"
- writeSource(t, template, templateContent)
+ writeSource(t, fs, template, templateContent)
},
[]fsnotify.Event{{Name: "layouts/_default/single.html", Op: fsnotify.Write}},
func(t *testing.T) {
require.Len(t, enSite.RegularPages, 5)
require.Len(t, enSite.AllPages, 30)
require.Len(t, frSite.RegularPages, 4)
- doc1 := readDestination(t, "public/en/sect/doc1-slug/index.html")
+ doc1 := readDestination(t, fs, "public/en/sect/doc1-slug/index.html")
require.True(t, strings.Contains(doc1, "Template Changed"), doc1)
},
},
// Change a language file
func(t *testing.T) {
languageFile := "i18n/fr.yaml"
- langContent := readSource(t, languageFile)
+ langContent := readSource(t, fs, languageFile)
langContent = strings.Replace(langContent, "Bonjour", "Salut", 1)
- writeSource(t, languageFile, langContent)
+ writeSource(t, fs, languageFile, langContent)
},
[]fsnotify.Event{{Name: "i18n/fr.yaml", Op: fsnotify.Write}},
func(t *testing.T) {
require.Len(t, enSite.RegularPages, 5)
require.Len(t, enSite.AllPages, 30)
require.Len(t, frSite.RegularPages, 4)
- docEn := readDestination(t, "public/en/sect/doc1-slug/index.html")
+ docEn := readDestination(t, fs, "public/en/sect/doc1-slug/index.html")
require.True(t, strings.Contains(docEn, "Hello"), "No Hello")
- docFr := readDestination(t, "public/fr/sect/doc1/index.html")
+ docFr := readDestination(t, fs, "public/fr/sect/doc1/index.html")
require.True(t, strings.Contains(docFr, "Salut"), "No Salut")
homeEn := enSite.getPage(KindHome)
// Change a shortcode
{
func(t *testing.T) {
- writeSource(t, "layouts/shortcodes/shortcode.html", "Modified Shortcode: {{ i18n \"hello\" }}")
+ writeSource(t, fs, "layouts/shortcodes/shortcode.html", "Modified Shortcode: {{ i18n \"hello\" }}")
},
[]fsnotify.Event{
{Name: "layouts/shortcodes/shortcode.html", Op: fsnotify.Write},
require.Len(t, enSite.RegularPages, 5)
require.Len(t, enSite.AllPages, 30)
require.Len(t, frSite.RegularPages, 4)
- assertFileContent(t, "public/fr/sect/doc1/index.html", true, "Single", "Modified Shortcode: Salut")
- assertFileContent(t, "public/en/sect/doc1-slug/index.html", true, "Single", "Modified Shortcode: Hello")
+ assertFileContent(t, fs, "public/fr/sect/doc1/index.html", true, "Single", "Modified Shortcode: Salut")
+ assertFileContent(t, fs, "public/en/sect/doc1-slug/index.html", true, "Single", "Modified Shortcode: Hello")
},
},
} {
filename = strings.Replace(filename, ".html", "/index.html", 1)
}
- require.Equal(t, p.shouldBuild(), destinationExists(filename), filename)
+ require.Equal(t, p.shouldBuild(), destinationExists(sites.Fs, filename), filename)
}
}
func TestAddNewLanguage(t *testing.T) {
testCommonResetState()
- siteConfig := testSiteConfig{DefaultContentLanguage: "fr"}
+ fs := hugofs.NewMem()
+ siteConfig := testSiteConfig{DefaultContentLanguage: "fr", Fs: fs}
sites := createMultiTestSites(t, siteConfig, multiSiteTOMLConfigTemplate)
cfg := BuildCfg{}
newConfig = createConfig(t, siteConfig, newConfig)
- writeNewContentFile(t, "Swedish Contentfile", "2016-01-01", "content/sect/doc1.sv.md", 10)
+ writeNewContentFile(t, fs, "Swedish Contentfile", "2016-01-01", "content/sect/doc1.sv.md", 10)
// replace the config
- writeSource(t, "multilangconfig.toml", newConfig)
+ writeSource(t, fs, "multilangconfig.toml", newConfig)
// Watching does not work with in-memory fs, so we trigger a reload manually
require.NoError(t, viper.ReadInConfig())
func TestChangeDefaultLanguage(t *testing.T) {
testCommonResetState()
viper.Set("defaultContentLanguageInSubdir", false)
-
- sites := createMultiTestSites(t, testSiteConfig{DefaultContentLanguage: "fr"}, multiSiteTOMLConfigTemplate)
+ fs := hugofs.NewMem()
+ sites := createMultiTestSites(t, testSiteConfig{DefaultContentLanguage: "fr", Fs: fs}, multiSiteTOMLConfigTemplate)
cfg := BuildCfg{}
err := sites.Build(cfg)
t.Fatalf("Failed to build sites: %s", err)
}
- assertFileContent(t, "public/sect/doc1/index.html", true, "Single", "Bonjour")
- assertFileContent(t, "public/en/sect/doc2/index.html", true, "Single", "Hello")
+ assertFileContent(t, fs, "public/sect/doc1/index.html", true, "Single", "Bonjour")
+ assertFileContent(t, fs, "public/en/sect/doc2/index.html", true, "Single", "Hello")
newConfig := createConfig(t, testSiteConfig{DefaultContentLanguage: "en"}, multiSiteTOMLConfigTemplate)
// replace the config
- writeSource(t, "multilangconfig.toml", newConfig)
+ writeSource(t, fs, "multilangconfig.toml", newConfig)
// Watching does not work with in-memory fs, so we trigger a reload manually
require.NoError(t, viper.ReadInConfig())
}
// Default language is now en, so that should now be the "root" language
- assertFileContent(t, "public/fr/sect/doc1/index.html", true, "Single", "Bonjour")
- assertFileContent(t, "public/sect/doc2/index.html", true, "Single", "Hello")
+ assertFileContent(t, fs, "public/fr/sect/doc1/index.html", true, "Single", "Bonjour")
+ assertFileContent(t, fs, "public/sect/doc2/index.html", true, "Single", "Hello")
}
func TestTableOfContentsInShortcodes(t *testing.T) {
testCommonResetState()
+ fs := hugofs.NewMem()
- sites := createMultiTestSites(t, testSiteConfig{DefaultContentLanguage: "en"}, multiSiteTOMLConfigTemplate)
+ writeSource(t, fs, "layouts/shortcodes/toc.html", tocShortcode)
+ writeSource(t, fs, "content/post/simple.en.md", tocPageSimple)
+ writeSource(t, fs, "content/post/withSCInHeading.en.md", tocPageWithShortcodesInHeadings)
- writeSource(t, "layouts/shortcodes/toc.html", tocShortcode)
- writeSource(t, "content/post/simple.en.md", tocPageSimple)
- writeSource(t, "content/post/withSCInHeading.en.md", tocPageWithShortcodesInHeadings)
+ sites := createMultiTestSites(t, testSiteConfig{DefaultContentLanguage: "en", Fs: fs}, multiSiteTOMLConfigTemplate)
cfg := BuildCfg{}
t.Fatalf("Failed to build sites: %s", err)
}
- assertFileContent(t, "public/en/post/simple/index.html", true, tocPageSimpleExpected)
- assertFileContent(t, "public/en/post/withSCInHeading/index.html", true, tocPageWithShortcodesInHeadingsExpected)
+ assertFileContent(t, fs, "public/en/post/simple/index.html", true, tocPageSimpleExpected)
+ assertFileContent(t, fs, "public/en/post/withSCInHeading/index.html", true, tocPageWithShortcodesInHeadingsExpected)
}
var tocShortcode = `
func createMultiTestSitesForConfig(t *testing.T, siteConfig testSiteConfig, configTemplate, configSuffix string) *HugoSites {
+ depsCfg := deps.DepsCfg{Fs: siteConfig.Fs}
configContent := createConfig(t, siteConfig, configTemplate)
// Add some layouts
- if err := afero.WriteFile(hugofs.Source(),
+ if err := afero.WriteFile(depsCfg.Fs.Source,
filepath.Join("layouts", "_default/single.html"),
[]byte("Single: {{ .Title }}|{{ i18n \"hello\" }}|{{.Lang}}|{{ .Content }}"),
0755); err != nil {
t.Fatalf("Failed to write layout file: %s", err)
}
- if err := afero.WriteFile(hugofs.Source(),
+ if err := afero.WriteFile(depsCfg.Fs.Source,
filepath.Join("layouts", "_default/list.html"),
[]byte("{{ $p := .Paginator }}List Page {{ $p.PageNumber }}: {{ .Title }}|{{ i18n \"hello\" }}|{{ .Permalink }}"),
0755); err != nil {
t.Fatalf("Failed to write layout file: %s", err)
}
- if err := afero.WriteFile(hugofs.Source(),
+ if err := afero.WriteFile(depsCfg.Fs.Source,
filepath.Join("layouts", "index.html"),
[]byte("{{ $p := .Paginator }}Home Page {{ $p.PageNumber }}: {{ .Title }}|{{ .IsHome }}|{{ i18n \"hello\" }}|{{ .Permalink }}|{{ .Site.Data.hugo.slogan }}"),
0755); err != nil {
}
// Add a shortcode
- if err := afero.WriteFile(hugofs.Source(),
+ if err := afero.WriteFile(depsCfg.Fs.Source,
filepath.Join("layouts", "shortcodes", "shortcode.html"),
[]byte("Shortcode: {{ i18n \"hello\" }}"),
0755); err != nil {
}
// Add some language files
- if err := afero.WriteFile(hugofs.Source(),
+ if err := afero.WriteFile(depsCfg.Fs.Source,
filepath.Join("i18n", "en.yaml"),
[]byte(`
- id: hello
0755); err != nil {
t.Fatalf("Failed to write language file: %s", err)
}
- if err := afero.WriteFile(hugofs.Source(),
+ if err := afero.WriteFile(depsCfg.Fs.Source,
filepath.Join("i18n", "fr.yaml"),
[]byte(`
- id: hello
}
configFile := "multilangconfig." + configSuffix
- writeSource(t, configFile, configContent)
+ writeSource(t, depsCfg.Fs, configFile, configContent)
+
+ viper.SetFs(depsCfg.Fs.Source)
+
if err := LoadGlobalConfig("", configFile); err != nil {
t.Fatalf("Failed to load config: %s", err)
}
// Hugo support using ByteSource's directly (for testing),
// but to make it more real, we write them to the mem file system.
for _, s := range sources {
- if err := afero.WriteFile(hugofs.Source(), filepath.Join("content", s.Name), s.Content, 0755); err != nil {
+ if err := afero.WriteFile(depsCfg.Fs.Source, filepath.Join("content", s.Name), s.Content, 0755); err != nil {
t.Fatalf("Failed to write file: %s", err)
}
}
// Add some data
- writeSource(t, "data/hugo.toml", "slogan = \"Hugo Rocks!\"")
+ writeSource(t, depsCfg.Fs, "data/hugo.toml", "slogan = \"Hugo Rocks!\"")
- sites, err := NewHugoSitesFromConfiguration(DepsCfg{})
+ sites, err := NewHugoSitesFromConfiguration(depsCfg)
if err != nil {
t.Fatalf("Failed to create sites: %s", err)
return sites
}
-func writeSource(t *testing.T, filename, content string) {
- if err := afero.WriteFile(hugofs.Source(), filepath.FromSlash(filename), []byte(content), 0755); err != nil {
+func writeSource(t *testing.T, fs *hugofs.Fs, filename, content string) {
+ if err := afero.WriteFile(fs.Source, filepath.FromSlash(filename), []byte(content), 0755); err != nil {
t.Fatalf("Failed to write file: %s", err)
}
}
-func readDestination(t *testing.T, filename string) string {
- return readFileFromFs(t, hugofs.Destination(), filename)
+func readDestination(t *testing.T, fs *hugofs.Fs, filename string) string {
+ return readFileFromFs(t, fs.Destination, filename)
}
-func destinationExists(filename string) bool {
- b, err := helpers.Exists(filename, hugofs.Destination())
+func destinationExists(fs *hugofs.Fs, filename string) bool {
+ b, err := helpers.Exists(filename, fs.Destination)
if err != nil {
panic(err)
}
return b
}
-func readSource(t *testing.T, filename string) string {
- return readFileFromFs(t, hugofs.Source(), filename)
+func readSource(t *testing.T, fs *hugofs.Fs, filename string) string {
+ return readFileFromFs(t, fs.Source, filename)
}
func readFileFromFs(t *testing.T, fs afero.Fs, filename string) string {
return fmt.Sprintf(testPageTemplate, title, date, weight, title)
}
-func writeNewContentFile(t *testing.T, title, date, filename string, weight int) {
+func writeNewContentFile(t *testing.T, fs *hugofs.Fs, title, date, filename string, weight int) {
content := newTestPage(title, date, weight)
- writeSource(t, filename, content)
+ writeSource(t, fs, filename, content)
}
func createConfig(t *testing.T, config testSiteConfig, configTemplate string) string {
"github.com/nicksnyder/go-i18n/i18n/bundle"
"github.com/spf13/hugo/source"
"github.com/spf13/hugo/tpl"
- jww "github.com/spf13/jwalterweatherman"
)
-func loadI18n(sources []source.Input) error {
- jww.DEBUG.Printf("Load I18n from %q", sources)
+func (s *Site) loadI18n(sources []source.Input) error {
+ s.Log.DEBUG.Printf("Load I18n from %q", sources)
i18nBundle := bundle.New()
"strings"
"testing"
+ "github.com/spf13/hugo/deps"
+
"github.com/spf13/hugo/helpers"
+ "github.com/spf13/hugo/hugofs"
"path/filepath"
toml "github.com/pelletier/go-toml"
- "github.com/spf13/hugo/hugofs"
"github.com/spf13/hugo/source"
"github.com/spf13/viper"
"github.com/stretchr/testify/assert"
}
func setupMenuTests(t *testing.T, pageSources []source.ByteSource) *Site {
- s := createTestSite(pageSources)
setupTestMenuState(t)
- testSiteSetup(s, t)
- return s
+ fs := hugofs.NewMem()
+
+ for _, src := range pageSources {
+ writeSource(t, fs, filepath.Join("content", src.Name), string(src.Content))
+
+ }
+
+ return buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
+
}
func createTestSite(pageSources []source.ByteSource) *Site {
- hugofs.InitMemFs()
return &Site{
- deps: newDeps(DepsCfg{}),
Source: &source.InMemorySource{ByteSource: pageSources},
Language: helpers.NewDefaultLanguage(),
}
}
-func testSiteSetup(s *Site, t *testing.T) {
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Sites build failed: %s", err)
- }
-}
-
func tomlToMap(s string) (map[string]interface{}, error) {
tree, err := toml.Load(s)
"path/filepath"
"strings"
"testing"
+
"time"
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/hugofs"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
)
viper.Set("uglyURLs", ugly)
viper.Set("preserveTaxonomyNames", preserveTaxonomyNames)
- writeLayoutsForNodeAsPageTests(t)
- writeNodePagesForNodeAsPageTests("", t)
-
- writeRegularPagesForNodeAsPageTests(t)
-
viper.Set("paginate", 1)
viper.Set("title", "Hugo Rocks")
viper.Set("rssURI", "customrss.xml")
- s := NewSiteDefaultLang()
+ depsCfg := newTestDepsConfig()
- if err := buildAndRenderSite(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ viper.SetFs(depsCfg.Fs.Source)
+
+ writeLayoutsForNodeAsPageTests(t, depsCfg.Fs)
+ writeNodePagesForNodeAsPageTests(t, depsCfg.Fs, "")
+
+ writeRegularPagesForNodeAsPageTests(t, depsCfg.Fs)
+
+ sites, err := NewHugoSitesFromConfiguration(depsCfg)
+
+ require.NoError(t, err)
+
+ require.NoError(t, sites.Build(BuildCfg{}))
// date order: home, sect1, sect2, cat/hugo, cat/web, categories
- assertFileContent(t, filepath.Join("public", "index.html"), false,
+ assertFileContent(t, depsCfg.Fs, filepath.Join("public", "index.html"), false,
"Index Title: Home Sweet Home!",
"Home <strong>Content!</strong>",
"# Pages: 4",
"GetPage: Section1 ",
)
- assertFileContent(t, expectedFilePath(ugly, "public", "sect1", "regular1"), false, "Single Title: Page 01", "Content Page 01")
+ assertFileContent(t, depsCfg.Fs, expectedFilePath(ugly, "public", "sect1", "regular1"), false, "Single Title: Page 01", "Content Page 01")
- h := s.owner
- nodes := h.findAllPagesByKindNotIn(KindPage)
+ nodes := sites.findAllPagesByKindNotIn(KindPage)
require.Len(t, nodes, 7)
section2 := nodes[4]
require.Equal(t, "Section2", section2.Title)
- pages := h.findAllPagesByKind(KindPage)
+ pages := sites.findAllPagesByKind(KindPage)
require.Len(t, pages, 4)
first := pages[0]
require.True(t, first.IsPage())
// Check Home paginator
- assertFileContent(t, expectedFilePath(ugly, "public", "page", "2"), false,
+ assertFileContent(t, depsCfg.Fs, expectedFilePath(ugly, "public", "page", "2"), false,
"Pag: Page 02")
// Check Sections
- assertFileContent(t, expectedFilePath(ugly, "public", "sect1"), false,
+ assertFileContent(t, depsCfg.Fs, expectedFilePath(ugly, "public", "sect1"), false,
"Section Title: Section", "Section1 <strong>Content!</strong>",
"Date: 2009-01-04",
"Lastmod: 2009-01-05",
)
- assertFileContent(t, expectedFilePath(ugly, "public", "sect2"), false,
+ assertFileContent(t, depsCfg.Fs, expectedFilePath(ugly, "public", "sect2"), false,
"Section Title: Section", "Section2 <strong>Content!</strong>",
"Date: 2009-01-06",
"Lastmod: 2009-01-07",
)
// Check Sections paginator
- assertFileContent(t, expectedFilePath(ugly, "public", "sect1", "page", "2"), false,
+ assertFileContent(t, depsCfg.Fs, expectedFilePath(ugly, "public", "sect1", "page", "2"), false,
"Pag: Page 02")
- sections := h.findAllPagesByKind(KindSection)
+ sections := sites.findAllPagesByKind(KindSection)
require.Len(t, sections, 2)
// Check taxonomy lists
- assertFileContent(t, expectedFilePath(ugly, "public", "categories", "hugo"), false,
+ assertFileContent(t, depsCfg.Fs, expectedFilePath(ugly, "public", "categories", "hugo"), false,
"Taxonomy Title: Taxonomy Hugo", "Taxonomy Hugo <strong>Content!</strong>",
"Date: 2009-01-08",
"Lastmod: 2009-01-09",
)
- assertFileContent(t, expectedFilePath(ugly, "public", "categories", "hugo-rocks"), false,
+ assertFileContent(t, depsCfg.Fs, expectedFilePath(ugly, "public", "categories", "hugo-rocks"), false,
"Taxonomy Title: Taxonomy Hugo Rocks",
)
+ s := sites.Sites[0]
+
web := s.getPage(KindTaxonomy, "categories", "web")
require.NotNil(t, web)
require.Len(t, web.Data["Pages"].(Pages), 4)
- assertFileContent(t, expectedFilePath(ugly, "public", "categories", "web"), false,
+ assertFileContent(t, depsCfg.Fs, expectedFilePath(ugly, "public", "categories", "web"), false,
"Taxonomy Title: Taxonomy Web",
"Taxonomy Web <strong>Content!</strong>",
"Date: 2009-01-10",
)
// Check taxonomy list paginator
- assertFileContent(t, expectedFilePath(ugly, "public", "categories", "hugo", "page", "2"), false,
+ assertFileContent(t, depsCfg.Fs, expectedFilePath(ugly, "public", "categories", "hugo", "page", "2"), false,
"Taxonomy Title: Taxonomy Hugo",
"Pag: Page 02")
// Check taxonomy terms
- assertFileContent(t, expectedFilePath(ugly, "public", "categories"), false,
+ assertFileContent(t, depsCfg.Fs, expectedFilePath(ugly, "public", "categories"), false,
"Taxonomy Terms Title: Taxonomy Term Categories", "Taxonomy Term Categories <strong>Content!</strong>", "k/v: hugo",
"Date: 2009-01-14",
"Lastmod: 2009-01-15",
// There are no pages to paginate over in the taxonomy terms.
// RSS
- assertFileContent(t, filepath.Join("public", "customrss.xml"), false, "Recent content in Home Sweet Home! on Hugo Rocks", "<rss")
- assertFileContent(t, filepath.Join("public", "sect1", "customrss.xml"), false, "Recent content in Section1 on Hugo Rocks", "<rss")
- assertFileContent(t, filepath.Join("public", "sect2", "customrss.xml"), false, "Recent content in Section2 on Hugo Rocks", "<rss")
- assertFileContent(t, filepath.Join("public", "categories", "hugo", "customrss.xml"), false, "Recent content in Taxonomy Hugo on Hugo Rocks", "<rss")
- assertFileContent(t, filepath.Join("public", "categories", "web", "customrss.xml"), false, "Recent content in Taxonomy Web on Hugo Rocks", "<rss")
+ assertFileContent(t, depsCfg.Fs, filepath.Join("public", "customrss.xml"), false, "Recent content in Home Sweet Home! on Hugo Rocks", "<rss")
+ assertFileContent(t, depsCfg.Fs, filepath.Join("public", "sect1", "customrss.xml"), false, "Recent content in Section1 on Hugo Rocks", "<rss")
+ assertFileContent(t, depsCfg.Fs, filepath.Join("public", "sect2", "customrss.xml"), false, "Recent content in Section2 on Hugo Rocks", "<rss")
+ assertFileContent(t, depsCfg.Fs, filepath.Join("public", "categories", "hugo", "customrss.xml"), false, "Recent content in Taxonomy Hugo on Hugo Rocks", "<rss")
+ assertFileContent(t, depsCfg.Fs, filepath.Join("public", "categories", "web", "customrss.xml"), false, "Recent content in Taxonomy Web on Hugo Rocks", "<rss")
}
func doTestNodesWithNoContentFile(t *testing.T, ugly bool) {
testCommonResetState()
- writeLayoutsForNodeAsPageTests(t)
- writeRegularPagesForNodeAsPageTests(t)
-
viper.Set("uglyURLs", ugly)
viper.Set("paginate", 1)
viper.Set("title", "Hugo Rocks!")
viper.Set("rssURI", "customrss.xml")
- s := NewSiteDefaultLang()
+ fs := hugofs.NewMem()
- if err := buildAndRenderSite(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ writeLayoutsForNodeAsPageTests(t, fs)
+ writeRegularPagesForNodeAsPageTests(t, fs)
+
+ sites, err := NewHugoSitesFromConfiguration(deps.DepsCfg{Fs: fs})
+
+ require.NoError(t, err)
+
+ require.NoError(t, sites.Build(BuildCfg{}))
+
+ s := sites.Sites[0]
// Home page
homePages := s.findPagesByKind(KindHome)
require.Len(t, homePage.Pages, 4)
require.True(t, homePage.Path() == "")
- assertFileContent(t, filepath.Join("public", "index.html"), false,
+ assertFileContent(t, fs, filepath.Join("public", "index.html"), false,
"Index Title: Hugo Rocks!",
"Date: 2010-06-12",
"Lastmod: 2010-06-13",
)
// Taxonomy list
- assertFileContent(t, expectedFilePath(ugly, "public", "categories", "hugo"), false,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "categories", "hugo"), false,
"Taxonomy Title: Hugo",
"Date: 2010-06-12",
"Lastmod: 2010-06-13",
)
// Taxonomy terms
- assertFileContent(t, expectedFilePath(ugly, "public", "categories"), false,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "categories"), false,
"Taxonomy Terms Title: Categories",
)
for _, p := range pages {
var want string
if ugly {
- want = "/" + p.Site.pathSpec.URLize(p.Title) + ".html"
+ want = "/" + p.s.PathSpec.URLize(p.Title) + ".html"
} else {
- want = "/" + p.Site.pathSpec.URLize(p.Title) + "/"
+ want = "/" + p.s.PathSpec.URLize(p.Title) + "/"
}
if p.URL() != want {
t.Errorf("Taxonomy term URL mismatch: want %q, got %q", want, p.URL())
}
// Sections
- assertFileContent(t, expectedFilePath(ugly, "public", "sect1"), false,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "sect1"), false,
"Section Title: Sect1s",
"Date: 2010-06-12",
"Lastmod: 2010-06-13",
)
- assertFileContent(t, expectedFilePath(ugly, "public", "sect2"), false,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "sect2"), false,
"Section Title: Sect2s",
"Date: 2008-07-06",
"Lastmod: 2008-07-09",
)
// RSS
- assertFileContent(t, filepath.Join("public", "customrss.xml"), false, "Hugo Rocks!", "<rss")
- assertFileContent(t, filepath.Join("public", "sect1", "customrss.xml"), false, "Recent content in Sect1s on Hugo Rocks!", "<rss")
- assertFileContent(t, filepath.Join("public", "sect2", "customrss.xml"), false, "Recent content in Sect2s on Hugo Rocks!", "<rss")
- assertFileContent(t, filepath.Join("public", "categories", "hugo", "customrss.xml"), false, "Recent content in Hugo on Hugo Rocks!", "<rss")
- assertFileContent(t, filepath.Join("public", "categories", "web", "customrss.xml"), false, "Recent content in Web on Hugo Rocks!", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "customrss.xml"), false, "Hugo Rocks!", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "sect1", "customrss.xml"), false, "Recent content in Sect1s on Hugo Rocks!", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "sect2", "customrss.xml"), false, "Recent content in Sect2s on Hugo Rocks!", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "categories", "hugo", "customrss.xml"), false, "Recent content in Hugo on Hugo Rocks!", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "categories", "web", "customrss.xml"), false, "Recent content in Web on Hugo Rocks!", "<rss")
}
func TestNodesAsPageMultilingual(t *testing.T) {
- for _, ugly := range []bool{true, false} {
+ for _, ugly := range []bool{false, true} {
doTestNodesAsPageMultilingual(t, ugly)
}
}
testCommonResetState()
+ fs := hugofs.NewMem()
+
viper.Set("uglyURLs", ugly)
- writeLayoutsForNodeAsPageTests(t)
+ viper.SetFs(fs.Source)
- writeSource(t, "config.toml",
+ writeSource(t, fs, "config.toml",
`
paginage = 1
title = "Hugo Multilingual Rocks!"
title = "Deutsche Hugo"
`)
+ writeLayoutsForNodeAsPageTests(t, fs)
+
for _, lang := range []string{"nn", "en"} {
- writeRegularPagesForNodeAsPageTestsWithLang(t, lang)
+ writeRegularPagesForNodeAsPageTestsWithLang(t, fs, lang)
}
- // Only write node pages for the English and Deutsch
- writeNodePagesForNodeAsPageTests("en", t)
- writeNodePagesForNodeAsPageTests("de", t)
-
if err := LoadGlobalConfig("", "config.toml"); err != nil {
t.Fatalf("Failed to load config: %s", err)
}
- sites, err := NewHugoSitesFromConfiguration(DepsCfg{})
+ sites, err := NewHugoSitesFromConfiguration(deps.DepsCfg{Fs: fs})
if err != nil {
t.Fatalf("Failed to create sites: %s", err)
t.Fatalf("Got %d sites", len(sites.Sites))
}
+ // Only write node pages for the English and Deutsch
+ writeNodePagesForNodeAsPageTests(t, fs, "en")
+ writeNodePagesForNodeAsPageTests(t, fs, "de")
+
err = sites.Build(BuildCfg{})
if err != nil {
require.Equal(t, expetedPermalink(ugly, "/en/sect1/"), enSect.Permalink())
- assertFileContent(t, filepath.Join("public", "nn", "index.html"), true,
+ assertFileContent(t, fs, filepath.Join("public", "nn", "index.html"), true,
"Index Title: Hugo på norsk")
- assertFileContent(t, filepath.Join("public", "en", "index.html"), true,
+ assertFileContent(t, fs, filepath.Join("public", "en", "index.html"), true,
"Index Title: Home Sweet Home!", "<strong>Content!</strong>")
- assertFileContent(t, filepath.Join("public", "de", "index.html"), true,
+ assertFileContent(t, fs, filepath.Join("public", "de", "index.html"), true,
"Index Title: Home Sweet Home!", "<strong>Content!</strong>")
// Taxonomy list
- assertFileContent(t, expectedFilePath(ugly, "public", "nn", "categories", "hugo"), true,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "nn", "categories", "hugo"), true,
"Taxonomy Title: Hugo")
- assertFileContent(t, expectedFilePath(ugly, "public", "en", "categories", "hugo"), true,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "en", "categories", "hugo"), true,
"Taxonomy Title: Taxonomy Hugo")
// Taxonomy terms
- assertFileContent(t, expectedFilePath(ugly, "public", "nn", "categories"), true,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "nn", "categories"), true,
"Taxonomy Terms Title: Categories")
- assertFileContent(t, expectedFilePath(ugly, "public", "en", "categories"), true,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "en", "categories"), true,
"Taxonomy Terms Title: Taxonomy Term Categories")
// Sections
- assertFileContent(t, expectedFilePath(ugly, "public", "nn", "sect1"), true,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "nn", "sect1"), true,
"Section Title: Sect1s")
- assertFileContent(t, expectedFilePath(ugly, "public", "nn", "sect2"), true,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "nn", "sect2"), true,
"Section Title: Sect2s")
- assertFileContent(t, expectedFilePath(ugly, "public", "en", "sect1"), true,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "en", "sect1"), true,
"Section Title: Section1")
- assertFileContent(t, expectedFilePath(ugly, "public", "en", "sect2"), true,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "en", "sect2"), true,
"Section Title: Section2")
// Regular pages
- assertFileContent(t, expectedFilePath(ugly, "public", "en", "sect1", "regular1"), true,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "en", "sect1", "regular1"), true,
"Single Title: Page 01")
- assertFileContent(t, expectedFilePath(ugly, "public", "nn", "sect1", "regular2"), true,
+ assertFileContent(t, fs, expectedFilePath(ugly, "public", "nn", "sect1", "regular2"), true,
"Single Title: Page 02")
// RSS
- assertFileContent(t, filepath.Join("public", "nn", "customrss.xml"), true, "Hugo på norsk", "<rss")
- assertFileContent(t, filepath.Join("public", "nn", "sect1", "customrss.xml"), true, "Recent content in Sect1s on Hugo på norsk", "<rss")
- assertFileContent(t, filepath.Join("public", "nn", "sect2", "customrss.xml"), true, "Recent content in Sect2s on Hugo på norsk", "<rss")
- assertFileContent(t, filepath.Join("public", "nn", "categories", "hugo", "customrss.xml"), true, "Recent content in Hugo on Hugo på norsk", "<rss")
- assertFileContent(t, filepath.Join("public", "nn", "categories", "web", "customrss.xml"), true, "Recent content in Web on Hugo på norsk", "<rss")
-
- assertFileContent(t, filepath.Join("public", "en", "customrss.xml"), true, "Recent content in Home Sweet Home! on Hugo in English", "<rss")
- assertFileContent(t, filepath.Join("public", "en", "sect1", "customrss.xml"), true, "Recent content in Section1 on Hugo in English", "<rss")
- assertFileContent(t, filepath.Join("public", "en", "sect2", "customrss.xml"), true, "Recent content in Section2 on Hugo in English", "<rss")
- assertFileContent(t, filepath.Join("public", "en", "categories", "hugo", "customrss.xml"), true, "Recent content in Taxonomy Hugo on Hugo in English", "<rss")
- assertFileContent(t, filepath.Join("public", "en", "categories", "web", "customrss.xml"), true, "Recent content in Taxonomy Web on Hugo in English", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "nn", "customrss.xml"), true, "Hugo på norsk", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "nn", "sect1", "customrss.xml"), true, "Recent content in Sect1s on Hugo på norsk", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "nn", "sect2", "customrss.xml"), true, "Recent content in Sect2s on Hugo på norsk", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "nn", "categories", "hugo", "customrss.xml"), true, "Recent content in Hugo on Hugo på norsk", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "nn", "categories", "web", "customrss.xml"), true, "Recent content in Web on Hugo på norsk", "<rss")
+
+ assertFileContent(t, fs, filepath.Join("public", "en", "customrss.xml"), true, "Recent content in Home Sweet Home! on Hugo in English", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "en", "sect1", "customrss.xml"), true, "Recent content in Section1 on Hugo in English", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "en", "sect2", "customrss.xml"), true, "Recent content in Section2 on Hugo in English", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "en", "categories", "hugo", "customrss.xml"), true, "Recent content in Taxonomy Hugo on Hugo in English", "<rss")
+ assertFileContent(t, fs, filepath.Join("public", "en", "categories", "web", "customrss.xml"), true, "Recent content in Taxonomy Web on Hugo in English", "<rss")
}
func TestNodesWithTaxonomies(t *testing.T) {
testCommonResetState()
- writeLayoutsForNodeAsPageTests(t)
- writeRegularPagesForNodeAsPageTests(t)
+ fs := hugofs.NewMem()
+
+ viper.Set("paginate", 1)
+ viper.Set("title", "Hugo Rocks!")
- writeSource(t, filepath.Join("content", "_index.md"), `---
+ writeLayoutsForNodeAsPageTests(t, fs)
+ writeRegularPagesForNodeAsPageTests(t, fs)
+
+ writeSource(t, fs, filepath.Join("content", "_index.md"), `---
title: Home With Taxonomies
categories: [
- "Hugo",
+ "Hugo",
"Home"
]
---
`)
- viper.Set("paginate", 1)
- viper.Set("title", "Hugo Rocks!")
+ h, err := NewHugoSitesFromConfiguration(deps.DepsCfg{Fs: fs})
- s := NewSiteDefaultLang()
+ require.NoError(t, err)
- if err := buildAndRenderSite(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ require.NoError(t, h.Build(BuildCfg{}))
- assertFileContent(t, filepath.Join("public", "categories", "hugo", "index.html"), true, "Taxonomy Title: Hugo", "# Pages: 5")
- assertFileContent(t, filepath.Join("public", "categories", "home", "index.html"), true, "Taxonomy Title: Home", "# Pages: 1")
+ assertFileContent(t, fs, filepath.Join("public", "categories", "hugo", "index.html"), true, "Taxonomy Title: Hugo", "# Pages: 5")
+ assertFileContent(t, fs, filepath.Join("public", "categories", "home", "index.html"), true, "Taxonomy Title: Home", "# Pages: 1")
}
func TestNodesWithMenu(t *testing.T) {
testCommonResetState()
- writeLayoutsForNodeAsPageTests(t)
- writeRegularPagesForNodeAsPageTests(t)
+ viper.Set("paginate", 1)
+ viper.Set("title", "Hugo Rocks!")
+
+ fs := hugofs.NewMem()
- writeSource(t, filepath.Join("content", "_index.md"), `---
+ writeLayoutsForNodeAsPageTests(t, fs)
+ writeRegularPagesForNodeAsPageTests(t, fs)
+
+ writeSource(t, fs, filepath.Join("content", "_index.md"), `---
title: Home With Menu
menu:
mymenu:
---
`)
- writeSource(t, filepath.Join("content", "sect1", "_index.md"), `---
+ writeSource(t, fs, filepath.Join("content", "sect1", "_index.md"), `---
title: Sect1 With Menu
menu:
mymenu:
---
`)
- writeSource(t, filepath.Join("content", "categories", "hugo", "_index.md"), `---
+ writeSource(t, fs, filepath.Join("content", "categories", "hugo", "_index.md"), `---
title: Taxonomy With Menu
menu:
mymenu:
---
`)
- viper.Set("paginate", 1)
- viper.Set("title", "Hugo Rocks!")
+ h, err := NewHugoSitesFromConfiguration(deps.DepsCfg{Fs: fs})
- s := NewSiteDefaultLang()
+ require.NoError(t, err)
- if err := buildAndRenderSite(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ require.NoError(t, h.Build(BuildCfg{}))
- assertFileContent(t, filepath.Join("public", "index.html"), true, "Home With Menu", "Home Menu Item: Go Home!: /")
- assertFileContent(t, filepath.Join("public", "sect1", "index.html"), true, "Sect1 With Menu", "Section Menu Item: Go Sect1!: /sect1/")
- assertFileContent(t, filepath.Join("public", "categories", "hugo", "index.html"), true, "Taxonomy With Menu", "Taxonomy Menu Item: Go Tax Hugo!: /categories/hugo/")
+ assertFileContent(t, fs, filepath.Join("public", "index.html"), true, "Home With Menu", "Home Menu Item: Go Home!: /")
+ assertFileContent(t, fs, filepath.Join("public", "sect1", "index.html"), true, "Sect1 With Menu", "Section Menu Item: Go Sect1!: /sect1/")
+ assertFileContent(t, fs, filepath.Join("public", "categories", "hugo", "index.html"), true, "Taxonomy With Menu", "Taxonomy Menu Item: Go Tax Hugo!: /categories/hugo/")
}
func TestNodesWithAlias(t *testing.T) {
testCommonResetState()
- writeLayoutsForNodeAsPageTests(t)
- writeRegularPagesForNodeAsPageTests(t)
+ fs := hugofs.NewMem()
+
+ viper.Set("paginate", 1)
+ viper.Set("baseURL", "http://base/")
+ viper.Set("title", "Hugo Rocks!")
+
+ writeLayoutsForNodeAsPageTests(t, fs)
+ writeRegularPagesForNodeAsPageTests(t, fs)
- writeSource(t, filepath.Join("content", "_index.md"), `---
+ writeSource(t, fs, filepath.Join("content", "_index.md"), `---
title: Home With Alias
aliases:
- /my/new/home.html
---
`)
- viper.Set("paginate", 1)
- viper.Set("baseURL", "http://base/")
- viper.Set("title", "Hugo Rocks!")
+ h, err := NewHugoSitesFromConfiguration(deps.DepsCfg{Fs: fs})
- s := NewSiteDefaultLang()
+ require.NoError(t, err)
- if err := buildAndRenderSite(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ require.NoError(t, h.Build(BuildCfg{}))
- assertFileContent(t, filepath.Join("public", "index.html"), true, "Home With Alias")
- assertFileContent(t, filepath.Join("public", "my", "new", "home.html"), true, "content=\"0; url=http://base/")
+ assertFileContent(t, fs, filepath.Join("public", "index.html"), true, "Home With Alias")
+ assertFileContent(t, fs, filepath.Join("public", "my", "new", "home.html"), true, "content=\"0; url=http://base/")
}
func TestNodesWithSectionWithIndexPageOnly(t *testing.T) {
testCommonResetState()
- writeLayoutsForNodeAsPageTests(t)
+ fs := hugofs.NewMem()
- writeSource(t, filepath.Join("content", "sect", "_index.md"), `---
+ viper.Set("paginate", 1)
+ viper.Set("title", "Hugo Rocks!")
+
+ writeLayoutsForNodeAsPageTests(t, fs)
+
+ writeSource(t, fs, filepath.Join("content", "sect", "_index.md"), `---
title: MySection
---
My Section Content
`)
- viper.Set("paginate", 1)
- viper.Set("title", "Hugo Rocks!")
+ h, err := NewHugoSitesFromConfiguration(deps.DepsCfg{Fs: fs})
- s := NewSiteDefaultLang()
+ require.NoError(t, err)
- if err := buildAndRenderSite(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ require.NoError(t, h.Build(BuildCfg{}))
- assertFileContent(t, filepath.Join("public", "sect", "index.html"), true, "My Section")
+ assertFileContent(t, fs, filepath.Join("public", "sect", "index.html"), true, "My Section")
}
func TestNodesWithURLs(t *testing.T) {
testCommonResetState()
- writeLayoutsForNodeAsPageTests(t)
+ fs := hugofs.NewMem()
- writeRegularPagesForNodeAsPageTests(t)
+ viper.Set("paginate", 1)
+ viper.Set("title", "Hugo Rocks!")
+ viper.Set("baseURL", "http://bep.is/base/")
+
+ writeLayoutsForNodeAsPageTests(t, fs)
+ writeRegularPagesForNodeAsPageTests(t, fs)
- writeSource(t, filepath.Join("content", "sect", "_index.md"), `---
+ writeSource(t, fs, filepath.Join("content", "sect", "_index.md"), `---
title: MySection
url: foo.html
---
My Section Content
`)
- viper.Set("paginate", 1)
- viper.Set("title", "Hugo Rocks!")
- viper.Set("baseURL", "http://bep.is/base/")
+ h, err := NewHugoSitesFromConfiguration(deps.DepsCfg{Fs: fs})
- s := NewSiteDefaultLang()
+ require.NoError(t, err)
- if err := buildAndRenderSite(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ require.NoError(t, h.Build(BuildCfg{}))
+
+ assertFileContent(t, fs, filepath.Join("public", "sect", "index.html"), true, "My Section")
- assertFileContent(t, filepath.Join("public", "sect", "index.html"), true, "My Section")
+ s := h.Sites[0]
p := s.RegularPages[0]
}
-func writeRegularPagesForNodeAsPageTests(t *testing.T) {
- writeRegularPagesForNodeAsPageTestsWithLang(t, "")
+func writeRegularPagesForNodeAsPageTests(t *testing.T, fs *hugofs.Fs) {
+ writeRegularPagesForNodeAsPageTestsWithLang(t, fs, "")
}
-func writeRegularPagesForNodeAsPageTestsWithLang(t *testing.T, lang string) {
+func writeRegularPagesForNodeAsPageTestsWithLang(t *testing.T, fs *hugofs.Fs, lang string) {
var langStr string
if lang != "" {
}
date = date.Add(-24 * time.Duration(i) * time.Hour)
- writeSource(t, filepath.Join("content", sect, fmt.Sprintf("regular%d.%smd", i, langStr)), fmt.Sprintf(`---
+ writeSource(t, fs, filepath.Join("content", sect, fmt.Sprintf("regular%d.%smd", i, langStr)), fmt.Sprintf(`---
title: Page %02d
lastMod : %q
date : %q
}
}
-func writeNodePagesForNodeAsPageTests(lang string, t *testing.T) {
+func writeNodePagesForNodeAsPageTests(t *testing.T, fs *hugofs.Fs, lang string) {
filename := "_index.md"
date, _ := time.Parse(format, "2009-01-01")
- writeSource(t, filepath.Join("content", filename), fmt.Sprintf(`---
+ writeSource(t, fs, filepath.Join("content", filename), fmt.Sprintf(`---
title: Home Sweet Home!
date : %q
lastMod : %q
l-%s Home **Content!**
`, date.Add(1*24*time.Hour).Format(time.RFC822), date.Add(2*24*time.Hour).Format(time.RFC822), lang))
- writeSource(t, filepath.Join("content", "sect1", filename), fmt.Sprintf(`---
+ writeSource(t, fs, filepath.Join("content", "sect1", filename), fmt.Sprintf(`---
title: Section1
date : %q
lastMod : %q
---
Section1 **Content!**
`, date.Add(3*24*time.Hour).Format(time.RFC822), date.Add(4*24*time.Hour).Format(time.RFC822)))
- writeSource(t, filepath.Join("content", "sect2", filename), fmt.Sprintf(`---
+ writeSource(t, fs, filepath.Join("content", "sect2", filename), fmt.Sprintf(`---
title: Section2
date : %q
lastMod : %q
Section2 **Content!**
`, date.Add(5*24*time.Hour).Format(time.RFC822), date.Add(6*24*time.Hour).Format(time.RFC822)))
- writeSource(t, filepath.Join("content", "categories", "hugo", filename), fmt.Sprintf(`---
+ writeSource(t, fs, filepath.Join("content", "categories", "hugo", filename), fmt.Sprintf(`---
title: Taxonomy Hugo
date : %q
lastMod : %q
Taxonomy Hugo **Content!**
`, date.Add(7*24*time.Hour).Format(time.RFC822), date.Add(8*24*time.Hour).Format(time.RFC822)))
- writeSource(t, filepath.Join("content", "categories", "web", filename), fmt.Sprintf(`---
+ writeSource(t, fs, filepath.Join("content", "categories", "web", filename), fmt.Sprintf(`---
title: Taxonomy Web
date : %q
lastMod : %q
Taxonomy Web **Content!**
`, date.Add(9*24*time.Hour).Format(time.RFC822), date.Add(10*24*time.Hour).Format(time.RFC822)))
- writeSource(t, filepath.Join("content", "categories", "hugo-rocks", filename), fmt.Sprintf(`---
+ writeSource(t, fs, filepath.Join("content", "categories", "hugo-rocks", filename), fmt.Sprintf(`---
title: Taxonomy Hugo Rocks
date : %q
lastMod : %q
Taxonomy Hugo Rocks **Content!**
`, date.Add(11*24*time.Hour).Format(time.RFC822), date.Add(12*24*time.Hour).Format(time.RFC822)))
- writeSource(t, filepath.Join("content", "categories", filename), fmt.Sprintf(`---
+ writeSource(t, fs, filepath.Join("content", "categories", filename), fmt.Sprintf(`---
title: Taxonomy Term Categories
date : %q
lastMod : %q
}
-func writeLayoutsForNodeAsPageTests(t *testing.T) {
- writeSource(t, filepath.Join("layouts", "index.html"), `
+func writeLayoutsForNodeAsPageTests(t *testing.T, fs *hugofs.Fs) {
+ writeSource(t, fs, filepath.Join("layouts", "index.html"), `
Index Title: {{ .Title }}
Index Content: {{ .Content }}
# Pages: {{ len .Data.Pages }}
GetPage: {{ with .Site.GetPage "section" "sect1" }}{{ .Title }}{{ end }}
`)
- writeSource(t, filepath.Join("layouts", "_default", "single.html"), `
+ writeSource(t, fs, filepath.Join("layouts", "_default", "single.html"), `
Single Title: {{ .Title }}
Single Content: {{ .Content }}
Date: {{ .Date.Format "2006-01-02" }}
Lastmod: {{ .Lastmod.Format "2006-01-02" }}
`)
- writeSource(t, filepath.Join("layouts", "_default", "section.html"), `
+ writeSource(t, fs, filepath.Join("layouts", "_default", "section.html"), `
Section Title: {{ .Title }}
Section Content: {{ .Content }}
# Pages: {{ len .Data.Pages }}
`)
// Taxonomy lists
- writeSource(t, filepath.Join("layouts", "_default", "taxonomy.html"), `
+ writeSource(t, fs, filepath.Join("layouts", "_default", "taxonomy.html"), `
Taxonomy Title: {{ .Title }}
Taxonomy Content: {{ .Content }}
# Pages: {{ len .Data.Pages }}
`)
// Taxonomy terms
- writeSource(t, filepath.Join("layouts", "_default", "terms.html"), `
+ writeSource(t, fs, filepath.Join("layouts", "_default", "terms.html"), `
Taxonomy Terms Title: {{ .Title }}
Taxonomy Terms Content: {{ .Content }}
{{ range $key, $value := .Data.Terms }}
"github.com/spf13/cast"
bp "github.com/spf13/hugo/bufferpool"
- "github.com/spf13/hugo/hugofs"
"github.com/spf13/hugo/source"
"github.com/spf13/viper"
)
p.renderingConfig = helpers.NewBlackfriday(p.Language())
if err := mapstructure.Decode(pageParam, p.renderingConfig); err != nil {
- p.s.log.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())
}
})
sections: sectionsFromFilename(filename),
}
- s.log.DEBUG.Println("Reading from", page.File.Path())
+ s.Log.DEBUG.Println("Reading from", page.File.Path())
return &page
}
func (p *Page) ReadFrom(buf io.Reader) (int64, error) {
// Parse for metadata & body
if err := p.parse(buf); err != nil {
- p.s.log.ERROR.Print(err)
+ p.s.Log.ERROR.Print(err)
return 0, err
}
p.pageURLInit.Do(func() {
u, err := p.createPermalink()
if err != nil {
- p.s.log.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
}
if p.IsNode() {
// No permalink config for nodes (currently)
- pURL := strings.TrimSpace(p.Site.pathSpec.URLize(p.URLPath.URL))
+ pURL := strings.TrimSpace(p.s.PathSpec.URLize(p.URLPath.URL))
pURL = p.addLangPathPrefix(pURL)
- pURL = p.Site.pathSpec.URLPrep(pURL)
+ pURL = p.s.PathSpec.URLPrep(pURL)
url := helpers.MakePermalink(baseURL, pURL)
return url, nil
}
- dir := strings.TrimSpace(p.Site.pathSpec.MakePath(filepath.ToSlash(strings.ToLower(p.Source.Dir()))))
- pSlug := strings.TrimSpace(p.Site.pathSpec.URLize(p.Slug))
- pURL := strings.TrimSpace(p.Site.pathSpec.URLize(p.URLPath.URL))
+ dir := strings.TrimSpace(p.s.PathSpec.MakePath(filepath.ToSlash(strings.ToLower(p.Source.Dir()))))
+ pSlug := strings.TrimSpace(p.s.PathSpec.URLize(p.Slug))
+ pURL := strings.TrimSpace(p.s.PathSpec.URLize(p.URLPath.URL))
var permalink string
var err error
}
} else {
if len(pSlug) > 0 {
- permalink = p.Site.pathSpec.URLPrep(path.Join(dir, p.Slug+"."+p.Extension()))
+ permalink = p.s.PathSpec.URLPrep(path.Join(dir, p.Slug+"."+p.Extension()))
} else {
t := p.Source.TranslationBaseName()
- permalink = p.Site.pathSpec.URLPrep(path.Join(dir, (strings.TrimSpace(t) + "." + p.Extension())))
+ permalink = p.s.PathSpec.URLPrep(path.Join(dir, (strings.TrimSpace(t) + "." + p.Extension())))
}
}
case "date":
p.Date, err = cast.ToTimeE(v)
if err != nil {
- p.s.log.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 {
- p.s.log.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 {
- p.s.log.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 {
- p.s.log.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
- p.s.log.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
}
if p.Date.IsZero() && viper.GetBool("useModTimeAsFallback") {
- fi, err := hugofs.Source().Stat(filepath.Join(helpers.AbsPathify(viper.GetString("contentDir")), p.File.Path()))
+ fi, err := p.s.Fs.Source.Stat(filepath.Join(helpers.AbsPathify(viper.GetString("contentDir")), p.File.Path()))
if err == nil {
p.Date = fi.ModTime()
}
return v
}
- p.s.log.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 {
- p.s.log.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 {
- p.s.log.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 {
- p.s.log.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)
l = p.layouts()
}
- return p.s.tmpl.ExecuteTemplateToHTML(p, l...)
+ return p.s.Tmpl.ExecuteTemplateToHTML(p, l...)
}
func (p *Page) determineMarkupType() string {
meta, err := psr.Metadata()
if meta != nil {
if err != nil {
- p.s.log.ERROR.Printf("Error parsing page meta data for %s", p.File.Path())
- p.s.log.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)
}
- p.s.log.INFO.Println("creating", inpath)
+ p.s.Log.INFO.Println("creating", inpath)
if safe {
- err = helpers.SafeWriteToDisk(inpath, bytes.NewReader(by), hugofs.Source())
+ err = helpers.SafeWriteToDisk(inpath, bytes.NewReader(by), p.s.Fs.Source)
} else {
- err = helpers.WriteToDisk(inpath, bytes.NewReader(by), hugofs.Source())
+ err = helpers.WriteToDisk(inpath, bytes.NewReader(by), p.s.Fs.Source)
}
if err != nil {
return
}
return p.addLangFilepathPrefix(filepath.Join(strings.ToLower(
- p.Site.pathSpec.MakePath(p.Source.Dir())), strings.TrimSpace(outfile)))
+ p.s.PathSpec.MakePath(p.Source.Dir())), strings.TrimSpace(outfile)))
}
// Pre render prepare steps
var layouts []string
if !p.IsRenderable() {
self := "__" + p.TargetPath()
- _, err := p.Site.owner.tmpl.GetClone().New(self).Parse(string(p.Content))
+ _, err := p.Site.owner.Tmpl.GetClone().New(self).Parse(string(p.Content))
if err != nil {
return err
}
layouts = append(layouts, self)
} else {
layouts = append(layouts, p.layouts()...)
- layouts = append(layouts, "_default/single.html")
}
p.layoutsCalculated = layouts
}
if language == nil {
// It can be a file named stefano.chiodino.md.
- p.s.log.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
}
"github.com/spf13/viper"
)
-func TestPermalink(t *testing.T) {
+// TODO(bep) globals test siteinfo
+func _TestPermalink(t *testing.T) {
testCommonResetState()
tests := []struct {
"time"
"github.com/spf13/cast"
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/helpers"
+ "github.com/spf13/hugo/hugofs"
"github.com/spf13/viper"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
Hi.
`
-var pageTestSite = NewSiteDefaultLang()
+func init() {
+ testCommonResetState()
+ pageTestSite, _ = NewSiteDefaultLang()
+}
+
+var pageTestSite *Site
func checkError(t *testing.T, err error, expected string) {
if err == nil {
testCommonResetState()
+ fs := hugofs.NewMem()
+
if settings != nil {
for k, v := range settings {
viper.Set(k, v)
}
for i := 0; i < len(fileSourcePairs); i += 2 {
- writeSource(t, filepath.Join(contentDir, fileSourcePairs[i]), fileSourcePairs[i+1])
+ writeSource(t, fs, filepath.Join(contentDir, fileSourcePairs[i]), fileSourcePairs[i+1])
}
- s := NewSiteDefaultLang()
-
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
require.Len(t, s.RegularPages, len(pageSources))
// Issue #1076
func TestPageWithDelimiterForMarkdownThatCrossesBorder(t *testing.T) {
- s := newSiteFromSources("simple.md", simplePageWithSummaryDelimiterAndMarkdownThatCrossesBorder)
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ testCommonResetState()
+
+ fs := hugofs.NewMem()
+
+ writeSource(t, fs, filepath.Join("content", "simple.md"), simplePageWithSummaryDelimiterAndMarkdownThatCrossesBorder)
+
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
require.Len(t, s.RegularPages, 1)
// Issue #2601
func TestPageRawContent(t *testing.T) {
- s := newSiteFromSources("raw.md", `---
+ testCommonResetState()
+
+ fs := hugofs.NewMem()
+
+ writeSource(t, fs, filepath.Join("content", "raw.md"), `---
title: Raw
---
**Raw**`)
- writeSource(t, filepath.Join("layouts", "_default", "single.html"), `{{ .RawContent }}`)
+ writeSource(t, fs, filepath.Join("layouts", "_default", "single.html"), `{{ .RawContent }}`)
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
require.Len(t, s.RegularPages, 1)
p := s.RegularPages[0]
}
func TestPageWithAdditionalExtension(t *testing.T) {
- s := newSiteFromSources("simple.md", simplePageWithAdditionalExtension)
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ fs := hugofs.NewMem()
+
+ writeSource(t, fs, filepath.Join("content", "simple.md"), simplePageWithAdditionalExtension)
+
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{SkipRender: true})
require.Len(t, s.RegularPages, 1)
}
func TestTableOfContents(t *testing.T) {
- s := newSiteFromSources("tocpage.md", pageWithToC)
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ fs := hugofs.NewMem()
+
+ writeSource(t, fs, filepath.Join("content", "tocpage.md"), pageWithToC)
+
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{SkipRender: true})
require.Len(t, s.RegularPages, 1)
}
func TestPageWithDate(t *testing.T) {
- s := newSiteFromSources("simple.md", simplePageRFC3339Date)
+ fs := hugofs.NewMem()
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ writeSource(t, fs, filepath.Join("content", "simple.md"), simplePageRFC3339Date)
+
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{SkipRender: true})
require.Len(t, s.RegularPages, 1)
func TestChompBOM(t *testing.T) {
const utf8BOM = "\xef\xbb\xbf"
- s := newSiteFromSources("simple.md", utf8BOM+simplePage)
+ fs := hugofs.NewMem()
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ writeSource(t, fs, filepath.Join("content", "simple.md"), utf8BOM+simplePage)
+
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{SkipRender: true})
require.Len(t, s.RegularPages, 1)
return
}
- pagers, err := paginatePages(p.Data["Pages"], pagerSize, p.sections...)
+ pagers, err := paginatePages(p.s.PathSpec, p.Data["Pages"], pagerSize, p.sections...)
if err != nil {
initError = err
if p.paginator != nil {
return
}
- pagers, err := paginatePages(seq, pagerSize, p.sections...)
+ pagers, err := paginatePages(p.s.PathSpec, seq, pagerSize, p.sections...)
if err != nil {
initError = err
return pas, nil
}
-func paginatePages(seq interface{}, pagerSize int, sections ...string) (pagers, error) {
+func paginatePages(pathSpec *helpers.PathSpec, seq interface{}, pagerSize int, sections ...string) (pagers, error) {
if pagerSize <= 0 {
return nil, errors.New("'paginate' configuration setting must be positive to paginate")
}
- urlFactory := newPaginationURLFactory(sections...)
+ urlFactory := newPaginationURLFactory(pathSpec, sections...)
var paginator *paginator
return p, nil
}
-func newPaginationURLFactory(pathElements ...string) paginationURLFactory {
- pathSpec := helpers.CurrentPathSpec()
+func newPaginationURLFactory(pathSpec *helpers.PathSpec, pathElements ...string) paginationURLFactory {
basePath := path.Join(pathElements...)
"path/filepath"
"testing"
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/helpers"
+ "github.com/spf13/hugo/hugofs"
"github.com/spf13/hugo/source"
"github.com/spf13/viper"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
func TestSplitPages(t *testing.T) {
testCommonResetState()
viper.Set("paginatePath", "zoo")
- unicode := newPaginationURLFactory("новости проекта")
- fooBar := newPaginationURLFactory("foo", "bar")
+
+ pathSpec := newTestPathSpec()
+
+ unicode := newPaginationURLFactory(pathSpec, "новости проекта")
+ fooBar := newPaginationURLFactory(pathSpec, "foo", "bar")
assert.Equal(t, "/foo/bar/", fooBar(1))
assert.Equal(t, "/%D0%BD%D0%BE%D0%B2%D0%BE%D1%81%D1%82%D0%B8-%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B0/zoo/4/", unicode(4))
+
+ unicoded := unicode(4)
+ unicodedExpected := "/%D0%BD%D0%BE%D0%B2%D0%BE%D1%81%D1%82%D0%B8-%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B0/zoo/4/"
+
+ if unicoded != unicodedExpected {
+ t.Fatal("Expected\n", unicodedExpected, "\nGot\n", unicoded)
+ }
+
assert.Equal(t, "/foo/bar/zoo/12345/", fooBar(12345))
}
viper.Set("paginate", -1)
}
pages := createTestPages(12)
- s := NewSiteDefaultLang()
+ s, err := NewSiteDefaultLang()
+ require.NoError(t, err)
n1 := s.newHomePage()
n2 := s.newHomePage()
n1.Data["Pages"] = pages
var paginator1 *Pager
- var err error
if useViper {
paginator1, err = n1.Paginator()
testCommonResetState()
viper.Set("paginate", -1)
- s := NewSiteDefaultLang()
- _, err := s.newHomePage().Paginator()
- assert.NotNil(t, err)
+ s, err := NewSiteDefaultLang()
+ require.NoError(t, err)
+ _, err = s.newHomePage().Paginator()
+ require.Error(t, err)
}
func TestPaginate(t *testing.T) {
viper.Set("paginate", 2)
viper.Set("paginatePath", "testing")
+ fs := hugofs.NewMem()
+
for i := 0; i < 10; i++ {
// Issue #2177, do not double encode URLs
- writeSource(t, filepath.Join("content", "阅读", fmt.Sprintf("page%d.md", (i+1))),
+ writeSource(t, fs, filepath.Join("content", "阅读", fmt.Sprintf("page%d.md", (i+1))),
fmt.Sprintf(`---
title: Page%d
---
`, (i+1), i+1))
}
- writeSource(t, filepath.Join("layouts", "_default", "single.html"), "<html><body>{{.Content}}</body></html>")
- writeSource(t, filepath.Join("layouts", "_default", "list.html"),
+ writeSource(t, fs, filepath.Join("layouts", "_default", "single.html"), "<html><body>{{.Content}}</body></html>")
+ writeSource(t, fs, filepath.Join("layouts", "_default", "list.html"),
`
<html><body>
Count: {{ .Paginator.TotalNumberOfElements }}
{{ end }}
</body></html>`)
- if err := buildAndRenderSite(NewSiteDefaultLang()); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
- assertFileContent(t, filepath.Join("public", "阅读", "testing", "2", "index.html"), false, "2: /%E9%98%85%E8%AF%BB/testing/2/")
+ assertFileContent(t, fs, filepath.Join("public", "阅读", "testing", "2", "index.html"), false, "2: /%E9%98%85%E8%AF%BB/testing/2/")
}
}
pages := createTestPages(6)
- s := NewSiteDefaultLang()
+ s, err := NewSiteDefaultLang()
+ require.NoError(t, err)
n1 := s.newHomePage()
n2 := s.newHomePage()
var paginator1, paginator2 *Pager
- var err error
if useViper {
paginator1, err = n1.Paginate(pages)
}
func TestInvalidOptions(t *testing.T) {
- s := NewSiteDefaultLang()
+ s, err := NewSiteDefaultLang()
+ require.NoError(t, err)
n1 := s.newHomePage()
- _, err := n1.Paginate(createTestPages(1), 1, 2)
+ _, err = n1.Paginate(createTestPages(1), 1, 2)
assert.NotNil(t, err)
_, err = n1.Paginator(1, 2)
assert.NotNil(t, err)
testCommonResetState()
viper.Set("paginate", -1)
- s := NewSiteDefaultLang()
- _, err := s.newHomePage().Paginate(createTestPages(2))
+ s, err := NewSiteDefaultLang()
+ require.NoError(t, err)
+ _, err = s.newHomePage().Paginate(createTestPages(2))
assert.NotNil(t, err)
}
func TestPaginatePages(t *testing.T) {
groups, _ := createTestPages(31).GroupBy("Weight", "desc")
+ pathSpec := newTestPathSpec()
+
for i, seq := range []interface{}{createTestPages(11), groups, WeightedPages{}, PageGroup{}, &Pages{}} {
- v, err := paginatePages(seq, 11, "t")
+ v, err := paginatePages(pathSpec, seq, 11, "t")
assert.NotNil(t, v, "Val %d", i)
assert.Nil(t, err, "Err %d", i)
}
- _, err := paginatePages(Site{}, 11, "t")
+ _, err := paginatePages(pathSpec, Site{}, 11, "t")
assert.NotNil(t, err)
}
testCommonResetState()
viper.Set("paginate", 10)
- s := NewSiteDefaultLang()
+ s, err := NewSiteDefaultLang()
+ require.NoError(t, err)
n1 := s.newHomePage()
n2 := s.newHomePage()
- _, err := n1.Paginator()
+ _, err = n1.Paginator()
assert.Nil(t, err)
_, err = n1.Paginate(createTestPages(2))
assert.NotNil(t, err)
testCommonResetState()
viper.Set("paginate", 10)
- s := NewSiteDefaultLang()
+ s, err := NewSiteDefaultLang()
+ require.NoError(t, err)
n1 := s.newHomePage()
n2 := s.newHomePage()
p1 := createTestPages(2)
p2 := createTestPages(10)
- _, err := n1.Paginate(p1)
+ _, err = n1.Paginate(p1)
assert.Nil(t, err)
_, err = n1.Paginate(p1)
func pageToPermalinkTitle(p *Page, _ string) (string, error) {
// Page contains Node which has Title
// (also contains URLPath which has Slug, sometimes)
- return p.Site.pathSpec.URLize(p.Title), nil
+ return p.s.PathSpec.URLize(p.Title), nil
}
// pageToPermalinkFilename returns the URL-safe form of the filename
func pageToPermalinkFilename(p *Page, _ string) (string, error) {
//var extension = p.Source.Ext
//var name = p.Source.Path()[0 : len(p.Source.Path())-len(extension)]
- return p.Site.pathSpec.URLize(p.Source.TranslationBaseName()), nil
+ return p.s.PathSpec.URLize(p.Source.TranslationBaseName()), nil
}
// if the page has a slug, return the slug, else return the title
if strings.HasSuffix(p.Slug, "-") {
p.Slug = p.Slug[0 : len(p.Slug)-1]
}
- return p.Site.pathSpec.URLize(p.Slug), nil
+ return p.s.PathSpec.URLize(p.Slug), nil
}
return pageToPermalinkTitle(p, a)
}
package hugolib
import (
- "bytes"
+ "path/filepath"
"testing"
- "github.com/spf13/hugo/helpers"
"github.com/spf13/hugo/hugofs"
- "github.com/spf13/hugo/source"
+
+ "github.com/spf13/hugo/deps"
"github.com/spf13/viper"
)
func TestRobotsTXTOutput(t *testing.T) {
testCommonResetState()
- hugofs.InitMemFs()
-
viper.Set("baseURL", "http://auth/bub/")
viper.Set("enableRobotsTXT", true)
- s := &Site{
- Source: &source.InMemorySource{ByteSource: weightedSources},
- Language: helpers.NewDefaultLanguage(),
- }
+ fs := hugofs.NewMem()
- if err := buildAndRenderSite(s, "robots.txt", robotTxtTemplate); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ writeSource(t, fs, filepath.Join("layouts", "robots.txt"), robotTxtTemplate)
+ writeSourcesToSource(t, "content", fs, weightedSources...)
- robotsFile, err := hugofs.Destination().Open("public/robots.txt")
+ buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
- if err != nil {
- t.Fatalf("Unable to locate: robots.txt")
- }
+ assertFileContent(t, fs, "public/robots.txt", true, "User-agent: Googlebot")
- robots := helpers.ReaderToBytes(robotsFile)
- if !bytes.HasPrefix(robots, []byte("User-agent: Googlebot")) {
- t.Errorf("Robots file should start with 'User-agent: Googlebot'. %s", robots)
- }
}
"path/filepath"
"testing"
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/hugofs"
"github.com/spf13/viper"
)
viper.Set("rssURI", rssURI)
viper.Set("title", "RSSTest")
- for _, s := range weightedSources {
- writeSource(t, filepath.Join("content", "sect", s.Name), string(s.Content))
- }
+ fs := hugofs.NewMem()
- if err := buildAndRenderSite(NewSiteDefaultLang()); err != nil {
- t.Fatalf("Failed to build site: %s", err)
+ for _, src := range weightedSources {
+ writeSource(t, fs, filepath.Join("content", "sect", src.Name), string(src.Content))
}
+ buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
+
// Home RSS
- assertFileContent(t, filepath.Join("public", rssURI), true, "<?xml", "rss version", "RSSTest")
+ assertFileContent(t, fs, filepath.Join("public", rssURI), true, "<?xml", "rss version", "RSSTest")
// Section RSS
- assertFileContent(t, filepath.Join("public", "sect", rssURI), true, "<?xml", "rss version", "Sects on RSSTest")
+ assertFileContent(t, fs, filepath.Join("public", "sect", rssURI), true, "<?xml", "rss version", "Sects on RSSTest")
// Taxonomy RSS
- assertFileContent(t, filepath.Join("public", "categories", "hugo", rssURI), true, "<?xml", "rss version", "Hugo on RSSTest")
+ assertFileContent(t, fs, filepath.Join("public", "categories", "hugo", rssURI), true, "<?xml", "rss version", "Hugo on RSSTest")
}
bp "github.com/spf13/hugo/bufferpool"
"github.com/spf13/hugo/helpers"
- "github.com/spf13/hugo/tpl"
+ "github.com/spf13/hugo/tplapi"
)
// ShortcodeWithPage is the "." context in a shortcode template.
const innerCleanupExpand = "$1"
func renderShortcode(sc shortcode, parent *ShortcodeWithPage, p *Page) string {
- tmpl := getShortcodeTemplate(sc.name, p.s.tmpl)
+ tmpl := getShortcodeTemplate(sc.name, p.s.Tmpl)
if tmpl == nil {
- p.s.log.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)
default:
- p.s.log.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
- p.s.log.ERROR.Println(err.Error())
+ p.s.Log.ERROR.Println(err.Error())
}
// Save for reuse
sc.inner = append(sc.inner, currItem.val)
case tScName:
sc.name = currItem.val
- tmpl := getShortcodeTemplate(sc.name, p.s.tmpl)
+ tmpl := getShortcodeTemplate(sc.name, p.s.Tmpl)
if tmpl == nil {
return sc, fmt.Errorf("Unable to locate template for shortcode '%s' in page %s", sc.name, p.BaseFileName())
return source, nil
}
-func getShortcodeTemplate(name string, t tpl.Template) *template.Template {
+func getShortcodeTemplate(name string, t tplapi.Template) *template.Template {
if x := t.Lookup("shortcodes/" + name + ".html"); x != nil {
return x
}
err := tmpl.Execute(buffer, data)
isInnerShortcodeCache.RUnlock()
if err != nil {
- // TODO(bep) globals
- data.Page.s.log.ERROR.Println("error processing shortcode", tmpl.Name(), "\n ERR:", err)
- data.Page.s.log.WARN.Println(data)
+ data.Page.s.Log.ERROR.Println("error processing shortcode", tmpl.Name(), "\n ERR:", err)
+ data.Page.s.Log.WARN.Println(data)
}
return buffer.String()
}
"strings"
"testing"
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/helpers"
"github.com/spf13/hugo/hugofs"
"github.com/spf13/hugo/source"
- "github.com/spf13/hugo/target"
- "github.com/spf13/hugo/tpl"
+ "github.com/spf13/hugo/tplapi"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
)
// TODO(bep) remove
-func pageFromString(in, filename string, withTemplate ...func(templ tpl.Template) error) (*Page, error) {
+func pageFromString(in, filename string, withTemplate ...func(templ tplapi.Template) error) (*Page, error) {
s := pageTestSite
if len(withTemplate) > 0 {
// Have to create a new site
- s = NewSiteDefaultLang(withTemplate...)
+ var err error
+ s, err = NewSiteDefaultLang(withTemplate...)
+ if err != nil {
+ return nil, err
+ }
}
return s.NewPageFrom(strings.NewReader(in), filename)
}
-func CheckShortCodeMatch(t *testing.T, input, expected string, withTemplate func(templ tpl.Template) error) {
+func CheckShortCodeMatch(t *testing.T, input, expected string, withTemplate func(templ tplapi.Template) error) {
CheckShortCodeMatchAndError(t, input, expected, withTemplate, false)
}
-func CheckShortCodeMatchAndError(t *testing.T, input, expected string, withTemplate func(templ tpl.Template) error, expectError bool) {
+func CheckShortCodeMatchAndError(t *testing.T, input, expected string, withTemplate func(templ tplapi.Template) error, expectError bool) {
testCommonResetState()
+ fs := hugofs.NewMem()
+
// Need some front matter, see https://github.com/spf13/hugo/issues/2337
contentFile := `---
title: "Title"
---
` + input
- writeSource(t, "content/simple.md", contentFile)
+ writeSource(t, fs, "content/simple.md", contentFile)
- h, err := newHugoSitesDefaultLanguage()
+ h, err := NewHugoSitesFromConfiguration(deps.DepsCfg{Fs: fs, WithTemplate: withTemplate})
- if err != nil {
- t.Fatalf("Failed to create sites: %s", err)
- }
+ require.NoError(t, err)
+ require.Len(t, h.Sites, 1)
- cfg := BuildCfg{SkipRender: true, withTemplate: withTemplate}
-
- err = h.Build(cfg)
+ err = h.Build(BuildCfg{})
if err != nil && !expectError {
t.Fatalf("Shortcode rendered error %s.", err)
func TestShortcodeGoFuzzReports(t *testing.T) {
- p, _ := pageFromString(simplePage, "simple.md", func(templ tpl.Template) error {
+ p, _ := pageFromString(simplePage, "simple.md", func(templ tplapi.Template) error {
return templ.AddInternalShortcode("sc.html", `foo`)
})
// Issue #929
func TestHyphenatedSC(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("hyphenated-video.html", `Playing Video {{ .Get 0 }}`)
return nil
}
// Issue #1753
func TestNoTrailingNewline(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("a.html", `{{ .Get 0 }}`)
return nil
}
}
func TestPositionalParamSC(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("video.html", `Playing Video {{ .Get 0 }}`)
return nil
}
}
func TestPositionalParamIndexOutOfBounds(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("video.html", `Playing Video {{ .Get 1 }}`)
return nil
}
// some repro issues for panics in Go Fuzz testing
func TestNamedParamSC(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("img.html", `<img{{ with .Get "src" }} src="{{.}}"{{end}}{{with .Get "class"}} class="{{.}}"{{end}}>`)
return nil
}
// Issue #2294
func TestNestedNamedMissingParam(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("acc.html", `<div class="acc">{{ .Inner }}</div>`)
tem.AddInternalShortcode("div.html", `<div {{with .Get "class"}} class="{{ . }}"{{ end }}>{{ .Inner }}</div>`)
tem.AddInternalShortcode("div2.html", `<div {{with .Get 0}} class="{{ . }}"{{ end }}>{{ .Inner }}</div>`)
}
func TestIsNamedParamsSC(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("byposition.html", `<div id="{{ .Get 0 }}">`)
tem.AddInternalShortcode("byname.html", `<div id="{{ .Get "id" }}">`)
tem.AddInternalShortcode("ifnamedparams.html", `<div id="{{ if .IsNamedParams }}{{ .Get "id" }}{{ else }}{{ .Get 0 }}{{end}}">`)
}
func TestInnerSC(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("inside.html", `<div{{with .Get "class"}} class="{{.}}"{{end}}>{{ .Inner }}</div>`)
return nil
}
}
func TestInnerSCWithMarkdown(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("inside.html", `<div{{with .Get "class"}} class="{{.}}"{{end}}>{{ .Inner }}</div>`)
return nil
}
}
func TestInnerSCWithAndWithoutMarkdown(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("inside.html", `<div{{with .Get "class"}} class="{{.}}"{{end}}>{{ .Inner }}</div>`)
return nil
}
}
func TestNestedSC(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("scn1.html", `<div>Outer, inner is {{ .Inner }}</div>`)
tem.AddInternalShortcode("scn2.html", `<div>SC2</div>`)
return nil
}
func TestNestedComplexSC(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("row.html", `-row-{{ .Inner}}-rowStop-`)
tem.AddInternalShortcode("column.html", `-col-{{.Inner }}-colStop-`)
tem.AddInternalShortcode("aside.html", `-aside-{{ .Inner }}-asideStop-`)
}
func TestParentShortcode(t *testing.T) {
- wt := func(tem tpl.Template) error {
+ wt := func(tem tplapi.Template) error {
tem.AddInternalShortcode("r1.html", `1: {{ .Get "pr1" }} {{ .Inner }}`)
tem.AddInternalShortcode("r2.html", `2: {{ .Parent.Get "pr1" }}{{ .Get "pr2" }} {{ .Inner }}`)
tem.AddInternalShortcode("r3.html", `3: {{ .Parent.Parent.Get "pr1" }}{{ .Parent.Get "pr2" }}{{ .Get "pr3" }} {{ .Inner }}`)
fmt.Sprintf("Hello %sworld%s. And that's it.", testScPlaceholderRegexp, testScPlaceholderRegexp), ""},
} {
- p, _ := pageFromString(simplePage, "simple.md", func(templ tpl.Template) error {
+ p, _ := pageFromString(simplePage, "simple.md", func(templ tplapi.Template) error {
templ.AddInternalShortcode("tag.html", `tag`)
templ.AddInternalShortcode("sc1.html", `sc1`)
templ.AddInternalShortcode("sc2.html", `sc2`)
expected string
}{
{"sect/doc1.md", `a{{< b >}}c`,
- filepath.FromSlash("sect/doc1/index.html"), "<p>abc</p>\n"},
+ filepath.FromSlash("
public/sect/doc1/index.html"), "<p>abc</p>\n"},
// Issue #1642: Multiple shortcodes wrapped in P
// Deliberately forced to pass even if they maybe shouldn't.
{"sect/doc2.md", `a
{{< d >}}
e`,
- filepath.FromSlash("sect/doc2/index.html"),
+ filepath.FromSlash("public/sect/doc2/index.html"),
"<p>a</p>\n\n<p>b<br />\nc\nd</p>\n\n<p>e</p>\n"},
{"sect/doc3.md", `a
{{< d >}}
e`,
- filepath.FromSlash("sect/doc3/index.html"),
+ filepath.FromSlash("public/sect/doc3/index.html"),
"<p>a</p>\n\n<p>b<br />\nc</p>\n\nd\n\n<p>e</p>\n"},
{"sect/doc4.md", `a
{{< b >}}
`,
- filepath.FromSlash("sect/doc4/index.html"),
+ filepath.FromSlash("public/sect/doc4/index.html"),
"<p>a\nb\nb\nb\nb\nb</p>\n"},
// #2192 #2209: Shortcodes in markdown headers
{"sect/doc5.md", `# {{< b >}}
## {{% c %}}`,
- filepath.FromSlash("sect/doc5/index.html"), "\n\n<h1 id=\"hahahugoshortcode-1hbhb\">b</h1>\n\n<h2 id=\"hahahugoshortcode-2hbhb\">c</h2>\n"},
+ filepath.FromSlash("public/sect/doc5/index.html"), "\n\n<h1 id=\"hahahugoshortcode-1hbhb\">b</h1>\n\n<h2 id=\"hahahugoshortcode-2hbhb\">c</h2>\n"},
// #2223 pygments
{"sect/doc6.md", "\n```bash\nb: {{< b >}} c: {{% c %}}\n```\n",
- filepath.FromSlash("sect/doc6/index.html"),
+ filepath.FromSlash("public/sect/doc6/index.html"),
"b: b c: c\n</code></pre></div>\n"},
// #2249
{"sect/doc7.ad", `_Shortcodes:_ *b: {{< b >}} c: {{% c %}}*`,
- filepath.FromSlash("sect/doc7/index.html"),
+ filepath.FromSlash("public/sect/doc7/index.html"),
"<div class=\"paragraph\">\n<p><em>Shortcodes:</em> <strong>b: b c: c</strong></p>\n</div>\n"},
{"sect/doc8.rst", `**Shortcodes:** *b: {{< b >}} c: {{% c %}}*`,
- filepath.FromSlash("sect/doc8/index.html"),
+ filepath.FromSlash("public/sect/doc8/index.html"),
"<div class=\"document\">\n\n\n<p><strong>Shortcodes:</strong> <em>b: b c: c</em></p>\n</div>"},
{"sect/doc9.mmark", `
---
parent: 'parent'
---
**Shortcodes:** *b: {{< b >}} c: {{% c %}}*`,
- filepath.FromSlash("sect/doc9/index.html"),
+ filepath.FromSlash("public/sect/doc9/index.html"),
"<p><strong>Shortcodes:</strong> <em>b: b c: c</em></p>\n"},
// Issue #1229: Menus not available in shortcode.
{"sect/doc10.md", `---
- Menu
---
**Menus:** {{< menu >}}`,
- filepath.FromSlash("sect/doc10/index.html"),
+ filepath.FromSlash("public/sect/doc10/index.html"),
"<p><strong>Menus:</strong> 1</p>\n"},
// Issue #2323: Taxonomies not available in shortcode.
{"sect/doc11.md", `---
- Bugs
---
**Tags:** {{< tags >}}`,
- filepath.FromSlash("sect/doc11/index.html"),
+ filepath.FromSlash("public/sect/doc11/index.html"),
"<p><strong>Tags:</strong> 2</p>\n"},
}
sources[i] = source.ByteSource{Name: filepath.FromSlash(test.contentPath), Content: []byte(test.content)}
}
- s := &Site{
- Source: &source.InMemorySource{ByteSource: sources},
- targets: targetList{page: &target.PagePub{UglyURLs: false}},
- Language: helpers.NewDefaultLanguage(),
- }
-
- addTemplates := func(templ tpl.Template) error {
+ addTemplates := func(templ tplapi.Template) error {
templ.AddTemplate("_default/single.html", "{{.Content}}")
templ.AddInternalShortcode("b.html", `b`)
}
- sites, err := newHugoSites(DepsCfg{}, s)
+ fs := hugofs.NewMem()
- if err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ writeSourcesToSource(t, "content", fs, sources...)
- if err = sites.Build(BuildCfg{withTemplate: addTemplates}); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ buildSingleSite(t, deps.DepsCfg{WithTemplate: addTemplates, Fs: fs}, BuildCfg{})
for _, test := range tests {
if strings.HasSuffix(test.contentPath, ".ad") && !helpers.HasAsciidoc() {
continue
}
- file, err := hugofs.Destination().Open(test.outFile)
-
- if err != nil {
- t.Fatalf("Did not find %s in target: %s", test.outFile, err)
- }
-
- content := helpers.ReaderToString(file)
-
- if !strings.Contains(content, test.expected) {
- t.Fatalf("%s content expected:\n%q\ngot:\n%q", test.outFile, test.expected, content)
- }
+ assertFileContent(t, fs, test.outFile, true, test.expected)
}
}
"github.com/spf13/afero"
"github.com/spf13/cast"
bp "github.com/spf13/hugo/bufferpool"
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/helpers"
"github.com/spf13/hugo/hugofs"
"github.com/spf13/hugo/parser"
"github.com/spf13/hugo/source"
"github.com/spf13/hugo/target"
"github.com/spf13/hugo/tpl"
+ "github.com/spf13/hugo/tplapi"
"github.com/spf13/hugo/transform"
"github.com/spf13/nitro"
"github.com/spf13/viper"
Language *helpers.Language
// Logger etc.
- *deps
+ *deps.Deps `json:"-"`
}
// reset returns a new Site prepared for rebuild.
func (s *Site) reset() *Site {
- return &Site{deps: s.deps, Language: s.Language, owner: s.owner, PageCollections: newPageCollections()}
+ return &Site{Deps: s.Deps, owner: s.owner, PageCollections: newPageCollections()}
}
-// newSite creates a new site in the given language.
-func newSite(lang *helpers.Language, deps *deps, withTemplate ...func(templ tpl.Template) error) *Site {
+// newSite creates a new site with the given configuration.
+func newSite(cfg deps.DepsCfg) (*Site, error) {
c := newPageCollections()
- // TODO(bep) globals
- viper.Set("currentContentLanguage", lang)
- if deps == nil {
- depsCfg := DepsCfg{WithTemplate: withTemplate}
- deps = newDeps(depsCfg)
+ if cfg.Language == nil {
+ cfg.Language = helpers.NewDefaultLanguage()
}
- return &Site{deps: deps, Language: lang, PageCollections: c, Info: newSiteInfo(siteBuilderCfg{pageCollections: c, language: lang})}
+ s := &Site{PageCollections: c, Language: cfg.Language}
-}
+ s.Info = newSiteInfo(siteBuilderCfg{s: s, pageCollections: c, language: s.Language})
+ return s, nil
-// NewSiteDefaultLang creates a new site in the default language.
-func NewSiteDefaultLang(withTemplate ...func(templ tpl.Template) error) *Site {
- return newSite(helpers.NewDefaultLanguage(), nil, withTemplate...)
}
-// Convenience func used in tests.
-func newSiteFromSources(pathContentPairs ...string) *Site {
- if len(pathContentPairs)%2 != 0 {
- panic("pathContentPairs must come in pairs")
+// NewSite creates a new site with the given dependency configuration.
+// The site will have a template system loaded and ready to use.
+// Note: This is mainly used in single site tests.
+func NewSite(cfg deps.DepsCfg) (*Site, error) {
+ s, err := newSite(cfg)
+
+ if err != nil {
+ return nil, err
}
- sources := make([]source.ByteSource, 0)
+ if err := applyDepsIfNeeded(cfg, s); err != nil {
+ return nil, err
+ }
+
+ return s, nil
+}
+
+// NewSiteDefaultLang creates a new site in the default language.
+// The site will have a template system loaded and ready to use.
+// Note: This is mainly used in single site tests.
+func NewSiteDefaultLang(withTemplate ...func(templ tplapi.Template) error) (*Site, error) {
+ return newSiteForLang(helpers.NewDefaultLanguage(), withTemplate...)
+}
+
+// NewSiteDefaultLang creates a new site in the default language.
+// The site will have a template system loaded and ready to use.
+// Note: This is mainly used in single site tests.
+func NewEnglishSite(withTemplate ...func(templ tplapi.Template) error) (*Site, error) {
+ return newSiteForLang(helpers.NewLanguage("en"), withTemplate...)
+}
- for i := 0; i < len(pathContentPairs); i += 2 {
- path := pathContentPairs[i]
- content := pathContentPairs[i+1]
- sources = append(sources, source.ByteSource{Name: filepath.FromSlash(path), Content: []byte(content)})
+// NewSiteDefaultLang creates a new site in the default language.
+func newSiteForLang(lang *helpers.Language, withTemplate ...func(templ tplapi.Template) error) (*Site, error) {
+ withTemplates := func(templ tplapi.Template) error {
+ for _, wt := range withTemplate {
+ if err := wt(templ); err != nil {
+ return err
+ }
+ }
+ return nil
}
+ cfg := deps.DepsCfg{WithTemplate: withTemplates, Language: lang}
+ s, err := newSite(cfg)
- lang := helpers.NewDefaultLanguage()
+ if err != nil {
+ return nil, err
+ }
- return &Site{
- deps: newDeps(DepsCfg{}),
- PageCollections: newPageCollections(),
- Source: &source.InMemorySource{ByteSource: sources},
- Language: lang,
- Info: newSiteInfo(siteBuilderCfg{language: lang}),
+ if err := applyDepsIfNeeded(cfg, s); err != nil {
+ return nil, err
}
+ return s, nil
}
type targetList struct {
Data *map[string]interface{}
owner *HugoSites
+ s *Site
multilingual *Multilingual
Language *helpers.Language
LanguagePrefix string
Languages helpers.Languages
defaultContentLanguageInSubdir bool
sectionPagesMenu string
-
- pathSpec *helpers.PathSpec
}
func (s *SiteInfo) String() string {
// Used in tests.
type siteBuilderCfg struct {
- language *helpers.Language
+ language *helpers.Language
+ // TOD(bep) globals fs
+ s *Site
+ fs *hugofs.Fs
pageCollections *PageCollections
baseURL string
}
+// TODO(bep) globals get rid of this
func newSiteInfo(cfg siteBuilderCfg) SiteInfo {
return SiteInfo{
+ s: cfg.s,
BaseURL: template.URL(cfg.baseURL),
- pathSpec: helpers.NewPathSpecFromConfig(cfg.language),
multilingual: newMultiLingualForLanguage(cfg.language),
PageCollections: cfg.pageCollections,
}
// It returns whetever the content source was changed.
func (s *Site) reProcess(events []fsnotify.Event) (whatChanged, error) {
- s.log.DEBUG.Printf("Rebuild for events %q", events)
+ s.Log.DEBUG.Printf("Rebuild for events %q", events)
s.timerStep("initialize rebuild")
}
if len(tmplChanged) > 0 {
- s.prepTemplates(nil)
- s.owner.tmpl.PrintErrors()
+ sites := s.owner.Sites
+ first := sites[0]
+
+ // TOD(bep) globals clean
+ if err := first.Deps.LoadTemplates(); err != nil {
+ s.Log.ERROR.Println(err)
+ }
+
+ s.Tmpl.PrintErrors()
+
+ for i := 1; i < len(sites); i++ {
+ site := sites[i]
+ var err error
+ site.Deps, err = first.Deps.ForLanguage(site.Language)
+ if err != nil {
+ return whatChanged{}, err
+ }
+ }
+
s.timerStep("template prep")
}
if len(i18nChanged) > 0 {
if err := s.readI18nSources(); err != nil {
- s.log.ERROR.Println(err)
+ s.Log.ERROR.Println(err)
}
}
// it's been updated
if ev.Op&fsnotify.Rename == fsnotify.Rename {
// If the file is still on disk, it's only been updated, if it's not, it's been moved
- if ex, err := afero.Exists(hugofs.Source(), ev.Name); !ex || err != nil {
+ if ex, err := afero.Exists(s.Fs.Source, ev.Name); !ex || err != nil {
path, _ := helpers.GetRelativePath(ev.Name, s.getContentDir(ev.Name))
s.removePageByPath(path)
continue
file, err := s.reReadFile(ev.Name)
if err != nil {
- s.log.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 {
- s.log.ERROR.Println(err)
+ s.Log.ERROR.Println(err)
}
}
}
-func (s *Site) prepTemplates(withTemplate func(templ tpl.Template) error) error {
-
- wt := func(tmpl tpl.Template) error {
- // TODO(bep) global error handling
- tmpl.LoadTemplates(s.absLayoutDir())
- if s.hasTheme() {
- tmpl.LoadTemplatesWithPrefix(s.absThemeDir()+"/layouts", "theme")
- }
- if withTemplate != nil {
- if err := withTemplate(tmpl); err != nil {
- return err
- }
- }
- return nil
- }
-
- s.refreshTemplates(wt)
-
- return nil
-}
-
func (s *Site) loadData(sources []source.Input) (err error) {
- s.log.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 {
// 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
- s.log.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
}
case "toml":
return parser.HandleTOMLMetaData(f.Bytes())
default:
- s.log.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
}
}
func (s *Site) readI18nSources() error {
- i18nSources := []source.Input{&source.Filesystem{Base: s.absI18nDir()}}
+ i18nSources := []source.Input{source.NewFilesystem(s.Fs, s.absI18nDir())}
- themeI18nDir, err := helpers.GetThemeI18nDirPath()
+ themeI18nDir, err := s.PathSpec.GetThemeI18nDirPath()
if err == nil {
- i18nSources = []source.Input{&source.Filesystem{Base: themeI18nDir}, i18nSources[0]}
+ i18nSources = []source.Input{source.NewFilesystem(s.Fs, themeI18nDir), i18nSources[0]}
}
- if err = loadI18n(i18nSources); err != nil {
+ if err = s.loadI18n(i18nSources); err != nil {
return err
}
func (s *Site) readDataFromSourceFS() error {
dataSources := make([]source.Input, 0, 2)
- dataSources = append(dataSources, &source.Filesystem{Base: s.absDataDir()})
+ dataSources = append(dataSources, source.NewFilesystem(s.Fs, s.absDataDir()))
// have to be last - duplicate keys in earlier entries will win
- themeDataDir, err := helpers.GetThemeDataDirPath()
+ themeDataDir, err := s.PathSpec.GetThemeDataDirPath()
if err == nil {
- dataSources = append(dataSources, &source.Filesystem{Base: themeDataDir})
+ dataSources = append(dataSources, source.NewFilesystem(s.Fs, themeDataDir))
}
err = s.loadData(dataSources)
if err = s.initialize(); err != nil {
return
}
-
- s.prepTemplates(config.withTemplate)
- s.owner.tmpl.PrintErrors()
- s.timerStep("initialize & template prep")
+ s.timerStep("initialize")
if err = s.readDataFromSourceFS(); err != nil {
return
viper.Set("currentContentLanguage", s.Language)
// Cache the current config.
helpers.InitConfigProviderForCurrentContentLanguage()
- s.Info.pathSpec = helpers.CurrentPathSpec()
return tpl.SetTranslateLang(s.Language)
}
// May be supplied in tests.
if s.Source != nil && len(s.Source.Files()) > 0 {
- s.log.DEBUG.Println("initialize: Source is already set")
+ s.Log.DEBUG.Println("initialize: Source is already set")
return
}
staticDir := helpers.AbsPathify(viper.GetString("staticDir") + "/")
- s.Source = &source.Filesystem{
- AvoidPaths: []string{staticDir},
- Base: s.absContentDir(),
- }
+ s.Source = source.NewFilesystem(s.Fs, s.absContentDir(), staticDir)
return
}
if s.IsMultiLingual() {
base = s.Language.Lang
}
- return s.pathSpec.AbsURL(base, false)
+ return s.owner.AbsURL(base, false)
}
// SitemapAbsURL is a convenience method giving the absolute URL to the sitemap.
Permalinks: permalinks,
Data: &s.Data,
owner: s.owner,
- pathSpec: helpers.NewPathSpecFromConfig(lang),
+ s: s,
}
s.Info.RSSLink = s.Info.permalinkStr(lang.GetString("rssURI"))
return base
}
- realDir, err := helpers.GetRealPath(hugofs.Source(), base)
+ realDir, err := helpers.GetRealPath(s.Fs.Source, base)
if err != nil {
if !os.IsNotExist(err) {
- s.log.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 ""
}
}
func (s *Site) checkDirectories() (err error) {
- if b, _ := helpers.DirExists(s.absContentDir(), hugofs.Source()); !b {
+ if b, _ := helpers.DirExists(s.absContentDir(), s.Fs.Source); !b {
return errors.New("No source directory found, expecting to find it at " + s.absContentDir())
}
return
// reReadFile resets file to be read from disk again
func (s *Site) reReadFile(absFilePath string) (*source.File, error) {
- s.log.INFO.Println("rereading", absFilePath)
+ s.Log.INFO.Println("rereading", absFilePath)
var file *source.File
- reader, err := source.NewLazyFileReader(hugofs.Source(), absFilePath)
+ reader, err := source.NewLazyFileReader(s.Fs.Source, absFilePath)
if err != nil {
return nil, err
}
panic(fmt.Sprintf("s.Source not set %s", s.absContentDir()))
}
- s.log.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 {
- s.log.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 {
- s.log.ERROR.Printf("unable to process menus in site config\n")
- s.log.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 {
- s.log.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 {
- s.log.ERROR.Printf("unable to process menus in site config\n")
- s.log.ERROR.Println(err)
+ s.Log.ERROR.Printf("unable to process menus in site config\n")
+ s.Log.ERROR.Println(err)
}
menuEntry.marshallMap(ime)
}
// make it match the nodes
menuEntryURL := in
- menuEntryURL = helpers.SanitizeURLKeepTrailingSlash(s.pathSpec.URLize(menuEntryURL))
+ menuEntryURL = helpers.SanitizeURLKeepTrailingSlash(s.s.PathSpec.URLize(menuEntryURL))
if !s.canonifyURLs {
menuEntryURL = helpers.AddContextRoot(string(s.BaseURL), menuEntryURL)
}
for name, me := range p.Menus() {
if _, ok := flat[twoD{name, me.KeyName()}]; ok {
- 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())
+ 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
}
}
+func (s *Site) getTaxonomyKey(key string) string {
+ if s.Info.preserveTaxonomyNames {
+ // Keep as is
+ return key
+ }
+ return s.PathSpec.MakePathSanitized(key)
+}
func (s *Site) assembleTaxonomies() {
s.Taxonomies = make(TaxonomyList)
s.taxonomiesPluralSingular = make(map[string]string)
taxonomies := s.Language.GetStringMapString("taxonomies")
- s.log.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)
if v, ok := vals.([]string); ok {
for _, idx := range v {
x := WeightedPage{weight.(int), p}
- s.Taxonomies[plural].add(idx, x, s.Info.preserveTaxonomyNames)
+ s.Taxonomies[plural].add(s.getTaxonomyKey(idx), x)
if s.Info.preserveTaxonomyNames {
// Need to track the original
- s.taxonomiesOrigKey[fmt.Sprintf("%s-%s", plural, kp(idx))] = idx
+ s.taxonomiesOrigKey[fmt.Sprintf("%s-%s", plural, s.PathSpec.MakePathSanitized(idx))] = idx
}
}
} else if v, ok := vals.(string); ok {
x := WeightedPage{weight.(int), p}
- s.Taxonomies[plural].add(v, x, s.Info.preserveTaxonomyNames)
+ s.Taxonomies[plural].add(s.getTaxonomyKey(v), x)
if s.Info.preserveTaxonomyNames {
// Need to track the original
- s.taxonomiesOrigKey[fmt.Sprintf("%s-%s", plural, kp(v))] = v
+ s.taxonomiesOrigKey[fmt.Sprintf("%s-%s", plural, s.PathSpec.MakePathSanitized(v))] = v
}
} else {
- s.log.ERROR.Printf("Invalid %s in %s\n", plural, p.File.Path())
+ s.Log.ERROR.Printf("Invalid %s in %s\n", plural, p.File.Path())
}
}
}
sectionPages := s.findPagesByKind(KindSection)
for i, p := range regularPages {
- s.Sections.add(p.Section(), WeightedPage{regularPages[i].Weight, regularPages[i]}, s.Info.preserveTaxonomyNames)
+ s.Sections.add(s.getTaxonomyKey(p.Section()), WeightedPage{regularPages[i].Weight, regularPages[i]})
}
// Add sections without regular pages, but with a content page
// Stats prints Hugo builds stats to the console.
// This is what you see after a successful hugo build.
func (s *Site) Stats() {
- 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)
+ 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 {
- s.log.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 *SiteInfo) permalinkStr(plink string) string {
return helpers.MakePermalink(
viper.GetString("baseURL"),
- s.pathSpec.URLizeAndPrep(plink)).String()
+ s.s.PathSpec.URLizeAndPrep(plink)).String()
}
func (s *Site) renderAndWriteXML(name string, dest string, d interface{}, layouts ...string) error {
- s.log.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 {
- s.log.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 {
- s.log.WARN.Printf("Unable to locate layout for %s: %s\n", name, layouts)
+ s.Log.WARN.Printf("[%s] Unable to locate layout for %s: %s\n", s.Language.Lang, name, layouts)
+
return nil
}
func (s *Site) findFirstLayout(layouts ...string) (string, bool) {
for _, layout := range layouts {
- if s.owner.tmpl.Lookup(layout) != nil {
+ if s.Tmpl.Lookup(layout) != nil {
return layout, true
}
}
func (s *Site) renderThing(d interface{}, layout string, w io.Writer) error {
// If the template doesn't exist, then return, but leave the Writer open
- if templ := s.owner.tmpl.Lookup(layout); templ != nil {
+ if templ := s.Tmpl.Lookup(layout); templ != nil {
return templ.Execute(w, d)
}
return fmt.Errorf("Layout not found: %s", layout)
}
func (s *Site) initTargetList() {
+ if s.Fs == nil {
+ panic("Must have Fs")
+ }
s.targetListInit.Do(func() {
langDir := ""
if s.Language.Lang != s.Info.multilingual.DefaultLang.Lang || s.Info.defaultContentLanguageInSubdir {
}
if s.targets.page == nil {
s.targets.page = &target.PagePub{
+ Fs: s.Fs,
PublishDir: s.absPublishDir(),
UglyURLs: viper.GetBool("uglyURLs"),
LangDir: langDir,
}
if s.targets.pageUgly == nil {
s.targets.pageUgly = &target.PagePub{
+ Fs: s.Fs,
PublishDir: s.absPublishDir(),
UglyURLs: true,
LangDir: langDir,
}
if s.targets.file == nil {
s.targets.file = &target.Filesystem{
+ Fs: s.Fs,
PublishDir: s.absPublishDir(),
}
}
if s.targets.alias == nil {
s.targets.alias = &target.HTMLRedirectAlias{
+ Fs: s.Fs,
PublishDir: s.absPublishDir(),
- Templates: s.owner.tmpl.Lookup("alias.html"),
+ Templates: s.Tmpl.Lookup("alias.html"),
}
}
if s.targets.languageAlias == nil {
s.targets.languageAlias = &target.HTMLRedirectAlias{
+ Fs: s.Fs,
PublishDir: s.absPublishDir(),
AllowRoot: true,
}
}
func (s *Site) writeDestFile(path string, reader io.Reader) (err error) {
- s.log.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) {
- s.log.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 {
- s.log.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)
}
- s.log.DEBUG.Println("creating alias:", path, "redirecting to", permalink)
+ s.Log.DEBUG.Println("creating alias:", path, "redirecting to", permalink)
return aliasPublisher.Publish(path, permalink, p)
}
}
func (s *Site) setPageURLs(p *Page, in string) {
- p.URLPath.URL = s.Info.pathSpec.URLizeAndPrep(in)
+ p.URLPath.URL = s.PathSpec.URLizeAndPrep(in)
p.URLPath.Permalink = s.Info.permalink(p.URLPath.URL)
p.RSSLink = template.HTML(s.Info.permalink(in + ".xml"))
}
p.sections = []string{plural, key}
if s.Info.preserveTaxonomyNames {
- key = s.Info.pathSpec.MakePathSanitized(key)
+ key = s.PathSpec.MakePathSanitized(key)
}
if s.Info.preserveTaxonomyNames {
import (
"encoding/json"
"testing"
+
+ "path/filepath"
+
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/hugofs"
)
// Issue #1123
// May be smart to run with: -timeout 4000ms
func TestEncodePage(t *testing.T) {
+ fs := hugofs.NewMem()
+
// borrowed from menu_test.go
- s := createTestSite(menuPageSources)
- testSiteSetup(s, t)
+ for _, src := range menuPageSources {
+ writeSource(t, fs, filepath.Join("content", src.Name), string(src.Content))
+
+ }
+
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
_, err := json.Marshal(s)
check(t, err)
for p := range pages {
targetPath := p.TargetPath()
layouts := p.layouts()
- s.log.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 {
- s.log.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
if s.owner.multilingual.enabled() {
mainLang := s.owner.multilingual.DefaultLang.Lang
if s.Info.defaultContentLanguageInSubdir {
- mainLangURL := s.Info.pathSpec.AbsURL(mainLang, false)
- s.log.DEBUG.Printf("Write redirect to main language %s: %s", mainLang, mainLangURL)
+ mainLangURL := s.PathSpec.AbsURL(mainLang, false)
+ 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)
- s.log.DEBUG.Printf("Write redirect to main language %s: %s", mainLang, mainLangURL)
+ mainLangURL := s.PathSpec.AbsURL("", false)
+ 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
}
"path/filepath"
"strings"
"testing"
- "time"
"github.com/bep/inflect"
jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/hugo/helpers"
- "github.com/spf13/hugo/hugofs"
"github.com/spf13/hugo/source"
- "github.com/spf13/hugo/target"
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/hugofs"
"github.com/spf13/viper"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
testMode = true
}
-// Issue #1797
-func TestReadPagesFromSourceWithEmptySource(t *testing.T) {
- testCommonResetState()
-
- viper.Set("defaultExtension", "html")
- viper.Set("verbose", true)
- viper.Set("baseURL", "http://auth/bub")
-
- sources := []source.ByteSource{}
-
- s := &Site{
- deps: newDeps(DepsCfg{}),
- Source: &source.InMemorySource{ByteSource: sources},
- targets: targetList{page: &target.PagePub{UglyURLs: true}},
- }
-
- var err error
- d := time.Second * 2
- ticker := time.NewTicker(d)
- select {
- case err = <-s.readPagesFromSource():
- break
- case <-ticker.C:
- err = fmt.Errorf("ReadPagesFromSource() never returns in %s", d.String())
- }
- ticker.Stop()
- if err != nil {
- t.Fatalf("Unable to read source: %s", err)
- }
-}
-
func pageMust(p *Page, err error) *Page {
if err != nil {
panic(err)
}
func TestDegenerateRenderThingMissingTemplate(t *testing.T) {
- s := newSiteFromSources("content/a/file.md", pageSimpleTitle)
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ fs := hugofs.NewMem()
+
+ writeSource(t, fs, filepath.Join("content", "a", "file.md"), pageSimpleTitle)
+
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
require.Len(t, s.RegularPages, 1)
func TestRenderWithInvalidTemplate(t *testing.T) {
- s := NewSiteDefaultLang()
- if err := buildAndRenderSite(s, "missing", templateMissingFunc); err != nil {
- t.Fatalf("Got build error: %s", err)
- }
+ fs := hugofs.NewMem()
+
+ writeSource(t, fs, filepath.Join("content", "foo.md"), "foo")
+
+ withTemplate := createWithTemplateFromNameValues("missing", templateMissingFunc)
+
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs, WithTemplate: withTemplate}, BuildCfg{})
- errCount := s.log.LogCountForLevelsGreaterThanorEqualTo(jww.LevelError)
+ errCount := s.Log.LogCountForLevelsGreaterThanorEqualTo(jww.LevelError)
// TODO(bep) globals clean up the template error handling
// The template errors are stored in a slice etc. so we get 4 log entries
func TestDraftAndFutureRender(t *testing.T) {
testCommonResetState()
- hugofs.InitMemFs()
sources := []source.ByteSource{
{Name: filepath.FromSlash("sect/doc1.md"), Content: []byte("---\ntitle: doc1\ndraft: true\npublishdate: \"2414-05-29\"\n---\n# doc1\n*some content*")},
{Name: filepath.FromSlash("sect/doc2.md"), Content: []byte("---\ntitle: doc2\ndraft: true\npublishdate: \"2012-05-29\"\n---\n# doc2\n*some content*")},
}
siteSetup := func(t *testing.T) *Site {
- s := &Site{
- deps: newDeps(DepsCfg{}),
- Source: &source.InMemorySource{ByteSource: sources},
- Language: helpers.NewDefaultLanguage(),
- }
+ fs := hugofs.NewMem()
+
+ for _, src := range sources {
+ writeSource(t, fs, filepath.Join("content", src.Name), string(src.Content))
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
}
- return s
+ return buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
}
viper.Set("baseURL", "http://auth/bub")
func TestFutureExpirationRender(t *testing.T) {
testCommonResetState()
- hugofs.InitMemFs()
sources := []source.ByteSource{
{Name: filepath.FromSlash("sect/doc3.md"), Content: []byte("---\ntitle: doc1\nexpirydate: \"2400-05-29\"\n---\n# doc1\n*some content*")},
{Name: filepath.FromSlash("sect/doc4.md"), Content: []byte("---\ntitle: doc2\nexpirydate: \"2000-05-29\"\n---\n# doc2\n*some content*")},
}
siteSetup := func(t *testing.T) *Site {
- s := &Site{
- deps: newDeps(DepsCfg{}),
- Source: &source.InMemorySource{ByteSource: sources},
- Language: helpers.NewDefaultLanguage(),
- }
+ fs := hugofs.NewMem()
+
+ for _, src := range sources {
+ writeSource(t, fs, filepath.Join("content", src.Name), string(src.Content))
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
}
- return s
+ return buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
}
viper.Set("baseURL", "http://auth/bub")
},
}
- s := &Site{
- deps: newDeps(DepsCfg{}),
- Source: &source.InMemorySource{ByteSource: sources},
- targets: targetList{page: &target.PagePub{UglyURLs: uglyURLs}},
- Language: helpers.NewDefaultLanguage(),
- }
+ fs := hugofs.NewMem()
- if err := buildAndRenderSite(s, "_default/single.html", "{{.Content}}"); err != nil {
- t.Fatalf("Failed to build site: %s", err)
+ for _, src := range sources {
+ writeSource(t, fs, filepath.Join("content", src.Name), string(src.Content))
}
+ s := buildSingleSite(
+ t,
+ deps.DepsCfg{
+ Fs: fs,
+ WithTemplate: createWithTemplateFromNameValues("_default/single.html", "{{.Content}}")},
+ BuildCfg{})
+
if len(s.RegularPages) != 3 {
t.Fatalf("Expected 3 got %d pages", len(s.AllPages))
}
doc string
expected string
}{
- {filepath.FromSlash(fmt.Sprintf("sect/doc1%s", expectedPathSuffix)), fmt.Sprintf("<p>Ref 2: %s/sect/doc2%s</p>\n", expectedBase, expectedURLSuffix)},
- {filepath.FromSlash(fmt.Sprintf("sect/doc2%s", expectedPathSuffix)), fmt.Sprintf("<p><strong>Ref 1:</strong></p>\n\n%s/sect/doc1%s\n\n<p>THE END.</p>\n", expectedBase, expectedURLSuffix)},
- {filepath.FromSlash(fmt.Sprintf("sect/doc3%s", expectedPathSuffix)), fmt.Sprintf("<p><strong>Ref 1:</strong>%s/sect/doc3%s.</p>\n", expectedBase, expectedURLSuffix)},
+ {filepath.FromSlash(fmt.Sprintf("
public/sect/doc1%s", expectedPathSuffix)), fmt.Sprintf("<p>Ref 2: %s/sect/doc2%s</p>\n", expectedBase, expectedURLSuffix)},
+ {filepath.FromSlash(fmt.Sprintf("
public/sect/doc2%s", expectedPathSuffix)), fmt.Sprintf("<p><strong>Ref 1:</strong></p>\n\n%s/sect/doc1%s\n\n<p>THE END.</p>\n", expectedBase, expectedURLSuffix)},
+ {filepath.FromSlash(fmt.Sprintf("
public/sect/doc3%s", expectedPathSuffix)), fmt.Sprintf("<p><strong>Ref 1:</strong>%s/sect/doc3%s.</p>\n", expectedBase, expectedURLSuffix)},
}
for _, test := range tests {
- file, err := hugofs.Destination().Open(test.doc)
-
- if err != nil {
- t.Fatalf("Did not find %s in target: %s", test.doc, err)
- }
-
- content := helpers.ReaderToString(file)
+ assertFileContent(t, fs, test.doc, true, test.expected)
- if content != test.expected {
- t.Fatalf("%s content expected:\n%q\ngot:\n%q", test.doc, test.expected, content)
- }
}
}
{Name: filepath.FromSlash("sect/doc2.md"), Content: []byte("---\nurl: /ugly.html\nmarkup: markdown\n---\n# title\ndoc2 *content*")},
}
- s := &Site{
- deps: newDeps(DepsCfg{}),
- Source: &source.InMemorySource{ByteSource: sources},
- targets: targetList{page: &target.PagePub{UglyURLs: uglyURLs, PublishDir: "public"}},
- Language: helpers.NewDefaultLanguage(),
- }
+ fs := hugofs.NewMem()
- if err := buildAndRenderSite(s,
- "index.html", "Home Sweet {{ if.IsHome }}Home{{ end }}.",
- "_default/single.html", "{{.Content}}{{ if.IsHome }}This is not home!{{ end }}",
- "404.html", "Page Not Found.{{ if.IsHome }}This is not home!{{ end }}",
- "rss.xml", "<root>RSS</root>",
- "sitemap.xml", "<root>SITEMAP</root>"); err != nil {
- t.Fatalf("Failed to build site: %s", err)
+ for _, src := range sources {
+ writeSource(t, fs, filepath.Join("content", src.Name), string(src.Content))
}
+ writeSource(t, fs, filepath.Join("layouts", "index.html"), "Home Sweet {{ if.IsHome }}Home{{ end }}.")
+ writeSource(t, fs, filepath.Join("layouts", "_default/single.html"), "{{.Content}}{{ if.IsHome }}This is not home!{{ end }}")
+ writeSource(t, fs, filepath.Join("layouts", "404.html"), "Page Not Found.{{ if.IsHome }}This is not home!{{ end }}")
+ writeSource(t, fs, filepath.Join("layouts", "rss.xml"), "<root>RSS</root>")
+ writeSource(t, fs, filepath.Join("layouts", "sitemap.xml"), "<root>SITEMAP</root>")
+
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
+
var expectedPagePath string
if uglyURLs {
expectedPagePath = "public/sect/doc1.html"
}
for _, test := range tests {
- content := readDestination(t, test.doc)
+ content := readDestination(t, fs, test.doc)
if content != test.expected {
t.Errorf("%s content expected:\n%q\ngot:\n%q", test.doc, test.expected, content)
{Name: filepath.FromSlash("ラーメン/doc3.html"), Content: []byte("doc3")},
}
+ fs := hugofs.NewMem()
+
for _, source := range sources {
- writeSource(t, filepath.Join("content", source.Name), string(source.Content))
+ writeSource(t, fs, filepath.Join("content", source.Name), string(source.Content))
}
- s := NewSiteDefaultLang()
+ writeSource(t, fs, filepath.Join("layouts", "_default/single.html"), "{{.Content}}")
+ writeSource(t, fs, filepath.Join("layouts", "_default/list.html"), "{{.Title}}")
- if err := buildAndRenderSite(s,
- "_default/single.html", "{{.Content}}",
- "_default/list.html", "{{ .Title }}"); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
tests := []struct {
doc string
test.expected = inflect.Pluralize(test.expected)
}
- assertFileContent(t, filepath.Join("public", test.doc), true, test.expected)
+ assertFileContent(t, fs, filepath.Join("public", test.doc), true, test.expected)
}
}
func TestSkipRender(t *testing.T) {
testCommonResetState()
- hugofs.InitMemFs()
sources := []source.ByteSource{
{Name: filepath.FromSlash("sect/doc1.html"), Content: []byte("---\nmarkup: markdown\n---\n# title\nsome *content*")},
{Name: filepath.FromSlash("sect/doc2.html"), Content: []byte("<!doctype html><html><body>more content</body></html>")},
viper.Set("defaultExtension", "html")
viper.Set("verbose", true)
viper.Set("canonifyURLs", true)
+ viper.Set("uglyURLs", 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(),
- }
- if err := buildAndRenderSite(s,
- "_default/single.html", "{{.Content}}",
- "head", "<head><script src=\"script.js\"></script></head>",
- "head_abs", "<head><script src=\"/script.js\"></script></head>"); err != nil {
- t.Fatalf("Failed to build site: %s", err)
+ fs := hugofs.NewMem()
+
+ for _, src := range sources {
+ writeSource(t, fs, filepath.Join("content", src.Name), string(src.Content))
+
}
+ writeSource(t, fs, filepath.Join("layouts", "_default/single.html"), "{{.Content}}")
+ writeSource(t, fs, filepath.Join("layouts", "head"), "<head><script src=\"script.js\"></script></head>")
+ writeSource(t, fs, filepath.Join("layouts", "head_abs"), "<head><script src=\"/script.js\"></script></head>")
+
+ buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
+
tests := []struct {
doc string
expected string
}{
- {filepath.FromSlash("sect/doc1.html"), "\n\n<h1 id=\"title\">title</h1>\n\n<p>some <em>content</em></p>\n"},
- {filepath.FromSlash("sect/doc2.html"), "<!doctype html><html><body>more content</body></html>"},
- {filepath.FromSlash("sect/doc3.html"), "\n\n<h1 id=\"doc3\">doc3</h1>\n\n<p><em>some</em> content</p>\n"},
- {filepath.FromSlash("sect/doc4.html"), "\n\n<h1 id=\"doc4\">doc4</h1>\n\n<p><em>some content</em></p>\n"},
- {filepath.FromSlash("sect/doc5.html"), "<!doctype html><html><head><script src=\"script.js\"></script></head><body>body5</body></html>"},
- {filepath.FromSlash("sect/doc6.html"), "<!doctype html><html><head><script src=\"http://auth/bub/script.js\"></script></head><body>body5</body></html>"},
- {filepath.FromSlash("doc7.html"), "<html><body>doc7 content</body></html>"},
- {filepath.FromSlash("sect/doc8.html"), "\n\n<h1 id=\"title\">title</h1>\n\n<p>some <em>content</em></p>\n"},
+ {filepath.FromSlash("
public/sect/doc1.html"), "\n\n<h1 id=\"title\">title</h1>\n\n<p>some <em>content</em></p>\n"},
+ {filepath.FromSlash("public/sect/doc2.html"), "<!doctype html><html><body>more content</body></html>"},
+ {filepath.FromSlash("
public/sect/doc3.html"), "\n\n<h1 id=\"doc3\">doc3</h1>\n\n<p><em>some</em> content</p>\n"},
+ {filepath.FromSlash("
public/sect/doc4.html"), "\n\n<h1 id=\"doc4\">doc4</h1>\n\n<p><em>some content</em></p>\n"},
+ {filepath.FromSlash("public/sect/doc5.html"), "<!doctype html><html><head><script src=\"script.js\"></script></head><body>body5</body></html>"},
+ {filepath.FromSlash("public/sect/doc6.html"), "<!doctype html><html><head><script src=\"http://auth/bub/script.js\"></script></head><body>body5</body></html>"},
+ {filepath.FromSlash("public/doc7.html"), "<html><body>doc7 content</body></html>"},
+ {filepath.FromSlash("
public/sect/doc8.html"), "\n\n<h1 id=\"title\">title</h1>\n\n<p>some <em>content</em></p>\n"},
}
for _, test := range tests {
- file, err := hugofs.Destination().Open(test.doc)
+ file, err := fs.Destination.Open(test.doc)
if err != nil {
t.Fatalf("Did not find %s in target.", test.doc)
}
testCommonResetState()
viper.Set("defaultExtension", "html")
+ viper.Set("uglyURLs", true)
- hugofs.InitMemFs()
sources := []source.ByteSource{
{Name: filepath.FromSlash("sect/doc1.html"), Content: []byte("<!doctype html><html><head></head><body><a href=\"#frag1\">link</a></body></html>")},
{Name: filepath.FromSlash("blue/doc2.html"), Content: []byte("---\nf: t\n---\n<!doctype html><html><body>more content</body></html>")},
for _, canonify := range []bool{true, false} {
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(),
- }
- t.Logf("Rendering with baseURL %q and canonifyURLs set %v", viper.GetString("baseURL"), canonify)
- if err := buildAndRenderSite(s, "blue/single.html", templateWithURLAbs); err != nil {
- t.Fatalf("Failed to build site: %s", err)
+ fs := hugofs.NewMem()
+
+ for _, src := range sources {
+ writeSource(t, fs, filepath.Join("content", src.Name), string(src.Content))
+
}
+ writeSource(t, fs, filepath.Join("layouts", "blue/single.html"), templateWithURLAbs)
+
+ buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
+
tests := []struct {
file, expected string
}{
- {"blue/doc2.html", "<a href=\"%s/foobar.jpg\">Going</a>"},
- {"sect/doc1.html", "<!doctype html><html><head></head><body><a href=\"#frag1\">link</a></body></html>"},
+ {"
public/blue/doc2.html", "<a href=\"%s/foobar.jpg\">Going</a>"},
+ {"
public/sect/doc1.html", "<!doctype html><html><head></head><body><a href=\"#frag1\">link</a></body></html>"},
}
for _, test := range tests {
- file, err := hugofs.Destination().Open(filepath.FromSlash(test.file))
- if err != nil {
- t.Fatalf("Unable to locate rendered content: %s", test.file)
- }
-
- content := helpers.ReaderToString(file)
-
expected := test.expected
if strings.Contains(expected, "%s") {
expected = strings.Replace(expected, baseURL, "", -1)
}
- if content != expected {
- t.Errorf("AbsURLify with baseURL %q content expected:\n%q\ngot\n%q", baseURL, expected, content)
- }
+ assertFileContent(t, fs, test.file, true, expected)
+
}
}
}
func TestOrderedPages(t *testing.T) {
testCommonResetState()
- hugofs.InitMemFs()
-
viper.Set("baseURL", "http://auth/bub")
- s := &Site{
- deps: newDeps(DepsCfg{}),
- Source: &source.InMemorySource{ByteSource: weightedSources},
- Language: helpers.NewDefaultLanguage(),
- }
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to process site: %s", err)
+ fs := hugofs.NewMem()
+
+ for _, src := range weightedSources {
+ writeSource(t, fs, filepath.Join("content", src.Name), string(src.Content))
+
}
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{SkipRender: true})
+
if s.Sections["sect"][0].Weight != 2 || s.Sections["sect"][3].Weight != 6 {
t.Errorf("Pages in unexpected order. First should be '%d', got '%d'", 2, s.Sections["sect"][0].Weight)
}
}
}()
- hugofs.InitMemFs()
-
viper.Set("baseURL", "http://auth/bub")
- s := &Site{
- deps: newDeps(DepsCfg{}),
- Source: &source.InMemorySource{ByteSource: groupedSources},
- Language: helpers.NewDefaultLanguage(),
- }
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ fs := hugofs.NewMem()
+ writeSourcesToSource(t, "content", fs, groupedSources...)
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
rbysection, err := s.RegularPages.GroupBy("Section", "desc")
if err != nil {
t.Fatalf("Unable to make PageGroup array: %s", err)
}
+
if rbysection[0].Key != "sect3" {
t.Errorf("PageGroup array in unexpected order. First group key should be '%s', got '%s'", "sect3", rbysection[0].Key)
}
func TestWeightedTaxonomies(t *testing.T) {
testCommonResetState()
- hugofs.InitMemFs()
sources := []source.ByteSource{
{Name: filepath.FromSlash("sect/doc1.md"), Content: pageWithWeightedTaxonomies2},
{Name: filepath.FromSlash("sect/doc2.md"), Content: pageWithWeightedTaxonomies1},
viper.Set("baseURL", "http://auth/bub")
viper.Set("taxonomies", taxonomies)
- s := &Site{
- deps: newDeps(DepsCfg{}),
- Source: &source.InMemorySource{ByteSource: sources},
- Language: helpers.NewDefaultLanguage(),
- }
- if err := buildSiteSkipRender(s); err != nil {
- t.Fatalf("Failed to process site: %s", err)
- }
+ fs := hugofs.NewMem()
+ writeSourcesToSource(t, "content", fs, sources...)
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
if s.Taxonomies["tags"]["a"][0].Page.Title != "foo" {
t.Errorf("Pages in unexpected order, 'foo' expected first, got '%v'", s.Taxonomies["tags"]["a"][0].Page.Title)
}
func setupLinkingMockSite(t *testing.T) *Site {
- hugofs.InitMemFs()
sources := []source.ByteSource{
{Name: filepath.FromSlash("index.md"), Content: []byte("")},
{Name: filepath.FromSlash("rootfile.md"), Content: []byte("")},
map[string]interface{}{
"sourceRelativeLinksProjectFolder": "/docs"})
- site := &Site{
- deps: newDeps(DepsCfg{}),
- Source: &source.InMemorySource{ByteSource: sources},
- Language: helpers.NewDefaultLanguage(),
- }
-
- if err := buildSiteSkipRender(site); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ fs := hugofs.NewMem()
+ writeSourcesToSource(t, "content", fs, sources...)
+ return buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
- return site
}
func TestRefLinking(t *testing.T) {
"path/filepath"
"testing"
- "github.com/spf13/hugo/helpers"
-
"html/template"
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/hugofs"
"github.com/spf13/hugo/source"
"github.com/spf13/viper"
+ "github.com/stretchr/testify/require"
)
const slugDoc1 = "---\ntitle: slug doc 1\nslug: slug-doc-1\naliases:\n - sd1/foo/\n - sd2\n - sd3/\n - sd4.html\n---\nslug doc 1 content\n"
{"http://base.com", "http://base.com"}} {
viper.Set("baseURL", this.in)
- s := NewSiteDefaultLang()
+ s, err := NewSiteDefaultLang()
+ require.NoError(t, err)
s.initializeSiteInfo()
if s.Info.BaseURL != template.URL(this.expected) {
func TestPageCount(t *testing.T) {
testCommonResetState()
- hugofs.InitMemFs()
viper.Set("uglyURLs", false)
viper.Set("paginate", 10)
- s := &Site{
- deps: newDeps(DepsCfg{}),
- Source: &source.InMemorySource{ByteSource: urlFakeSource},
- Language: helpers.NewDefaultLanguage(),
- }
- if err := buildAndRenderSite(s, "indexes/blue.html", indexTemplate); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
- _, err := hugofs.Destination().Open("public/blue")
+ fs := hugofs.NewMem()
+ writeSourcesToSource(t, "content", fs, urlFakeSource...)
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
+
+ _, err := s.Fs.Destination.Open("public/blue")
if err != nil {
t.Errorf("No indexed rendered.")
}
- for _, s := range []string{
+ for _, pth := range []string{
"public/sd1/foo/index.html",
"public/sd2/index.html",
"public/sd3/index.html",
"public/sd4.html",
} {
- if _, err := hugofs.Destination().Open(filepath.FromSlash(s)); err != nil {
- t.Errorf("No alias rendered: %s", s)
+ if _, err := s.Fs.Destination.Open(filepath.FromSlash(pth)); err != nil {
+ t.Errorf("No alias rendered: %s", pth)
}
}
}
"reflect"
- "github.com/spf13/hugo/helpers"
- "github.com/spf13/hugo/source"
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/hugofs"
+ "github.com/spf13/hugo/tplapi"
"github.com/spf13/viper"
)
viper.Set("baseURL", "http://auth/bub/")
- s := &Site{
- deps: newDeps(DepsCfg{}),
- Source: &source.InMemorySource{ByteSource: weightedSources},
- Language: helpers.NewDefaultLanguage(),
- }
+ fs := hugofs.NewMem()
- if internal {
- if err := buildAndRenderSite(s); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ depsCfg := deps.DepsCfg{Fs: fs}
- } else {
- if err := buildAndRenderSite(s, "sitemap.xml", sitemapTemplate); err != nil {
- t.Fatalf("Failed to build site: %s", err)
+ if !internal {
+ depsCfg.WithTemplate = func(templ tplapi.Template) error {
+ templ.AddTemplate("sitemap.xml", sitemapTemplate)
+ return nil
}
}
- assertFileContent(t, "public/sitemap.xml", true,
+ writeSourcesToSource(t, "content", fs, weightedSources...)
+ s := buildSingleSite(t, depsCfg, BuildCfg{})
+
+ assertFileContent(t, s.Fs, "public/sitemap.xml", true,
// Regular page
" <loc>http://auth/bub/sect/doc1/</loc>",
// Home page
import (
"fmt"
"sort"
-
- "github.com/spf13/hugo/helpers"
)
// The TaxonomyList is a list of all taxonomies and their values
WeightedPages WeightedPages
}
-// KeyPrep... Taxonomies should be case insensitive. Can make it easily conditional later.
-func kp(in string) string {
- return helpers.CurrentPathSpec().MakePathSanitized(in)
-}
-
// Get the weighted pages for the given key.
func (i Taxonomy) Get(key string) WeightedPages {
- if val, ok := i[key]; ok {
- return val
- }
- return i[kp(key)]
+ return i[key]
}
// Count the weighted pages for the given key.
-func (i Taxonomy) Count(key string) int { return len(i[kp(key)]) }
+func (i Taxonomy) Count(key string) int { return len(i[key]) }
-func (i Taxonomy) add(key string, w WeightedPage, pretty bool) {
- if !pretty {
- key = kp(key)
- }
+func (i Taxonomy) add(key string, w WeightedPage) {
i[key] = append(i[key], w)
}
"reflect"
"testing"
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/hugofs"
+
"github.com/spf13/viper"
)
viper.Set("taxonomies", taxonomies)
- writeSource(t, filepath.Join("content", "page.md"), pageYamlWithTaxonomiesA)
+ fs := hugofs.NewMem()
- site := NewSiteDefaultLang()
+ writeSource(t, fs, filepath.Join("content", "page.md"), pageYamlWithTaxonomiesA)
- if err := buildSiteSkipRender(site); err != nil {
- t.Fatalf("Failed to build site: %s", err)
- }
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
st := make([]string, 0)
- for _, t := range site.Taxonomies["tags"].ByCount() {
+ for _, t := range s.Taxonomies["tags"].ByCount() {
st = append(st, t.Name)
}
--- /dev/null
+// Copyright 2017 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 hugolib
+
+import (
+ "fmt"
+ "path/filepath"
+ "testing"
+
+ "strings"
+
+ "github.com/spf13/viper"
+
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/hugofs"
+)
+
+func TestAllTemplateEngines(t *testing.T) {
+ noOp := func(s string) string {
+ return s
+ }
+
+ amberFixer := func(s string) string {
+ fixed := strings.Replace(s, "{{ .Title", "{{ Title", -1)
+ fixed = strings.Replace(fixed, ".Content", "Content", -1)
+ fixed = strings.Replace(fixed, "{{", "#{", -1)
+ fixed = strings.Replace(fixed, "}}", "}", -1)
+ fixed = strings.Replace(fixed, `title "hello world"`, `title("hello world")`, -1)
+
+ return fixed
+ }
+
+ for _, config := range []struct {
+ suffix string
+ templateFixer func(s string) string
+ }{
+ {"amber", amberFixer},
+ {"html", noOp},
+ {"ace", noOp},
+ } {
+ doTestTemplateEngine(t, config.suffix, config.templateFixer)
+
+ }
+
+}
+
+func doTestTemplateEngine(t *testing.T, suffix string, templateFixer func(s string) string) {
+
+ testCommonResetState()
+
+ fs := hugofs.NewMem()
+ viper.SetFs(fs.Source)
+
+ writeSource(t, fs, filepath.Join("content", "p.md"), `
+---
+title: My Title
+---
+My Content
+`)
+
+ t.Log("Testing", suffix)
+
+ templTemplate := `
+p
+ |
+ | Page Title: {{ .Title }}
+ br
+ | Page Content: {{ .Content }}
+ br
+ | {{ title "hello world" }}
+
+`
+
+ templ := templateFixer(templTemplate)
+
+ t.Log(templ)
+
+ writeSource(t, fs, filepath.Join("layouts", "_default", fmt.Sprintf("single.%s", suffix)), templ)
+
+ buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
+
+ assertFileContent(t, fs, filepath.Join("public", "p", "index.html"), true,
+ "Page Title: My Title",
+ "My Content",
+ "Hello World",
+ )
+
+}
"path/filepath"
"testing"
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/hugofs"
+
"github.com/spf13/viper"
)
func TestBaseGoTemplate(t *testing.T) {
+
+ var fs *hugofs.Fs
+
// Variants:
// 1. <current-path>/<template-name>-baseof.<suffix>, e.g. list-baseof.<suffix>.
// 2. <current-path>/baseof.<suffix>
// 3. _default/<template-name>-baseof.<suffix>, e.g. list-baseof.<suffix>.
// 4. _default/baseof.<suffix>
- for i, this := range []struct {
+ for _, this := range []struct {
setup func(t *testing.T)
assert func(t *testing.T)
}{
{
// Variant 1
func(t *testing.T) {
- writeSource(t, filepath.Join("layouts", "section", "sect-baseof.html"), `Base: {{block "main" .}}block{{end}}`)
- writeSource(t, filepath.Join("layouts", "section", "sect.html"), `{{define "main"}}sect{{ end }}`)
+ writeSource(t, fs, filepath.Join("layouts", "section", "sect-baseof.html"), `Base: {{block "main" .}}block{{end}}`)
+ writeSource(t, fs, filepath.Join("layouts", "section", "sect.html"), `{{define "main"}}sect{{ end }}`)
},
func(t *testing.T) {
- assertFileContent(t, filepath.Join("public", "sect", "index.html"), false, "Base: sect")
+ assertFileContent(t, fs, filepath.Join("public", "sect", "index.html"), false, "Base: sect")
},
},
{
// Variant 2
func(t *testing.T) {
- writeSource(t, filepath.Join("layouts", "baseof.html"), `Base: {{block "main" .}}block{{end}}`)
- writeSource(t, filepath.Join("layouts", "index.html"), `{{define "main"}}index{{ end }}`)
+ writeSource(t, fs, filepath.Join("layouts", "baseof.html"), `Base: {{block "main" .}}block{{end}}`)
+ writeSource(t, fs, filepath.Join("layouts", "index.html"), `{{define "main"}}index{{ end }}`)
},
func(t *testing.T) {
- assertFileContent(t, filepath.Join("public", "index.html"), false, "Base: index")
+ assertFileContent(t, fs, filepath.Join("public", "index.html"), false, "Base: index")
},
},
{
// Variant 3
func(t *testing.T) {
- writeSource(t, filepath.Join("layouts", "_default", "list-baseof.html"), `Base: {{block "main" .}}block{{end}}`)
- writeSource(t, filepath.Join("layouts", "_default", "list.html"), `{{define "main"}}list{{ end }}`)
+ writeSource(t, fs, filepath.Join("layouts", "_default", "list-baseof.html"), `Base: {{block "main" .}}block{{end}}`)
+ writeSource(t, fs, filepath.Join("layouts", "_default", "list.html"), `{{define "main"}}list{{ end }}`)
},
func(t *testing.T) {
- assertFileContent(t, filepath.Join("public", "sect", "index.html"), false, "Base: list")
+ assertFileContent(t, fs, filepath.Join("public", "sect", "index.html"), false, "Base: list")
},
},
{
// Variant 4
func(t *testing.T) {
- writeSource(t, filepath.Join("layouts", "_default", "baseof.html"), `Base: {{block "main" .}}block{{end}}`)
- writeSource(t, filepath.Join("layouts", "_default", "list.html"), `{{define "main"}}list{{ end }}`)
+ writeSource(t, fs, filepath.Join("layouts", "_default", "baseof.html"), `Base: {{block "main" .}}block{{end}}`)
+ writeSource(t, fs, filepath.Join("layouts", "_default", "list.html"), `{{define "main"}}list{{ end }}`)
},
func(t *testing.T) {
- assertFileContent(t, filepath.Join("public", "sect", "index.html"), false, "Base: list")
+ assertFileContent(t, fs, filepath.Join("public", "sect", "index.html"), false, "Base: list")
},
},
{
// Variant 1, theme, use project's base
func(t *testing.T) {
viper.Set("theme", "mytheme")
- writeSource(t, filepath.Join("layouts", "section", "sect-baseof.html"), `Base: {{block "main" .}}block{{end}}`)
- writeSource(t, filepath.Join("themes", "mytheme", "layouts", "section", "sect-baseof.html"), `Base Theme: {{block "main" .}}block{{end}}`)
- writeSource(t, filepath.Join("layouts", "section", "sect.html"), `{{define "main"}}sect{{ end }}`)
+ writeSource(t, fs, filepath.Join("layouts", "section", "sect-baseof.html"), `Base: {{block "main" .}}block{{end}}`)
+ writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "section", "sect-baseof.html"), `Base Theme: {{block "main" .}}block{{end}}`)
+ writeSource(t, fs, filepath.Join("layouts", "section", "sect.html"), `{{define "main"}}sect{{ end }}`)
},
func(t *testing.T) {
- assertFileContent(t, filepath.Join("public", "sect", "index.html"), false, "Base: sect")
+ assertFileContent(t, fs, filepath.Join("public", "sect", "index.html"), false, "Base: sect")
},
},
{
// Variant 1, theme, use theme's base
func(t *testing.T) {
viper.Set("theme", "mytheme")
- writeSource(t, filepath.Join("themes", "mytheme", "layouts", "section", "sect-baseof.html"), `Base Theme: {{block "main" .}}block{{end}}`)
- writeSource(t, filepath.Join("layouts", "section", "sect.html"), `{{define "main"}}sect{{ end }}`)
+ writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "section", "sect-baseof.html"), `Base Theme: {{block "main" .}}block{{end}}`)
+ writeSource(t, fs, filepath.Join("layouts", "section", "sect.html"), `{{define "main"}}sect{{ end }}`)
},
func(t *testing.T) {
- assertFileContent(t, filepath.Join("public", "sect", "index.html"), false, "Base Theme: sect")
+ assertFileContent(t, fs, filepath.Join("public", "sect", "index.html"), false, "Base Theme: sect")
},
},
{
// Variant 4, theme, use project's base
func(t *testing.T) {
viper.Set("theme", "mytheme")
- writeSource(t, filepath.Join("layouts", "_default", "baseof.html"), `Base: {{block "main" .}}block{{end}}`)
- writeSource(t, filepath.Join("themes", "mytheme", "layouts", "_default", "baseof.html"), `Base Theme: {{block "main" .}}block{{end}}`)
- writeSource(t, filepath.Join("themes", "mytheme", "layouts", "_default", "list.html"), `{{define "main"}}list{{ end }}`)
+ writeSource(t, fs, filepath.Join("layouts", "_default", "baseof.html"), `Base: {{block "main" .}}block{{end}}`)
+ writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "_default", "baseof.html"), `Base Theme: {{block "main" .}}block{{end}}`)
+ writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "_default", "list.html"), `{{define "main"}}list{{ end }}`)
},
func(t *testing.T) {
- assertFileContent(t, filepath.Join("public", "sect", "index.html"), false, "Base: list")
+ assertFileContent(t, fs, filepath.Join("public", "sect", "index.html"), false, "Base: list")
},
},
{
// Variant 4, theme, use themes's base
func(t *testing.T) {
viper.Set("theme", "mytheme")
- writeSource(t, filepath.Join("themes", "mytheme", "layouts", "_default", "baseof.html"), `Base Theme: {{block "main" .}}block{{end}}`)
- writeSource(t, filepath.Join("themes", "mytheme", "layouts", "_default", "list.html"), `{{define "main"}}list{{ end }}`)
+ writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "_default", "baseof.html"), `Base Theme: {{block "main" .}}block{{end}}`)
+ writeSource(t, fs, filepath.Join("themes", "mytheme", "layouts", "_default", "list.html"), `{{define "main"}}list{{ end }}`)
},
func(t *testing.T) {
- assertFileContent(t, filepath.Join("public", "sect", "index.html"), false, "Base Theme: list")
+ assertFileContent(t, fs, filepath.Join("public", "sect", "index.html"), false, "Base Theme: list")
},
},
} {
testCommonResetState()
- writeSource(t, filepath.Join("content", "sect", "page.md"), `---
+ fs = hugofs.NewMem()
+
+ writeSource(t, fs, filepath.Join("content", "sect", "page.md"), `---
title: Template test
---
Some content
`)
this.setup(t)
- if err := buildAndRenderSite(NewSiteDefaultLang()); err != nil {
- t.Fatalf("[%d] Failed to build site: %s", i, err)
- }
+ buildSingleSite(t, deps.DepsCfg{Fs: fs}, BuildCfg{})
this.assert(t)
--- /dev/null
+package hugolib
+
+import (
+ "path/filepath"
+ "testing"
+
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/helpers"
+ "github.com/spf13/hugo/hugofs"
+ "github.com/spf13/hugo/source"
+ "github.com/spf13/hugo/tplapi"
+ "github.com/spf13/viper"
+
+ "github.com/stretchr/testify/require"
+)
+
+func newTestDepsConfig() deps.DepsCfg {
+ return deps.DepsCfg{Fs: hugofs.NewMem()}
+}
+
+func newTestPathSpec() *helpers.PathSpec {
+ return helpers.NewPathSpec(hugofs.NewMem(), viper.GetViper())
+}
+
+func createWithTemplateFromNameValues(additionalTemplates ...string) func(templ tplapi.Template) error {
+
+ return func(templ tplapi.Template) error {
+ for i := 0; i < len(additionalTemplates); i += 2 {
+ err := templ.AddTemplate(additionalTemplates[i], additionalTemplates[i+1])
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+ }
+}
+
+func buildSingleSite(t *testing.T, depsCfg deps.DepsCfg, buildCfg BuildCfg) *Site {
+ h, err := NewHugoSitesFromConfiguration(depsCfg)
+
+ require.NoError(t, err)
+ require.Len(t, h.Sites, 1)
+
+ require.NoError(t, h.Build(buildCfg))
+
+ return h.Sites[0]
+}
+
+func writeSourcesToSource(t *testing.T, base string, fs *hugofs.Fs, sources ...source.ByteSource) {
+ for _, src := range sources {
+ writeSource(t, fs, filepath.Join(base, src.Name), string(src.Content))
+ }
+}
files []*File
Base string
AvoidPaths []string
+
+ fs *hugofs.Fs
+}
+
+func NewFilesystem(fs *hugofs.Fs, base string, avoidPaths ...string) *Filesystem {
+ return &Filesystem{fs: fs, Base: base, AvoidPaths: avoidPaths}
}
func (f *Filesystem) FilesByExts(exts ...string) []*File {
return err
}
if b {
- rd, err := NewLazyFileReader(hugofs.Source(), filePath)
+ rd, err := NewLazyFileReader(f.fs.Source, filePath)
if err != nil {
return err
}
return err
}
- err := helpers.SymbolicWalk(hugofs.Source(), f.Base, walker)
+ if f.fs == nil {
+ panic("Must have a fs")
+ }
+ err := helpers.SymbolicWalk(f.fs.Source, f.Base, walker)
if err != nil {
jww.ERROR.Println(err)
jww.ERROR.Printf("Cannot read symbolic link '%s', error was: %s", filePath, err)
return false, nil
}
- linkfi, err := hugofs.Source().Stat(link)
+ linkfi, err := f.fs.Source.Stat(link)
if err != nil {
jww.ERROR.Printf("Cannot stat '%s', error was: %s", link, err)
return false, nil
"runtime"
"strings"
"testing"
+
+ "github.com/spf13/hugo/hugofs"
)
func TestEmptySourceFilesystem(t *testing.T) {
- src := &Filesystem{Base: "Empty"}
+ src := NewFilesystem(hugofs.NewMem(), "Empty")
if len(src.Files()) != 0 {
t.Errorf("new filesystem should contain 0 files.")
}
}
func TestAddFile(t *testing.T) {
+ fs := hugofs.NewMem()
tests := platformPaths
for _, test := range tests {
base := platformBase
- srcDefault := new(Filesystem)
- srcWithBase := &Filesystem{
- Base: base,
- }
+ srcDefault := NewFilesystem(fs, "")
+ srcWithBase := NewFilesystem(fs, base)
for _, src := range []*Filesystem{srcDefault, srcWithBase} {
{NFC: "é", NFD: "\x65\xcc\x81"},
}
+ fs := hugofs.NewMem()
+
for _, path := range paths {
- src := new(Filesystem)
+ src := NewFilesystem(fs, "")
_ = src.add(path.NFD, strings.NewReader(""))
f := src.Files()[0]
if f.BaseFileName() != path.NFC {
type Filesystem struct {
PublishDir string
+
+ Fs *hugofs.Fs
}
func (fs *Filesystem) Publish(path string, r io.Reader) (err error) {
return
}
- return helpers.WriteToDisk(translated, r, hugofs.Destination())
+ return helpers.WriteToDisk(translated, r, fs.Fs.Destination)
}
func (fs *Filesystem) Translate(src string) (dest string, err error) {
PublishDir string
Templates *template.Template
AllowRoot bool // for the language redirects
+
+ Fs *hugofs.Fs
}
func (h *HTMLRedirectAlias) Translate(alias string) (aliasPath string, err error) {
return
}
- return helpers.WriteToDisk(path, buffer, hugofs.Destination())
+ return helpers.WriteToDisk(path, buffer, h.Fs.Destination)
}
// LangDir will contain the subdir for the language, i.e. "en", "de" etc.
// It will be empty if the site is rendered in root.
LangDir string
+
+ Fs *hugofs.Fs
}
func (pp *PagePub) Publish(path string, r io.Reader) (err error) {
return
}
- return helpers.WriteToDisk(translated, r, hugofs.Destination())
+ return helpers.WriteToDisk(translated, r, pp.Fs.Destination)
}
func (pp *PagePub) Translate(src string) (dest string, err error) {
import (
"path/filepath"
"testing"
+
+ "github.com/spf13/hugo/hugofs"
)
func TestPageTranslator(t *testing.T) {
+ fs := hugofs.NewMem()
+
tests := []struct {
content string
expected string
}
for _, test := range tests {
- f := new(PagePub)
+ f := &PagePub{Fs: fs}
dest, err := f.Translate(filepath.FromSlash(test.content))
expected := filepath.FromSlash(test.expected)
if err != nil {
--- /dev/null
+// Copyright 2017 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 (
+ "html/template"
+
+ "github.com/eknkc/amber"
+)
+
+func (gt *GoHTMLTemplate) CompileAmberWithTemplate(b []byte, path string, t *template.Template) (*template.Template, error) {
+ c := amber.New()
+
+ if err := c.ParseData(b, path); err != nil {
+ return nil, err
+ }
+
+ data, err := c.CompileString()
+
+ if err != nil {
+ return nil, err
+ }
+
+ tpl, err := t.Funcs(gt.amberFuncMap).Parse(data)
+
+ if err != nil {
+ return nil, err
+ }
+
+ return tpl, nil
+}
"github.com/eknkc/amber"
"github.com/spf13/afero"
bp "github.com/spf13/hugo/bufferpool"
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/helpers"
- "github.com/spf13/hugo/hugofs"
- jww "github.com/spf13/jwalterweatherman"
"github.com/yosssi/ace"
)
// TODO(bep) globals get rid of the rest of the jww.ERR etc.
-//var tmpl *GoHTMLTemplate
-
-// TODO(bep) an interface with hundreds of methods ... remove it.
-// And unexport most of these methods.
-type Template interface {
- ExecuteTemplate(wr io.Writer, name string, data interface{}) error
- Lookup(name string) *template.Template
- Templates() []*template.Template
- New(name string) *template.Template
- GetClone() *template.Template
- LoadTemplates(absPath string)
- LoadTemplatesWithPrefix(absPath, prefix string)
- AddTemplate(name, tpl string) error
- AddTemplateFileWithMaster(name, overlayFilename, masterFilename string) error
- AddAceTemplate(name, basePath, innerPath string, baseContent, innerContent []byte) error
- AddInternalTemplate(prefix, name, tpl string) error
- AddInternalShortcode(name, tpl string) error
- PrintErrors()
- Funcs(funcMap template.FuncMap)
-}
type templateErr struct {
name string
funcster *templateFuncster
- // TODO(bep) globals template
- log *jww.Notepad
+ amberFuncMap template.FuncMap
+
+ *deps.Deps
}
-// New returns a new Hugo Template System
+type TemplateProvider struct{}
+
+var DefaultTemplateProvider *TemplateProvider
+
+// Update updates the Hugo Template System in the provided Deps.
// with all the additional features, templates & functions
-func New(logger *jww.Notepad, withTemplate ...func(templ Template) error) *GoHTMLTemplate {
+func (*TemplateProvider) Update(deps *deps.Deps) error {
+ // TODO(bep) check that this isn't called too many times.
tmpl := &GoHTMLTemplate{
Template: template.New(""),
overlays: make(map[string]*template.Template),
errors: make([]*templateErr, 0),
- log: logger,
+ Deps: deps,
}
- tmpl.funcster = newTemplateFuncster(tmpl)
+ deps.Tmpl = tmpl
- // The URL funcs in the funcMap is somewhat language dependent,
- // so we need to wait until the language and site config is loaded.
- // TODO(bep) globals
- tmpl.funcster.initFuncMap()
-
- // TODO(bep) globals
- for k, v := range tmpl.funcster.funcMap {
- amber.FuncMap[k] = v
- }
+ tmpl.initFuncs(deps)
tmpl.LoadEmbedded()
- for _, wt := range withTemplate {
- err := wt(tmpl)
+ if deps.WithTemplate != nil {
+ err := deps.WithTemplate(tmpl)
if err != nil {
tmpl.errors = append(tmpl.errors, &templateErr{"init", err})
}
}
- tmpl.markReady()
+ tmpl.MarkReady()
+
+ return nil
+
+}
+
+// Clone clones
+func (*TemplateProvider) Clone(d *deps.Deps) error {
+
+ t := d.Tmpl.(*GoHTMLTemplate)
+
+ // 1. Clone the clone with new template funcs
+ // 2. Clone any overlays with new template funcs
+
+ tmpl := &GoHTMLTemplate{
+ Template: template.Must(t.Template.Clone()),
+ overlays: make(map[string]*template.Template),
+ errors: make([]*templateErr, 0),
+ Deps: d,
+ }
+
+ d.Tmpl = tmpl
+ tmpl.initFuncs(d)
+
+ for k, v := range t.overlays {
+ vc := template.Must(v.Clone())
+ vc.Funcs(tmpl.funcster.funcMap)
+ tmpl.overlays[k] = vc
+ }
+
+ tmpl.MarkReady()
+
+ return nil
+}
+
+func (t *GoHTMLTemplate) initFuncs(d *deps.Deps) {
+
+ t.funcster = newTemplateFuncster(d)
+
+ // The URL funcs in the funcMap is somewhat language dependent,
+ // so we need to wait until the language and site config is loaded.
+ t.funcster.initFuncMap()
+
+ t.amberFuncMap = template.FuncMap{}
+
+ for k, v := range amber.FuncMap {
+ t.amberFuncMap[k] = v
+ }
+
+ for k, v := range t.funcster.funcMap {
+ t.amberFuncMap[k] = v
+ // Hacky, but we need to make sure that the func names are in the global map.
+ amber.FuncMap[k] = func() string {
+ panic("should never be invoked")
+ return ""
+ }
+ }
- return tmpl
}
func (t *GoHTMLTemplate) Funcs(funcMap template.FuncMap) {
t.Template.Funcs(funcMap)
}
-func (t *GoHTMLTemplate) partial(name string, contextList ...interface{}) template.HTML {
+func (t *GoHTMLTemplate) Partial(name string, contextList ...interface{}) template.HTML {
if strings.HasPrefix("partials/", name) {
name = name[8:]
}
}
}
if !worked {
- t.log.ERROR.Println("Unable to render", layouts)
- t.log.ERROR.Println("Expecting to find a template in either the theme/layouts or /layouts in one of the following relative locations", layouts)
+ t.Log.ERROR.Println("Unable to render", layouts)
+ t.Log.ERROR.Println("Expecting to find a template in either the theme/layouts or /layouts in one of the following relative locations", layouts)
}
}
t.EmbedTemplates()
}
-// markReady marks the template as "ready for execution". No changes allowed
+// MarkReady marks the template as "ready for execution". No changes allowed
// after this is set.
-func (t *GoHTMLTemplate) markReady() {
+func (t *GoHTMLTemplate) MarkReady() {
if t.clone == nil {
t.clone = template.Must(t.Template.Clone())
}
masterTpl := t.Lookup(masterFilename)
if masterTpl == nil {
- b, err := afero.ReadFile(hugofs.Source(), masterFilename)
+ b, err := afero.ReadFile(t.Fs.Source, masterFilename)
if err != nil {
return err
}
}
}
- b, err := afero.ReadFile(hugofs.Source(), overlayFilename)
+ b, err := afero.ReadFile(t.Fs.Source, overlayFilename)
if err != nil {
return err
}
switch ext {
case ".amber":
templateName := strings.TrimSuffix(name, filepath.Ext(name)) + ".html"
- compiler := amber.New()
- b, err := afero.ReadFile(hugofs.Source(), path)
+ b, err := afero.ReadFile(t.Fs.Source, path)
if err != nil {
return err
}
- // Parse the input data
- if err := compiler.ParseData(b, path); err != nil {
- return err
- }
-
- templ, err := compiler.CompileWithTemplate(t.New(templateName))
+ templ, err := t.CompileAmberWithTemplate(b, path, t.New(templateName))
if err != nil {
return err
}
return applyTemplateTransformers(templ)
case ".ace":
var innerContent, baseContent []byte
- innerContent, err := afero.ReadFile(hugofs.Source(), path)
+ innerContent, err := afero.ReadFile(t.Fs.Source, path)
if err != nil {
return err
}
if baseTemplatePath != "" {
- baseContent, err = afero.ReadFile(hugofs.Source(), baseTemplatePath)
+ baseContent, err = afero.ReadFile(t.Fs.Source, baseTemplatePath)
if err != nil {
return err
}
return t.AddTemplateFileWithMaster(name, path, baseTemplatePath)
}
- b, err := afero.ReadFile(hugofs.Source(), path)
+ b, err := afero.ReadFile(t.Fs.Source, path)
if err != nil {
return err
}
- t.log.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) {
- t.log.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
}
- t.log.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 {
- t.log.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)
+ linkfi, err := t.Fs.Source.Stat(link)
if err != nil {
- t.log.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() {
- t.log.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
}
// This may be a view that shouldn't have base template
// Have to look inside it to make sure
- needsBase, err := helpers.FileContainsAny(path, innerMarkers, hugofs.Source())
+ needsBase, err := helpers.FileContainsAny(path, innerMarkers, t.Fs.Source)
if err != nil {
return err
}
for _, pair := range pairsToCheck {
pathsToCheck := basePathsToCheck(pair, layoutDir, themeDir)
for _, pathToCheck := range pathsToCheck {
- if ok, err := helpers.Exists(pathToCheck, hugofs.Source()); err == nil && ok {
+ if ok, err := helpers.Exists(pathToCheck, t.Fs.Source); err == nil && ok {
baseTemplatePath = pathToCheck
break Loop
}
}
if err := t.AddTemplateFile(tplName, baseTemplatePath, path); err != nil {
- t.log.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 {
- t.log.ERROR.Printf("Failed to load templates: %s", err)
+ if err := helpers.SymbolicWalk(t.Fs.Source, absPath, walker); err != nil {
+ t.Log.ERROR.Printf("Failed to load templates: %s", err)
}
}
func (t *GoHTMLTemplate) PrintErrors() {
for i, e := range t.errors {
- t.log.ERROR.Println(i, ":", e.err)
+ t.Log.ERROR.Println(i, ":", e.err)
}
}
"github.com/bep/inflect"
"github.com/spf13/afero"
"github.com/spf13/cast"
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/helpers"
- "github.com/spf13/hugo/hugofs"
jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
// Some of the template funcs are'nt entirely stateless.
type templateFuncster struct {
- t *GoHTMLTemplate
funcMap template.FuncMap
cachedPartials partialCache
+
+ *deps.Deps
}
-func newTemplateFuncster(t *GoHTMLTemplate) *templateFuncster {
+func newTemplateFuncster(deps *deps.Deps) *templateFuncster {
return &templateFuncster{
- t: t,
+ Deps: deps,
cachedPartials: partialCache{p: make(map[string]template.HTML)},
}
}
// imageConfig returns the image.Config for the specified path relative to the
// working directory. resetImageConfigCache must be run beforehand.
-func imageConfig(path interface{}) (image.Config, error) {
+func (t *templateFuncster) imageConfig(path interface{}) (image.Config, error) {
filename, err := cast.ToStringE(path)
if err != nil {
return image.Config{}, err
return config, nil
}
- f, err := hugofs.WorkingDir().Open(filename)
+ f, err := t.Fs.WorkingDir.Open(filename)
if err != nil {
return image.Config{}, err
}
}
// apply takes a map, array, or slice and returns a new slice with the function fname applied over it.
-func (tf *templateFuncster) apply(seq interface{}, fname string, args ...interface{}) (interface{}, error) {
+func (t *templateFuncster) apply(seq interface{}, fname string, args ...interface{}) (interface{}, error) {
if seq == nil {
return make([]interface{}, 0), nil
}
return nil, errors.New("can't iterate over a nil value")
}
- fn, found := tf.funcMap[fname]
+ fn, found := t.funcMap[fname]
if !found {
return nil, errors.New("can't find function " + fname)
}
// Get retrieves partial output from the cache based upon the partial name.
// If the partial is not found in the cache, the partial is rendered and added
// to the cache.
-func (tf *templateFuncster) Get(key, name string, context interface{}) (p template.HTML) {
+func (t *templateFuncster) Get(key, name string, context interface{}) (p template.HTML) {
var ok bool
- tf.cachedPartials.RLock()
- p, ok = tf.cachedPartials.p[key]
- tf.cachedPartials.RUnlock()
+ t.cachedPartials.RLock()
+ p, ok = t.cachedPartials.p[key]
+ t.cachedPartials.RUnlock()
if ok {
return p
}
- tf.cachedPartials.Lock()
- if p, ok = tf.cachedPartials.p[key]; !ok {
- tf.cachedPartials.Unlock()
- p = tf.t.partial(name, context)
+ t.cachedPartials.Lock()
+ if p, ok = t.cachedPartials.p[key]; !ok {
+ t.cachedPartials.Unlock()
+ p = t.Tmpl.Partial(name, context)
+
+ t.cachedPartials.Lock()
+ t.cachedPartials.p[key] = p
- tf.cachedPartials.Lock()
- tf.cachedPartials.p[key] = p
}
- tf.cachedPartials.Unlock()
+ t.cachedPartials.Unlock()
return p
}
// string parameter (a string slice actually, but be only use a variadic
// argument to make it optional) can be passed so that a given partial can have
// multiple uses. The cache is created with name+variant as the key.
-func (tf *templateFuncster) partialCached(name string, context interface{}, variant ...string) template.HTML {
+func (t *templateFuncster) partialCached(name string, context interface{}, variant ...string) template.HTML {
key := name
if len(variant) > 0 {
for i := 0; i < len(variant); i++ {
key += variant[i]
}
}
- return tf.Get(key, name, context)
+ return t.Get(key, name, context)
}
// regexpCache represents a cache of regexp objects protected by a mutex.
// configured WorkingDir.
// It returns the contents as a string.
// There is a upper size limit set at 1 megabytes.
-func readFileFromWorkingDir(i interface{}) (string, error) {
+func (t *templateFuncster) readFileFromWorkingDir(i interface{}) (string, error) {
s, err := cast.ToStringE(i)
if err != nil {
return "", err
}
- return readFile(hugofs.WorkingDir(), s)
+ return readFile(t.Fs.WorkingDir, s)
}
// readDirFromWorkingDir listst the directory content relative to the
// configured WorkingDir.
-func readDirFromWorkingDir(i interface{}) ([]os.FileInfo, error) {
+func (t *templateFuncster) readDirFromWorkingDir(i interface{}) ([]os.FileInfo, error) {
path, err := cast.ToStringE(i)
if err != nil {
return nil, err
}
- list, err := afero.ReadDir(hugofs.WorkingDir(), path)
+ list, err := afero.ReadDir(t.Fs.WorkingDir, path)
if err != nil {
return nil, fmt.Errorf("Failed to read Directory %s with error message %s", path, err)
return html.UnescapeString(conv), nil
}
-func absURL(a interface{}) (template.HTML, error) {
+func (t *templateFuncster) absURL(a interface{}) (template.HTML, error) {
s, err := cast.ToStringE(a)
if err != nil {
return "", nil
}
- return template.HTML(helpers.CurrentPathSpec().AbsURL(s, false)), nil
+ return template.HTML(t.PathSpec.AbsURL(s, false)), nil
}
-func relURL(a interface{}) (template.HTML, error) {
+func (t *templateFuncster) relURL(a interface{}) (template.HTML, error) {
s, err := cast.ToStringE(a)
if err != nil {
return "", nil
}
- return template.HTML(helpers.CurrentPathSpec().RelURL(s, false)), nil
+ return template.HTML(t.PathSpec.RelURL(s, false)), nil
}
// getenv retrieves the value of the environment variable named by the key.
return os.Getenv(skey), nil
}
-func (tf *templateFuncster) initFuncMap() {
+func (t *templateFuncster) initFuncMap() {
funcMap := template.FuncMap{
- "absURL": absURL,
+ "absURL": t.absURL,
"absLangURL": func(i interface{}) (template.HTML, error) {
s, err := cast.ToStringE(i)
if err != nil {
return "", err
}
- return template.HTML(helpers.CurrentPathSpec().AbsURL(s, true)), nil
+ return template.HTML(t.PathSpec.AbsURL(s, true)), nil
},
"add": func(a, b interface{}) (interface{}, error) { return helpers.DoArithmetic(a, b, '+') },
"after": after,
- "apply": tf.apply,
+ "apply": t.apply,
"base64Decode": base64Decode,
"base64Encode": base64Encode,
"chomp": chomp,
"findRE": findRE,
"first": first,
"ge": ge,
- "getCSV": getCSV,
- "getJSON": getJSON,
+ "getCSV": t.getCSV,
+ "getJSON": t.getJSON,
"getenv": getenv,
"gt": gt,
"hasPrefix": hasPrefix,
"htmlEscape": htmlEscape,
"htmlUnescape": htmlUnescape,
"humanize": humanize,
- "imageConfig": imageConfig,
+ "imageConfig": t.imageConfig,
"in": in,
"index": index,
"int": func(v interface{}) (int, error) { return cast.ToIntE(v) },
"mul": func(a, b interface{}) (interface{}, error) { return helpers.DoArithmetic(a, b, '*') },
"ne": ne,
"now": func() time.Time { return time.Now() },
- "partial": tf.t.partial,
- "partialCached": tf.partialCached,
+ "partial": t.Tmpl.Partial,
+ "partialCached": t.partialCached,
"plainify": plainify,
"pluralize": pluralize,
"querify": querify,
- "readDir": readDirFromWorkingDir,
- "readFile": readFileFromWorkingDir,
+ "readDir": t.readDirFromWorkingDir,
+ "readFile": t.readFileFromWorkingDir,
"ref": ref,
- "relURL": relURL,
+ "relURL": t.relURL,
"relLangURL": func(i interface{}) (template.HTML, error) {
s, err := cast.ToStringE(i)
if err != nil {
return "", err
}
- return template.HTML(helpers.CurrentPathSpec().RelURL(s, true)), nil
+ return template.HTML(t.PathSpec.RelURL(s, true)), nil
},
"relref": relRef,
"replace": replace,
"trim": trim,
"truncate": truncate,
"upper": upper,
- "urlize": helpers.CurrentPathSpec().URLize,
+ "urlize": t.PathSpec.URLize,
"where": where,
"i18n": i18nTranslate,
"T": i18nTranslate,
}
- tf.funcMap = funcMap
- tf.t.Funcs(funcMap)
+ t.funcMap = funcMap
+ t.Tmpl.Funcs(funcMap)
}
"testing"
"time"
+ "github.com/spf13/hugo/tplapi"
+
+ "github.com/spf13/hugo/deps"
"github.com/spf13/hugo/helpers"
"io/ioutil"
jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
-var logger = jww.NewNotepad(jww.LevelFatal, jww.LevelFatal, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+var (
+ logger = jww.NewNotepad(jww.LevelFatal, jww.LevelFatal, os.Stdout, ioutil.Discard, "", log.Ldate|log.Ltime)
+ defaultDepsConfig = deps.DepsCfg{
+ Language: helpers.NewLanguage("en"),
+ Logger: logger,
+ TemplateProvider: DefaultTemplateProvider,
+ }
+)
type tstNoStringer struct {
}
func TestFuncsInTemplate(t *testing.T) {
- viper.Reset()
- defer viper.Reset()
+ testReset()
workingDir := "/home/hugo"
viper.Set("currentContentLanguage", helpers.NewDefaultLanguage())
viper.Set("multilingual", true)
- fs := &afero.MemMapFs{}
- hugofs.InitFs(fs)
+ fs := hugofs.NewMem()
- afero.WriteFile(fs, filepath.Join(workingDir, "README.txt"), []byte("Hugo Rocks!"), 0755)
+ afero.WriteFile(fs.Source, filepath.Join(workingDir, "README.txt"), []byte("Hugo Rocks!"), 0755)
// Add the examples from the docs: As a smoke test and to make sure the examples work.
// TODO(bep): docs: fix title example
`
var b bytes.Buffer
- templ, err := New(logger).New("test").Parse(in)
+
var data struct {
Title string
Section string
tstInitTemplates()
- if err != nil {
- t.Fatal("Got error on parse", err)
+ config := defaultDepsConfig
+ config.WithTemplate = func(templ tplapi.Template) error {
+ if _, err := templ.New("test").Parse(in); err != nil {
+ t.Fatal("Got error on parse", err)
+ }
+ return nil
+ }
+ config.Fs = fs
+
+ d := deps.New(config)
+ if err := d.LoadTemplates(); err != nil {
+ t.Fatal(err)
}
- err = templ.Execute(&b, &data)
+ err := d.Tmpl.Lookup("test").Execute(&b, &data)
if err != nil {
t.Fatal("Got error on execute", err)
}
func TestImageConfig(t *testing.T) {
- viper.Reset()
- defer viper.Reset()
+ testReset()
workingDir := "/home/hugo"
viper.Set("workingDir", workingDir)
- fs := &afero.MemMapFs{}
- hugofs.InitFs(fs)
+ f := newTestFuncster()
for i, this := range []struct {
resetCache bool
},
},
} {
- afero.WriteFile(fs, filepath.Join(workingDir, this.path), this.input, 0755)
+ afero.WriteFile(f.Fs.Source, filepath.Join(workingDir, this.path), this.input, 0755)
if this.resetCache {
resetImageConfigCache()
}
- result, err := imageConfig(this.path)
+ result, err := f.imageConfig(this.path)
if err != nil {
t.Errorf("imageConfig returned error: %s", err)
}
}
}
- if _, err := imageConfig(t); err == nil {
+ if _, err := f.imageConfig(t); err == nil {
t.Error("Expected error from imageConfig when passed invalid path")
}
- if _, err := imageConfig("non-existent.png"); err == nil {
+ if _, err := f.imageConfig("non-existent.png"); err == nil {
t.Error("Expected error from imageConfig when passed non-existent file")
}
- if _, err := imageConfig(""); err == nil {
+ if _, err := f.imageConfig(""); err == nil {
t.Error("Expected error from imageConfig when passed empty path")
}
{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(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
- }
+
+ tmpl := newTestTemplate(t, "test", this.tpl)
buf := new(bytes.Buffer)
- err = tmpl.Execute(buf, this.input)
+ err := tmpl.Execute(buf, this.input)
if (err == nil) != this.ok {
t.Errorf("[%d] execute template returned unexpected error: %s", i, err)
continue
}
}
+// TODO(bep) what is this? Also look above.
func TestSafeJS(t *testing.T) {
for i, this := range []struct {
str string
}
}
+// TODO(bep) what is this?
func TestSafeURL(t *testing.T) {
for i, this := range []struct {
str string
}
func TestReadFile(t *testing.T) {
- viper.Reset()
- defer viper.Reset()
+ testReset()
workingDir := "/home/hugo"
viper.Set("workingDir", workingDir)
- fs := &afero.MemMapFs{}
- hugofs.InitFs(fs)
+ f := newTestFuncster()
- afero.WriteFile(fs, filepath.Join(workingDir, "/f/f1.txt"), []byte("f1-content"), 0755)
- afero.WriteFile(fs, filepath.Join("/home", "f2.txt"), []byte("f2-content"), 0755)
+ afero.WriteFile(f.Fs.Source, filepath.Join(workingDir, "/f/f1.txt"), []byte("f1-content"), 0755)
+ afero.WriteFile(f.Fs.Source, filepath.Join("/home", "f2.txt"), []byte("f2-content"), 0755)
for i, this := range []struct {
filename string
{filepath.FromSlash("f/f1.txt"), "f1-content"},
{filepath.FromSlash("../f2.txt"), false},
} {
- result, err := readFileFromWorkingDir(this.filename)
+ result, err := f.readFileFromWorkingDir(this.filename)
if b, ok := this.expect.(bool); ok && !b {
if err == nil {
t.Errorf("[%d] readFile didn't return an expected error", i)
{"test1", "{{ .Title }} seq: {{ shuffle (seq 1 20) }}", `{{ partialCached "test1" . "%s" }}`, "header"},
}
- results := make(map[string]string, len(testCases))
-
var data struct {
Title string
Section string
tmp = tc.tmpl
}
- tmpl, err := New(logger).New("testroot").Parse(tmp)
- if err != nil {
- t.Fatalf("[%d] unable to create new html template: %s", i, err)
- }
+ defaultDepsConfig.WithTemplate = func(templ tplapi.Template) error {
+ err := templ.AddTemplate("testroot", tmp)
+ if err != nil {
+ return err
+ }
+ err = templ.AddTemplate("partials/"+tc.name, tc.partial)
+ if err != nil {
+ return err
+ }
- if tmpl == nil {
- t.Fatalf("[%d] tmpl should not be nil!", i)
+ return nil
}
- tmpl.New("partials/" + tc.name).Parse(tc.partial)
+ de := deps.New(defaultDepsConfig)
+ require.NoError(t, de.LoadTemplates())
buf := new(bytes.Buffer)
- err = tmpl.Execute(buf, &data)
+ templ := de.Tmpl.Lookup("testroot")
+ err := templ.Execute(buf, &data)
if err != nil {
t.Fatalf("[%d] error executing template: %s", i, err)
}
for j := 0; j < 10; j++ {
buf2 := new(bytes.Buffer)
- err = tmpl.Execute(buf2, nil)
+ err := templ.Execute(buf2, nil)
if err != nil {
t.Fatalf("[%d] error executing template 2nd time: %s", i, err)
}
t.Fatalf("[%d] cached results do not match:\nResult 1:\n%q\nResult 2:\n%q", i, buf, buf2)
}
}
-
- // double-check against previous test cases of the same variant
- previous, ok := results[tc.name+tc.variant]
- if !ok {
- results[tc.name+tc.variant] = buf.String()
- } else {
- if previous != buf.String() {
- t.Errorf("[%d] cached variant differs from previous rendering; got:\n%q\nwant:\n%q", i, buf.String(), previous)
- }
- }
}
}
func BenchmarkPartial(b *testing.B) {
- tstInitTemplates()
- tmpl, err := New(logger).New("testroot").Parse(`{{ partial "bench1" . }}`)
- if err != nil {
- b.Fatalf("unable to create new html template: %s", err)
+ defaultDepsConfig.WithTemplate = func(templ tplapi.Template) error {
+ err := templ.AddTemplate("testroot", `{{ partial "bench1" . }}`)
+ if err != nil {
+ return err
+ }
+ err = templ.AddTemplate("partials/bench1", `{{ shuffle (seq 1 10) }}`)
+ if err != nil {
+ return err
+ }
+
+ return nil
}
- tmpl.New("partials/bench1").Parse(`{{ shuffle (seq 1 10) }}`)
+ de := deps.New(defaultDepsConfig)
+ require.NoError(b, de.LoadTemplates())
+
buf := new(bytes.Buffer)
+ tmpl := de.Tmpl.Lookup("testroot")
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
- if err = tmpl.Execute(buf, nil); err != nil {
+ if err := tmpl.Execute(buf, nil); err != nil {
b.Fatalf("error executing template: %s", err)
}
buf.Reset()
}
func BenchmarkPartialCached(b *testing.B) {
- tstInitTemplates()
- tmpl, err := New(logger).New("testroot").Parse(`{{ partialCached "bench1" . }}`)
- if err != nil {
- b.Fatalf("unable to create new html template: %s", err)
+ defaultDepsConfig.WithTemplate = func(templ tplapi.Template) error {
+ err := templ.AddTemplate("testroot", `{{ partialCached "bench1" . }}`)
+ if err != nil {
+ return err
+ }
+ err = templ.AddTemplate("partials/bench1", `{{ shuffle (seq 1 10) }}`)
+ if err != nil {
+ return err
+ }
+
+ return nil
}
- tmpl.New("partials/bench1").Parse(`{{ shuffle (seq 1 10) }}`)
+ de := deps.New(defaultDepsConfig)
+ require.NoError(b, de.LoadTemplates())
+
buf := new(bytes.Buffer)
+ tmpl := de.Tmpl.Lookup("testroot")
b.ReportAllocs()
b.ResetTimer()
for i := 0; i < b.N; i++ {
- if err = tmpl.Execute(buf, nil); err != nil {
+ if err := tmpl.Execute(buf, nil); err != nil {
b.Fatalf("error executing template: %s", err)
}
buf.Reset()
}
}
-func BenchmarkPartialCachedVariants(b *testing.B) {
- tmpl, err := New(logger).New("testroot").Parse(`{{ partialCached "bench1" . "header" }}`)
- if err != nil {
- b.Fatalf("unable to create new html template: %s", err)
+func newTestFuncster() *templateFuncster {
+ d := deps.New(defaultDepsConfig)
+ if err := d.LoadTemplates(); err != nil {
+ panic(err)
}
- tmpl.New("partials/bench1").Parse(`{{ shuffle (seq 1 10) }}`)
- buf := new(bytes.Buffer)
+ return d.Tmpl.(*GoHTMLTemplate).funcster
+}
- b.ReportAllocs()
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- if err = tmpl.Execute(buf, nil); err != nil {
- b.Fatalf("error executing template: %s", err)
+func newTestTemplate(t *testing.T, name, template string) *template.Template {
+ defaultDepsConfig.WithTemplate = func(templ tplapi.Template) error {
+ err := templ.AddTemplate(name, template)
+ if err != nil {
+ return err
}
- buf.Reset()
+ return nil
}
-}
-func newTestFuncster() *templateFuncster {
- return New(logger).funcster
+ de := deps.New(defaultDepsConfig)
+ require.NoError(t, de.LoadTemplates())
+
+ return de.Tmpl.Lookup(name)
}
current bundle.TranslateFunc
}
+// TODO(bep) global translator
var translator *translate
// SetTranslateLang sets the translations language to use during template processing.
"github.com/spf13/afero"
"github.com/spf13/hugo/helpers"
- "github.com/spf13/hugo/hugofs"
jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
)
}
// resGetResource loads the content of a local or remote file
-func resGetResource(url string) ([]byte, error) {
+func (t *templateFuncster) resGetResource(url string) ([]byte, error) {
if url == "" {
return nil, nil
}
if strings.Contains(url, "://") {
- return resGetRemote(url, hugofs.Source(), http.DefaultClient)
+ return resGetRemote(url, t.Fs.Source, http.DefaultClient)
}
- return resGetLocal(url, hugofs.Source())
+ return resGetLocal(url, t.Fs.Source)
}
// getJSON expects one or n-parts of a URL to a resource which can either be a local or a remote one.
// If you provide multiple parts they will be joined together to the final URL.
// GetJSON returns nil or parsed JSON to use in a short code.
-func getJSON(urlParts ...string) interface{} {
+func (t *templateFuncster) getJSON(urlParts ...string) interface{} {
var v interface{}
url := strings.Join(urlParts, "")
for i := 0; i <= resRetries; i++ {
- c, err := resGetResource(url)
+ c, err := t.resGetResource(url)
if err != nil {
jww.ERROR.Printf("Failed to get json resource %s with error message %s", url, err)
return nil
jww.ERROR.Printf("Cannot read json from resource %s with error message %s", url, err)
jww.ERROR.Printf("Retry #%d for %s and sleeping for %s", i, url, resSleep)
time.Sleep(resSleep)
- resDeleteCache(url, hugofs.Source())
+ resDeleteCache(url, t.Fs.Source)
continue
}
break
// The data separator can be a comma, semi-colon, pipe, etc, but only one character.
// If you provide multiple parts for the URL they will be joined together to the final URL.
// GetCSV returns nil or a slice slice to use in a short code.
-func getCSV(sep string, urlParts ...string) [][]string {
+func (t *templateFuncster) getCSV(sep string, urlParts ...string) [][]string {
var d [][]string
url := strings.Join(urlParts, "")
var clearCacheSleep = func(i int, u string) {
jww.ERROR.Printf("Retry #%d for %s and sleeping for %s", i, url, resSleep)
time.Sleep(resSleep)
- resDeleteCache(url, hugofs.Source())
+ resDeleteCache(url, t.Fs.Source)
}
for i := 0; i <= resRetries; i++ {
- c, err := resGetResource(url)
+ c, err := t.resGetResource(url)
if err == nil && !bytes.Contains(c, []byte(sep)) {
err = errors.New("Cannot find separator " + sep + " in CSV.")
}
func TestScpGetLocal(t *testing.T) {
- fs := new(afero.MemMapFs)
+ testReset()
+ fs := hugofs.NewMem()
ps := helpers.FilePathSeparator
+
tests := []struct {
path string
content []byte
for _, test := range tests {
r := bytes.NewReader(test.content)
- err := helpers.WriteToDisk(test.path, r, fs)
+ err := helpers.WriteToDisk(test.path, r, fs.Source)
if err != nil {
t.Error(err)
}
- c, err := resGetLocal(test.path, fs)
+ c, err := resGetLocal(test.path, fs.Source)
if err != nil {
t.Errorf("Error getting resource content: %s", err)
}
Reset func()
}
-func testRetryWhenDone() wd {
+func testRetryWhenDone(f *templateFuncster) wd {
cd := viper.GetString("cacheDir")
- viper.Set("cacheDir", helpers.GetTempDir("", hugofs.Source()))
+ viper.Set("cacheDir", helpers.GetTempDir("", f.Fs.Source))
var tmpSleep time.Duration
tmpSleep, resSleep = resSleep, time.Millisecond
return wd{func() {
}
func TestGetJSONFailParse(t *testing.T) {
- defer testRetryWhenDone().Reset()
+
+ f := newTestFuncster()
+
+ defer testRetryWhenDone(f).Reset()
reqCount := 0
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer os.Remove(getCacheFileID(url))
want := map[string]interface{}{"gomeetup": []interface{}{"Sydney", "San Francisco", "Stockholm"}}
- have := getJSON(url)
+ have := f.getJSON(url)
assert.NotNil(t, have)
if have != nil {
assert.EqualValues(t, want, have)
}
func TestGetCSVFailParseSep(t *testing.T) {
- defer testRetryWhenDone().Reset()
+ f := newTestFuncster()
+
+ defer testRetryWhenDone(f).Reset()
reqCount := 0
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer os.Remove(getCacheFileID(url))
want := [][]string{{"gomeetup", "city"}, {"yes", "Sydney"}, {"yes", "San Francisco"}, {"yes", "Stockholm"}}
- have := getCSV(",", url)
+ have := f.getCSV(",", url)
assert.NotNil(t, have)
if have != nil {
assert.EqualValues(t, want, have)
}
func TestGetCSVFailParse(t *testing.T) {
- defer testRetryWhenDone().Reset()
+
+ f := newTestFuncster()
+
+ defer testRetryWhenDone(f).Reset()
reqCount := 0
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer os.Remove(getCacheFileID(url))
want := [][]string{{"gomeetup", "city"}, {"yes", "Sydney"}, {"yes", "San Francisco"}, {"yes", "Stockholm"}}
- have := getCSV(",", url)
+ have := f.getCSV(",", url)
assert.NotNil(t, have)
if have != nil {
assert.EqualValues(t, want, have)
"testing"
"github.com/spf13/afero"
+ "github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/helpers"
"github.com/spf13/hugo/hugofs"
+ "github.com/spf13/hugo/tplapi"
+ "github.com/spf13/viper"
+ "github.com/stretchr/testify/require"
)
+func testReset() {
+ viper.Reset()
+
+ // TODO(bep) viper-globals
+ viper.Set("currentContentLanguage", helpers.NewLanguage("en"))
+}
+
// Some tests for Issue #1178 -- Ace
func TestAceTemplates(t *testing.T) {
d := "DATA"
- templ := New(logger, func(templ Template) error {
+ config := defaultDepsConfig
+ config.WithTemplate = func(templ tplapi.Template) error {
return templ.AddAceTemplate("mytemplate.ace", basePath, innerPath,
[]byte(this.baseContent), []byte(this.innerContent))
+ }
- })
+ a := deps.New(config)
+
+ if err := a.LoadTemplates(); err != nil {
+ t.Fatal(err)
+ }
+
+ templ := a.Tmpl.(*GoHTMLTemplate)
if len(templ.errors) > 0 && this.expectErr == 0 {
t.Errorf("Test %d with root '%s' errored: %v", i, root, templ.errors)
}
var buff bytes.Buffer
- err := templ.ExecuteTemplate(&buff, "mytemplate.html", d)
+ err := a.Tmpl.ExecuteTemplate(&buff, "mytemplate.html", d)
if err != nil && this.expectErr == 0 {
t.Errorf("Test %d with root '%s' errored: %s", i, root, err)
t.Errorf("Test %d with root '%s' got\n%s\nexpected\n%s", i, root, result, this.expect)
}
}
+
}
}
{`tpl`, `{{.0.E}}`, 0, false},
} {
- hugofs.InitMemFs()
- templ := New(logger)
overlayTplName := "ot"
masterTplName := "mt"
finalTplName := "tp"
- if this.writeSkipper != 1 {
- afero.WriteFile(hugofs.Source(), masterTplName, []byte(this.masterTplContent), 0644)
- }
- if this.writeSkipper != 2 {
- afero.WriteFile(hugofs.Source(), overlayTplName, []byte(this.overlayTplContent), 0644)
- }
+ defaultDepsConfig.WithTemplate = func(templ tplapi.Template) error {
- err := templ.AddTemplateFileWithMaster(finalTplName, overlayTplName, masterTplName)
+ err := templ.AddTemplateFileWithMaster(finalTplName, overlayTplName, masterTplName)
- if b, ok := this.expect.(bool); ok && !b {
- if err == nil {
- t.Errorf("[%d] AddTemplateFileWithMaster didn't return an expected error", i)
- }
- } else {
+ if b, ok := this.expect.(bool); ok && !b {
+ if err == nil {
+ t.Errorf("[%d] AddTemplateFileWithMaster didn't return an expected error", i)
+ }
+ } else {
- if err != nil {
- t.Errorf("[%d] AddTemplateFileWithMaster failed: %s", i, err)
- continue
- }
+ if err != nil {
+ t.Errorf("[%d] AddTemplateFileWithMaster failed: %s", i, err)
+ return nil
+ }
- resultTpl := templ.Lookup(finalTplName)
+ resultTpl := templ.Lookup(finalTplName)
- if resultTpl == nil {
- t.Errorf("[%d] AddTemplateFileWithMaster: Result template not found", i)
- continue
- }
+ if resultTpl == nil {
+ t.Errorf("[%d] AddTemplateFileWithMaster: Result template not found", i)
+ return nil
+ }
- var b bytes.Buffer
- err := resultTpl.Execute(&b, nil)
+ var b bytes.Buffer
+ err := resultTpl.Execute(&b, nil)
- if err != nil {
- t.Errorf("[%d] AddTemplateFileWithMaster execute failed: %s", i, err)
- continue
- }
- resultContent := b.String()
+ if err != nil {
+ t.Errorf("[%d] AddTemplateFileWithMaster execute failed: %s", i, err)
+ return nil
+ }
+ resultContent := b.String()
- if resultContent != this.expect {
- t.Errorf("[%d] AddTemplateFileWithMaster got \n%s but expected \n%v", i, resultContent, this.expect)
+ if resultContent != this.expect {
+ t.Errorf("[%d] AddTemplateFileWithMaster got \n%s but expected \n%v", i, resultContent, this.expect)
+ }
}
+
+ return nil
}
+ defaultDepsConfig.Fs = hugofs.NewMem()
+
+ if this.writeSkipper != 1 {
+ afero.WriteFile(defaultDepsConfig.Fs.Source, masterTplName, []byte(this.masterTplContent), 0644)
+ }
+ if this.writeSkipper != 2 {
+ afero.WriteFile(defaultDepsConfig.Fs.Source, overlayTplName, []byte(this.overlayTplContent), 0644)
+ }
+
+ deps.New(defaultDepsConfig)
+
}
}
H: "a,b,c,d,e,f",
}
- templ := New(logger, func(templ Template) error {
+ defaultDepsConfig.WithTemplate = func(templ tplapi.Template) error {
return templ.AddTemplate("fuzz", this.data)
+ }
+
+ de := deps.New(defaultDepsConfig)
+ require.NoError(t, de.LoadTemplates())
- })
+ templ := de.Tmpl.(*GoHTMLTemplate)
if len(templ.errors) > 0 && this.expectErr == 0 {
t.Errorf("Test %d errored: %v", i, templ.errors)
} else if len(templ.errors) == 0 && this.expectErr == 1 {
t.Errorf("#1 Test %d should have errored", i)
}
- err := templ.ExecuteTemplate(ioutil.Discard, "fuzz", d)
+
+ err := de.Tmpl.ExecuteTemplate(ioutil.Discard, "fuzz", d)
if err != nil && this.expectErr == 0 {
t.Fatalf("Test %d errored: %s", i, err)
} else if err == nil && this.expectErr == 2 {
t.Fatalf("#2 Test %d should have errored", i)
}
+
}
}
--- /dev/null
+package tplapi
+
+import (
+ "html/template"
+ "io"
+)
+
+// TODO(bep) make smaller
+// TODO(bep) consider putting this into /tpl and the implementation in /tpl/tplimpl or something
+type Template interface {
+ ExecuteTemplate(wr io.Writer, name string, data interface{}) error
+ ExecuteTemplateToHTML(context interface{}, layouts ...string) template.HTML
+ Lookup(name string) *template.Template
+ Templates() []*template.Template
+ New(name string) *template.Template
+ GetClone() *template.Template
+ LoadTemplates(absPath string)
+ LoadTemplatesWithPrefix(absPath, prefix string)
+ AddTemplate(name, tpl string) error
+ AddTemplateFileWithMaster(name, overlayFilename, masterFilename string) error
+ AddAceTemplate(name, basePath, innerPath string, baseContent, innerContent []byte) error
+ AddInternalTemplate(prefix, name, tpl string) error
+ AddInternalShortcode(name, tpl string) error
+ Partial(name string, contextList ...interface{}) template.HTML
+ PrintErrors()
+ Funcs(funcMap template.FuncMap)
+ MarkReady()
+}
projects / brevno-suite / hugo / commitdiff