hugo

config.go (11056B)

 // Copyright 2019 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 modules
 
 import (
 	"fmt"
 	"path/filepath"
 	"strings"
 
 	"github.com/gohugoio/hugo/common/hugo"
 
 	"github.com/gohugoio/hugo/config"
 	"github.com/gohugoio/hugo/hugofs/files"
 	"github.com/gohugoio/hugo/langs"
 	"github.com/mitchellh/mapstructure"
 )
 
 var DefaultModuleConfig = Config{
 
 	// Default to direct, which means "git clone" and similar. We
 	// will investigate proxy settings in more depth later.
 	// See https://github.com/golang/go/issues/26334
 	Proxy: "direct",
 
 	// Comma separated glob list matching paths that should not use the
 	// proxy configured above.
 	NoProxy: "none",
 
 	// Comma separated glob list matching paths that should be
 	// treated as private.
 	Private: "*.*",
 
 	// A list of replacement directives mapping a module path to a directory
 	// or a theme component in the themes folder.
 	// Note that this will turn the component into a traditional theme component
 	// that does not partake in vendoring etc.
 	// The syntax is the similar to the replacement directives used in go.mod, e.g:
 	//    github.com/mod1 -> ../mod1,github.com/mod2 -> ../mod2
 	Replacements: nil,
 }
 
 // ApplyProjectConfigDefaults applies default/missing module configuration for
 // the main project.
 func ApplyProjectConfigDefaults(cfg config.Provider, mod Module) error {
 	moda := mod.(*moduleAdapter)
 
 	// Map legacy directory config into the new module.
 	languages := cfg.Get("languagesSortedDefaultFirst").(langs.Languages)
 	isMultiHost := languages.IsMultihost()
 
 	// To bridge between old and new configuration format we need
 	// a way to make sure all of the core components are configured on
 	// the basic level.
 	componentsConfigured := make(map[string]bool)
 	for _, mnt := range moda.mounts {
 		if !strings.HasPrefix(mnt.Target, files.JsConfigFolderMountPrefix) {
 			componentsConfigured[mnt.Component()] = true
 		}
 	}
 
 	type dirKeyComponent struct {
 		key          string
 		component    string
 		multilingual bool
 	}
 
 	dirKeys := []dirKeyComponent{
 		{"contentDir", files.ComponentFolderContent, true},
 		{"dataDir", files.ComponentFolderData, false},
 		{"layoutDir", files.ComponentFolderLayouts, false},
 		{"i18nDir", files.ComponentFolderI18n, false},
 		{"archetypeDir", files.ComponentFolderArchetypes, false},
 		{"assetDir", files.ComponentFolderAssets, false},
 		{"", files.ComponentFolderStatic, isMultiHost},
 	}
 
 	createMountsFor := func(d dirKeyComponent, cfg config.Provider) []Mount {
 		var lang string
 		if language, ok := cfg.(*langs.Language); ok {
 			lang = language.Lang
 		}
 
 		// Static mounts are a little special.
 		if d.component == files.ComponentFolderStatic {
 			var mounts []Mount
 			staticDirs := getStaticDirs(cfg)
 			if len(staticDirs) > 0 {
 				componentsConfigured[d.component] = true
 			}
 
 			for _, dir := range staticDirs {
 				mounts = append(mounts, Mount{Lang: lang, Source: dir, Target: d.component})
 			}
 
 			return mounts
 
 		}
 
 		if cfg.IsSet(d.key) {
 			source := cfg.GetString(d.key)
 			componentsConfigured[d.component] = true
 
 			return []Mount{{
 				// No lang set for layouts etc.
 				Source: source,
 				Target: d.component,
 			}}
 		}
 
 		return nil
 	}
 
 	createMounts := func(d dirKeyComponent) []Mount {
 		var mounts []Mount
 		if d.multilingual {
 			if d.component == files.ComponentFolderContent {
 				seen := make(map[string]bool)
 				hasContentDir := false
 				for _, language := range languages {
 					if language.ContentDir != "" {
 						hasContentDir = true
 						break
 					}
 				}
 
 				if hasContentDir {
 					for _, language := range languages {
 						contentDir := language.ContentDir
 						if contentDir == "" {
 							contentDir = files.ComponentFolderContent
 						}
 						if contentDir == "" || seen[contentDir] {
 							continue
 						}
 						seen[contentDir] = true
 						mounts = append(mounts, Mount{Lang: language.Lang, Source: contentDir, Target: d.component})
 					}
 				}
 
 				componentsConfigured[d.component] = len(seen) > 0
 
 			} else {
 				for _, language := range languages {
 					mounts = append(mounts, createMountsFor(d, language)...)
 				}
 			}
 		} else {
 			mounts = append(mounts, createMountsFor(d, cfg)...)
 		}
 
 		return mounts
 	}
 
 	var mounts []Mount
 	for _, dirKey := range dirKeys {
 		if componentsConfigured[dirKey.component] {
 			continue
 		}
 
 		mounts = append(mounts, createMounts(dirKey)...)
 
 	}
 
 	// Add default configuration
 	for _, dirKey := range dirKeys {
 		if componentsConfigured[dirKey.component] {
 			continue
 		}
 		mounts = append(mounts, Mount{Source: dirKey.component, Target: dirKey.component})
 	}
 
 	// Prepend the mounts from configuration.
 	mounts = append(moda.mounts, mounts...)
 
 	moda.mounts = mounts
 
 	return nil
 }
 
 // DecodeConfig creates a modules Config from a given Hugo configuration.
 func DecodeConfig(cfg config.Provider) (Config, error) {
 	return decodeConfig(cfg, nil)
 }
 
 func decodeConfig(cfg config.Provider, pathReplacements map[string]string) (Config, error) {
 	c := DefaultModuleConfig
 	c.replacementsMap = pathReplacements
 
 	if cfg == nil {
 		return c, nil
 	}
 
 	themeSet := cfg.IsSet("theme")
 	moduleSet := cfg.IsSet("module")
 
 	if moduleSet {
 		m := cfg.GetStringMap("module")
 		if err := mapstructure.WeakDecode(m, &c); err != nil {
 			return c, err
 		}
 
 		if c.replacementsMap == nil {
 
 			if len(c.Replacements) == 1 {
 				c.Replacements = strings.Split(c.Replacements[0], ",")
 			}
 
 			for i, repl := range c.Replacements {
 				c.Replacements[i] = strings.TrimSpace(repl)
 			}
 
 			c.replacementsMap = make(map[string]string)
 			for _, repl := range c.Replacements {
 				parts := strings.Split(repl, "->")
 				if len(parts) != 2 {
 					return c, fmt.Errorf(`invalid module.replacements: %q; configure replacement pairs on the form "oldpath->newpath" `, repl)
 				}
 
 				c.replacementsMap[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
 			}
 		}
 
 		if c.replacementsMap != nil && c.Imports != nil {
 			for i, imp := range c.Imports {
 				if newImp, found := c.replacementsMap[imp.Path]; found {
 					imp.Path = newImp
 					imp.pathProjectReplaced = true
 					c.Imports[i] = imp
 				}
 			}
 		}
 
 		for i, mnt := range c.Mounts {
 			mnt.Source = filepath.Clean(mnt.Source)
 			mnt.Target = filepath.Clean(mnt.Target)
 			c.Mounts[i] = mnt
 		}
 
 	}
 
 	if themeSet {
 		imports := config.GetStringSlicePreserveString(cfg, "theme")
 		for _, imp := range imports {
 			c.Imports = append(c.Imports, Import{
 				Path: imp,
 			})
 		}
 
 	}
 
 	return c, nil
 }
 
 // Config holds a module config.
 type Config struct {
 	Mounts  []Mount
 	Imports []Import
 
 	// Meta info about this module (license information etc.).
 	Params map[string]any
 
 	// Will be validated against the running Hugo version.
 	HugoVersion HugoVersion
 
 	// A optional Glob pattern matching module paths to skip when vendoring, e.g.
 	// "github.com/**".
 	NoVendor string
 
 	// When enabled, we will pick the vendored module closest to the module
 	// using it.
 	// The default behaviour is to pick the first.
 	// Note that there can still be only one dependency of a given module path,
 	// so once it is in use it cannot be redefined.
 	VendorClosest bool
 
 	Replacements    []string
 	replacementsMap map[string]string
 
 	// Configures GOPROXY.
 	Proxy string
 	// Configures GONOPROXY.
 	NoProxy string
 	// Configures GOPRIVATE.
 	Private string
 
 	// Set the workspace file to use, e.g. hugo.work.
 	// Enables Go "Workspace" mode.
 	// Requires Go 1.18+
 	// See https://tip.golang.org/doc/go1.18
 	Workspace string
 }
 
 // hasModuleImport reports whether the project config have one or more
 // modules imports, e.g. github.com/bep/myshortcodes.
 func (c Config) hasModuleImport() bool {
 	for _, imp := range c.Imports {
 		if isProbablyModule(imp.Path) {
 			return true
 		}
 	}
 	return false
 }
 
 // HugoVersion holds Hugo binary version requirements for a module.
 type HugoVersion struct {
 	// The minimum Hugo version that this module works with.
 	Min hugo.VersionString
 
 	// The maximum Hugo version that this module works with.
 	Max hugo.VersionString
 
 	// Set if the extended version is needed.
 	Extended bool
 }
 
 func (v HugoVersion) String() string {
 	extended := ""
 	if v.Extended {
 		extended = " extended"
 	}
 
 	if v.Min != "" && v.Max != "" {
 		return fmt.Sprintf("%s/%s%s", v.Min, v.Max, extended)
 	}
 
 	if v.Min != "" {
 		return fmt.Sprintf("Min %s%s", v.Min, extended)
 	}
 
 	if v.Max != "" {
 		return fmt.Sprintf("Max %s%s", v.Max, extended)
 	}
 
 	return extended
 }
 
 // IsValid reports whether this version is valid compared to the running
 // Hugo binary.
 func (v HugoVersion) IsValid() bool {
 	current := hugo.CurrentVersion.Version()
 	if v.Extended && !hugo.IsExtended {
 		return false
 	}
 
 	isValid := true
 
 	if v.Min != "" && current.Compare(v.Min) > 0 {
 		isValid = false
 	}
 
 	if v.Max != "" && current.Compare(v.Max) < 0 {
 		isValid = false
 	}
 
 	return isValid
 }
 
 type Import struct {
 	Path                string // Module path
 	pathProjectReplaced bool   // Set when Path is replaced in project config.
 	IgnoreConfig        bool   // Ignore any config in config.toml (will still follow imports).
 	IgnoreImports       bool   // Do not follow any configured imports.
 	NoMounts            bool   // Do not mount any folder in this import.
 	NoVendor            bool   // Never vendor this import (only allowed in main project).
 	Disable             bool   // Turn off this module.
 	Mounts              []Mount
 }
 
 type Mount struct {
 	Source string // relative path in source repo, e.g. "scss"
 	Target string // relative target path, e.g. "assets/bootstrap/scss"
 
 	Lang string // any language code associated with this mount.
 
 	// Include only files matching the given Glob patterns (string or slice).
 	IncludeFiles any
 
 	// Exclude all files matching the given Glob patterns (string or slice).
 	ExcludeFiles any
 }
 
 // Used as key to remove duplicates.
 func (m Mount) key() string {
 	return strings.Join([]string{m.Lang, m.Source, m.Target}, "/")
 }
 
 func (m Mount) Component() string {
 	return strings.Split(m.Target, fileSeparator)[0]
 }
 
 func (m Mount) ComponentAndName() (string, string) {
 	c, n, _ := strings.Cut(m.Target, fileSeparator)
 	return c, n
 }
 
 func getStaticDirs(cfg config.Provider) []string {
 	var staticDirs []string
 	for i := -1; i <= 10; i++ {
 		staticDirs = append(staticDirs, getStringOrStringSlice(cfg, "staticDir", i)...)
 	}
 	return staticDirs
 }
 
 func getStringOrStringSlice(cfg config.Provider, key string, id int) []string {
 	if id >= 0 {
 		key = fmt.Sprintf("%s%d", key, id)
 	}
 
 	return config.GetStringSlicePreserveString(cfg, key)
 }