*pageCommon
}
+func (p *pageState) Err() error {
+ return nil
+}
+
// Eq returns whether the current page equals the given page.
// This is what's invoked when doing `{{ if eq $page $otherPage }}`
func (p *pageState) Eq(other interface{}) bool {
{{ $rimg := resources.Get "%[1]s/sunset.jpg" }}
{{ $remotenotfound := resources.Get "%[1]s/notfound.jpg" }}
{{ $localnotfound := resources.Get "images/notfound.jpg" }}
+{{ $gopherprotocol := resources.Get "gopher://example.org" }}
{{ $rfit := $rimg.Fit "200x200" }}
{{ $rfit2 := $rfit.Fit "100x200" }}
{{ $rimg = $rimg | fingerprint }}
FIT REMOTE: {{ $rfit.Name }}|{{ $rfit.RelPermalink }}|{{ $rfit.Width }}
REMOTE NOT FOUND: {{ if $remotenotfound }}FAILED{{ else}}OK{{ end }}
LOCAL NOT FOUND: {{ if $localnotfound }}FAILED{{ else}}OK{{ end }}
+PRINT PROTOCOL ERROR1: {{ with $gopherprotocol }}{{ . | safeHTML }}{{ end }}
+PRINT PROTOCOL ERROR2: {{ with $gopherprotocol }}{{ .Err | safeHTML }}{{ end }}
`, ts.URL))
FIT REMOTE: sunset_%[1]s.jpg|/sunset_%[1]s_hu59e56ffff1bc1d8d122b1403d34e039f_0_200x200_fit_q75_box.jpg|200
REMOTE NOT FOUND: OK
LOCAL NOT FOUND: OK
+PRINT PROTOCOL ERROR1: error calling resources.Get: Get "gopher://example.org": unsupported protocol scheme "gopher"
+PRINT PROTOCOL ERROR2: error calling resources.Get: Get "gopher://example.org": unsupported protocol scheme "gopher"
`, helpers.HashString(ts.URL+"/sunset.jpg", map[string]interface{}{})))
--- /dev/null
+// Copyright 2021 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package resources
+
+import (
+ "image"
+
+ "github.com/gohugoio/hugo/common/hugio"
+ "github.com/gohugoio/hugo/common/maps"
+ "github.com/gohugoio/hugo/media"
+
+ "github.com/gohugoio/hugo/resources/images/exif"
+
+ "github.com/gohugoio/hugo/resources/resource"
+)
+
+var (
+ _ error = (*errorResource)(nil)
+ // Imnage covers all current Resource implementations.
+ _ resource.Image = (*errorResource)(nil)
+ // The list of user facing and exported interfaces in resource.go
+ // Note that if we're missing some interface here, the user will still
+ // get an error, but not as pretty.
+ _ resource.ContentResource = (*errorResource)(nil)
+ _ resource.ReadSeekCloserResource = (*errorResource)(nil)
+ _ resource.ResourcesLanguageMerger = (*resource.Resources)(nil)
+ // Make sure it also fails when passed to a pipe function.
+ _ ResourceTransformer = (*errorResource)(nil)
+)
+
+// NewErrorResource wraps err in a Resource where all but the Err method will panic.
+func NewErrorResource(err error) resource.Resource {
+ return &errorResource{error: err}
+}
+
+type errorResource struct {
+ error
+}
+
+func (e *errorResource) Err() error {
+ return e.error
+}
+
+func (e *errorResource) ReadSeekCloser() (hugio.ReadSeekCloser, error) {
+ panic(e.error)
+}
+
+func (e *errorResource) Content() (interface{}, error) {
+ panic(e.error)
+}
+
+func (e *errorResource) ResourceType() string {
+ panic(e.error)
+}
+
+func (e *errorResource) MediaType() media.Type {
+ panic(e.error)
+}
+
+func (e *errorResource) Permalink() string {
+ panic(e.error)
+}
+
+func (e *errorResource) RelPermalink() string {
+ panic(e.error)
+}
+
+func (e *errorResource) Name() string {
+ panic(e.error)
+}
+
+func (e *errorResource) Title() string {
+ panic(e.error)
+}
+
+func (e *errorResource) Params() maps.Params {
+ panic(e.error)
+}
+
+func (e *errorResource) Data() interface{} {
+ panic(e.error)
+}
+
+func (e *errorResource) Height() int {
+ panic(e.error)
+}
+
+func (e *errorResource) Width() int {
+ panic(e.error)
+}
+
+func (e *errorResource) Fill(spec string) (resource.Image, error) {
+ panic(e.error)
+}
+
+func (e *errorResource) Fit(spec string) (resource.Image, error) {
+ panic(e.error)
+}
+
+func (e *errorResource) Resize(spec string) (resource.Image, error) {
+ panic(e.error)
+}
+
+func (e *errorResource) Filter(filters ...interface{}) (resource.Image, error) {
+ panic(e.error)
+}
+
+func (e *errorResource) Exif() *exif.Exif {
+ panic(e.error)
+}
+
+func (e *errorResource) DecodeImage() (image.Image, error) {
+ panic(e.error)
+}
+
+func (e *errorResource) Transform(...ResourceTransformation) (ResourceTransformer, error) {
+ panic(e.error)
+}
// PageNop implements Page, but does nothing.
type nopPage int
+func (p *nopPage) Err() error {
+ return nil
+}
+
func (p *nopPage) Aliases() []string {
return nil
}
"github.com/bep/gitmap"
"github.com/gohugoio/hugo/helpers"
"github.com/gohugoio/hugo/resources/resource"
-
"github.com/gohugoio/hugo/navigation"
sectionEntries []string
}
+func (p *testPage) Err() error {
+ return nil
+}
+
func (p *testPage) Aliases() []string {
panic("not implemented")
}
return l.content, nil
}
+func (r *genericResource) Err() error {
+ return nil
+}
+
func (l *genericResource) Data() interface{} {
return l.data
}
ResourceMetaProvider
ResourceParamsProvider
ResourceDataProvider
+ Err() error
}
// Image represents an image resource.
"github.com/gohugoio/hugo/hugofs"
"github.com/gohugoio/hugo/cache/filecache"
- "github.com/gohugoio/hugo/common/herrors"
"github.com/gohugoio/hugo/common/hugio"
"github.com/gohugoio/hugo/common/maps"
"github.com/gohugoio/hugo/common/types"
// FromRemote expects one or n-parts of a URL to a resource
// If you provide multiple parts they will be joined together to the final URL.
func (c *Client) FromRemote(uri string, options map[string]interface{}) (resource.Resource, error) {
- defer herrors.Recover()
rURL, err := url.Parse(uri)
if err != nil {
return nil, errors.Wrapf(err, "failed to parse URL for resource %s", uri)
return r.target.Content()
}
+func (r *resourceAdapter) Err() error {
+ return nil
+}
+
func (r *resourceAdapter) Data() interface{} {
r.init(false, false)
return r.target.Data()
// further transformations.
//
// For URLs an additional argument with options can be provided.
-func (ns *Namespace) Get(args ...interface{}) (resource.Resource, error) {
- if len(args) != 1 && len(args) != 2 {
- return nil, errors.New("must provide a filename or URL")
- }
+func (ns *Namespace) Get(args ...interface{}) resource.Resource {
+ get := func(args ...interface{}) (resource.Resource, error) {
+ if len(args) != 1 && len(args) != 2 {
+ return nil, errors.New("must provide a filename or URL")
+ }
- filenamestr, err := cast.ToStringE(args[0])
- if err != nil {
- return nil, err
- }
+ filenamestr, err := cast.ToStringE(args[0])
+ if err != nil {
+ return nil, err
+ }
- if u, err := url.Parse(filenamestr); err == nil && u.Scheme != "" {
- if len(args) == 2 {
- options, err := maps.ToStringMapE(args[1])
- if err != nil {
- return nil, err
+ if u, err := url.Parse(filenamestr); err == nil && u.Scheme != "" {
+ if len(args) == 2 {
+ options, err := maps.ToStringMapE(args[1])
+ if err != nil {
+ return nil, err
+ }
+ return ns.createClient.FromRemote(filenamestr, options)
}
- return ns.createClient.FromRemote(filenamestr, options)
+ return ns.createClient.FromRemote(filenamestr, nil)
}
- return ns.createClient.FromRemote(filenamestr, nil)
+
+ filenamestr = filepath.Clean(filenamestr)
+
+ return ns.createClient.Get(filenamestr)
}
- filenamestr = filepath.Clean(filenamestr)
+ r, err := get(args...)
+ if err != nil {
+ // This allows the client to reason about the .Err in the template.
+ return resources.NewErrorResource(errors.Wrap(err, "error calling resources.Get"))
+ }
+ return r
- return ns.createClient.Get(filenamestr)
}
// GetMatch finds the first Resource matching the given pattern, or nil if none found.
projects / brevno-suite / hugo / commitdiff