mirror of
https://github.com/gohugoio/hugo.git
synced 2024-11-07 20:30:36 -05:00
7829474088
This commit adds support for a configuration directory (default `config`). The different pieces in this puzzle are: * A new `--environment` (or `-e`) flag. This can also be set with the `HUGO_ENVIRONMENT` OS environment variable. The value for `environment` defaults to `production` when running `hugo` and `development` when running `hugo server`. You can set it to any value you want (e.g. `hugo server -e "Sensible Environment"`), but as it is used to load configuration from the file system, the letter case may be important. You can get this value in your templates with `{{ hugo.Environment }}`. * A new `--configDir` flag (defaults to `config` below your project). This can also be set with `HUGO_CONFIGDIR` OS environment variable. If the `configDir` exists, the configuration files will be read and merged on top of each other from left to right; the right-most value will win on duplicates. Given the example tree below: If `environment` is `production`, the left-most `config.toml` would be the one directly below the project (this can now be omitted if you want), and then `_default/config.toml` and finally `production/config.toml`. And since these will be merged, you can just provide the environment specific configuration setting in you production config, e.g. `enableGitInfo = true`. The order within the directories will be lexical (`config.toml` and then `params.toml`). ```bash config ├── _default │ ├── config.toml │ ├── languages.toml │ ├── menus │ │ ├── menus.en.toml │ │ └── menus.zh.toml │ └── params.toml ├── development │ └── params.toml └── production ├── config.toml └── params.toml ``` Some configuration maps support the language code in the filename (e.g. `menus.en.toml`): `menus` (`menu` also works) and `params`. Also note that the only folders with "a meaning" in the above listing is the top level directories below `config`. The `menus` sub folder is just added for better organization. We use `TOML` in the example above, but Hugo also supports `JSON` and `YAML` as configuration formats. These can be mixed. Fixes #5422
273 lines
6.1 KiB
Go
273 lines
6.1 KiB
Go
// +build mage
|
|
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/magefile/mage/mg"
|
|
"github.com/magefile/mage/sh"
|
|
)
|
|
|
|
const (
|
|
packageName = "github.com/gohugoio/hugo"
|
|
noGitLdflags = "-X $PACKAGE/common/hugo.buildDate=$BUILD_DATE"
|
|
)
|
|
|
|
var ldflags = "-X $PACKAGE/common/hugo.commitHash=$COMMIT_HASH -X $PACKAGE/common/hugo.buildDate=$BUILD_DATE"
|
|
|
|
// allow user to override go executable by running as GOEXE=xxx make ... on unix-like systems
|
|
var goexe = "go"
|
|
|
|
func init() {
|
|
if exe := os.Getenv("GOEXE"); exe != "" {
|
|
goexe = exe
|
|
}
|
|
|
|
// We want to use Go 1.11 modules even if the source lives inside GOPATH.
|
|
// The default is "auto".
|
|
os.Setenv("GO111MODULE", "on")
|
|
}
|
|
|
|
// Build hugo binary
|
|
func Hugo() error {
|
|
return sh.RunWith(flagEnv(), goexe, "build", "-ldflags", ldflags, "-tags", buildTags(), packageName)
|
|
}
|
|
|
|
// Build hugo binary with race detector enabled
|
|
func HugoRace() error {
|
|
return sh.RunWith(flagEnv(), goexe, "build", "-race", "-ldflags", ldflags, "-tags", buildTags(), packageName)
|
|
}
|
|
|
|
// Install hugo binary
|
|
func Install() error {
|
|
return sh.RunWith(flagEnv(), goexe, "install", "-ldflags", ldflags, "-tags", buildTags(), packageName)
|
|
}
|
|
|
|
func flagEnv() map[string]string {
|
|
hash, _ := sh.Output("git", "rev-parse", "--short", "HEAD")
|
|
return map[string]string{
|
|
"PACKAGE": packageName,
|
|
"COMMIT_HASH": hash,
|
|
"BUILD_DATE": time.Now().Format("2006-01-02T15:04:05Z0700"),
|
|
}
|
|
}
|
|
|
|
func Generate() error {
|
|
return sh.RunWith(flagEnv(), goexe, "generate", path.Join(packageName, "tpl/tplimpl/embedded/generate"))
|
|
}
|
|
|
|
// Build hugo without git info
|
|
func HugoNoGitInfo() error {
|
|
ldflags = noGitLdflags
|
|
return Hugo()
|
|
}
|
|
|
|
var docker = sh.RunCmd("docker")
|
|
|
|
// Build hugo Docker container
|
|
func Docker() error {
|
|
if err := docker("build", "-t", "hugo", "."); err != nil {
|
|
return err
|
|
}
|
|
// yes ignore errors here
|
|
docker("rm", "-f", "hugo-build")
|
|
if err := docker("run", "--name", "hugo-build", "hugo ls /go/bin"); err != nil {
|
|
return err
|
|
}
|
|
if err := docker("cp", "hugo-build:/go/bin/hugo", "."); err != nil {
|
|
return err
|
|
}
|
|
return docker("rm", "hugo-build")
|
|
}
|
|
|
|
// Run tests and linters
|
|
func Check() {
|
|
if strings.Contains(runtime.Version(), "1.8") {
|
|
// Go 1.8 doesn't play along with go test ./... and /vendor.
|
|
// We could fix that, but that would take time.
|
|
fmt.Printf("Skip Check on %s\n", runtime.Version())
|
|
return
|
|
}
|
|
|
|
mg.Deps(Test386)
|
|
|
|
mg.Deps(Fmt, Vet)
|
|
|
|
// don't run two tests in parallel, they saturate the CPUs anyway, and running two
|
|
// causes memory issues in CI.
|
|
mg.Deps(TestRace)
|
|
}
|
|
|
|
// Run tests in 32-bit mode
|
|
// Note that we don't run with the extended tag. Currently not supported in 32 bit.
|
|
func Test386() error {
|
|
return sh.RunWith(map[string]string{"GOARCH": "386"}, goexe, "test", "./...")
|
|
}
|
|
|
|
// Run tests
|
|
func Test() error {
|
|
return sh.Run(goexe, "test", "./...", "-tags", buildTags())
|
|
}
|
|
|
|
// Run tests with race detector
|
|
func TestRace() error {
|
|
return sh.Run(goexe, "test", "-race", "./...", "-tags", buildTags())
|
|
}
|
|
|
|
// Run gofmt linter
|
|
func Fmt() error {
|
|
if !isGoLatest() {
|
|
return nil
|
|
}
|
|
pkgs, err := hugoPackages()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
failed := false
|
|
first := true
|
|
for _, pkg := range pkgs {
|
|
files, err := filepath.Glob(filepath.Join(pkg, "*.go"))
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
for _, f := range files {
|
|
// gofmt doesn't exit with non-zero when it finds unformatted code
|
|
// so we have to explicitly look for output, and if we find any, we
|
|
// should fail this target.
|
|
s, err := sh.Output("gofmt", "-l", f)
|
|
if err != nil {
|
|
fmt.Printf("ERROR: running gofmt on %q: %v\n", f, err)
|
|
failed = true
|
|
}
|
|
if s != "" {
|
|
if first {
|
|
fmt.Println("The following files are not gofmt'ed:")
|
|
first = false
|
|
}
|
|
failed = true
|
|
fmt.Println(s)
|
|
}
|
|
}
|
|
}
|
|
if failed {
|
|
return errors.New("improperly formatted go files")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var (
|
|
pkgPrefixLen = len("github.com/gohugoio/hugo")
|
|
pkgs []string
|
|
pkgsInit sync.Once
|
|
)
|
|
|
|
func hugoPackages() ([]string, error) {
|
|
var err error
|
|
pkgsInit.Do(func() {
|
|
var s string
|
|
s, err = sh.Output(goexe, "list", "./...")
|
|
if err != nil {
|
|
return
|
|
}
|
|
pkgs = strings.Split(s, "\n")
|
|
for i := range pkgs {
|
|
pkgs[i] = "." + pkgs[i][pkgPrefixLen:]
|
|
}
|
|
})
|
|
return pkgs, err
|
|
}
|
|
|
|
// Run golint linter
|
|
func Lint() error {
|
|
pkgs, err := hugoPackages()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
failed := false
|
|
for _, pkg := range pkgs {
|
|
// We don't actually want to fail this target if we find golint errors,
|
|
// so we don't pass -set_exit_status, but we still print out any failures.
|
|
if _, err := sh.Exec(nil, os.Stderr, nil, "golint", pkg); err != nil {
|
|
fmt.Printf("ERROR: running go lint on %q: %v\n", pkg, err)
|
|
failed = true
|
|
}
|
|
}
|
|
if failed {
|
|
return errors.New("errors running golint")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Run go vet linter
|
|
func Vet() error {
|
|
if err := sh.Run(goexe, "vet", "./..."); err != nil {
|
|
return fmt.Errorf("error running go vet: %v", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Generate test coverage report
|
|
func TestCoverHTML() error {
|
|
const (
|
|
coverAll = "coverage-all.out"
|
|
cover = "coverage.out"
|
|
)
|
|
f, err := os.Create(coverAll)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
if _, err := f.Write([]byte("mode: count")); err != nil {
|
|
return err
|
|
}
|
|
pkgs, err := hugoPackages()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, pkg := range pkgs {
|
|
if err := sh.Run(goexe, "test", "-coverprofile="+cover, "-covermode=count", pkg); err != nil {
|
|
return err
|
|
}
|
|
b, err := ioutil.ReadFile(cover)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
continue
|
|
}
|
|
return err
|
|
}
|
|
idx := bytes.Index(b, []byte{'\n'})
|
|
b = b[idx+1:]
|
|
if _, err := f.Write(b); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := f.Close(); err != nil {
|
|
return err
|
|
}
|
|
return sh.Run(goexe, "tool", "cover", "-html="+coverAll)
|
|
}
|
|
|
|
func isGoLatest() bool {
|
|
return strings.Contains(runtime.Version(), "1.11")
|
|
}
|
|
|
|
func buildTags() string {
|
|
// To build the extended Hugo SCSS/SASS enabled version, build with
|
|
// HUGO_BUILD_TAGS=extended mage install etc.
|
|
if envtags := os.Getenv("HUGO_BUILD_TAGS"); envtags != "" {
|
|
return envtags
|
|
}
|
|
return "none"
|
|
|
|
}
|