"path/filepath"
"strconv"
"strings"
+ "sync"
"github.com/spf13/cast"
+ "github.com/gobwas/glob"
+ "github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/media"
"github.com/gohugoio/hugo/source"
-
- "github.com/gohugoio/hugo/helpers"
)
var (
return filtered
}
+const prefixDeprecatedMsg = `We have added the more flexible Resources.GetMatch (find one) and Resources.Match (many) to replace the "prefix" methods.
+
+These matches by a given globbing pattern, e.g. "*.jpg".
+
+Some examples:
+
+* To find all resources by its prefix in the root dir of the bundle: .Match image*
+* To find one resource by its prefix in the root dir of the bundle: .GetMatch image*
+* To find all JPEG images anywhere in the bundle: .Match **.jpg`
+
// GetBySuffix gets the first resource matching the given filename prefix, e.g
// "logo" will match logo.png. It returns nil of none found.
// In potential ambiguous situations, combine it with ByType.
func (r Resources) GetByPrefix(prefix string) Resource {
+ helpers.Deprecated("Resources", "GetByPrefix", prefixDeprecatedMsg, false)
prefix = strings.ToLower(prefix)
for _, resource := range r {
if matchesPrefix(resource, prefix) {
// ByPrefix gets all resources matching the given base filename prefix, e.g
// "logo" will match logo.png.
func (r Resources) ByPrefix(prefix string) Resources {
+ helpers.Deprecated("Resources", "ByPrefix", prefixDeprecatedMsg, false)
var matches Resources
prefix = strings.ToLower(prefix)
for _, resource := range r {
return matches
}
+// GetMatch finds the first Resource matching the given pattern, or nil if none found.
+// See Match for a more complete explanation about the rules used.
+func (r Resources) GetMatch(pattern string) Resource {
+ g, err := getGlob(pattern)
+ if err != nil {
+ return nil
+ }
+
+ for _, resource := range r {
+ if g.Match(strings.ToLower(resource.Name())) {
+ return resource
+ }
+ }
+
+ return nil
+}
+
+// Match gets all resources matching the given base filename prefix, e.g
+// "*.png" will match all png files. The "*" does not match path delimiters (/),
+// so if you organize your resources in sub-folders, you need to be explicit about it, e.g.:
+// "images/*.png". To match any PNG image anywhere in the bundle you can do "**.png", and
+// to match all PNG images below the images folder, use "images/**.jpg".
+// The matching is case insensitive.
+// Match matches by using the value of Resource.Name, which, by default, is a filename with
+// path relative to the bundle root with Unix style slashes (/) and no leading slash, e.g. "images/logo.png".
+// See https://github.com/gobwas/glob for the full rules set.
+func (r Resources) Match(pattern string) Resources {
+ g, err := getGlob(pattern)
+ if err != nil {
+ return nil
+ }
+
+ var matches Resources
+ for _, resource := range r {
+ if g.Match(strings.ToLower(resource.Name())) {
+ matches = append(matches, resource)
+ }
+ }
+ return matches
+}
+
func matchesPrefix(r Resource, prefix string) bool {
return strings.HasPrefix(strings.ToLower(r.Name()), prefix)
}
+var (
+ globCache = make(map[string]glob.Glob)
+ globMu sync.RWMutex
+)
+
+func getGlob(pattern string) (glob.Glob, error) {
+ pattern = strings.ToLower(pattern)
+
+ var g glob.Glob
+
+ globMu.RLock()
+ g, found := globCache[pattern]
+ globMu.RUnlock()
+ if !found {
+ var err error
+ g, err = glob.Compile(pattern, '/')
+ if err != nil {
+ return nil, err
+ }
+
+ globMu.Lock()
+ globCache[pattern] = g
+ globMu.Unlock()
+ }
+
+ return g, nil
+
+}
+
type Spec struct {
*helpers.PathSpec
mimeTypes media.Types
srcKey := strings.ToLower(cast.ToString(src))
- match, err := path.Match(srcKey, resourceSrcKey)
+ glob, err := getGlob(srcKey)
if err != nil {
return fmt.Errorf("failed to match resource with metadata: %s", err)
}
+ match := glob.Match(resourceSrcKey)
+
if match {
if !nameSet {
name, found := meta["name"]
import (
"fmt"
+ "math/rand"
"path"
"path/filepath"
+ "strings"
"testing"
+ "time"
"github.com/stretchr/testify/require"
)
}
+func TestResourcesGetMatch(t *testing.T) {
+ assert := require.New(t)
+ spec := newTestResourceSpec(assert)
+ resources := Resources{
+ spec.newGenericResource(nil, nil, "/public", "/a/foo1.css", "foo1.css", "css"),
+ spec.newGenericResource(nil, nil, "/public", "/a/logo1.png", "logo1.png", "image"),
+ spec.newGenericResource(nil, nil, "/public", "/b/Logo2.png", "Logo2.png", "image"),
+ spec.newGenericResource(nil, nil, "/public", "/b/foo2.css", "foo2.css", "css"),
+ spec.newGenericResource(nil, nil, "/public", "/b/foo3.css", "foo3.css", "css"),
+ spec.newGenericResource(nil, nil, "/public", "/b/c/foo4.css", "c/foo4.css", "css"),
+ spec.newGenericResource(nil, nil, "/public", "/b/c/foo5.css", "c/foo5.css", "css"),
+ spec.newGenericResource(nil, nil, "/public", "/b/c/d/foo6.css", "c/d/foo6.css", "css"),
+ }
+
+ assert.Equal("/logo1.png", resources.GetMatch("logo*").RelPermalink())
+ assert.Equal("/logo1.png", resources.GetMatch("loGo*").RelPermalink())
+ assert.Equal("/Logo2.png", resources.GetMatch("logo2*").RelPermalink())
+ assert.Equal("/foo2.css", resources.GetMatch("foo2*").RelPermalink())
+ assert.Equal("/foo1.css", resources.GetMatch("foo1*").RelPermalink())
+ assert.Equal("/foo1.css", resources.GetMatch("foo1*").RelPermalink())
+ assert.Equal("/c/foo4.css", resources.GetMatch("*/foo*").RelPermalink())
+
+ assert.Nil(resources.GetMatch("asdfasdf"))
+
+ assert.Equal(2, len(resources.Match("Logo*")))
+ assert.Equal(1, len(resources.Match("logo2*")))
+ assert.Equal(2, len(resources.Match("c/*")))
+
+ assert.Equal(6, len(resources.Match("**.css")))
+ assert.Equal(3, len(resources.Match("**/*.css")))
+ assert.Equal(1, len(resources.Match("c/**/*.css")))
+
+ // Matches only CSS files in c/
+ assert.Equal(3, len(resources.Match("c/**.css")))
+
+ // Matches all CSS files below c/ (including in c/d/)
+ assert.Equal(3, len(resources.Match("c/**.css")))
+
+ // Patterns beginning with a slash will not match anything.
+ // We could maybe consider trimming that slash, but let's be explicit about this.
+ // (it is possible for users to do a rename)
+ // This is analogous to standing in a directory and doing "ls *.*".
+ assert.Equal(0, len(resources.Match("/c/**.css")))
+
+}
+
func TestAssignMetadata(t *testing.T) {
assert := require.New(t)
spec := newTestResourceSpec(assert)
}
+func BenchmarkResourcesByPrefix(b *testing.B) {
+ resources := benchResources(b)
+ prefixes := []string{"abc", "jkl", "nomatch", "sub/"}
+ rnd := rand.New(rand.NewSource(time.Now().Unix()))
+
+ b.RunParallel(func(pb *testing.PB) {
+ for pb.Next() {
+ resources.ByPrefix(prefixes[rnd.Intn(len(prefixes))])
+ }
+ })
+}
+
+func BenchmarkResourcesMatch(b *testing.B) {
+ resources := benchResources(b)
+ prefixes := []string{"abc*", "jkl*", "nomatch*", "sub/*"}
+ rnd := rand.New(rand.NewSource(time.Now().Unix()))
+
+ b.RunParallel(func(pb *testing.PB) {
+ for pb.Next() {
+ resources.Match(prefixes[rnd.Intn(len(prefixes))])
+ }
+ })
+}
+
+// This adds a benchmark for the a100 test case as described by Russ Cox here:
+// https://research.swtch.com/glob (really interesting article)
+// I don't expect Hugo users to "stumble upon" this problem, so this is more to satisfy
+// my own curiosity.
+func BenchmarkResourcesMatchA100(b *testing.B) {
+ assert := require.New(b)
+ spec := newTestResourceSpec(assert)
+ a100 := strings.Repeat("a", 100)
+ pattern := "a*a*a*a*a*a*a*a*b"
+
+ resources := Resources{spec.newGenericResource(nil, nil, "/public", "/a/"+a100, a100, "css")}
+
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ resources.Match(pattern)
+ }
+
+}
+
+func benchResources(b *testing.B) Resources {
+ assert := require.New(b)
+ spec := newTestResourceSpec(assert)
+ var resources Resources
+
+ for i := 0; i < 30; i++ {
+ name := fmt.Sprintf("abcde%d_%d.css", i%5, i)
+ resources = append(resources, spec.newGenericResource(nil, nil, "/public", "/a/"+name, name, "css"))
+ }
+
+ for i := 0; i < 30; i++ {
+ name := fmt.Sprintf("efghi%d_%d.css", i%5, i)
+ resources = append(resources, spec.newGenericResource(nil, nil, "/public", "/a/"+name, name, "css"))
+ }
+
+ for i := 0; i < 30; i++ {
+ name := fmt.Sprintf("jklmn%d_%d.css", i%5, i)
+ resources = append(resources, spec.newGenericResource(nil, nil, "/public", "/b/sub/"+name, "sub/"+name, "css"))
+ }
+
+ return resources
+
+}
+
func BenchmarkAssignMetadata(b *testing.B) {
assert := require.New(b)
spec := newTestResourceSpec(assert)
}
}
-
}
projects / brevno-suite / hugo / commitdiff