Fs: fs.Source,
Filename: r.cfgFile,
ConfigDir: r.cfgDir,
+ Logger: r.logger,
Environment: r.environment,
},
)
Filename: r.cfgFile,
ConfigDir: r.cfgDir,
Environment: r.environment,
+ Logger: r.logger,
},
)
if err != nil {
"time"
"github.com/gohugoio/hugo/cache/filecache"
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/common/maps"
"github.com/gohugoio/hugo/common/urls"
"github.com/gohugoio/hugo/config"
}
type configCompiler interface {
- CompileConfig() error
+ CompileConfig(logger loggers.Logger) error
}
func (c Config) cloneForLang() *Config {
return &x
}
-func (c *Config) CompileConfig() error {
+func (c *Config) CompileConfig(logger loggers.Logger) error {
var transientErr error
s := c.Timeout
if _, err := strconv.Atoi(s); err == nil {
for _, s := range allDecoderSetups {
if getCompiler := s.getCompiler; getCompiler != nil {
- if err := getCompiler(c).CompileConfig(); err != nil {
+ if err := getCompiler(c).CompileConfig(logger); err != nil {
return err
}
}
return nil
}
-// FromLoadConfigResult creates a new Config from res.
-func FromLoadConfigResult(fs afero.Fs, res config.LoadConfigResult) (*Configs, error) {
+// fromLoadConfigResult creates a new Config from res.
+func fromLoadConfigResult(fs afero.Fs, logger loggers.Logger, res config.LoadConfigResult) (*Configs, error) {
if !res.Cfg.IsSet("languages") {
// We need at least one
lang := res.Cfg.GetString("defaultContentLanguage")
languagesConfig := cfg.GetStringMap("languages")
var isMultiHost bool
- if err := all.CompileConfig(); err != nil {
+ if err := all.CompileConfig(logger); err != nil {
return nil, err
}
if err := decodeConfigFromParams(fs, bcfg, mergedConfig, clone, differentRootKeys); err != nil {
return nil, fmt.Errorf("failed to decode config for language %q: %w", k, err)
}
- if err := clone.CompileConfig(); err != nil {
+ if err := clone.CompileConfig(logger); err != nil {
return nil, err
}
langConfigMap[k] = clone
p.c.Build = config.DecodeBuildConfig(p.p)
return nil
},
+ getCompiler: func(c *Config) configCompiler {
+ return &c.Build
+ },
},
"frontmatter": {
key: "frontmatter",
d.Environ = os.Environ()
}
+ if d.Logger == nil {
+ d.Logger = loggers.NewErrorLogger()
+ }
+
l := &configLoader{ConfigSourceDescriptor: d, cfg: config.New()}
// Make sure we always do this, even in error situations,
// as we have commands (e.g. "hugo mod init") that will
return nil, fmt.Errorf("failed to load config: %w", err)
}
- configs, err := FromLoadConfigResult(d.Fs, res)
+ configs, err := fromLoadConfigResult(d.Fs, d.Logger, res)
if err != nil {
return nil, fmt.Errorf("failed to create config from result: %w", err)
}
if len(l.ModulesConfigFiles) > 0 {
// Config merged in from modules.
// Re-read the config.
- configs, err = FromLoadConfigResult(d.Fs, res)
+ configs, err = fromLoadConfigResult(d.Fs, d.Logger, res)
if err != nil {
return nil, fmt.Errorf("failed to create config from modules config: %w", err)
}
import (
"fmt"
+ "regexp"
"sort"
"strings"
+ "github.com/gobwas/glob"
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/common/types"
- "github.com/gobwas/glob"
"github.com/gohugoio/hugo/common/herrors"
"github.com/mitchellh/mapstructure"
"github.com/spf13/cast"
BaseConfig BaseConfig
}
-var DefaultBuild = BuildConfig{
+var defaultBuild = BuildConfig{
UseResourceCacheWhen: "fallback",
WriteStats: false,
+
+ CacheBusters: []CacheBuster{
+ {
+ Source: `assets/.*\.(js|ts|jsx|tsx)`,
+ Target: `(js|scripts|javascript)`,
+ },
+ {
+ Source: `assets/.*\.(css|sass|scss)$`,
+ Target: cssTargetCachebusterRe,
+ },
+ {
+ Source: `(postcss|tailwind)\.config\.js`,
+ Target: cssTargetCachebusterRe,
+ },
+ // This is deliberatly coarse grained; it will cache bust resources with "json" in the cache key when js files changes, which is good.
+ {
+ Source: `assets/.*\.(.*)$`,
+ Target: `$1`,
+ },
+ },
}
// BuildConfig holds some build related configuration.
// Can be used to toggle off writing of the intellinsense /assets/jsconfig.js
// file.
NoJSConfigInAssets bool
+
+ // Can used to control how the resource cache gets evicted on rebuilds.
+ CacheBusters []CacheBuster
+}
+
+func (b BuildConfig) clone() BuildConfig {
+ b.CacheBusters = append([]CacheBuster{}, b.CacheBusters...)
+ return b
}
func (b BuildConfig) UseResourceCache(err error) bool {
return true
}
+// MatchCacheBuster returns the cache buster for the given path p, nil if none.
+func (s BuildConfig) MatchCacheBuster(logger loggers.Logger, p string) (func(string) bool, error) {
+ var matchers []func(string) bool
+ for _, cb := range s.CacheBusters {
+ if matcher := cb.compiledSource(p); matcher != nil {
+ matchers = append(matchers, matcher)
+ }
+ }
+ if len(matchers) > 0 {
+ return (func(cacheKey string) bool {
+ for _, m := range matchers {
+ if m(cacheKey) {
+ return true
+ }
+ }
+ return false
+ }), nil
+ }
+ return nil, nil
+}
+
+func (b *BuildConfig) CompileConfig(logger loggers.Logger) error {
+ for i, cb := range b.CacheBusters {
+ if err := cb.CompileConfig(logger); err != nil {
+ return fmt.Errorf("failed to compile cache buster %q: %w", cb.Source, err)
+ }
+ b.CacheBusters[i] = cb
+ }
+ return nil
+}
+
func DecodeBuildConfig(cfg Provider) BuildConfig {
m := cfg.GetStringMap("build")
- b := DefaultBuild
+ b := defaultBuild.clone()
if m == nil {
return b
}
err := mapstructure.WeakDecode(m, &b)
if err != nil {
- return DefaultBuild
+ return defaultBuild
}
b.UseResourceCacheWhen = strings.ToLower(b.UseResourceCacheWhen)
compiledRedirects []glob.Glob
}
-func (s *Server) CompileConfig() error {
+func (s *Server) CompileConfig(logger loggers.Logger) error {
if s.compiledHeaders != nil {
return nil
}
for _, r := range s.Redirects {
s.compiledRedirects = append(s.compiledRedirects, glob.MustCompile(r.From))
}
+
return nil
}
Force bool
}
+// CacheBuster configures cache busting for assets.
+type CacheBuster struct {
+ // Trigger for files matching this regexp.
+ Source string
+
+ // Cache bust targets matching this regexp.
+ // This regexp can contain group matches (e.g. $1) from the source regexp.
+ Target string
+
+ compiledSource func(string) func(string) bool
+}
+
+func (c *CacheBuster) CompileConfig(logger loggers.Logger) error {
+ if c.compiledSource != nil {
+ return nil
+ }
+ source := c.Source
+ target := c.Target
+ sourceRe, err := regexp.Compile(source)
+ if err != nil {
+ return fmt.Errorf("failed to compile cache buster source %q: %w", c.Source, err)
+ }
+ var compileErr error
+ c.compiledSource = func(s string) func(string) bool {
+ m := sourceRe.FindStringSubmatch(s)
+ matchString := "no match"
+ match := m != nil
+ if match {
+ matchString = "match!"
+ }
+ logger.Debugf("cachebuster: Matching %q with source %q: %s\n", s, source, matchString)
+ if !match {
+ return nil
+ }
+ groups := m[1:]
+ // Replace $1, $2 etc. in target.
+
+ for i, g := range groups {
+ target = strings.ReplaceAll(target, fmt.Sprintf("$%d", i+1), g)
+ }
+ targetRe, err := regexp.Compile(target)
+ if err != nil {
+ compileErr = fmt.Errorf("failed to compile cache buster target %q: %w", target, err)
+ return nil
+ }
+ return func(s string) bool {
+ match = targetRe.MatchString(s)
+ matchString := "no match"
+ if match {
+ matchString = "match!"
+ }
+ logger.Debugf("cachebuster: Matching %q with target %q: %s\n", s, target, matchString)
+
+ return match
+ }
+
+ }
+ return compileErr
+}
+
func (r Redirect) IsZero() bool {
return r.From == ""
}
+const (
+ // Keep this a little coarse grained, some false positives are OK.
+ cssTargetCachebusterRe = `(css|styles|scss|sass)`
+)
+
func DecodeServer(cfg Provider) (Server, error) {
s := &Server{}
"testing"
"github.com/gohugoio/hugo/common/herrors"
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/common/types"
qt "github.com/frankban/quicktest"
s, err := DecodeServer(cfg)
c.Assert(err, qt.IsNil)
- c.Assert(s.CompileConfig(), qt.IsNil)
+ c.Assert(s.CompileConfig(loggers.NewErrorLogger()), qt.IsNil)
c.Assert(s.MatchHeaders("/foo.jpg"), qt.DeepEquals, []types.KeyValueStr{
{Key: "X-Content-Type-Options", Value: "nosniff"},
}
}
+
+func TestBuildConfigCacheBusters(t *testing.T) {
+ c := qt.New(t)
+ cfg := New()
+ conf := DecodeBuildConfig(cfg)
+ l := loggers.NewInfoLogger()
+ c.Assert(conf.CompileConfig(l), qt.IsNil)
+
+ m, err := conf.MatchCacheBuster(l, "assets/foo/main.js")
+ c.Assert(err, qt.IsNil)
+ c.Assert(m, qt.IsNotNil)
+ c.Assert(m("scripts"), qt.IsTrue)
+ c.Assert(m("asdf"), qt.IsFalse)
+
+ m, _ = conf.MatchCacheBuster(l, "tailwind.config.js")
+ c.Assert(m("css"), qt.IsTrue)
+ c.Assert(m("js"), qt.IsFalse)
+
+ m, err = conf.MatchCacheBuster(l, "assets/foo.json")
+ c.Assert(err, qt.IsNil)
+ c.Assert(m, qt.IsNotNil)
+ c.Assert(m("json"), qt.IsTrue)
+
+}
return eg.glob, eg.err
}
+// Or creates a new Glob from the given globs.
+func Or(globs ...glob.Glob) glob.Glob {
+ return globSlice{globs: globs}
+}
+
+// MatchesFunc is a convenience type to create a glob.Glob from a function.
+type MatchesFunc func(s string) bool
+
+func (m MatchesFunc) Match(s string) bool {
+ return m(s)
+}
+
+type globSlice struct {
+ globs []glob.Glob
+}
+
+func (g globSlice) Match(s string) bool {
+ for _, g := range g.globs {
+ if g.Match(s) {
+ return true
+ }
+ }
+ return false
+}
+
type globDecorator struct {
// On Windows we may get filenames with Windows slashes to match,
// which we need to normalize.
func (s *Site) publishDestAlias(allowRoot bool, path, permalink string, outputFormat output.Format, p page.Page) (err error) {
handler := newAliasHandler(s.Tmpl(), s.Log, allowRoot)
- s.Log.Debugln("creating alias:", path, "redirecting to", permalink)
-
targetPath, err := handler.targetPathAlias(path)
if err != nil {
return err
theBigFs *filesystemsCollector
+ workingDir string
+
// Locks.
buildMu Lockable // <project>/.hugo_build.lock
}
return ""
}
+// MakePathRelative creates a relative path from the given filename.
+// It returns both the component name (e.g. layouts) and the path relative to that.
+func (fs *BaseFs) MakePathRelative(filename string) (string, string) {
+ for _, sfs := range fs.FileSystems() {
+ if sfs.Contains(filename) {
+ if s, found := sfs.MakePathRelative(filename); found {
+ return sfs.Name, s
+ }
+ }
+ }
+ // May be a static file.
+ if s := fs.MakeStaticPathRelative(filename); s != "" {
+ return files.ComponentFolderStatic, s
+ }
+ // Fall back to relative to the working dir.
+ if strings.HasPrefix(filename, fs.workingDir) {
+ return "", strings.TrimPrefix(filename, fs.workingDir)
+ }
+ return "", ""
+}
+
// SourceFilesystems contains the different source file systems. These can be
// composite file systems (theme and project etc.), and they have all root
// set to the source type the provides: data, i18n, static, layouts.
func (s *SourceFilesystems) FileSystems() []*SourceFilesystem {
return []*SourceFilesystem{
s.Content,
+ s.Assets,
s.Data,
s.I18n,
s.Layouts,
WorkDir: fs.WorkingDirReadOnly,
PublishFs: publishFs,
PublishFsStatic: publishFsStatic,
+ workingDir: p.Cfg.BaseConfig().WorkingDir,
buildMu: buildMu,
}
"time"
qt "github.com/frankban/quicktest"
+ "github.com/gohugoio/hugo/common/loggers"
"github.com/gohugoio/hugo/htesting"
"github.com/gohugoio/hugo/resources/page"
}
func TestRebuildOnAssetChange(t *testing.T) {
- b := newTestSitesBuilder(t).Running()
+ b := newTestSitesBuilder(t).Running().WithLogger(loggers.NewInfoLogger())
b.WithTemplatesAdded("index.html", `
{{ (resources.Get "data.json").Content }}
`)
"net/url"
"path"
"path/filepath"
- "regexp"
"runtime"
"sort"
"strings"
"github.com/gohugoio/hugo/common/paths"
- "github.com/gohugoio/hugo/resources"
-
"github.com/gohugoio/hugo/identity"
"github.com/gohugoio/hugo/markup/converter/hooks"
"github.com/gohugoio/hugo/markup/converter"
"github.com/gohugoio/hugo/hugofs/files"
+ hglob "github.com/gohugoio/hugo/hugofs/glob"
"github.com/gohugoio/hugo/common/maps"
return filtered
}
-var (
- // These are only used for cache busting, so false positives are fine.
- // We also deliberately do not match for file suffixes to also catch
- // directory names.
- // TODO(bep) consider this when completing the relevant PR rewrite on this.
- cssFileRe = regexp.MustCompile("(css|sass|scss)")
- cssConfigRe = regexp.MustCompile(`(postcss|tailwind)\.config\.js`)
- jsFileRe = regexp.MustCompile("(js|ts|jsx|tsx)")
-)
-
// reBuild partially rebuilds a site given the filesystem events.
// It returns whatever the content source was changed.
// TODO(bep) clean up/rewrite this method.
logger = helpers.NewDistinctErrorLogger()
)
- var cachePartitions []string
- // Special case
- // TODO(bep) I have a ongoing branch where I have redone the cache. Consider this there.
- var (
- evictCSSRe *regexp.Regexp
- evictJSRe *regexp.Regexp
- )
+ var cacheBusters []func(string) bool
+ bcfg := s.conf.Build
for _, ev := range events {
- if assetsFilename, _ := s.BaseFs.Assets.MakePathRelative(ev.Name); assetsFilename != "" {
- cachePartitions = append(cachePartitions, resources.ResourceKeyPartitions(assetsFilename)...)
- if evictCSSRe == nil {
- if cssFileRe.MatchString(assetsFilename) || cssConfigRe.MatchString(assetsFilename) {
- evictCSSRe = cssFileRe
- }
- }
- if evictJSRe == nil && jsFileRe.MatchString(assetsFilename) {
- evictJSRe = jsFileRe
+ component, relFilename := s.BaseFs.MakePathRelative(ev.Name)
+ if relFilename != "" {
+ p := hglob.NormalizePath(path.Join(component, relFilename))
+ g, err := bcfg.MatchCacheBuster(s.Log, p)
+ if err == nil && g != nil {
+ cacheBusters = append(cacheBusters, g)
}
}
return err
}
- // These in memory resource caches will be rebuilt on demand.
- for _, s := range s.h.Sites {
- s.ResourceSpec.ResourceCache.DeletePartitions(cachePartitions...)
- if evictCSSRe != nil {
- s.ResourceSpec.ResourceCache.DeleteMatches(evictCSSRe)
- }
- if evictJSRe != nil {
- s.ResourceSpec.ResourceCache.DeleteMatches(evictJSRe)
+ var cacheBusterOr func(string) bool
+ if len(cacheBusters) > 0 {
+ cacheBusterOr = func(s string) bool {
+ for _, cb := range cacheBusters {
+ if cb(s) {
+ return true
+ }
+ }
+ return false
}
}
+ // These in memory resource caches will be rebuilt on demand.
+ if len(cacheBusters) > 0 {
+ s.h.ResourceSpec.ResourceCache.DeleteMatches(cacheBusterOr)
+ }
+
if tmplChanged || i18nChanged {
s.h.init.Reset()
var prototype *deps.Deps
}
func (s *Site) renderAndWriteXML(ctx context.Context, statCounter *uint64, name string, targetPath string, d any, templ tpl.Template) error {
- s.Log.Debugf("Render XML for %q to %q", name, targetPath)
renderBuffer := bp.GetBuffer()
defer bp.PutBuffer(renderBuffer)
}
func (s *Site) renderAndWritePage(statCounter *uint64, name string, targetPath string, p *pageState, templ tpl.Template) error {
- s.Log.Debugf("Render %s to %q", name, targetPath)
s.h.IncrPageRender()
renderBuffer := bp.GetBuffer()
defer bp.PutBuffer(renderBuffer)
"github.com/gohugoio/hugo/helpers"
- "github.com/gohugoio/hugo/hugofs/glob"
+ hglob "github.com/gohugoio/hugo/hugofs/glob"
"github.com/gohugoio/hugo/resources/resource"
// e.g. "scss" will also return "sass".
func ResourceKeyPartitions(filename string) []string {
var partitions []string
- filename = glob.NormalizePath(filename)
+ filename = hglob.NormalizePath(filename)
dir, name := path.Split(filename)
ext := strings.TrimPrefix(path.Ext(filepath.ToSlash(name)), ".")
}
}
-func (c *ResourceCache) DeleteMatches(re *regexp.Regexp) {
+func (c *ResourceCache) DeleteMatchesRe(re *regexp.Regexp) {
c.Lock()
defer c.Unlock()
}
}
}
+
+func (c *ResourceCache) DeleteMatches(match func(string) bool) {
+ c.Lock()
+ defer c.Unlock()
+
+ for k := range c.cache {
+ if match(k) {
+ delete(c.cache, k)
+ }
+ }
+}
projects / brevno-suite / hugo / commitdiff