magefile.go - hugo - [fork] hugo port for 9front
HTML git clone https://git.drkhsh.at/hugo.git
DIR Log
DIR Files
DIR Refs
DIR Submodules
DIR README
DIR LICENSE
---
magefile.go (7078B)
---
1 //go:build mage
2
3 package main
4
5 import (
6 "bytes"
7 "fmt"
8 "os"
9 "path"
10 "path/filepath"
11 "runtime"
12 "strings"
13 "sync"
14 "time"
15
16 "github.com/gohugoio/hugo/codegen"
17 "github.com/gohugoio/hugo/resources/page/page_generate"
18
19 "github.com/magefile/mage/mg"
20 "github.com/magefile/mage/sh"
21 )
22
23 const (
24 packageName = "github.com/gohugoio/hugo"
25 noGitLdflags = "-X github.com/gohugoio/hugo/common/hugo.vendorInfo=mage"
26 )
27
28 var ldflags = noGitLdflags
29
30 // allow user to override go executable by running as GOEXE=xxx make ... on unix-like systems
31 var goexe = "go"
32
33 func init() {
34 if exe := os.Getenv("GOEXE"); exe != "" {
35 goexe = exe
36 }
37 }
38
39 func runWith(env map[string]string, cmd string, inArgs ...any) error {
40 s := argsToStrings(inArgs...)
41 return sh.RunWith(env, cmd, s...)
42 }
43
44 // Build hugo binary
45 func Hugo() error {
46 return runWith(flagEnv(), goexe, "build", "-ldflags", ldflags, buildFlags(), "-tags", buildTags(), packageName)
47 }
48
49 // Build hugo binary with race detector enabled
50 func HugoRace() error {
51 return runWith(flagEnv(), goexe, "build", "-race", "-ldflags", ldflags, buildFlags(), "-tags", buildTags(), packageName)
52 }
53
54 // Install hugo binary
55 func Install() error {
56 return runWith(flagEnv(), goexe, "install", "-ldflags", ldflags, buildFlags(), "-tags", buildTags(), packageName)
57 }
58
59 // Uninstall hugo binary
60 func Uninstall() error {
61 return sh.Run(goexe, "clean", "-i", packageName)
62 }
63
64 func flagEnv() map[string]string {
65 hash, _ := sh.Output("git", "rev-parse", "--short", "HEAD")
66 return map[string]string{
67 "PACKAGE": packageName,
68 "COMMIT_HASH": hash,
69 "BUILD_DATE": time.Now().Format("2006-01-02T15:04:05Z0700"),
70 }
71 }
72
73 // Generate autogen packages
74 func Generate() error {
75 generatorPackages := []string{
76 "livereload/gen",
77 }
78
79 for _, pkg := range generatorPackages {
80 if err := runWith(flagEnv(), goexe, "generate", path.Join(packageName, pkg)); err != nil {
81 return err
82 }
83 }
84
85 dir, _ := os.Getwd()
86 c := codegen.NewInspector(dir)
87
88 if err := page_generate.Generate(c); err != nil {
89 return err
90 }
91
92 goFmtPatterns := []string{
93 // TODO(bep) check: stat ./resources/page/*autogen*: no such file or directory
94 "./resources/page/page_marshaljson.autogen.go",
95 "./resources/page/page_wrappers.autogen.go",
96 "./resources/page/zero_file.autogen.go",
97 }
98
99 for _, pattern := range goFmtPatterns {
100 if err := sh.Run("gofmt", "-w", filepath.FromSlash(pattern)); err != nil {
101 return err
102 }
103 }
104
105 return nil
106 }
107
108 // Generate docs helper
109 func GenDocsHelper() error {
110 return runCmd(flagEnv(), goexe, "run", "-tags", buildTags(), "main.go", "gen", "docshelper")
111 }
112
113 // Build hugo without git info
114 func HugoNoGitInfo() error {
115 ldflags = noGitLdflags
116 return Hugo()
117 }
118
119 // Build hugo Docker container
120 func Docker() error {
121 docker := sh.RunCmd("docker")
122
123 if err := docker("build", "-t", "hugo", "."); err != nil {
124 return err
125 }
126 // yes ignore errors here
127 docker("rm", "-f", "hugo-build")
128 if err := docker("run", "--name", "hugo-build", "hugo ls /go/bin"); err != nil {
129 return err
130 }
131 if err := docker("cp", "hugo-build:/go/bin/hugo", "."); err != nil {
132 return err
133 }
134 return docker("rm", "hugo-build")
135 }
136
137 // Run tests and linters
138 func Check() {
139 if runtime.GOARCH == "amd64" && runtime.GOOS != "darwin" {
140 mg.Deps(Test386)
141 } else {
142 fmt.Printf("Skip Test386 on %s and/or %s\n", runtime.GOARCH, runtime.GOOS)
143 }
144
145 if isCI() && isDarwin() {
146 // Skip on macOS in CI (disk space issues)
147 } else {
148 mg.Deps(Fmt, Vet)
149 }
150
151 // don't run two tests in parallel, they saturate the CPUs anyway, and running two
152 // causes memory issues in CI.
153 mg.Deps(TestRace)
154 }
155
156 func testGoFlags() string {
157 if isCI() {
158 return ""
159 }
160
161 return "-timeout=1m"
162 }
163
164 // Run tests in 32-bit mode
165 // Note that we don't run with the extended tag. Currently not supported in 32 bit.
166 func Test386() error {
167 env := map[string]string{"GOARCH": "386", "GOFLAGS": testGoFlags()}
168 return runCmd(env, goexe, "test", "-p", "2", "./...")
169 }
170
171 // Run tests
172 func Test() error {
173 env := map[string]string{"GOFLAGS": testGoFlags()}
174 return runCmd(env, goexe, "test", "-p", "2", "./...", "-tags", buildTags())
175 }
176
177 // Run tests with race detector
178 func TestRace() error {
179 env := map[string]string{"GOFLAGS": testGoFlags()}
180 return runCmd(env, goexe, "test", "-p", "2", "-race", "./...", "-tags", buildTags())
181 }
182
183 // Run gofmt linter
184 func Fmt() error {
185 if !isGoLatest() && !isUnix() {
186 return nil
187 }
188 s, err := sh.Output("./check_gofmt.sh")
189 if err != nil {
190 fmt.Println(s)
191 return fmt.Errorf("gofmt needs to be run: %s", err)
192 }
193
194 return nil
195 }
196
197 const pkgPrefixLen = len("github.com/gohugoio/hugo")
198
199 var hugoPackages = sync.OnceValues(func() ([]string, error) {
200 s, err := sh.Output(goexe, "list", "./...")
201 if err != nil {
202 return nil, err
203 }
204 pkgs := strings.Split(s, "\n")
205 for i := range pkgs {
206 pkgs[i] = "." + pkgs[i][pkgPrefixLen:]
207 }
208 return pkgs, nil
209 })
210
211 // Run go vet linter
212 func Vet() error {
213 if err := sh.Run(goexe, "vet", "./..."); err != nil {
214 return fmt.Errorf("error running go vet: %v", err)
215 }
216 return nil
217 }
218
219 // Generate test coverage report
220 func TestCoverHTML() error {
221 const (
222 coverAll = "coverage-all.out"
223 cover = "coverage.out"
224 )
225 f, err := os.Create(coverAll)
226 if err != nil {
227 return err
228 }
229 defer f.Close()
230 if _, err := f.WriteString("mode: count"); err != nil {
231 return err
232 }
233 pkgs, err := hugoPackages()
234 if err != nil {
235 return err
236 }
237 for _, pkg := range pkgs {
238 if err := sh.Run(goexe, "test", "-coverprofile="+cover, "-covermode=count", pkg); err != nil {
239 return err
240 }
241 b, err := os.ReadFile(cover)
242 if err != nil {
243 if os.IsNotExist(err) {
244 continue
245 }
246 return err
247 }
248 idx := bytes.Index(b, []byte{'\n'})
249 b = b[idx+1:]
250 if _, err := f.Write(b); err != nil {
251 return err
252 }
253 }
254 if err := f.Close(); err != nil {
255 return err
256 }
257 return sh.Run(goexe, "tool", "cover", "-html="+coverAll)
258 }
259
260 func runCmd(env map[string]string, cmd string, args ...any) error {
261 if mg.Verbose() {
262 return runWith(env, cmd, args...)
263 }
264 output, err := sh.OutputWith(env, cmd, argsToStrings(args...)...)
265 if err != nil {
266 fmt.Fprint(os.Stderr, output)
267 }
268
269 return err
270 }
271
272 func isGoLatest() bool {
273 return strings.Contains(runtime.Version(), "1.21")
274 }
275
276 func isUnix() bool {
277 return runtime.GOOS != "windows"
278 }
279
280 func isDarwin() bool {
281 return runtime.GOOS == "darwin"
282 }
283
284 func isCI() bool {
285 return os.Getenv("CI") != ""
286 }
287
288 func buildFlags() []string {
289 if runtime.GOOS == "windows" {
290 return []string{"-buildmode", "exe"}
291 }
292 return nil
293 }
294
295 func buildTags() string {
296 // To build the extended Hugo SCSS/SASS enabled version, build with
297 // HUGO_BUILD_TAGS=extended mage install etc.
298 // To build with `hugo deploy`, use HUGO_BUILD_TAGS=withdeploy
299 if envtags := os.Getenv("HUGO_BUILD_TAGS"); envtags != "" {
300 return envtags
301 }
302 return "none"
303 }
304
305 func argsToStrings(v ...any) []string {
306 var args []string
307 for _, arg := range v {
308 switch v := arg.(type) {
309 case string:
310 if v != "" {
311 args = append(args, v)
312 }
313 case []string:
314 if v != nil {
315 args = append(args, v...)
316 }
317 default:
318 panic("invalid type")
319 }
320 }
321
322 return args
323 }