Image resource refactor

This commit pulls most of the image related logic into its own package, to make it easier to reason about and extend.

This is also a rewrite of the transformation logic used in Hugo Pipes, mostly to allow constructs like the one below:

    {{ ($myimg | fingerprint ).Width }}

Fixes #5903
Fixes #6234
Fixes #6266

resources/resource_transformers/htesting/testhelpers.go

@@ -0,0 +1,80 @@
+// Copyright 2019 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 htesting
+
+import (
+	"path/filepath"
+
+	"github.com/gohugoio/hugo/cache/filecache"
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/gohugoio/hugo/media"
+	"github.com/gohugoio/hugo/output"
+	"github.com/gohugoio/hugo/resources"
+	"github.com/spf13/afero"
+	"github.com/spf13/viper"
+)
+
+func NewTestResourceSpec() (*resources.Spec, error) {
+	cfg := viper.New()
+	cfg.Set("baseURL", "https://example.org")
+	cfg.Set("publishDir", "public")
+
+	imagingCfg := map[string]interface{}{
+		"resampleFilter": "linear",
+		"quality":        68,
+		"anchor":         "left",
+	}
+
+	cfg.Set("imaging", imagingCfg)
+
+	fs := hugofs.NewMem(cfg)
+
+	s, err := helpers.NewPathSpec(fs, cfg, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	filecaches, err := filecache.NewCaches(s)
+	if err != nil {
+		return nil, err
+	}
+
+	spec, err := resources.NewSpec(s, filecaches, nil, output.DefaultFormats, media.DefaultTypes)
+	return spec, err
+}
+
+func NewResourceTransformer(filename, content string) (resources.ResourceTransformer, error) {
+	spec, err := NewTestResourceSpec()
+	if err != nil {
+		return nil, err
+	}
+	return NewResourceTransformerForSpec(spec, filename, content)
+}
+
+func NewResourceTransformerForSpec(spec *resources.Spec, filename, content string) (resources.ResourceTransformer, error) {
+	filename = filepath.FromSlash(filename)
+
+	fs := spec.Fs.Source
+	if err := afero.WriteFile(fs, filename, []byte(content), 0777); err != nil {
+		return nil, err
+	}
+
+	r, err := spec.New(resources.ResourceSourceDescriptor{Fs: fs, SourceFilename: filename})
+	if err != nil {
+		return nil, err
+	}
+
+	return r.(resources.ResourceTransformer), nil
+}

resources/resource_transformers/integrity/integrity.go

@@ -23,6 +23,8 @@ import (
 	"html/template"
 	"io"
 
+	"github.com/gohugoio/hugo/resources/internal"
+
 	"github.com/pkg/errors"
 
 	"github.com/gohugoio/hugo/resources"
@@ -46,8 +48,8 @@ type fingerprintTransformation struct {
 	algo string
 }
 
-func (t *fingerprintTransformation) Key() resources.ResourceTransformationKey {
-	return resources.NewResourceTransformationKey("fingerprint", t.algo)
+func (t *fingerprintTransformation) Key() internal.ResourceTransformationKey {
+	return internal.NewResourceTransformationKey("fingerprint", t.algo)
 }
 
 // Transform creates a MD5 hash of the Resource content and inserts that hash before
@@ -59,7 +61,17 @@ func (t *fingerprintTransformation) Transform(ctx *resources.ResourceTransformat
 		return err
 	}
 
-	io.Copy(io.MultiWriter(h, ctx.To), ctx.From)
+	var w io.Writer
+	if rc, ok := ctx.From.(io.ReadSeeker); ok {
+		// This transformation does not change the content, so try to
+		// avoid writing to To if we can.
+		defer rc.Seek(0, 0)
+		w = h
+	} else {
+		w = io.MultiWriter(h, ctx.To)
+	}
+
+	io.Copy(w, ctx.From)
 	d, err := digest(h)
 	if err != nil {
 		return err
@@ -91,15 +103,12 @@ func newHash(algo string) (hash.Hash, error) {
 // the base64-encoded Subresource Integrity hash, so you will have to stay away from
 // md5 if you plan to use both.
 // See https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity
-func (c *Client) Fingerprint(res resource.Resource, algo string) (resource.Resource, error) {
+func (c *Client) Fingerprint(res resources.ResourceTransformer, algo string) (resource.Resource, error) {
 	if algo == "" {
 		algo = defaultHashAlgo
 	}
 
-	return c.rs.Transform(
-		res,
-		&fingerprintTransformation{algo: algo},
-	)
+	return res.Transform(&fingerprintTransformation{algo: algo})
 }
 
 func integrity(algo string, sum []byte) template.HTMLAttr {

resources/resource_transformers/integrity/integrity_test.go

@@ -14,9 +14,13 @@
 package integrity
 
 import (
+	"html/template"
 	"testing"
 
+	"github.com/gohugoio/hugo/resources/resource"
+
 	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/resources/resource_transformers/htesting"
 )
 
 func TestHashFromAlgo(t *testing.T) {
@@ -46,3 +50,23 @@ func TestHashFromAlgo(t *testing.T) {
 		})
 	}
 }
+
+func TestTransform(t *testing.T) {
+	c := qt.New(t)
+
+	spec, err := htesting.NewTestResourceSpec()
+	c.Assert(err, qt.IsNil)
+	client := New(spec)
+
+	r, err := htesting.NewResourceTransformerForSpec(spec, "hugo.txt", "Hugo Rocks!")
+	c.Assert(err, qt.IsNil)
+
+	transformed, err := client.Fingerprint(r, "")
+
+	c.Assert(err, qt.IsNil)
+	c.Assert(transformed.RelPermalink(), qt.Equals, "/hugo.a5ad1c6961214a55de53c1ce6e60d27b6b761f54851fa65e33066460dfa6a0db.txt")
+	c.Assert(transformed.Data(), qt.DeepEquals, map[string]interface{}{"Integrity": template.HTMLAttr("sha256-pa0caWEhSlXeU8HObmDSe2t2H1SFH6ZeMwZkYN+moNs=")})
+	content, err := transformed.(resource.ContentProvider).Content()
+	c.Assert(err, qt.IsNil)
+	c.Assert(content, qt.Equals, "Hugo Rocks!")
+}

resources/resource_transformers/minifier/minify.go

@@ -16,6 +16,7 @@ package minifier
 import (
 	"github.com/gohugoio/hugo/minifiers"
 	"github.com/gohugoio/hugo/resources"
+	"github.com/gohugoio/hugo/resources/internal"
 	"github.com/gohugoio/hugo/resources/resource"
 )
 
@@ -37,8 +38,8 @@ type minifyTransformation struct {
 	m  minifiers.Client
 }
 
-func (t *minifyTransformation) Key() resources.ResourceTransformationKey {
-	return resources.NewResourceTransformationKey("minify")
+func (t *minifyTransformation) Key() internal.ResourceTransformationKey {
+	return internal.NewResourceTransformationKey("minify")
 }
 
 func (t *minifyTransformation) Transform(ctx *resources.ResourceTransformationCtx) error {
@@ -49,11 +50,10 @@ func (t *minifyTransformation) Transform(ctx *resources.ResourceTransformationCt
 	return nil
 }
 
-func (c *Client) Minify(res resource.Resource) (resource.Resource, error) {
-	return c.rs.Transform(
-		res,
-		&minifyTransformation{
-			rs: c.rs,
-			m:  c.m},
-	)
+func (c *Client) Minify(res resources.ResourceTransformer) (resource.Resource, error) {
+	return res.Transform(&minifyTransformation{
+		rs: c.rs,
+		m:  c.m,
+	})
+
 }

resources/resource_transformers/minifier/minify_test.go

@@ -0,0 +1,43 @@
+// Copyright 2019 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 minifier
+
+import (
+	"testing"
+
+	"github.com/gohugoio/hugo/resources/resource"
+
+	qt "github.com/frankban/quicktest"
+	"github.com/gohugoio/hugo/resources/resource_transformers/htesting"
+)
+
+func TestTransform(t *testing.T) {
+	c := qt.New(t)
+
+	spec, err := htesting.NewTestResourceSpec()
+	c.Assert(err, qt.IsNil)
+	client := New(spec)
+
+	r, err := htesting.NewResourceTransformerForSpec(spec, "hugo.html", "<h1>   Hugo Rocks!   </h1>")
+	c.Assert(err, qt.IsNil)
+
+	transformed, err := client.Minify(r)
+	c.Assert(err, qt.IsNil)
+
+	c.Assert(transformed.RelPermalink(), qt.Equals, "/hugo.min.html")
+	content, err := transformed.(resource.ContentProvider).Content()
+	c.Assert(err, qt.IsNil)
+	c.Assert(content, qt.Equals, "<h1>Hugo Rocks!</h1>")
+
+}

resources/resource_transformers/postcss/postcss.go

@@ -17,6 +17,7 @@ import (
 	"io"
 	"path/filepath"
 
+	"github.com/gohugoio/hugo/resources/internal"
 	"github.com/spf13/cast"
 
 	"github.com/gohugoio/hugo/hugofs"
@@ -98,8 +99,8 @@ type postcssTransformation struct {
 	rs      *resources.Spec
 }
 
-func (t *postcssTransformation) Key() resources.ResourceTransformationKey {
-	return resources.NewResourceTransformationKey("postcss", t.options)
+func (t *postcssTransformation) Key() internal.ResourceTransformationKey {
+	return internal.NewResourceTransformationKey("postcss", t.options)
 }
 
 // Transform shells out to postcss-cli to do the heavy lifting.
@@ -187,9 +188,6 @@ func (t *postcssTransformation) Transform(ctx *resources.ResourceTransformationC
 }
 
 // Process transforms the given Resource with the PostCSS processor.
-func (c *Client) Process(res resource.Resource, options Options) (resource.Resource, error) {
-	return c.rs.Transform(
-		res,
-		&postcssTransformation{rs: c.rs, options: options},
-	)
+func (c *Client) Process(res resources.ResourceTransformer, options Options) (resource.Resource, error) {
+	return res.Transform(&postcssTransformation{rs: c.rs, options: options})
 }

resources/resource_transformers/templates/execute_as_template.go

@@ -17,6 +17,7 @@ package templates
 import (
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/resources"
+	"github.com/gohugoio/hugo/resources/internal"
 	"github.com/gohugoio/hugo/resources/resource"
 	"github.com/gohugoio/hugo/tpl"
 	"github.com/pkg/errors"
@@ -47,8 +48,8 @@ type executeAsTemplateTransform struct {
 	data         interface{}
 }
 
-func (t *executeAsTemplateTransform) Key() resources.ResourceTransformationKey {
-	return resources.NewResourceTransformationKey("execute-as-template", t.targetPath)
+func (t *executeAsTemplateTransform) Key() internal.ResourceTransformationKey {
+	return internal.NewResourceTransformationKey("execute-as-template", t.targetPath)
 }
 
 func (t *executeAsTemplateTransform) Transform(ctx *resources.ResourceTransformationCtx) error {
@@ -63,14 +64,11 @@ func (t *executeAsTemplateTransform) Transform(ctx *resources.ResourceTransforma
 	return templ.Execute(ctx.To, t.data)
 }
 
-func (c *Client) ExecuteAsTemplate(res resource.Resource, targetPath string, data interface{}) (resource.Resource, error) {
-	return c.rs.Transform(
-		res,
-		&executeAsTemplateTransform{
-			rs:           c.rs,
-			targetPath:   helpers.ToSlashTrimLeading(targetPath),
-			textTemplate: c.textTemplate,
-			data:         data,
-		},
-	)
+func (c *Client) ExecuteAsTemplate(res resources.ResourceTransformer, targetPath string, data interface{}) (resource.Resource, error) {
+	return res.Transform(&executeAsTemplateTransform{
+		rs:           c.rs,
+		targetPath:   helpers.ToSlashTrimLeading(targetPath),
+		textTemplate: c.textTemplate,
+		data:         data,
+	})
 }

resources/resource_transformers/tocss/scss/client.go

@@ -18,6 +18,7 @@ import (
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugolib/filesystems"
 	"github.com/gohugoio/hugo/resources"
+	"github.com/gohugoio/hugo/resources/internal"
 	"github.com/gohugoio/hugo/resources/resource"
 	"github.com/spf13/afero"
 
@@ -68,7 +69,7 @@ type options struct {
 	to scss.Options
 }
 
-func (c *Client) ToCSS(res resource.Resource, opts Options) (resource.Resource, error) {
+func (c *Client) ToCSS(res resources.ResourceTransformer, opts Options) (resource.Resource, error) {
 	internalOptions := options{
 		from: opts,
 	}
@@ -83,10 +84,7 @@ func (c *Client) ToCSS(res resource.Resource, opts Options) (resource.Resource,
 		internalOptions.to.Precision = 8
 	}
 
-	return c.rs.Transform(
-		res,
-		&toCSSTransformation{c: c, options: internalOptions},
-	)
+	return res.Transform(&toCSSTransformation{c: c, options: internalOptions})
 }
 
 type toCSSTransformation struct {
@@ -94,8 +92,8 @@ type toCSSTransformation struct {
 	options options
 }
 
-func (t *toCSSTransformation) Key() resources.ResourceTransformationKey {
-	return resources.NewResourceTransformationKey("tocss", t.options.from)
+func (t *toCSSTransformation) Key() internal.ResourceTransformationKey {
+	return internal.NewResourceTransformationKey("tocss", t.options.from)
 }
 
 func DecodeOptions(m map[string]interface{}) (opts Options, err error) {