return err
}
- for i := 0; i < 3; i++ {
- for j := 0; j < 3; j++ {
+ for i := range 3 {
+ for range 3 {
c.Assert(willPanic(i), qt.PanicMatches, fmt.Sprintf("panic-%d", i))
c.Assert(willErr(i), qt.ErrorMatches, fmt.Sprintf("error-%d", i))
}
}
// Test the same keys again without the panic.
- for i := 0; i < 3; i++ {
- for j := 0; j < 3; j++ {
+ for i := range 3 {
+ for range 3 {
v, err := p1.GetOrCreate(fmt.Sprintf("panic-%d", i), func(key string) (testItem, error) {
return testItem{
name: key,
caches, err := filecache.NewCaches(p)
c.Assert(err, qt.IsNil)
cache := caches[name]
- for i := 0; i < 10; i++ {
+ for i := range 10 {
id := fmt.Sprintf("i%d", i)
cache.GetOrCreateBytes(id, func() ([]byte, error) {
return []byte("abc"), nil
c.Assert(err, qt.IsNil)
c.Assert(count, qt.Equals, 5, msg)
- for i := 0; i < 10; i++ {
+ for i := range 10 {
id := fmt.Sprintf("i%d", i)
v := cache.GetString(id)
if i < 5 {
c.Assert(count, qt.Equals, 4)
// Now only the i5 should be left.
- for i := 0; i < 10; i++ {
+ for i := range 10 {
id := fmt.Sprintf("i%d", i)
v := cache.GetString(id)
if i != 5 {
}
for _, ca := range []*filecache.Cache{caches.ImageCache(), caches.AssetsCache(), caches.GetJSONCache(), caches.GetCSVCache()} {
- for i := 0; i < 2; i++ {
+ for range 2 {
info, r, err := ca.GetOrCreate("a", rf("abc"))
c.Assert(err, qt.IsNil)
c.Assert(r, qt.Not(qt.IsNil))
var wg sync.WaitGroup
- for i := 0; i < 50; i++ {
+ for i := range 50 {
wg.Add(1)
go func(i int) {
defer wg.Done()
- for j := 0; j < 20; j++ {
+ for range 20 {
ca := caches.Get(cacheName)
c.Assert(ca, qt.Not(qt.IsNil))
filename, data := filenameData(i)
"path/filepath"
"reflect"
"regexp"
+ "slices"
"sort"
"strings"
"sync"
}
for _, t := range include {
- for i := 0; i < t.NumMethod(); i++ {
+ for i := range t.NumMethod() {
m := t.Method(i)
if excludes[m.Name] || seen[m.Name] {
method := Method{Owner: t, OwnerName: ownerName, Name: m.Name}
- for i := 0; i < numIn; i++ {
+ for i := range numIn {
in := m.Type.In(i)
name, pkg := nameAndPackage(in)
numOut := m.Type.NumOut()
if numOut > 0 {
- for i := 0; i < numOut; i++ {
+ for i := range numOut {
out := m.Type.Out(i)
name, pkg := nameAndPackage(out)
}
args := make([]string, len(m.In))
- for i := 0; i < len(args); i++ {
+ for i := range args {
args[i] = fmt.Sprintf("arg%d", i)
}
return "(" + strings.Join(args, ", ") + ")"
}
args := make([]string, len(m.In))
- for i := 0; i < len(args); i++ {
+ for i := range args {
args[i] = fmt.Sprintf("arg%d %s", i, m.In[i])
}
return "(" + strings.Join(args, ", ") + ")"
}
outs := make([]string, len(m.Out))
- for i := 0; i < len(outs); i++ {
+ for i := range outs {
outs[i] = fmt.Sprintf("o%d %s", i, m.Out[i])
}
// Exclude self
for i, pkgImp := range pkgImports {
if pkgImp == pkgPath {
- pkgImports = append(pkgImports[:i], pkgImports[i+1:]...)
+ pkgImports = slices.Delete(pkgImports, i, i+1)
}
}
}
// This is the root command.
type rootCommand struct {
- Printf func(format string, v ...interface{})
- Println func(a ...interface{})
+ Printf func(format string, v ...any)
+ Println func(a ...any)
StdOut io.Writer
StdErr io.Writer
// Used by mkcert (server).
log.SetOutput(r.StdOut)
- r.Printf = func(format string, v ...interface{}) {
+ r.Printf = func(format string, v ...any) {
if !r.quiet {
fmt.Fprintf(r.StdOut, format, v...)
}
}
- r.Println = func(a ...interface{}) {
+ r.Println = func(a ...any) {
if !r.quiet {
fmt.Fprintln(r.StdOut, a...)
}
os.Stdout.Write(buf.Bytes())
default:
// Decode the JSON to a map[string]interface{} and then unmarshal it again to the correct format.
- var m map[string]interface{}
+ var m map[string]any
if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
return err
}
}
// Decode the JSON to a map[string]interface{} and then unmarshal it again to the correct format.
- var m map[string]interface{}
+ var m map[string]any
if err := json.Unmarshal(buf.Bytes(), &m); err != nil {
return err
}
"github.com/spf13/fsync"
"golang.org/x/sync/errgroup"
"golang.org/x/sync/semaphore"
+ "maps"
)
var (
}
f.prev = make(map[string]uint64)
- for k, v := range f.current {
- f.prev[k] = v
- }
+ maps.Copy(f.prev, f.current)
f.current = make(map[string]uint64)
}
c.serverPorts = make([]serverPortListener, len(conf.configs.Languages))
}
currentServerPort := c.serverPort
- for i := 0; i < len(c.serverPorts); i++ {
+ for i := range c.serverPorts {
l, err := net.Listen("tcp", net.JoinHostPort(c.serverInterface, strconv.Itoa(currentServerPort)))
if err == nil {
c.serverPorts[i] = serverPortListener{ln: l, p: currentServerPort}
tos = append(tos, nil)
continue
}
- for i := 0; i < slice.Len(); i++ {
+ for i := range slice.Len() {
tos = append(tos, slice.Index(i).Interface())
}
}
func appendToInterfaceSlice(tov reflect.Value, from ...any) ([]any, error) {
var tos []any
- for i := 0; i < tov.Len(); i++ {
+ for i := range tov.Len() {
tos = append(tos, tov.Index(i).Interface())
}
package collections
+import "slices"
+
import "sync"
// Stack is a simple LIFO stack that is safe for concurrent use.
for i := len(s.items) - 1; i >= 0; i-- {
if predicate(s.items[i]) {
items = append(items, s.items[i])
- s.items = append(s.items[:i], s.items[i+1:]...)
+ s.items = slices.Delete(s.items, i, i+1)
}
}
return items
c := qt.New(t)
var wg sync.WaitGroup
- for i := 0; i < 10; i++ {
+ for i := range 10 {
i := i
wg.Add(1)
go func() {
defer wg.Done()
- for j := 0; j < 100; j++ {
+ for j := range 100 {
s := strings.Repeat("Hello ", i+j+1*42)
r := strings.NewReader(s)
got, size, err := XXHashFromReader(r)
}
func BenchmarkHashMap(b *testing.B) {
- m := map[string]interface{}{}
- for i := 0; i < 1000; i++ {
+ m := map[string]any{}
+ for i := range 1000 {
m[fmt.Sprintf("key%d", i)] = i
}
}
if ectx.Position.LineNumber > 0 {
- low := ectx.Position.LineNumber - 3
- if low < 0 {
- low = 0
- }
+ low := max(ectx.Position.LineNumber-3, 0)
if ectx.Position.LineNumber > 2 {
ectx.LinesPos = 2
ectx.LinesPos = ectx.Position.LineNumber - 1
}
- high := ectx.Position.LineNumber + 2
- if high > len(lines) {
- high = len(lines)
- }
+ high := min(ectx.Position.LineNumber+2, len(lines))
ectx.Lines = lines[low:high]
vvv := reflect.ValueOf(v)
if vvv.Kind() == reflect.Slice {
out := make([]any, vvv.Len())
- for i := 0; i < vvv.Len(); i++ {
+ for i := range vvv.Len() {
out[i] = vvv.Index(i).Interface()
}
return out, true
"sync"
"github.com/gohugoio/hugo/compare"
+ "slices"
)
var _ compare.Eqer = StringEqualFold("")
// EqualAny returns whether a string is equal to any of the given strings.
func EqualAny(a string, b ...string) bool {
- for _, s := range b {
- if a == s {
- return true
- }
- }
- return false
+ return slices.Contains(b, a)
}
// regexpCache represents a cache of regexp objects protected by a mutex.
// InSlice checks if a string is an element of a slice of strings
// and returns a boolean value.
func InSlice(arr []string, el string) bool {
- for _, v := range arr {
- if v == el {
- return true
- }
- }
- return false
+ return slices.Contains(arr, el)
}
// InSlicEqualFold checks if a string is an element of a slice of strings
return strings.Repeat("ab cfo", r.Intn(33))
}
- for i := 0; i < 22; i++ {
+ for range 22 {
h, w := neww()
fmt.Fprint(w, rndStr()+"abc __foobar"+rndStr())
c.Assert(h.Patterns[0].Match, qt.Equals, true)
// DeprecateLevelMin informs about a deprecation starting at the given version, but with a minimum log level.
func DeprecateLevelMin(item, alternative string, version string, minLevel logg.Level) {
- level := deprecationLogLevelFromVersion(version)
- if level < minLevel {
- level = minLevel
- }
+ level := max(deprecationLogLevelFromVersion(version), minLevel)
DeprecateLevel(item, alternative, version, level)
}
l := loggers.New(opts)
- for i := 0; i < 10; i++ {
+ for range 10 {
l.Errorln("error 1")
l.Errorln("error 2")
l.Warnln("warn 1")
l := loggers.New(opts)
- for i := 0; i < 3; i++ {
+ for range 3 {
l.Errorln("error 1")
l.Errorln("error 2")
l.Errorln("error 1")
import (
"github.com/gohugoio/hugo/common/hashing"
+ "slices"
)
// Ordered is a map that can be iterated in the order of insertion.
delete(m.values, key)
for i, k := range m.keys {
if k == key {
- m.keys = append(m.keys[:i], m.keys[i+1:]...)
+ m.keys = slices.Delete(m.keys, i, i+1)
break
}
}
for i := 1; i <= 10; i++ {
wg.Add(1)
go func(j int) {
- for k := 0; k < 10; k++ {
+ for k := range 10 {
newVal := int64(k + j)
_, err := scratch.Add(key, newVal)
c.Run("Order", func(c *qt.C) {
n := 500
ints := make([]int, n)
- for i := 0; i < n; i++ {
+ for i := range n {
ints[i] = i
}
var result []int
var mu sync.Mutex
- for i := 0; i < n; i++ {
+ for i := range n {
i := i
r.Run(func() error {
mu.Lock()
var counter int64
- for i := 0; i < n; i++ {
+ for range n {
r.Run(func() error {
atomic.AddInt64(&counter, 1)
time.Sleep(1 * time.Millisecond)
// Buffered for performance.
ch := make(chan T, cfg.NumWorkers)
- for i := 0; i < cfg.NumWorkers; i++ {
+ for range cfg.NumWorkers {
g.Go(func() error {
for {
select {
f.IntervalHigh = 20 * time.Second
}
- start := f.IntervalHigh / 3
- if start < f.IntervalLow {
- start = f.IntervalLow
- }
+ start := max(f.IntervalHigh/3, f.IntervalLow)
f.interval = start
f.last = time.Now()
switch vv.Kind() {
case reflect.Slice, reflect.Array:
result = make([]string, vv.Len())
- for i := 0; i < vv.Len(); i++ {
+ for i := range vv.Len() {
s, err := cast.ToStringE(vv.Index(i).Interface())
if err != nil {
return nil, err
package types
import (
+ "slices"
"sync"
)
if len(q.set) == q.size {
// Full
delete(q.set, q.vals[0])
- q.vals = append(q.vals[:0], q.vals[1:]...)
+ q.vals = slices.Delete(q.vals, 0, 1)
}
q.set[v] = true
q.vals = append(q.vals, v)
queue := NewEvictingQueue[string](3)
- for j := 0; j < 100; j++ {
+ for range 100 {
wg.Add(1)
go func() {
defer wg.Done()
// KeyValues struct.
func NewKeyValuesStrings(key string, values ...string) KeyValues {
iv := make([]any, len(values))
- for i := 0; i < len(values); i++ {
+ for i := range values {
iv[i] = values[i]
}
return KeyValues{Key: key, Values: iv}
}
configLanguageKeys = make(map[string]bool)
addKeys := func(v reflect.Value) {
- for i := 0; i < v.NumField(); i++ {
+ for i := range v.NumField() {
name := strings.ToLower(v.Type().Field(i).Name)
if skip[name] {
continue
_, ok := allDecoderSetups[key]
if ok {
// A map.
- if v, err := metadecoders.Default.UnmarshalStringTo(env.Value, map[string]interface{}{}); err == nil {
+ if v, err := metadecoders.Default.UnmarshalStringTo(env.Value, map[string]any{}); err == nil {
val = v
}
}
"github.com/gohugoio/hugo/common/herrors"
"github.com/mitchellh/mapstructure"
"github.com/spf13/cast"
+ "slices"
)
type BaseConfig struct {
}
func (b BuildConfig) clone() BuildConfig {
- b.CacheBusters = append([]CacheBuster{}, b.CacheBusters...)
+ b.CacheBusters = slices.Clone(b.CacheBusters)
return b
}
func TestBuildConfigCacheBusterstTailwindSetup(t *testing.T) {
c := qt.New(t)
cfg := New()
- cfg.Set("build", map[string]interface{}{
+ cfg.Set("build", map[string]any{
"cacheBusters": []map[string]string{
{
"source": "assets/watching/hugo_stats\\.json",
c.keyCache.Store(key, parts)
}
current := c.root
- for i := 0; i < len(parts)-1; i++ {
+ for i := range len(parts) - 1 {
next, found := current[parts[i]]
if !found {
if create {
return nil
}
- for i := 0; i < 20; i++ {
+ for i := range 20 {
i := i
r.Run(func() error {
const v = 42
// ns, err := config.DecodeNamespace[map[string]DocsMediaTypeConfig](in, defaultMediaTypesConfig, buildConfig)
ns, err := DecodeNamespace[[]*tstNsExt](
- map[string]interface{}{"foo": "bar"},
+ map[string]any{"foo": "bar"},
func(v any) (*tstNsExt, any, error) {
t := &tstNsExt{}
m, err := maps.ToStringMapE(v)
c.Assert(err, qt.IsNil)
c.Assert(ns, qt.Not(qt.IsNil))
- c.Assert(ns.SourceStructure, qt.DeepEquals, map[string]interface{}{"foo": "bar"})
+ c.Assert(ns.SourceStructure, qt.DeepEquals, map[string]any{"foo": "bar"})
c.Assert(ns.SourceHash, qt.Equals, "1420f6c7782f7459")
c.Assert(ns.Config, qt.DeepEquals, &tstNsExt{Foo: "bar"})
c.Assert(ns.Signature(), qt.DeepEquals, []*tstNsExt(nil))
var patternsr []*regexp.Regexp
- for i := 0; i < len(patterns); i++ {
+ for i := range patterns {
p := strings.TrimSpace(patterns[i])
if p == "" {
continue
`
- c.Assert(afero.WriteFile(mm, filepath.Join(archetypeDir, "index.md"), []byte(fmt.Sprintf(contentFile, "index.md")), 0o755), qt.IsNil)
+ c.Assert(afero.WriteFile(mm, filepath.Join(archetypeDir, "index.md"), fmt.Appendf(nil, contentFile, "index.md"), 0o755), qt.IsNil)
c.Assert(afero.WriteFile(mm, filepath.Join(defaultArchetypeDir, "index.md"), []byte("default archetype index.md"), 0o755), qt.IsNil)
c.Assert(initFs(mm), qt.IsNil)
startOfTOC := bytes.Index(content, first)
- peekEnd := len(content)
- if peekEnd > 70+startOfTOC {
- peekEnd = 70 + startOfTOC
- }
+ peekEnd := min(len(content), 70+startOfTOC)
if startOfTOC < 0 {
return stripEmptyNav(content), toc
j := start + k
- upper := j + emojiMaxSize
-
- if upper > len(source) {
- upper = len(source)
- }
+ upper := min(j+emojiMaxSize, len(source))
endEmoji := bytes.Index(source[j+1:upper], emojiDelim)
nextWordDelim := bytes.Index(source[j:upper], emojiWordDelim)
unique := make([]string, 0, len(s))
for i, val := range s {
var seen bool
- for j := 0; j < i; j++ {
+ for j := range i {
if s[j] == val {
seen = true
break
for i, val := range s {
var seen bool
- for j := 0; j < i; j++ {
+ for j := range i {
if s[j] == val {
seen = true
break
var data [][]string
- for i := 0; i < len(stats); i++ {
+ for i := range stats {
stat := stats[i]
names[i+1] = stat.Name
v := config.New()
if multilingual {
v.Set("languages", map[string]any{
- "fr": map[string]interface{}{
+ "fr": map[string]any{
"weight": 20,
},
- "en": map[string]interface{}{
+ "en": map[string]any{
"weight": 10,
},
})
} else {
v.Set("defaultContentLanguage", lang)
v.Set("languages", map[string]any{
- lang: map[string]interface{}{
+ lang: map[string]any{
"weight": 10,
},
})
v := config.New()
if multilingual {
v.Set("languages", map[string]any{
- "fr": map[string]interface{}{
+ "fr": map[string]any{
"weight": 20,
},
- "en": map[string]interface{}{
+ "en": map[string]any{
"weight": 10,
},
})
} else {
v.Set("defaultContentLanguage", lang)
v.Set("languages", map[string]any{
- lang: map[string]interface{}{
+ lang: map[string]any{
"weight": 10,
},
})
structTypes(v.Elem(), m)
}
case reflect.Slice, reflect.Array:
- for i := 0; i < v.Len(); i++ {
+ for i := range v.Len() {
structTypes(v.Index(i), m)
}
case reflect.Map:
}
case reflect.Struct:
m[v.Type()] = struct{}{}
- for i := 0; i < v.NumField(); i++ {
+ for i := range v.NumField() {
structTypes(v.Field(i), m)
}
}
dstv := reflect.Indirect(reflect.ValueOf(m))
srcv := reflect.Indirect(reflect.ValueOf(from))
- for i := 0; i < dstv.NumField(); i++ {
+ for i := range dstv.NumField() {
v := dstv.Field(i)
if !v.CanSet() {
continue
}
}
} else if cfs, ok := fs.(overlayfs.FilesystemIterator); ok {
- for i := 0; i < cfs.NumFilesystems(); i++ {
+ for i := range cfs.NumFilesystems() {
if WalkFilesystems(cfs.Filesystem(i), fn) {
return true
}
// HasGlobChar returns whether s contains any glob wildcards.
func HasGlobChar(s string) bool {
- for i := 0; i < len(s); i++ {
+ for i := range len(s) {
if syntax.Special(s[i]) {
return true
}
p := para.New(4)
r, _ := p.Start(context.Background())
- for i := 0; i < 8; i++ {
+ for range 8 {
r.Run(func() error {
_, err := collectPaths(bfs, "")
if err != nil {
fs := NewBaseFileDecorator(afero.NewMemMapFs())
writeFiles := func(dir string, numfiles int) {
- for i := 0; i < numfiles; i++ {
+ for i := range numfiles {
filename := filepath.Join(dir, fmt.Sprintf("file%d.txt", i))
c.Assert(afero.WriteFile(fs, filename, []byte("content"), 0o777), qt.IsNil)
}
{{ .Title }}|
`
- for i := 0; i < 10; i++ {
+ for range 10 {
b := Test(t, files)
b.AssertFileContent("public/p1/index.html", "Background: yosemite.jpg")
}
files := strings.ReplaceAll(filesTemplate, "WEIGHT_EN", "2")
files = strings.ReplaceAll(files, "WEIGHT_SV", "1")
- for i := 0; i < 20; i++ {
+ for range 20 {
cfg := config.New()
b, err := NewIntegrationTestBuilder(
IntegrationTestConfig{
`
- for i := 0; i < 3; i++ {
+ for range 3 {
b := Test(t, files)
b.AssertFileContent("public/index.html", "R: Data 1.txt|", "Len: 1|")
}
pageReverseIndex := newContentTreeTreverseIndex(
func(get func(key any) (contentNodeI, bool), set func(key any, val contentNodeI)) {
- for i := 0; i < 10; i++ {
+ for i := range 10 {
key := fmt.Sprint(i)
set(key, &testContentNode{key: key})
}
},
)
- for i := 0; i < 10; i++ {
+ for i := range 10 {
key := fmt.Sprint(i)
v := pageReverseIndex.Get(key)
c.Assert(v, qt.Not(qt.IsNil))
var wg sync.WaitGroup
- for i := 0; i < 10; i++ {
+ for range 10 {
pageReverseIndex := newContentTreeTreverseIndex(
func(get func(key any) (contentNodeI, bool), set func(key any, val contentNodeI)) {
- for i := 0; i < 10; i++ {
+ for i := range 10 {
key := fmt.Sprint(i)
set(key, &testContentNode{key: key})
}
},
)
- for j := 0; j < 10; j++ {
+ for j := range 10 {
wg.Add(1)
go func(i int) {
defer wg.Done()
},
)
- for i := 0; i < 8; i++ {
+ for i := range 8 {
i := i
r.Run(func() error {
a := &testValue{ID: "/a"}
},
)
- for i := 0; i < numElements; i++ {
+ for i := range numElements {
lang := rand.Intn(2)
tree.InsertIntoValuesDimension(fmt.Sprintf("/%d", i), &testValue{ID: fmt.Sprintf("/%d", i), Lang: lang, Weight: i, NoCopy: true})
}
},
)
- for i := 0; i < numElements; i++ {
+ for i := range numElements {
lang := rand.Intn(2)
tree.InsertIntoValuesDimension(fmt.Sprintf("/%d", i), &testValue{ID: fmt.Sprintf("/%d", i), Lang: lang, Weight: i, NoCopy: true})
}
base := createTree()
b.ResetTimer()
for i := 0; i < b.N; i++ {
- for d1 := 0; d1 < 1; d1++ {
- for d2 := 0; d2 < 2; d2++ {
+ for d1 := range 1 {
+ for d2 := range 2 {
tree := base.Shape(d1, d2)
w := &doctree.NodeShiftTreeWalker[*testValue]{
Tree: tree,
main := r.Tree
var err error
- fnMain := func(s string, v interface{}) bool {
+ fnMain := func(s string, v any) bool {
if r.ShouldSkip(s) {
return false
}
panic("length must be > 0")
}
trees := make([]*SimpleTree[T], length)
- for i := 0; i < length; i++ {
+ for i := range length {
trees[i] = NewSimpleTree[T]()
}
return &TreeShiftTree[T]{d: d, trees: trees}
mounts := make([]mountsDescriptor, len(mods))
- for i := 0; i < len(mods); i++ {
+ for i := range mods {
mod := mods[i]
dir := mod.Dir()
filenameTheme := filepath.Join(base, fmt.Sprintf("theme-file-%s.txt", theme))
filenameOverlap := filepath.Join(base, "f3.txt")
afs.Mkdir(base, 0o755)
- content := []byte(fmt.Sprintf("content:%s:%s", theme, dir))
+ content := fmt.Appendf(nil, "content:%s:%s", theme, dir)
afero.WriteFile(afs, filenameTheme, content, 0o755)
afero.WriteFile(afs, filenameOverlap, content, 0o755)
}
// Write some files to the root of the theme
base := filepath.Join(workingDir, "themes", theme)
- afero.WriteFile(afs, filepath.Join(base, fmt.Sprintf("theme-root-%s.txt", theme)), []byte(fmt.Sprintf("content:%s", theme)), 0o755)
- afero.WriteFile(afs, filepath.Join(base, "file-theme-root.txt"), []byte(fmt.Sprintf("content:%s", theme)), 0o755)
+ afero.WriteFile(afs, filepath.Join(base, fmt.Sprintf("theme-root-%s.txt", theme)), fmt.Appendf(nil, "content:%s", theme), 0o755)
+ afero.WriteFile(afs, filepath.Join(base, "file-theme-root.txt"), fmt.Appendf(nil, "content:%s", theme), 0o755)
}
afero.WriteFile(afs, filepath.Join(workingDir, "file-root.txt"), []byte("content-project"), 0o755)
workingDir := v.GetString("workingDir")
v.Set(key, val)
fs.Mkdir(val, 0o755)
- for i := 0; i < num; i++ {
+ for i := range num {
filename := filepath.Join(workingDir, val, fmt.Sprintf("f%d.txt", i+1))
- afero.WriteFile(fs, filename, []byte(fmt.Sprintf("content:%s:%d", key, i+1)), 0o755)
+ afero.WriteFile(fs, filename, fmt.Appendf(nil, "content:%s:%d", key, i+1), 0o755)
}
}
func (h *HugoSites) PrintProcessingStats(w io.Writer) {
stats := make([]*helpers.ProcessingStats, len(h.Sites))
- for i := 0; i < len(h.Sites); i++ {
+ for i := range h.Sites {
stats[i] = h.Sites[i].PathSpec.ProcessingStats
}
helpers.ProcessingStatsTable(w, stats...)
cp := p.pageOutput.pco
if cp == nil && p.reusePageOutputContent() {
// Look for content to reuse.
- for i := 0; i < len(p.pageOutputs); i++ {
+ for i := range p.pageOutputs {
if i == idx {
continue
}
"github.com/gohugoio/hugo/tpl"
"github.com/mitchellh/mapstructure"
"github.com/spf13/cast"
+ maps0 "maps"
)
const (
cp.otherOutputs.Set(cp2.po.p.pid, cp2)
// Merge content placeholders
- for k, v := range ct2.contentPlaceholders {
- ct.contentPlaceholders[k] = v
- }
+ maps0.Copy(ct.contentPlaceholders, ct2.contentPlaceholders)
if p.s.conf.Internal.Watch {
for _, s := range cp2.po.p.m.content.shortcodeState.shortcodes {
`)
- for i := 0; i < 3; i++ {
+ for range 3 {
b.Build(BuildCfg{})
b.Fatal(err)
}
- for i := 0; i < 10; i++ {
- for j := 0; j < 100; j++ {
+ for i := range 10 {
+ for j := range 100 {
writeSource(b, fs, filepath.Join("content", fmt.Sprintf("sect%d", i), fmt.Sprintf("page%d.md", j)), "CONTENT")
}
}
return fmt.Sprintf(pageCollectionsPageTemplate, title)
}
- for i := 0; i < 10; i++ {
- for j := 0; j < 100; j++ {
+ for i := range 10 {
+ for j := range 100 {
content := pc(fmt.Sprintf("Title%d_%d", i, j))
writeSource(c, fs, filepath.Join("content", fmt.Sprintf("sect%d", i), fmt.Sprintf("page%d.md", j)), content)
}
c := qt.New(t)
s := createGetPageRegularBenchmarkSite(t)
- for i := 0; i < 10; i++ {
+ for i := range 10 {
pp := path.Join("/", fmt.Sprintf("sect%d", i), fmt.Sprintf("page%d.md", i))
page, _ := s.getPage(nil, pp)
c.Assert(page, qt.Not(qt.IsNil), qt.Commentf(pp))
return fmt.Sprintf(pageCollectionsPageTemplate, title)
}
- for i := 0; i < 10; i++ {
- for j := 0; j < 10; j++ {
+ for i := range 10 {
+ for j := range 10 {
content := pc(fmt.Sprintf("Title%d_%d", i, j))
writeSource(t, fs, filepath.Join("content", fmt.Sprintf("sect%d", i), fmt.Sprintf("page%d.md", j)), content)
}
c.Assert(len(frSite.RegularPages()), qt.Equals, 6)
c.Assert(len(nnSite.RegularPages()), qt.Equals, 12)
- for i := 0; i < 2; i++ {
+ for range 2 {
mergedNN := nnSite.RegularPages().MergeByLanguage(enSite.RegularPages())
c.Assert(len(mergedNN), qt.Equals, 31)
for i := 1; i <= 31; i++ {
// Add a bundles
j := 100
contentPairs = append(contentPairs, []string{"bundle/index.md", fmt.Sprintf(contentTemplate, j, j)}...)
- for i := 0; i < 6; i++ {
+ for i := range 6 {
contentPairs = append(contentPairs, []string{fmt.Sprintf("bundle/pb%d.md", i), fmt.Sprintf(contentTemplate, i+j, i+j)}...)
}
contentPairs = append(contentPairs, []string{"bundle/index.nn.md", fmt.Sprintf(contentTemplate, j, j)}...)
`
b := newTestSitesBuilder(t).WithConfigFile("toml", configFile)
var content []string
- for i := 0; i < 9; i++ {
+ for i := range 9 {
for _, contentDir := range []string{"content/en", "content/nn"} {
content = append(content, fmt.Sprintf(contentDir+"/blog/page%d.md", i), fmt.Sprintf(`---
title: Page %d
- JSON
---`)
- for i := 0; i < 22; i++ {
+ for i := range 22 {
b.WithContent(fmt.Sprintf("p%d.md", i+1), fmt.Sprintf(`---
title: "Page"
weight: %d
func TestRebuildEditTextFileInShortcode(t *testing.T) {
t.Parallel()
- for i := 0; i < 3; i++ {
+ for range 3 {
b := TestRunning(t, rebuildFilesSimple)
b.AssertFileContent("public/mythirdsection/mythirdsectionpage/index.html",
"Text: Assets My Shortcode Text.")
func TestRebuildEditTextFileInHook(t *testing.T) {
t.Parallel()
- for i := 0; i < 3; i++ {
+ for range 3 {
b := TestRunning(t, rebuildFilesSimple)
b.AssertFileContent("public/mythirdsection/mythirdsectionpage/index.html",
"Text: Assets My Other Text.")
P%d Content.
`
- for i := 0; i < count; i++ {
+ for i := range count {
files += fmt.Sprintf("-- content/mysect/p%d/index.md --\n%s", i, fmt.Sprintf(contentTemplate, i, i))
}
b.Running()
- for i := 0; i < 2; i++ {
+ for i := range 2 {
b.Logf("Test run %d", i)
b.Build(BuildCfg{})
for i := 0; i < b.N; i++ {
b.StopTimer()
s := newTestSitesBuilder(b)
- for i := 0; i < 300; i++ {
+ for i := range 300 {
s.WithContent(fmt.Sprintf("page%d.md", i+1), "---\ntitle: Page\n---")
}
s.WithTemplates("_default/single.html", `Start.
func TestShortcodeStableOutputFormatTemplates(t *testing.T) {
t.Parallel()
- for i := 0; i < 5; i++ {
+ for range 5 {
b := newTestSitesBuilder(t)
const numPages = 10
- for i := 0; i < numPages; i++ {
+ for i := range numPages {
b.WithContent(fmt.Sprintf("page%d.md", i), `---
title: "Page"
outputs: ["html", "css", "csv", "json"]
// helpers.PrintFs(b.Fs.Destination, "public", os.Stdout)
- for i := 0; i < numPages; i++ {
+ for i := range numPages {
b.AssertFileContent(fmt.Sprintf("public/page%d/index.html", i), "Short-HTML")
b.AssertFileContent(fmt.Sprintf("public/page%d/index.csv", i), "Short-CSV")
b.AssertFileContent(fmt.Sprintf("public/page%d/index.json", i), "Short-HTML")
}
- for i := 0; i < numPages; i++ {
+ for i := range numPages {
b.AssertFileContent(fmt.Sprintf("public/page%d/styles.css", i), "Short-HTML")
}
func newHugoSites(cfg deps.DepsCfg, d *deps.Deps, pageTrees *pageTrees, sites []*Site) (*HugoSites, error) {
numWorkers := config.GetNumWorkerMultiplier()
- numWorkersSite := numWorkers
- if numWorkersSite > len(sites) {
- numWorkersSite = len(sites)
- }
+ numWorkersSite := min(numWorkers, len(sites))
workersSite := para.New(numWorkersSite)
h := &HugoSites{
wg := &sync.WaitGroup{}
- for i := 0; i < numWorkers; i++ {
+ for range numWorkers {
wg.Add(1)
go pageRenderer(ctx, s, pages, results, wg)
}
"_default/terms.html", "Terms List|{{ .Title }}|{{ .Content }}",
)
- for i := 0; i < 2; i++ {
- for j := 0; j < 2; j++ {
+ for i := range 2 {
+ for j := range 2 {
pageID := i + j + 1
b.WithContent(fmt.Sprintf("content/sect/p%d.md", pageID),
fmt.Sprintf(pageTemplate, pageID, fmt.Sprintf("- tag%d", j), fmt.Sprintf("- category%d", j), pageID))
}
}
- for i := 0; i < 5; i++ {
+ for i := range 5 {
b.WithContent(fmt.Sprintf("assets/image%d.png", i+1), "image")
}
b := newTestSitesBuilder(c).WithViper(v)
- for i := 0; i < 20; i++ {
+ for i := range 20 {
b.WithContent(fmt.Sprintf("page%d.md", i), `---
title: "Page"
---
`)
}
- for i := 0; i < 5; i++ {
+ for i := range 5 {
b.WithContent(fmt.Sprintf("blog/page%d.md", i), `---
title: "Page"
tags: ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
`)
}
- for i := 0; i < 3; i++ {
+ for i := range 3 {
b.WithContent(fmt.Sprintf("docs/page%d.md", i), `---
title: "Page"
---
writeSource(t, fs, filepath.Join("content", "sect1", "_index.md"), fmt.Sprintf(st, "/ss1/"))
writeSource(t, fs, filepath.Join("content", "sect2", "_index.md"), fmt.Sprintf(st, "/ss2/"))
- for i := 0; i < 5; i++ {
+ for i := range 5 {
writeSource(t, fs, filepath.Join("content", "sect1", fmt.Sprintf("p%d.md", i+1)), pt)
writeSource(t, fs, filepath.Join("content", "sect2", fmt.Sprintf("p%d.md", i+1)), pt)
}
</ul>
`)
- for i := 0; i < 10; i++ {
+ for i := range 10 {
b.WithContent(fmt.Sprintf("page%d.md", i+1), `
---
Title: "Taxonomy!"
Base %d: {{ block "main" . }}FOO{{ end }}
`
- for i := 0; i < numPages; i++ {
+ for i := range numPages {
id := i + 1
b.WithContent(fmt.Sprintf("page%d.md", id), fmt.Sprintf(pageTemplate, id, id))
b.WithTemplates(fmt.Sprintf("_default/layout%d.html", id), fmt.Sprintf(singleTemplate, id))
}
b.Build(BuildCfg{})
- for i := 0; i < numPages; i++ {
+ for i := range numPages {
id := i + 1
b.AssertFileContent(fmt.Sprintf("public/page%d/index.html", id), fmt.Sprintf(`Base %d: %d`, id, id))
}
}
var searchIDPool = sync.Pool{
- New: func() interface{} {
+ New: func() any {
return &searchID{seen: make(map[Manager]bool)}
},
}
func BenchmarkIdentityManager(b *testing.B) {
createIds := func(num int) []identity.Identity {
ids := make([]identity.Identity, num)
- for i := 0; i < num; i++ {
+ for i := range num {
name := fmt.Sprintf("id%d", i)
ids[i] = &testIdentity{base: name, name: name}
}
newNestedManager := func(depth, count int) identity.Manager {
m1 := identity.NewManager("")
- for i := 0; i < depth; i++ {
+ for range depth {
m2 := identity.NewManager("")
m1.AddIdentity(m2)
- for j := 0; j < count; j++ {
+ for j := range count {
id := fmt.Sprintf("id%d", j)
m2.AddIdentity(&testIdentity{id, id, "", ""})
}
"github.com/gohugoio/hugo/resources"
"github.com/gohugoio/hugo/resources/resource"
"github.com/spf13/afero"
+ "slices"
)
const (
}
}
- for _, ext := range opts.Externals {
- // ESBuild will do a more thorough check for packages resolved in node_modules,
- // but we need to make sure that we don't try to resolve these in the /assets folder.
- if ext == impPath {
- return api.OnResolveResult{
- Path: impPath,
- External: true,
- }, nil
- }
+ if slices.Contains(opts.Externals, impPath) {
+ return api.OnResolveResult{
+ Path: impPath,
+ External: true,
+ }, nil
}
if opts.ImportOnResolveFunc != nil {
}
inOuts := make([]*inOut, opts.PoolSize)
- for i := 0; i < opts.PoolSize; i++ {
+ for i := range opts.PoolSize {
var stdin, stdout hugio.ReadWriteCloser
stdin = hugio.NewPipeReadWriteCloser()
close(dp.donec)
}()
- for i := 0; i < len(inOuts); i++ {
+ for i := range inOuts {
d := &dispatcher[Q, R]{
pending: make(map[uint32]*call[Q, R]),
inOut: inOuts[i],
Infof: t.Logf,
}
- for i := 0; i < 2; i++ {
+ for range 2 {
func() {
d, err := Start[person, greeting](opts)
if err != nil {
},
}
- for j := 0; j < 20; j++ {
+ for j := range 20 {
inputMessage.Header.ID = uint32(j + 1)
g, err := d.Execute(ctx, inputMessage)
if err != nil {
ctx := context.Background()
- for j := 0; j < 5; j++ {
+ for j := range 5 {
base := i * 100
id := uint32(base + j)
ctx := context.Background()
- for j := 0; j < 1; j++ {
+ for j := range 1 {
base := i * 100
id := uint32(base + j)
coll := &Collator{c: collate.New(language.English, collate.Loose)}
- for i := 0; i < 10; i++ {
+ for range 10 {
wg.Add(1)
go func() {
coll.Lock()
defer coll.Unlock()
defer wg.Done()
- for j := 0; j < 10; j++ {
+ for range 10 {
k := coll.CompareStrings("abc", "def")
c.Assert(k, qt.Equals, -1)
}
s := []string{"foo", "bar", "éntre", "baz", "qux", "quux", "corge", "grault", "garply", "waldo", "fred", "plugh", "xyzzy", "thud"}
doWork := func(coll *Collator) {
- for i := 0; i < len(s); i++ {
+ for i := range s {
for j := i + 1; j < len(s); j++ {
_ = coll.CompareStrings(s[i], s[j])
}
// Add some concurrency and randomness to verify thread safety and
// init order.
- for i := 0; i < 100; i++ {
+ for i := range 100 {
wg.Add(1)
go func(i int) {
defer wg.Done()
var buff bytes.Buffer
l := n.Lines().Len()
- for i := 0; i < l; i++ {
+ for i := range l {
line := n.Lines().At(i)
buff.Write(line.Value(src))
}
if entering {
if r.Unsafe {
l := n.Lines().Len()
- for i := 0; i < l; i++ {
+ for i := range l {
line := n.Lines().At(i)
linev := line.Value(source)
var stripped bool
n := node.(*ast.RawHTML)
l := n.Segments.Len()
if r.Unsafe {
- for i := 0; i < l; i++ {
+ for i := range l {
segment := n.Segments.At(i)
_, _ = w.Write(segment.Value(source))
}
case (*passthrough.PassthroughBlock):
l := nn.Lines().Len()
var buff bytes.Buffer
- for i := 0; i < l; i++ {
+ for i := range l {
line := nn.Lines().At(i)
buff.Write(line.Value(src))
}
bodyEnd := bytes.Index(result, []byte("\n</body>"))
if bodyEnd < 0 || bodyEnd >= len(result) {
- bodyEnd = len(result) - 1
- if bodyEnd < 0 {
- bodyEnd = 0
- }
+ bodyEnd = max(len(result)-1, 0)
}
return result[bodyStart+7 : bodyEnd], err
}
func (b *tocBuilder) indent(n int) {
- for i := 0; i < n; i++ {
+ for range n {
b.s.WriteString(" ")
}
}
func BenchmarkToc(b *testing.B) {
newTocs := func(n int) []*Fragments {
var tocs []*Fragments
- for i := 0; i < n; i++ {
+ for range n {
tocs = append(tocs, newTestToc())
}
return tocs
"github.com/mitchellh/mapstructure"
"github.com/spf13/cast"
+ "slices"
)
// DefaultTypes is the default media types supported by Hugo.
// Initialize the Builtin types with values from DefaultTypes.
v := reflect.ValueOf(&Builtin).Elem()
- for i := 0; i < v.NumField(); i++ {
+ for i := range v.NumField() {
f := v.Field(i)
fieldName := v.Type().Field(i).Name
builtinType := f.Interface().(Type)
// IsHTMLSuffix returns whether the given suffix is a HTML media type.
func (t ContentTypes) IsHTMLSuffix(suffix string) bool {
- for _, s := range t.HTML.Suffixes() {
- if s == suffix {
- return true
- }
- }
- return false
+ return slices.Contains(t.HTML.Suffixes(), suffix)
}
// Types is a slice of media types.
if err != nil {
if clean {
m := verifyErrorDirRe.FindAllStringSubmatch(err.Error(), -1)
- if m != nil {
- for i := 0; i < len(m); i++ {
- c, err := hugofs.MakeReadableAndRemoveAllModulePkgDir(c.fs, m[i][1])
- if err != nil {
- return err
- }
- fmt.Println("Cleaned", c)
+ for i := range m {
+ c, err := hugofs.MakeReadableAndRemoveAllModulePkgDir(c.fs, m[i][1])
+ if err != nil {
+ return err
}
+ fmt.Println("Cleaned", c)
}
// Try to verify it again.
err = c.runVerify()
"github.com/mitchellh/mapstructure"
"github.com/spf13/cast"
+ "slices"
)
var smc = newMenuCache()
// Clone clones the menu entries.
// This is for internal use only.
func (m Menu) Clone() Menu {
- return append(Menu(nil), m...)
+ return slices.Clone(m)
}
func DecodeConfig(in any) (*config.ConfigNamespace[map[string]MenuConfig, Menus], error) {
package navigation
import (
+ "slices"
"sync"
)
}
m := menuLists[0]
- menuCopy := append(Menu(nil), m...)
+ menuCopy := slices.Clone(m)
if apply != nil {
apply(&menuCopy)
func createSortTestMenu(num int) Menu {
menu := make(Menu, num)
- for i := 0; i < num; i++ {
+ for i := range num {
m := &MenuEntry{}
menu[i] = m
}
var testMenuSets []Menu
- for i := 0; i < 50; i++ {
+ for i := range 50 {
testMenuSets = append(testMenuSets, createSortTestMenu(i+1))
}
- for j := 0; j < 100; j++ {
+ for range 100 {
wg.Add(1)
go func() {
defer wg.Done()
for i, val := range s {
var seen bool
- for j := 0; j < i; j++ {
+ for j := range i {
if s[j] == val {
seen = true
break
if c.OmitEmpty {
// It's tricky to do this with a regexp, so convert it to a map, remove zero values and convert back.
- var m map[string]interface{}
+ var m map[string]any
err = json.Unmarshal(converted, &m)
if err != nil {
return nil, err
delete(m, k)
} else {
switch vv := v.(type) {
- case map[string]interface{}:
+ case map[string]any:
removeZeroVAlues(vv)
- case []interface{}:
+ case []any:
for _, vvv := range vv {
if m, ok := vvv.(map[string]any); ok {
removeZeroVAlues(m)
// Handle YAML or TOML front matter.
func (l *pageLexer) lexFrontMatterSection(tp ItemType, delimr rune, name string, delim []byte) stateFunc {
- for i := 0; i < 2; i++ {
+ for range 2 {
if r := l.next(); r != delimr {
return l.errorf("invalid %s delimiter", name)
}
// Consume is a convenience method to consume the next n tokens,
// but back off Errors and EOF.
func (t *Iterator) Consume(cnt int) {
- for i := 0; i < cnt; i++ {
+ for range cnt {
token := t.Next()
if token.Type == tError || token.Type == tEOF {
t.Backup()
}
var rankPool = sync.Pool{
- New: func() interface{} {
+ New: func() any {
return &rank{}
},
}
keywords = append(keywords, cfg.stringToKeyword(vv))
case []string:
vvv := make([]Keyword, len(vv))
- for i := 0; i < len(vvv); i++ {
+ for i := range vvv {
vvv[i] = cfg.stringToKeyword(vv[i])
}
keywords = append(keywords, vvv...)
func (cfg IndexConfig) StringsToKeywords(s ...string) []Keyword {
kw := make([]Keyword, len(s))
- for i := 0; i < len(s); i++ {
+ for i := range s {
kw[i] = cfg.stringToKeyword(s[i])
}
for k, v := range keywordm {
keywords := make([]Keyword, len(v))
- for i := 0; i < len(v); i++ {
+ for i := range v {
keywords[i] = StringKeyword(v[i])
}
d.keywords[k] = keywords
doc := newTestDocWithDate("keywords", date, "a", "b")
doc.name = "thedoc"
- for i := 0; i < 10; i++ {
+ for i := range 10 {
docc := *doc
docc.name = fmt.Sprintf("doc%d", i)
idx.Add(context.Background(), &docc)
m, err := idx.Search(context.Background(), SearchOpts{Document: doc, Indices: []string{"keywords"}})
c.Assert(err, qt.IsNil)
c.Assert(len(m), qt.Equals, 10)
- for i := 0; i < 10; i++ {
+ for i := range 10 {
c.Assert(m[i].Name(), qt.Equals, fmt.Sprintf("doc%d", i))
}
})
pages := make([]*testDoc, 100)
numkeywords := 30
allKeywords := make([]string, numkeywords)
- for i := 0; i < numkeywords; i++ {
+ for i := range numkeywords {
allKeywords[i] = fmt.Sprintf("keyword%d", i+1)
}
- for i := 0; i < len(pages); i++ {
+ for i := range pages {
start := rand.Intn(len(allKeywords))
end := start + 3
if end >= len(allKeywords) {
for i := 0; i < b.N; i++ {
idx := NewInvertedIndex(cfg)
docs := make([]Document, len(pages))
- for i := 0; i < len(pages); i++ {
+ for i := range pages {
docs[i] = pages[i]
}
idx.Add(context.Background(), docs...)
docs := make([]*testDoc, 1000)
numkeywords := 20
allKeywords := make([]string, numkeywords)
- for i := 0; i < numkeywords; i++ {
+ for i := range numkeywords {
allKeywords[i] = fmt.Sprintf("keyword%d", i+1)
}
idx := NewInvertedIndex(cfg)
- for i := 0; i < len(docs); i++ {
+ for i := range docs {
start := rand.Intn(len(allKeywords))
end := start + 3
if end >= len(allKeywords) {
---
`
- for i := 0; i < 32; i++ {
+ for range 32 {
base += fmt.Sprintf("\n## Title %d", rand.Intn(100))
}
return string(out), nil
}
-func logf(format string, args ...interface{}) {
+func logf(format string, args ...any) {
fmt.Fprintf(os.Stderr, format, args...)
}
-func logln(args ...interface{}) {
+func logln(args ...any) {
fmt.Fprintln(os.Stderr, args...)
}
image := fetchImageForSpec(spec, c, "sunset.jpg")
- for i := 0; i < 4; i++ {
+ for i := range 4 {
wg.Add(1)
go func(id int) {
defer wg.Done()
- for j := 0; j < 5; j++ {
+ for j := range 5 {
img := image
- for k := 0; k < 2; k++ {
+ for k := range 2 {
r1, err := img.Resize(fmt.Sprintf("%dx", id-k))
if err != nil {
t.Error(err)
b.StartTimer()
for i := 0; i < b.N; i++ {
- for j := 0; j < 10; j++ {
+ for range 10 {
getAndCheckExif(c, images[i])
}
}
"strings"
"github.com/gohugoio/hugo/common/hstrings"
+ "slices"
)
type colorGoProvider interface {
// that the palette is valid for the relevant format.
func AddColorToPalette(c color.Color, p color.Palette) color.Palette {
var found bool
- for _, cc := range p {
- if c == cc {
- found = true
- break
- }
+ if slices.Contains(p, c) {
+ found = true
}
if !found {
if len(img1.Pix) != len(img2.Pix) {
return false
}
- for i := 0; i < len(img1.Pix); i++ {
+ for i := range img1.Pix {
diff := int(img1.Pix[i]) - int(img2.Pix[i])
if diff < 0 {
diff = -diff
"github.com/gohugoio/hugo/hugofs/glob"
"github.com/gohugoio/hugo/resources/kinds"
"github.com/mitchellh/mapstructure"
+ "slices"
)
// A PageMatcher can be used to match a Page with Glob patterns.
v.Kind = strings.ToLower(v.Kind)
if v.Kind != "" {
g, _ := glob.GetGlob(v.Kind)
- found := false
- for _, k := range kinds.AllKindsInPages {
- if g.Match(k) {
- found = true
- break
- }
- }
+ found := slices.ContainsFunc(kinds.AllKindsInPages, g.Match)
if !found {
return fmt.Errorf("%q did not match a valid Page Kind", v.Kind)
}
func toLowerSlice(in any) []string {
out := cast.ToStringSlice(in)
- for i := 0; i < len(out); i++ {
+ for i := range out {
out[i] = strings.ToLower(out[i])
}
func newTestFd() *pagemeta.FrontMatterDescriptor {
return &pagemeta.FrontMatterDescriptor{
PageConfig: &pagemeta.PageConfig{
- Params: make(map[string]interface{}),
+ Params: make(map[string]any),
},
Location: time.UTC,
}
package page
import (
+ "slices"
"sync"
)
}
p := pageLists[0]
- pagesCopy := append(Pages(nil), p...)
+ pagesCopy := slices.Clone(p)
if apply != nil {
apply(&pagesCopy)
return true
}
- for i := 0; i < len(p1); i++ {
+ for i := range p1 {
if p1[i] != p2[i] {
return false
}
var testPageSets []Pages
- for i := 0; i < 50; i++ {
+ for i := range 50 {
testPageSets = append(testPageSets, createSortTestPages(i+1))
}
- for j := 0; j < 100; j++ {
+ for range 100 {
wg.Add(1)
go func() {
defer wg.Done()
func BenchmarkPageCache(b *testing.B) {
cache := newPageCache()
pages := make(Pages, 30)
- for i := 0; i < 30; i++ {
+ for i := range 30 {
pages[i] = &testPage{title: "p" + strconv.Itoa(i)}
}
key := "key"
p := createSortTestPages(10)
firstFive := p.Limit(5)
c.Assert(len(firstFive), qt.Equals, 5)
- for i := 0; i < 5; i++ {
+ for i := range 5 {
c.Assert(firstFive[i], qt.Equals, p[i])
}
c.Assert(p.Limit(10), eq, p)
n := 10
unsorted := createSortTestPages(n)
- for i := 0; i < n; i++ {
+ for i := range n {
v := 100 - i
if i%2 == 0 {
v = 100.0 - i
func createSortTestPages(num int) Pages {
pages := make(Pages, num)
- for i := 0; i < num; i++ {
+ for i := range num {
p := newTestPage()
p.path = fmt.Sprintf("/x/y/p%d.md", i)
p.title = fmt.Sprintf("Title %d", i%((num+1)/2))
chunks := splitPages(pages, 5)
c.Assert(len(chunks), qt.Equals, 5)
- for i := 0; i < 4; i++ {
+ for i := range 4 {
c.Assert(chunks[i].Len(), qt.Equals, 5)
}
Config() SiteConfig
// Deprecated: Use taxonomies instead.
- Author() map[string]interface{}
+ Author() map[string]any
// Deprecated: Use taxonomies instead.
Authors() AuthorList
}
// Deprecated: Use taxonomies instead.
-func (s *siteWrapper) Author() map[string]interface{} {
+func (s *siteWrapper) Author() map[string]any {
return s.s.Author()
}
}
// Deprecated: Use taxonomies instead.
-func (s testSite) Author() map[string]interface{} {
+func (s testSite) Author() map[string]any {
return nil
}
func createTestPages(num int) Pages {
pages := make(Pages, num)
- for i := 0; i < num; i++ {
+ for i := range num {
m := &testPage{
path: fmt.Sprintf("/x/y/z/p%d.md", i),
weight: 5,
m := make(map[string]any)
t := reflect.TypeOf(s)
- for i := 0; i < t.NumMethod(); i++ {
+ for i := range t.NumMethod() {
method := t.Method(i)
if method.PkgPath != "" {
continue
}
}
- for i := 0; i < t.NumField(); i++ {
+ for i := range t.NumField() {
field := t.Field(i)
if field.PkgPath != "" {
continue
"github.com/gohugoio/hugo/common/paths"
"github.com/gohugoio/hugo/hugofs/glob"
"github.com/spf13/cast"
+ "slices"
)
var _ ResourceFinder = (*Resources)(nil)
// MergeByLanguage adds missing translations in r1 from r2.
func (r Resources) MergeByLanguage(r2 Resources) Resources {
- result := append(Resources(nil), r...)
+ result := slices.Clone(r)
m := make(map[string]bool)
for _, rr := range r {
if translated, ok := rr.(translatedResource); ok {
if resolvedm.MainType == media.Builtin.JavascriptType.MainType && resolvedm.SubType == media.Builtin.JavascriptType.SubType {
readers := make([]hugio.ReadSeekCloser, 2*len(rcsources)-1)
j := 0
- for i := 0; i < len(rcsources); i++ {
+ for i := range rcsources {
if i > 0 {
readers[j] = hugio.NewReadSeekerNoOpCloserFromString("\n;\n")
j++
hugio.NewReadSeekerNoOpCloserFromString("C"),
)
- for i := 0; i < 3; i++ {
+ for range 3 {
s1 := helpers.ReaderToString(rc)
c.Assert(s1, qt.Equals, "ABC")
_, err := rc.Seek(0, 0)
{{ end }}
`
- for i := 0; i < numPages; i++ {
+ for i := range numPages {
filesTemplate += fmt.Sprintf("-- content/post/p%d.md --\n", i)
}
b.Build()
- for i := 0; i < numPages; i++ {
+ for i := range numPages {
b.AssertFileContent(fmt.Sprintf("public/post/p%d/index.html", i), fmt.Sprintf("Content: Response for /post/p%d/.", i))
}
})
"github.com/gohugoio/hugo/common/maps"
"github.com/gohugoio/hugo/common/paths"
+ maps0 "maps"
)
var (
func (r *metaResource) updateParams(params map[string]any) {
if r.params == nil {
- r.params = make(map[string]interface{})
- }
- for k, v := range params {
- r.params[k] = v
+ r.params = make(map[string]any)
}
+ maps0.Copy(r.params, params)
r.changed = true
}
c.Assert(err, qt.IsNil)
c.Cleanup(clean)
- for i := 0; i < 2; i++ {
+ for i := range 2 {
files := postCSSIntegrationTestFiles
if i == 1 {
`
- for i := 0; i < 3; i++ {
+ for range 3 {
b := hugolib.NewIntegrationTestBuilder(
hugolib.IntegrationTestConfig{
fs := afero.NewMemMapFs()
- for i := 0; i < 2; i++ {
+ for i := range 2 {
spec := newTestResourceSpec(specDescriptor{c: c, fs: fs})
r := createTransformer(c, spec, "f1.txt", "color is blue")
const count = 26 // A-Z
transformations := make([]resources.ResourceTransformation, count)
- for i := 0; i < count; i++ {
+ for i := range count {
transformations[i] = createContentReplacer(fmt.Sprintf("t%d", i), fmt.Sprint(i), string(rune(i+65)))
}
var countstr strings.Builder
- for i := 0; i < count; i++ {
+ for i := range count {
countstr.WriteString(fmt.Sprint(i))
}
transformers := make([]resources.Transformer, 10)
transformations := make([]resources.ResourceTransformation, 10)
- for i := 0; i < 10; i++ {
+ for i := range 10 {
transformers[i] = createTransformer(c, spec, fmt.Sprintf("f%d.txt", i), fmt.Sprintf("color is %d", i))
transformations[i] = createContentReplacer("test", strconv.Itoa(i), "blue")
}
var wg sync.WaitGroup
- for i := 0; i < 13; i++ {
+ for i := range 13 {
wg.Add(1)
go func(i int) {
defer wg.Done()
- for j := 0; j < 23; j++ {
+ for j := range 23 {
id := (i + j) % 10
tr, err := transformers[id].Transform(transformations[id])
c.Assert(err, qt.IsNil)
switch seqv.Kind() {
case reflect.Array, reflect.Slice:
r := make([]any, seqv.Len())
- for i := 0; i < seqv.Len(); i++ {
+ for i := range seqv.Len() {
vv := seqv.Index(i)
vvv, err := applyFnToThis(ctx, fnv, vv, args...)
return reflect.ValueOf(nil), errors.New("Too many arguments")
}*/
- for i := 0; i < num; i++ {
+ for i := range num {
// AssignableTo reports whether xt is assignable to type targ.
if xt, targ := n[i].Type(), fn.Type().In(i); !xt.AssignableTo(targ) {
return reflect.ValueOf(nil), errors.New("called apply using " + xt.String() + " as type " + targ.String())
lv = reflect.ValueOf(sortSeq)
fallthrough
case reflect.Array, reflect.Slice, reflect.String:
- for i := 0; i < lv.Len(); i++ {
+ for i := range lv.Len() {
val := lv.Index(i).Interface()
valStr, err := cast.ToStringE(val)
if err != nil {
case string:
key = v
case []string:
- for i := 0; i < len(v)-1; i++ {
+ for i := range len(v) - 1 {
key = v[i]
var m map[string]any
v, found := dict[key]
switch lv.Kind() {
case reflect.Array, reflect.Slice:
- for i := 0; i < lv.Len(); i++ {
+ for i := range lv.Len() {
lvv, isNil := indirectInterface(lv.Index(i))
if isNil {
continue
ins = &intersector{r: reflect.MakeSlice(l1v.Type(), 0, 0), seen: make(map[any]bool)}
switch l2v.Kind() {
case reflect.Array, reflect.Slice:
- for i := 0; i < l1v.Len(); i++ {
+ for i := range l1v.Len() {
l1vv := l1v.Index(i)
if !l1vv.Type().Comparable() {
return make([]any, 0), errors.New("intersect does not support slices or arrays of uncomparable types")
}
- for j := 0; j < l2v.Len(); j++ {
+ for j := range l2v.Len() {
l2vv := l2v.Index(j)
if !l2vv.Type().Comparable() {
return make([]any, 0), errors.New("intersect does not support slices or arrays of uncomparable types")
isNil bool
)
- for i := 0; i < l1v.Len(); i++ {
+ for i := range l1v.Len() {
l1vv, isNil = indirectInterface(l1v.Index(i))
if !l1vv.Type().Comparable() {
}
}
- for j := 0; j < l2v.Len(); j++ {
+ for j := range l2v.Len() {
l2vv := l2v.Index(j)
switch kind := l1vv.Kind(); {
seen := make(map[any]bool)
- for i := 0; i < v.Len(); i++ {
+ for i := range v.Len() {
ev, _ := indirectInterface(v.Index(i))
key := normalize(ev)
`
- for i := 0; i < 4; i++ {
+ for range 4 {
b := hugolib.NewIntegrationTestBuilder(
hugolib.IntegrationTestConfig{
`
- for i := 0; i < 4; i++ {
+ for range 4 {
b := hugolib.NewIntegrationTestBuilder(
hugolib.IntegrationTestConfig{
}
tis := make([]TstXI, s.Len())
- for i := 0; i < s.Len(); i++ {
+ for i := range s.Len() {
tsti, ok := s.Index(i).Interface().(TstXI)
if !ok {
return nil
switch v.Kind() {
case reflect.Array, reflect.Slice:
sl := reflect.MakeSlice(v.Type(), 0, 0)
- for i := 0; i < v.Len(); i++ {
+ for i := range v.Len() {
ev, _ := indirectInterface(v.Index(i))
if _, found := aset[normalize(ev)]; !found {
sl = reflect.Append(sl, ev)
if len(args) == 1 {
v := reflect.ValueOf(args[0])
if v.Kind() == reflect.Slice {
- for i := 0; i < v.Len(); i++ {
+ for i := range v.Len() {
indices = append(indices, v.Index(i).Interface())
}
} else {
v := reflect.ValueOf(seq)
switch v.Kind() {
case reflect.Array, reflect.Slice:
- for i := 0; i < v.Len(); i++ {
+ for i := range v.Len() {
ev, _ := indirectInterface(v.Index(i))
if !ev.Type().Comparable() {
switch seqv.Kind() {
case reflect.Array, reflect.Slice:
- for i := 0; i < seqv.Len(); i++ {
+ for i := range seqv.Len() {
p.Pairs[i].Value = seqv.Index(i)
if sortByField == "" || sortByField == "value" {
p.Pairs[i].Key = p.Pairs[i].Value
slice = reflect.MakeSlice(sliceType, 0, 0)
}
- for i := 0; i < v.Len(); i++ {
+ for i := range v.Len() {
ev, _ := indirectInterface(v.Index(i))
key := normalize(ev)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
iv := v.Int()
ivp = &iv
- for i := 0; i < mv.Len(); i++ {
+ for i := range mv.Len() {
if anInt, err := toInt(mv.Index(i)); err == nil {
ima = append(ima, anInt)
}
case reflect.String:
sv := v.String()
svp = &sv
- for i := 0; i < mv.Len(); i++ {
+ for i := range mv.Len() {
if aString, err := toString(mv.Index(i)); err == nil {
sma = append(sma, aString)
}
case reflect.Float64:
fv := v.Float()
fvp = &fv
- for i := 0; i < mv.Len(); i++ {
+ for i := range mv.Len() {
if aFloat, err := toFloat(mv.Index(i)); err == nil {
fma = append(fma, aFloat)
}
if hreflect.IsTime(v.Type()) {
iv := ns.toTimeUnix(v)
ivp = &iv
- for i := 0; i < mv.Len(); i++ {
+ for i := range mv.Len() {
ima = append(ima, ns.toTimeUnix(mv.Index(i)))
}
}
func (ns *Namespace) checkWhereArray(ctxv, seqv, kv, mv reflect.Value, path []string, op string) (any, error) {
rv := reflect.MakeSlice(seqv.Type(), 0, 0)
- for i := 0; i < seqv.Len(); i++ {
+ for i := range seqv.Len() {
var vvv reflect.Value
rvv := seqv.Index(i)
ns := newNs()
var seq []map[string]string
ctx := context.Background()
- for i := 0; i < 500; i++ {
+ for range 500 {
seq = append(seq, map[string]string{"foo": "bar"})
}
- for i := 0; i < 500; i++ {
+ for range 500 {
seq = append(seq, map[string]string{"foo": "baz"})
}
// Shuffle the sequence.
ns := newNs()
seq := map[string]string{}
- for i := 0; i < 1000; i++ {
+ for i := range 1000 {
seq[fmt.Sprintf("key%d", i)] = "value"
}
"github.com/spf13/cast"
"github.com/gohugoio/hugo/deps"
+ "slices"
)
// New returns a new instance of the data-namespaced template functions.
return false
}
- for _, v := range s {
- if v == value {
- return true
- }
- }
- return false
+ return slices.Contains(s, value)
}
func hasHeaderKey(m http.Header, key string) bool {
var wg sync.WaitGroup
- for i := 0; i < 1; i++ {
+ for i := range 1 {
wg.Add(1)
go func(gor int) {
defer wg.Done()
- for j := 0; j < 10; j++ {
+ for range 10 {
var cb []byte
f := func(b []byte) (bool, error) {
cb = b
return nil, nil
}
ctxType := reflect.TypeOf(tctx)
- for i := 0; i < ctxType.NumMethod(); i++ {
+ for i := range ctxType.NumMethod() {
method := ctxType.Method(i)
if ignoreFuncs[method.Name] {
continue
switch vv.Kind() {
case reflect.Slice, reflect.Array:
var floats []float64
- for i := 0; i < vv.Len(); i++ {
+ for i := range vv.Len() {
f, err := cast.ToFloat64E(vv.Index(i).Interface())
if err != nil {
return nil, true, err
f := func(d *deps.Deps) *internal.TemplateFuncsNamespace {
ns := &internal.TemplateFuncsNamespace{
Name: name,
- Context: func(ctx context.Context, args ...interface{}) (interface{}, error) {
+ Context: func(ctx context.Context, args ...any) (any, error) {
v := tpl.Context.Page.Get(ctx)
if v == nil {
// The multilingual sitemap does not have a page as its context.
b := hugolib.TestRunning(t, deferFilesCommon)
- for i := 0; i < 5; i++ {
+ for i := range 5 {
old := fmt.Sprintf("EDIT_COUNTER_OUTSIDE_%d", i)
new := fmt.Sprintf("EDIT_COUNTER_OUTSIDE_%d", i+1)
b.EditFileReplaceAll("layouts/index.html", old, new).Build()
b := hugolib.TestRunning(t, deferFilesCommon)
- for i := 0; i < 8; i++ {
+ for i := range 8 {
old := fmt.Sprintf("EDIT_COUNTER_DEFER_%d", i)
new := fmt.Sprintf("EDIT_COUNTER_DEFER_%d", i+1)
b.EditFileReplaceAll("layouts/index.html", old, new).Build()
}
variants := make([]tpl.Template, len(s.variants))
- for i := 0; i < len(variants); i++ {
+ for i := range variants {
variants[i] = s.variants[i].ts
}
func (t *templateHandler) extractIdentifiers(line string) []string {
m := identifiersRe.FindAllStringSubmatch(line, -1)
identifiers := make([]string, len(m))
- for i := 0; i < len(m); i++ {
+ for i := range m {
identifiers[i] = m[i][1]
}
return identifiers
"github.com/gohugoio/hugo/common/maps"
"github.com/gohugoio/hugo/tpl"
"github.com/mitchellh/mapstructure"
+ "slices"
)
type templateType int
for i, cmd := range x.Cmds {
keep, _ := c.applyTransformations(cmd)
if !keep {
- x.Cmds = append(x.Cmds[:i], x.Cmds[i+1:]...)
+ x.Cmds = slices.Delete(x.Cmds, i, i+1)
}
}
}
func (c *templateContext) hasIdent(idents []string, ident string) bool {
- for _, id := range idents {
- if id == ident {
- return true
- }
- }
- return false
+ return slices.Contains(idents, ident)
}
// collectConfig collects and parses any leading template config variable declaration.
_ "github.com/gohugoio/hugo/tpl/time"
_ "github.com/gohugoio/hugo/tpl/transform"
_ "github.com/gohugoio/hugo/tpl/urls"
+ maps0 "maps"
)
var (
}
if d.OverloadedTemplateFuncs != nil {
- for k, v := range d.OverloadedTemplateFuncs {
- funcMap[k] = v
- }
+ maps0.Copy(funcMap, d.OverloadedTemplateFuncs)
}
d.TmplFuncMap = funcMap
const numJsons = 100
var jsons [numJsons]string
- for i := 0; i < numJsons; i++ {
+ for i := range numJsons {
jsons[i] = strings.Replace(testJSON, "ROOT_KEY", fmt.Sprintf("root%d", i), 1)
}
const numJsons = 100
var jsons [numJsons]testContentResource
- for i := 0; i < numJsons; i++ {
+ for i := range numJsons {
key := fmt.Sprintf("root%d", i)
jsons[i] = testContentResource{key: key, content: strings.Replace(testJSON, "ROOT_KEY", key, 1), mime: media.Builtin.JSONType}
}
src += "&port=" + baseURL.Port()
src += "&path=" + strings.TrimPrefix(path+"/livereload", "/")
- script := []byte(fmt.Sprintf(`<script src="%s" data-no-instant defer></script>`, html.EscapeString(src)))
+ script := fmt.Appendf(nil, `<script src="%s" data-no-instant defer></script>`, html.EscapeString(src))
c := make([]byte, len(b)+len(script))
copy(c, b[:idx])
}
head := "<head>"
- replace := []byte(fmt.Sprintf("%s\n\t%s", head, hugoGeneratorTag))
+ replace := fmt.Appendf(nil, "%s\n\t%s", head, hugoGeneratorTag)
newcontent := bytes.Replace(b, []byte(head), replace, 1)
if len(newcontent) == len(b) {
head := "<HEAD>"
- replace := []byte(fmt.Sprintf("%s\n\t%s", head, hugoGeneratorTag))
+ replace := fmt.Appendf(nil, "%s\n\t%s", head, hugoGeneratorTag)
newcontent = bytes.Replace(b, []byte(head), replace, 1)
}
c.Assert(os.MkdirAll(filepath.Join(dir, subdir1), 0o777), qt.IsNil)
c.Assert(os.MkdirAll(filepath.Join(dir, subdir2), 0o777), qt.IsNil)
- for i := 0; i < 3; i++ {
+ for i := range 3 {
c.Assert(os.WriteFile(filepath.Join(dir, subdir1, fmt.Sprintf("file%d", i)), []byte("hello1"), 0o600), qt.IsNil)
}
- for i := 0; i < 3; i++ {
+ for i := range 3 {
c.Assert(os.WriteFile(filepath.Join(dir, subdir2, fmt.Sprintf("file%d", i)), []byte("hello2"), 0o600), qt.IsNil)
}
projects / brevno-suite / hugo / commitdiff