From 0e38e162b297c234125cf521eeab7b4ef23950a8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B8rn=20Erik=20Pedersen?= Date: Wed, 20 Oct 2021 10:11:48 +0200 Subject: [PATCH] resources: Create a ResourceFinder interface And make both .Resources and resources implement it. This commit: * Preserves the `interface{}` arguments, which is unfortunate, but probably needed. Maybe Go 1.18's generics can fix that. * Removes any `error` in return values; all errors are in the "should not happen" category, we return `nil` on not found. Fixes #8653 --- hugolib/hugo_sites_build_test.go | 2 + hugolib/pagebundler_test.go | 3 +- hugolib/resource_chain_test.go | 11 ++- resources/resource/resources.go | 93 +++++++++++++++++-- resources/resource_factories/create/create.go | 25 +++-- tpl/resources/resources.go | 43 +++++++-- 6 files changed, 146 insertions(+), 31 deletions(-) diff --git a/hugolib/hugo_sites_build_test.go b/hugolib/hugo_sites_build_test.go index fdfc33c5a15..ef70bfcb0ed 100644 --- a/hugolib/hugo_sites_build_test.go +++ b/hugolib/hugo_sites_build_test.go @@ -397,6 +397,8 @@ func doTestMultiSitesBuild(t *testing.T, configTemplate, configSuffix string) { c.Assert(bundleFr, qt.Not(qt.IsNil)) c.Assert(len(bundleFr.Resources()), qt.Equals, 1) logoFr := bundleFr.Resources().GetMatch("logo*") + logoFrGet := bundleFr.Resources().Get("logo.png") + c.Assert(logoFrGet, qt.Equals, logoFr) c.Assert(logoFr, qt.Not(qt.IsNil)) b.AssertFileContent("public/fr/bundles/b1/index.html", "Resources: image/png: /blog/fr/bundles/b1/logo.png") b.AssertFileContent("public/fr/bundles/b1/logo.png", "PNG Data") diff --git a/hugolib/pagebundler_test.go b/hugolib/pagebundler_test.go index 1694b02ee8a..38303a90c47 100644 --- a/hugolib/pagebundler_test.go +++ b/hugolib/pagebundler_test.go @@ -553,7 +553,8 @@ HEADLESS {{< myShort >}} headlessResources := headless.Resources() c.Assert(len(headlessResources), qt.Equals, 3) - c.Assert(len(headlessResources.Match("l*")), qt.Equals, 2) + res := headlessResources.Match("l*") + c.Assert(len(res), qt.Equals, 2) pageResource := headlessResources.GetMatch("p*") c.Assert(pageResource, qt.Not(qt.IsNil)) p := pageResource.(page.Page) diff --git a/hugolib/resource_chain_test.go b/hugolib/resource_chain_test.go index 85b1b3abdcd..09688111d2b 100644 --- a/hugolib/resource_chain_test.go +++ b/hugolib/resource_chain_test.go @@ -887,6 +887,8 @@ func TestResourcesMatch(t *testing.T) { b.WithContent("page.md", "") b.WithSourceFile( + "assets/images/img1.png", "png", + "assets/images/img2.jpg", "jpg", "assets/jsons/data1.json", "json1 content", "assets/jsons/data2.json", "json2 content", "assets/jsons/data3.xml", "xml content", @@ -895,7 +897,9 @@ func TestResourcesMatch(t *testing.T) { b.WithTemplates("index.html", ` {{ $jsons := (resources.Match "jsons/*.json") }} {{ $json := (resources.GetMatch "jsons/*.json") }} -{{ printf "JSONS: %d" (len $jsons) }} +{{ printf "jsonsMatch: %d" (len $jsons) }} +{{ printf "imagesByType: %d" (len (resources.ByType "image") ) }} +{{ printf "applicationByType: %d" (len (resources.ByType "application") ) }} JSON: {{ $json.RelPermalink }}: {{ $json.Content }} {{ range $jsons }} {{- .RelPermalink }}: {{ .Content }} @@ -906,7 +910,10 @@ JSON: {{ $json.RelPermalink }}: {{ $json.Content }} b.AssertFileContent("public/index.html", "JSON: /jsons/data1.json: json1 content", - "JSONS: 2", "/jsons/data1.json: json1 content") + "jsonsMatch: 2", + "imagesByType: 2", + "applicationByType: 3", + "/jsons/data1.json: json1 content") } func TestExecuteAsTemplateWithLanguage(t *testing.T) { diff --git a/resources/resource/resources.go b/resources/resource/resources.go index ac5dd0b2b03..453c07b7366 100644 --- a/resources/resource/resources.go +++ b/resources/resource/resources.go @@ -18,35 +18,64 @@ import ( "strings" "github.com/gohugoio/hugo/hugofs/glob" + "github.com/spf13/cast" ) +var _ ResourceFinder = (*Resources)(nil) + // Resources represents a slice of resources, which can be a mix of different types. // I.e. both pages and images etc. type Resources []Resource +// var _ resource.ResourceFinder = (*Namespace)(nil) // ResourcesConverter converts a given slice of Resource objects to Resources. type ResourcesConverter interface { ToResources() Resources } -// ByType returns resources of a given resource type (ie. "image"). -func (r Resources) ByType(tp string) Resources { +// ByType returns resources of a given resource type (e.g. "image"). +func (r Resources) ByType(tp interface{}) Resources { + tpstr, err := cast.ToStringE(tp) + if err != nil { + panic(err) + } var filtered Resources for _, resource := range r { - if resource.ResourceType() == tp { + if resource.ResourceType() == tpstr { filtered = append(filtered, resource) } } return filtered } +// Get locates the name given in Resources. +// The search is case insensitive. +func (r Resources) Get(name interface{}) Resource { + namestr, err := cast.ToStringE(name) + if err != nil { + panic(err) + } + namestr = strings.ToLower(namestr) + for _, resource := range r { + if strings.EqualFold(namestr, resource.Name()) { + return resource + } + } + return nil +} + // 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 := glob.GetGlob(pattern) +func (r Resources) GetMatch(pattern interface{}) Resource { + patternstr, err := cast.ToStringE(pattern) + if err != nil { + panic(err) + } + + g, err := glob.GetGlob(patternstr) if err != nil { - return nil + panic(err) } for _, resource := range r { @@ -67,10 +96,15 @@ func (r Resources) GetMatch(pattern string) Resource { // 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 := glob.GetGlob(pattern) +func (r Resources) Match(pattern interface{}) Resources { + patternstr, err := cast.ToStringE(pattern) if err != nil { - return nil + panic(err) + } + + g, err := glob.GetGlob(patternstr) + if err != nil { + panic(err) } var matches Resources @@ -121,3 +155,44 @@ func (r Resources) MergeByLanguageInterface(in interface{}) (interface{}, error) type Source interface { Publish() error } + +// ResourceFinder provides method to find Resources. +type ResourceFinder interface { + + // Get locates the filename given in Hugo's assets filesystem + // and creates a Resource object that can be used for further transformations. + // + // It returns nil if no Resource could found, panics if filename is invalid. + Get(filename interface{}) Resource + + // 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. + // + // It returns nil if no Resource could found, panics if pattern is invalid. + GetMatch(pattern interface{}) Resource + + // Match gets all resources matching the given base path 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 a relative pathwith Unix style slashes (/) and no + // leading slash, e.g. "images/logo.png". + // + // See https://github.com/gobwas/glob for the full rules set. + // + // It looks for files in the assets file system. + // + // See Match for a more complete explanation about the rules used. + // + // It returns nil if no Resources could found, panics if pattern is invalid. + Match(pattern interface{}) Resources + + // ByType returns resources of a given resource type (e.g. "image"). + // It returns nil if no Resources could found, panics if tp is invalid. + ByType(tp interface{}) Resources +} diff --git a/resources/resource_factories/create/create.go b/resources/resource_factories/create/create.go index 97a3fc0c4e9..a74f3e3f017 100644 --- a/resources/resource_factories/create/create.go +++ b/resources/resource_factories/create/create.go @@ -54,26 +54,27 @@ func (c *Client) Get(filename string) (resource.Resource, error) { // Match gets the resources matching the given pattern from the assets filesystem. func (c *Client) Match(pattern string) (resource.Resources, error) { - return c.match(pattern, false) + return c.match("__match", pattern, nil, false) +} + +func (c *Client) ByType(tp string) resource.Resources { + res, err := c.match(path.Join("_byType", tp), "**", func(r resource.Resource) bool { return r.ResourceType() == tp }, false) + if err != nil { + panic(err) + } + return res } // GetMatch gets first resource matching the given pattern from the assets filesystem. func (c *Client) GetMatch(pattern string) (resource.Resource, error) { - res, err := c.match(pattern, true) + res, err := c.match("__get-match", pattern, nil, true) if err != nil || len(res) == 0 { return nil, err } return res[0], err } -func (c *Client) match(pattern string, firstOnly bool) (resource.Resources, error) { - var name string - if firstOnly { - name = "__get-match" - } else { - name = "__match" - } - +func (c *Client) match(name, pattern string, matchFunc func(r resource.Resource) bool, firstOnly bool) (resource.Resources, error) { pattern = glob.NormalizePath(pattern) partitions := glob.FilterGlobParts(strings.Split(pattern, "/")) if len(partitions) == 0 { @@ -99,6 +100,10 @@ func (c *Client) match(pattern string, firstOnly bool) (resource.Resources, erro return true, err } + if matchFunc != nil && !matchFunc(r) { + return false, nil + } + res = append(res, r) return firstOnly, nil diff --git a/tpl/resources/resources.go b/tpl/resources/resources.go index 850def00e27..eebd0b7de1b 100644 --- a/tpl/resources/resources.go +++ b/tpl/resources/resources.go @@ -19,6 +19,8 @@ import ( "path/filepath" "sync" + "github.com/gohugoio/hugo/common/herrors" + "github.com/gohugoio/hugo/common/maps" "github.com/pkg/errors" @@ -73,6 +75,8 @@ func New(deps *deps.Deps) (*Namespace, error) { }, nil } +var _ resource.ResourceFinder = (*Namespace)(nil) + // Namespace provides template functions for the "resources" namespace. type Namespace struct { deps *deps.Deps @@ -109,15 +113,20 @@ func (ns *Namespace) getscssClientDartSass() (*dartsass.Client, error) { // Get locates the filename given in Hugo's assets filesystem // and creates a Resource object that can be used for further transformations. -func (ns *Namespace) Get(filename interface{}) (resource.Resource, error) { +func (ns *Namespace) Get(filename interface{}) resource.Resource { filenamestr, err := cast.ToStringE(filename) if err != nil { - return nil, err + panic(err) } filenamestr = filepath.Clean(filenamestr) - return ns.createClient.Get(filenamestr) + r, err := ns.createClient.Get(filenamestr) + if err != nil { + panic(err) + } + + return r } // GetMatch finds the first Resource matching the given pattern, or nil if none found. @@ -125,13 +134,23 @@ func (ns *Namespace) Get(filename interface{}) (resource.Resource, error) { // It looks for files in the assets file system. // // See Match for a more complete explanation about the rules used. -func (ns *Namespace) GetMatch(pattern interface{}) (resource.Resource, error) { +func (ns *Namespace) GetMatch(pattern interface{}) resource.Resource { patternStr, err := cast.ToStringE(pattern) if err != nil { - return nil, err + panic(err) + } + + r, err := ns.createClient.GetMatch(patternStr) + if err != nil { + panic(err) } - return ns.createClient.GetMatch(patternStr) + return r +} + +// ByType returns resources of a given resource type (e.g. "image"). +func (ns *Namespace) ByType(tp interface{}) resource.Resources { + return ns.createClient.ByType(cast.ToString(tp)) } // Match gets all resources matching the given base path prefix, e.g @@ -150,13 +169,19 @@ func (ns *Namespace) GetMatch(pattern interface{}) (resource.Resource, error) { // It looks for files in the assets file system. // // See Match for a more complete explanation about the rules used. -func (ns *Namespace) Match(pattern interface{}) (resource.Resources, error) { +func (ns *Namespace) Match(pattern interface{}) resource.Resources { + defer herrors.Recover() patternStr, err := cast.ToStringE(pattern) if err != nil { - return nil, err + panic(err) + } + + r, err := ns.createClient.Match(patternStr) + if err != nil { + panic(err) } - return ns.createClient.Match(patternStr) + return r } // Concat concatenates a slice of Resource objects. These resources must