2018-08-05 09:13:49 +00:00
|
|
|
// Copyright 2018 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 minifiers contains minifiers mapped to MIME types. This package is used
|
|
|
|
// in both the resource transformation, i.e. resources.Minify, and in the publishing
|
|
|
|
// chain.
|
|
|
|
package minifiers
|
|
|
|
|
|
|
|
import (
|
|
|
|
"io"
|
2018-08-14 17:24:33 +00:00
|
|
|
"regexp"
|
2018-08-05 09:13:49 +00:00
|
|
|
|
2020-02-29 09:44:05 +00:00
|
|
|
"github.com/gohugoio/hugo/config"
|
2018-08-05 09:13:49 +00:00
|
|
|
"github.com/gohugoio/hugo/output"
|
|
|
|
"github.com/gohugoio/hugo/transform"
|
|
|
|
|
|
|
|
"github.com/gohugoio/hugo/media"
|
2018-11-06 19:10:02 +00:00
|
|
|
"github.com/tdewolff/minify/v2"
|
2018-08-05 09:13:49 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// Client wraps a minifier.
|
|
|
|
type Client struct {
|
2020-03-20 15:34:53 +00:00
|
|
|
// Whether output minification is enabled (HTML in /public)
|
|
|
|
MinifyOutput bool
|
|
|
|
|
2018-08-05 09:13:49 +00:00
|
|
|
m *minify.M
|
|
|
|
}
|
|
|
|
|
|
|
|
// Transformer returns a func that can be used in the transformer publishing chain.
|
|
|
|
// TODO(bep) minify config etc
|
|
|
|
func (m Client) Transformer(mediatype media.Type) transform.Transformer {
|
|
|
|
_, params, min := m.m.Match(mediatype.Type())
|
|
|
|
if min == nil {
|
|
|
|
// No minifier for this MIME type
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return func(ft transform.FromTo) error {
|
|
|
|
// Note that the source io.Reader will already be buffered, but it implements
|
|
|
|
// the Bytes() method, which is recognized by the Minify library.
|
|
|
|
return min.Minify(m.m, ft.To(), ft.From(), params)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Minify tries to minify the src into dst given a MIME type.
|
|
|
|
func (m Client) Minify(mediatype media.Type, dst io.Writer, src io.Reader) error {
|
|
|
|
return m.m.Minify(mediatype.Type(), dst, src)
|
|
|
|
}
|
|
|
|
|
Pass minification errors to the user
Previously, *minifyTransformation.Transform suppressed the
error returned by t.m.Minify. This meant that when minification
returned an error, the error would not reach the user. Instead,
minification would silently fail. For example, if a JavaScript
file included a call to the Date constructor with:
new Date(2020, 04, 02)
The package that the minification library uses to parse JS files,
github.com/tdewolff/parse would return an error, since "04" would
be parsed as a legacy octal. However, the JS file would remain
un-minified with no error.
Fixing this is not as simple as replacing "_" with an "err" in
*minifyTransformation.Transform, however (though this is
necessary). If we only returned this error from Transform,
then hugolib.TestResourceMinifyDisabled would fail. Instead of
being a no-op, as TestResourceMinifyDisabled expects, using the
"minify" template function with a "disableXML=true" config
setting instead returns the error, "minifier does not exist for
mimetype."
The "minifier does not exist" error is returned because of the
way minifiers.New works. If the user's config disables
minification for a particular MIME type, minifiers.New does
not add it to the resulting Client's *minify.M. However, this
also means that when the "minify" template function is executed,
a *resourceAdapter's transformations still add a minification.
When it comes time to call the minify.Minifier for a specific
MIME type via *M.MinifyMimetype, the github.com/tdewolff/minify
library throws the "does not exist" error for the missing MIME
type.
The solution was to change minifiers.New so, instead of skipping
a minifier for each disabled MIME type, it adds a NoOpMinifier,
which simply copies the source to the destination without
minification. This means that when the "minify" template
function is used for a particular resource, and that resource's
MIME type has minification disabled, minification is genuinely
skipped, and does not result in an error.
In order to add this, I've fixed a possibly unwanted interaction
between minifiers.TestConfigureMinify and
hugolib.TestResourceMinifyDisabled. The latter disables
minification and expects minification to be a no-op. The former
disables minification and expects it to result in an error. The
only reason hugolib.TestResourceMinifyDisabled passes in the
original code is that the "does not exist" error is suppressed.
However, we shouldn't suppress minification errors, since they
can leave users perplexed. I've changed the test assertion in
minifiers.TestConfigureMinify to expect no errors and a no-op
if minification is disabled for a particular MIME type.
Fixes #8954
2021-09-22 18:54:40 +00:00
|
|
|
// noopMinifier implements minify.Minifier [1], but doesn't minify content. This means
|
|
|
|
// that we can avoid missing minifiers for any MIME types in our minify.M, which
|
|
|
|
// causes minify to return errors, while still allowing minification to be
|
|
|
|
// disabled for specific types.
|
|
|
|
//
|
|
|
|
// [1]: https://pkg.go.dev/github.com/tdewolff/minify#Minifier
|
|
|
|
type noopMinifier struct{}
|
|
|
|
|
|
|
|
// Minify copies r into w without transformation.
|
|
|
|
func (m noopMinifier) Minify(_ *minify.M, w io.Writer, r io.Reader, _ map[string]string) error {
|
|
|
|
_, err := io.Copy(w, r)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2018-08-05 09:13:49 +00:00
|
|
|
// New creates a new Client with the provided MIME types as the mapping foundation.
|
|
|
|
// The HTML minifier is also registered for additional HTML types (AMP etc.) in the
|
|
|
|
// provided list of output formats.
|
2020-02-29 09:44:05 +00:00
|
|
|
func New(mediaTypes media.Types, outputFormats output.Formats, cfg config.Provider) (Client, error) {
|
|
|
|
conf, err := decodeConfig(cfg)
|
2018-08-05 09:13:49 +00:00
|
|
|
|
2020-02-29 09:44:05 +00:00
|
|
|
m := minify.New()
|
|
|
|
if err != nil {
|
2020-03-20 15:34:53 +00:00
|
|
|
return Client{}, err
|
2018-12-07 06:49:26 +00:00
|
|
|
}
|
|
|
|
|
2018-08-05 09:13:49 +00:00
|
|
|
// We use the Type definition of the media types defined in the site if found.
|
Pass minification errors to the user
Previously, *minifyTransformation.Transform suppressed the
error returned by t.m.Minify. This meant that when minification
returned an error, the error would not reach the user. Instead,
minification would silently fail. For example, if a JavaScript
file included a call to the Date constructor with:
new Date(2020, 04, 02)
The package that the minification library uses to parse JS files,
github.com/tdewolff/parse would return an error, since "04" would
be parsed as a legacy octal. However, the JS file would remain
un-minified with no error.
Fixing this is not as simple as replacing "_" with an "err" in
*minifyTransformation.Transform, however (though this is
necessary). If we only returned this error from Transform,
then hugolib.TestResourceMinifyDisabled would fail. Instead of
being a no-op, as TestResourceMinifyDisabled expects, using the
"minify" template function with a "disableXML=true" config
setting instead returns the error, "minifier does not exist for
mimetype."
The "minifier does not exist" error is returned because of the
way minifiers.New works. If the user's config disables
minification for a particular MIME type, minifiers.New does
not add it to the resulting Client's *minify.M. However, this
also means that when the "minify" template function is executed,
a *resourceAdapter's transformations still add a minification.
When it comes time to call the minify.Minifier for a specific
MIME type via *M.MinifyMimetype, the github.com/tdewolff/minify
library throws the "does not exist" error for the missing MIME
type.
The solution was to change minifiers.New so, instead of skipping
a minifier for each disabled MIME type, it adds a NoOpMinifier,
which simply copies the source to the destination without
minification. This means that when the "minify" template
function is used for a particular resource, and that resource's
MIME type has minification disabled, minification is genuinely
skipped, and does not result in an error.
In order to add this, I've fixed a possibly unwanted interaction
between minifiers.TestConfigureMinify and
hugolib.TestResourceMinifyDisabled. The latter disables
minification and expects minification to be a no-op. The former
disables minification and expects it to result in an error. The
only reason hugolib.TestResourceMinifyDisabled passes in the
original code is that the "does not exist" error is suppressed.
However, we shouldn't suppress minification errors, since they
can leave users perplexed. I've changed the test assertion in
minifiers.TestConfigureMinify to expect no errors and a no-op
if minification is disabled for a particular MIME type.
Fixes #8954
2021-09-22 18:54:40 +00:00
|
|
|
addMinifier(m, mediaTypes, "css", getMinifier(conf, "css"))
|
|
|
|
|
|
|
|
addMinifier(m, mediaTypes, "js", getMinifier(conf, "js"))
|
|
|
|
m.AddRegexp(regexp.MustCompile("^(application|text)/(x-)?(java|ecma)script$"), getMinifier(conf, "js"))
|
|
|
|
|
|
|
|
addMinifier(m, mediaTypes, "json", getMinifier(conf, "json"))
|
|
|
|
m.AddRegexp(regexp.MustCompile(`^(application|text)/(x-|(ld|manifest)\+)?json$`), getMinifier(conf, "json"))
|
|
|
|
|
|
|
|
addMinifier(m, mediaTypes, "svg", getMinifier(conf, "svg"))
|
|
|
|
|
|
|
|
addMinifier(m, mediaTypes, "xml", getMinifier(conf, "xml"))
|
2018-08-05 09:13:49 +00:00
|
|
|
|
|
|
|
// HTML
|
Pass minification errors to the user
Previously, *minifyTransformation.Transform suppressed the
error returned by t.m.Minify. This meant that when minification
returned an error, the error would not reach the user. Instead,
minification would silently fail. For example, if a JavaScript
file included a call to the Date constructor with:
new Date(2020, 04, 02)
The package that the minification library uses to parse JS files,
github.com/tdewolff/parse would return an error, since "04" would
be parsed as a legacy octal. However, the JS file would remain
un-minified with no error.
Fixing this is not as simple as replacing "_" with an "err" in
*minifyTransformation.Transform, however (though this is
necessary). If we only returned this error from Transform,
then hugolib.TestResourceMinifyDisabled would fail. Instead of
being a no-op, as TestResourceMinifyDisabled expects, using the
"minify" template function with a "disableXML=true" config
setting instead returns the error, "minifier does not exist for
mimetype."
The "minifier does not exist" error is returned because of the
way minifiers.New works. If the user's config disables
minification for a particular MIME type, minifiers.New does
not add it to the resulting Client's *minify.M. However, this
also means that when the "minify" template function is executed,
a *resourceAdapter's transformations still add a minification.
When it comes time to call the minify.Minifier for a specific
MIME type via *M.MinifyMimetype, the github.com/tdewolff/minify
library throws the "does not exist" error for the missing MIME
type.
The solution was to change minifiers.New so, instead of skipping
a minifier for each disabled MIME type, it adds a NoOpMinifier,
which simply copies the source to the destination without
minification. This means that when the "minify" template
function is used for a particular resource, and that resource's
MIME type has minification disabled, minification is genuinely
skipped, and does not result in an error.
In order to add this, I've fixed a possibly unwanted interaction
between minifiers.TestConfigureMinify and
hugolib.TestResourceMinifyDisabled. The latter disables
minification and expects minification to be a no-op. The former
disables minification and expects it to result in an error. The
only reason hugolib.TestResourceMinifyDisabled passes in the
original code is that the "does not exist" error is suppressed.
However, we shouldn't suppress minification errors, since they
can leave users perplexed. I've changed the test assertion in
minifiers.TestConfigureMinify to expect no errors and a no-op
if minification is disabled for a particular MIME type.
Fixes #8954
2021-09-22 18:54:40 +00:00
|
|
|
addMinifier(m, mediaTypes, "html", getMinifier(conf, "html"))
|
|
|
|
for _, of := range outputFormats {
|
|
|
|
if of.IsHTML {
|
|
|
|
m.Add(of.MediaType.Type(), getMinifier(conf, "html"))
|
2018-08-05 09:13:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-20 15:34:53 +00:00
|
|
|
return Client{m: m, MinifyOutput: conf.MinifyOutput}, nil
|
2018-08-05 09:13:49 +00:00
|
|
|
}
|
|
|
|
|
Pass minification errors to the user
Previously, *minifyTransformation.Transform suppressed the
error returned by t.m.Minify. This meant that when minification
returned an error, the error would not reach the user. Instead,
minification would silently fail. For example, if a JavaScript
file included a call to the Date constructor with:
new Date(2020, 04, 02)
The package that the minification library uses to parse JS files,
github.com/tdewolff/parse would return an error, since "04" would
be parsed as a legacy octal. However, the JS file would remain
un-minified with no error.
Fixing this is not as simple as replacing "_" with an "err" in
*minifyTransformation.Transform, however (though this is
necessary). If we only returned this error from Transform,
then hugolib.TestResourceMinifyDisabled would fail. Instead of
being a no-op, as TestResourceMinifyDisabled expects, using the
"minify" template function with a "disableXML=true" config
setting instead returns the error, "minifier does not exist for
mimetype."
The "minifier does not exist" error is returned because of the
way minifiers.New works. If the user's config disables
minification for a particular MIME type, minifiers.New does
not add it to the resulting Client's *minify.M. However, this
also means that when the "minify" template function is executed,
a *resourceAdapter's transformations still add a minification.
When it comes time to call the minify.Minifier for a specific
MIME type via *M.MinifyMimetype, the github.com/tdewolff/minify
library throws the "does not exist" error for the missing MIME
type.
The solution was to change minifiers.New so, instead of skipping
a minifier for each disabled MIME type, it adds a NoOpMinifier,
which simply copies the source to the destination without
minification. This means that when the "minify" template
function is used for a particular resource, and that resource's
MIME type has minification disabled, minification is genuinely
skipped, and does not result in an error.
In order to add this, I've fixed a possibly unwanted interaction
between minifiers.TestConfigureMinify and
hugolib.TestResourceMinifyDisabled. The latter disables
minification and expects minification to be a no-op. The former
disables minification and expects it to result in an error. The
only reason hugolib.TestResourceMinifyDisabled passes in the
original code is that the "does not exist" error is suppressed.
However, we shouldn't suppress minification errors, since they
can leave users perplexed. I've changed the test assertion in
minifiers.TestConfigureMinify to expect no errors and a no-op
if minification is disabled for a particular MIME type.
Fixes #8954
2021-09-22 18:54:40 +00:00
|
|
|
// getMinifier returns the appropriate minify.MinifierFunc for the MIME
|
|
|
|
// type suffix s, given the config c.
|
|
|
|
func getMinifier(c minifyConfig, s string) minify.Minifier {
|
|
|
|
switch {
|
|
|
|
case s == "css" && !c.DisableCSS:
|
|
|
|
return &c.Tdewolff.CSS
|
|
|
|
case s == "js" && !c.DisableJS:
|
|
|
|
return &c.Tdewolff.JS
|
|
|
|
case s == "json" && !c.DisableJSON:
|
|
|
|
return &c.Tdewolff.JSON
|
|
|
|
case s == "svg" && !c.DisableSVG:
|
|
|
|
return &c.Tdewolff.SVG
|
|
|
|
case s == "xml" && !c.DisableXML:
|
|
|
|
return &c.Tdewolff.XML
|
|
|
|
case s == "html" && !c.DisableHTML:
|
|
|
|
return &c.Tdewolff.HTML
|
|
|
|
default:
|
|
|
|
return noopMinifier{}
|
2018-08-05 09:13:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Pass minification errors to the user
Previously, *minifyTransformation.Transform suppressed the
error returned by t.m.Minify. This meant that when minification
returned an error, the error would not reach the user. Instead,
minification would silently fail. For example, if a JavaScript
file included a call to the Date constructor with:
new Date(2020, 04, 02)
The package that the minification library uses to parse JS files,
github.com/tdewolff/parse would return an error, since "04" would
be parsed as a legacy octal. However, the JS file would remain
un-minified with no error.
Fixing this is not as simple as replacing "_" with an "err" in
*minifyTransformation.Transform, however (though this is
necessary). If we only returned this error from Transform,
then hugolib.TestResourceMinifyDisabled would fail. Instead of
being a no-op, as TestResourceMinifyDisabled expects, using the
"minify" template function with a "disableXML=true" config
setting instead returns the error, "minifier does not exist for
mimetype."
The "minifier does not exist" error is returned because of the
way minifiers.New works. If the user's config disables
minification for a particular MIME type, minifiers.New does
not add it to the resulting Client's *minify.M. However, this
also means that when the "minify" template function is executed,
a *resourceAdapter's transformations still add a minification.
When it comes time to call the minify.Minifier for a specific
MIME type via *M.MinifyMimetype, the github.com/tdewolff/minify
library throws the "does not exist" error for the missing MIME
type.
The solution was to change minifiers.New so, instead of skipping
a minifier for each disabled MIME type, it adds a NoOpMinifier,
which simply copies the source to the destination without
minification. This means that when the "minify" template
function is used for a particular resource, and that resource's
MIME type has minification disabled, minification is genuinely
skipped, and does not result in an error.
In order to add this, I've fixed a possibly unwanted interaction
between minifiers.TestConfigureMinify and
hugolib.TestResourceMinifyDisabled. The latter disables
minification and expects minification to be a no-op. The former
disables minification and expects it to result in an error. The
only reason hugolib.TestResourceMinifyDisabled passes in the
original code is that the "does not exist" error is suppressed.
However, we shouldn't suppress minification errors, since they
can leave users perplexed. I've changed the test assertion in
minifiers.TestConfigureMinify to expect no errors and a no-op
if minification is disabled for a particular MIME type.
Fixes #8954
2021-09-22 18:54:40 +00:00
|
|
|
func addMinifier(m *minify.M, mt media.Types, suffix string, min minify.Minifier) {
|
2018-08-28 12:18:12 +00:00
|
|
|
types := mt.BySuffix(suffix)
|
|
|
|
for _, t := range types {
|
Pass minification errors to the user
Previously, *minifyTransformation.Transform suppressed the
error returned by t.m.Minify. This meant that when minification
returned an error, the error would not reach the user. Instead,
minification would silently fail. For example, if a JavaScript
file included a call to the Date constructor with:
new Date(2020, 04, 02)
The package that the minification library uses to parse JS files,
github.com/tdewolff/parse would return an error, since "04" would
be parsed as a legacy octal. However, the JS file would remain
un-minified with no error.
Fixing this is not as simple as replacing "_" with an "err" in
*minifyTransformation.Transform, however (though this is
necessary). If we only returned this error from Transform,
then hugolib.TestResourceMinifyDisabled would fail. Instead of
being a no-op, as TestResourceMinifyDisabled expects, using the
"minify" template function with a "disableXML=true" config
setting instead returns the error, "minifier does not exist for
mimetype."
The "minifier does not exist" error is returned because of the
way minifiers.New works. If the user's config disables
minification for a particular MIME type, minifiers.New does
not add it to the resulting Client's *minify.M. However, this
also means that when the "minify" template function is executed,
a *resourceAdapter's transformations still add a minification.
When it comes time to call the minify.Minifier for a specific
MIME type via *M.MinifyMimetype, the github.com/tdewolff/minify
library throws the "does not exist" error for the missing MIME
type.
The solution was to change minifiers.New so, instead of skipping
a minifier for each disabled MIME type, it adds a NoOpMinifier,
which simply copies the source to the destination without
minification. This means that when the "minify" template
function is used for a particular resource, and that resource's
MIME type has minification disabled, minification is genuinely
skipped, and does not result in an error.
In order to add this, I've fixed a possibly unwanted interaction
between minifiers.TestConfigureMinify and
hugolib.TestResourceMinifyDisabled. The latter disables
minification and expects minification to be a no-op. The former
disables minification and expects it to result in an error. The
only reason hugolib.TestResourceMinifyDisabled passes in the
original code is that the "does not exist" error is suppressed.
However, we shouldn't suppress minification errors, since they
can leave users perplexed. I've changed the test assertion in
minifiers.TestConfigureMinify to expect no errors and a no-op
if minification is disabled for a particular MIME type.
Fixes #8954
2021-09-22 18:54:40 +00:00
|
|
|
m.Add(t.Type(), min)
|
2018-08-05 09:13:49 +00:00
|
|
|
}
|
|
|
|
}
|