github/hugo
1
0
Fork 0
mirror of https://github.com/gohugoio/hugo.git synced 2024-11-21 20:46:30 -05:00
Code Issues Projects Releases Packages Wiki Activity

media: Make Type comparable

Browse source 
So we can use it and output.Format as map key etc.

This commit also fixes the media.Type implementation so it does not need to mutate itself to handle different suffixes for the same MIME type, e.g. jpg vs. jpeg.

This means that there are no Suffix or FullSuffix on media.Type anymore.

Fixes #8317
Fixes #8324
This commit is contained in:
Bjørn Erik Pedersen 2021-03-11 09:18:01 +01:00
parent 1b1dcf586e
commit ba1d0051b4
19 changed files with 254 additions and 195 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
deploy/deploy.go
View file

@ -432,7 +432,7 @@ func (lf *localFile) ContentType() string {
}
ext := filepath.Ext(lf.NativePath)
if mimeType, found := lf.mediaTypes.GetFirstBySuffix(strings.TrimPrefix(ext, ".")); found {
if mimeType, _, found := lf.mediaTypes.GetFirstBySuffix(strings.TrimPrefix(ext, ".")); found {
return mimeType.Type()
}

10
hugolib/config_test.go
View file

@ -220,8 +220,9 @@ map[string]interface {}{
MainType: "text",
SubType: "m1",
Delimiter: ".",
Suffixes: []string{
"m1main",
FirstSuffix: SuffixInfo{
Suffix: "m1main",
FullSuffix: ".m1main",
},
},
},
@ -231,8 +232,9 @@ map[string]interface {}{
MainType: "text",
SubType: "m2",
Delimiter: ".",
Suffixes: []string{
"m2theme",
FirstSuffix: SuffixInfo{
Suffix: "m2theme",
FullSuffix: ".m2theme",
},
},
},

4
hugolib/pagebundler_test.go
View file

@ -34,8 +34,6 @@ import (
"github.com/gohugoio/hugo/htesting"
"github.com/gohugoio/hugo/media"
"github.com/gohugoio/hugo/deps"
"github.com/spf13/viper"
@ -76,7 +74,7 @@ func TestPageBundlerSiteRegular(t *testing.T) {
cfg.Set("outputFormats", map[string]interface{}{
"CUSTOMO": map[string]interface{}{
"mediaType": media.HTMLType,
"mediaType": "text/html",
"baseName": "cindex",
"path": "cpath",
"permalinkable": true,

2
hugolib/site.go
View file

@ -913,7 +913,7 @@ type whatChanged struct {
// package, so it will behave correctly with Hugo's built-in server.
func (s *Site) RegisterMediaTypes() {
for _, mt := range s.mediaTypesConfig {
for _, suffix := range mt.Suffixes {
for _, suffix := range mt.Suffixes() {
_ = mime.AddExtensionType(mt.Delimiter+suffix, mt.Type()+"; charset=utf-8")
}
}

3
hugolib/site_output_test.go
View file

@ -305,13 +305,14 @@ baseName = "customdelimbase"
c.Assert(err, qt.IsNil)
s := h.Sites[0]
th.assertFileContent("public/_redirects", "a dotless")
th.assertFileContent("public/defaultdelimbase.defd", "default delimim")
// This looks weird, but the user has chosen this definition.
th.assertFileContent("public/nosuffixbase", "no suffix")
th.assertFileContent("public/customdelimbase_del", "custom delim")
s := h.Sites[0]
home := s.getPage(page.KindHome)
c.Assert(home, qt.Not(qt.IsNil))

184
media/mediaType.go
View file

@ -20,6 +20,8 @@ import (
"sort"
"strings"
"github.com/spf13/cast"
"github.com/gohugoio/hugo/common/maps"
"github.com/mitchellh/mapstructure"
@ -38,26 +40,35 @@ const (
type Type struct {
MainType string `json:"mainType"` // i.e. text
SubType string `json:"subType"` // i.e. html
Delimiter string `json:"delimiter"` // e.g. "."
// FirstSuffix holds the first suffix defined for this Type.
FirstSuffix SuffixInfo `json:"firstSuffix"`
// This is the optional suffix after the "+" in the MIME type,
// e.g. "xml" in "application/rss+xml".
mimeSuffix string
Delimiter string `json:"delimiter"` // e.g. "."
Suffixes []string `json:"suffixes"`
// Set when doing lookup by suffix.
fileSuffix string
// E.g. "jpg,jpeg"
// Stored as a string to make Type comparable.
suffixesCSV string
}
// FromStringAndExt is same as FromString, but adds the file extension to the type.
// SuffixInfo holds information about a Type's suffix.
type SuffixInfo struct {
Suffix string `json:"suffix"`
FullSuffix string `json:"fullSuffix"`
}
// FromStringAndExt creates a Type from a MIME string and a given extension.
func FromStringAndExt(t, ext string) (Type, error) {
tp, err := fromString(t)
if err != nil {
return tp, err
}
tp.Suffixes = []string{strings.TrimPrefix(ext, ".")}
tp.suffixesCSV = strings.TrimPrefix(ext, ".")
tp.Delimiter = defaultDelimiter
tp.init()
return tp, nil
}
@ -102,61 +113,83 @@ func (m Type) String() string {
return m.Type()
}
// FullSuffix returns the file suffix with any delimiter prepended.
func (m Type) FullSuffix() string {
return m.Delimiter + m.Suffix()
// Suffixes returns all valid file suffixes for this type.
func (m Type) Suffixes() []string {
if m.suffixesCSV == "" {
return nil
}
// Suffix returns the file suffix without any delimiter prepended.
func (m Type) Suffix() string {
if m.fileSuffix != "" {
return m.fileSuffix
return strings.Split(m.suffixesCSV, ",")
}
if len(m.Suffixes) > 0 {
return m.Suffixes[0]
func (m *Type) init() {
m.FirstSuffix.FullSuffix = ""
m.FirstSuffix.Suffix = ""
if suffixes := m.Suffixes(); suffixes != nil {
m.FirstSuffix.Suffix = suffixes[0]
m.FirstSuffix.FullSuffix = m.Delimiter + m.FirstSuffix.Suffix
}
// There are MIME types without file suffixes.
return ""
}
// WithDelimiterAndSuffixes is used in tests.
func WithDelimiterAndSuffixes(t Type, delimiter, suffixesCSV string) Type {
t.Delimiter = delimiter
t.suffixesCSV = suffixesCSV
t.init()
return t
}
func newMediaType(main, sub string, suffixes []string) Type {
t := Type{MainType: main, SubType: sub, suffixesCSV: strings.Join(suffixes, ","), Delimiter: defaultDelimiter}
t.init()
return t
}
func newMediaTypeWithMimeSuffix(main, sub, mimeSuffix string, suffixes []string) Type {
mt := newMediaType(main, sub, suffixes)
mt.mimeSuffix = mimeSuffix
mt.init()
return mt
}
// Definitions from https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types etc.
// Note that from Hugo 0.44 we only set Suffix if it is part of the MIME type.
var (
CalendarType = Type{MainType: "text", SubType: "calendar", Suffixes: []string{"ics"}, Delimiter: defaultDelimiter}
CSSType = Type{MainType: "text", SubType: "css", Suffixes: []string{"css"}, Delimiter: defaultDelimiter}
SCSSType = Type{MainType: "text", SubType: "x-scss", Suffixes: []string{"scss"}, Delimiter: defaultDelimiter}
SASSType = Type{MainType: "text", SubType: "x-sass", Suffixes: []string{"sass"}, Delimiter: defaultDelimiter}
CSVType = Type{MainType: "text", SubType: "csv", Suffixes: []string{"csv"}, Delimiter: defaultDelimiter}
HTMLType = Type{MainType: "text", SubType: "html", Suffixes: []string{"html"}, Delimiter: defaultDelimiter}
JavascriptType = Type{MainType: "application", SubType: "javascript", Suffixes: []string{"js"}, Delimiter: defaultDelimiter}
TypeScriptType = Type{MainType: "application", SubType: "typescript", Suffixes: []string{"ts"}, Delimiter: defaultDelimiter}
TSXType = Type{MainType: "text", SubType: "tsx", Suffixes: []string{"tsx"}, Delimiter: defaultDelimiter}
JSXType = Type{MainType: "text", SubType: "jsx", Suffixes: []string{"jsx"}, Delimiter: defaultDelimiter}
CalendarType = newMediaType("text", "calendar", []string{"ics"})
CSSType = newMediaType("text", "css", []string{"css"})
SCSSType = newMediaType("text", "x-scss", []string{"scss"})
SASSType = newMediaType("text", "x-sass", []string{"sass"})
CSVType = newMediaType("text", "csv", []string{"csv"})
HTMLType = newMediaType("text", "html", []string{"html"})
JavascriptType = newMediaType("application", "javascript", []string{"js"})
TypeScriptType = newMediaType("application", "typescript", []string{"ts"})
TSXType = newMediaType("text", "tsx", []string{"tsx"})
JSXType = newMediaType("text", "jsx", []string{"jsx"})
JSONType = Type{MainType: "application", SubType: "json", Suffixes: []string{"json"}, Delimiter: defaultDelimiter}
RSSType = Type{MainType: "application", SubType: "rss", mimeSuffix: "xml", Suffixes: []string{"xml"}, Delimiter: defaultDelimiter}
XMLType = Type{MainType: "application", SubType: "xml", Suffixes: []string{"xml"}, Delimiter: defaultDelimiter}
SVGType = Type{MainType: "image", SubType: "svg", mimeSuffix: "xml", Suffixes: []string{"svg"}, Delimiter: defaultDelimiter}
TextType = Type{MainType: "text", SubType: "plain", Suffixes: []string{"txt"}, Delimiter: defaultDelimiter}
TOMLType = Type{MainType: "application", SubType: "toml", Suffixes: []string{"toml"}, Delimiter: defaultDelimiter}
YAMLType = Type{MainType: "application", SubType: "yaml", Suffixes: []string{"yaml", "yml"}, Delimiter: defaultDelimiter}
JSONType = newMediaType("application", "json", []string{"json"})
RSSType = newMediaTypeWithMimeSuffix("application", "rss", "xml", []string{"xml"})
XMLType = newMediaType("application", "xml", []string{"xml"})
SVGType = newMediaTypeWithMimeSuffix("image", "svg", "xml", []string{"svg"})
TextType = newMediaType("text", "plain", []string{"txt"})
TOMLType = newMediaType("application", "toml", []string{"toml"})
YAMLType = newMediaType("application", "yaml", []string{"yaml", "yml"})
// Common image types
PNGType = Type{MainType: "image", SubType: "png", Suffixes: []string{"png"}, Delimiter: defaultDelimiter}
JPEGType = Type{MainType: "image", SubType: "jpeg", Suffixes: []string{"jpg", "jpeg"}, Delimiter: defaultDelimiter}
GIFType = Type{MainType: "image", SubType: "gif", Suffixes: []string{"gif"}, Delimiter: defaultDelimiter}
TIFFType = Type{MainType: "image", SubType: "tiff", Suffixes: []string{"tif", "tiff"}, Delimiter: defaultDelimiter}
BMPType = Type{MainType: "image", SubType: "bmp", Suffixes: []string{"bmp"}, Delimiter: defaultDelimiter}
PNGType = newMediaType("image", "png", []string{"png"})
JPEGType = newMediaType("image", "jpeg", []string{"jpg", "jpeg"})
GIFType = newMediaType("image", "gif", []string{"gif"})
TIFFType = newMediaType("image", "tiff", []string{"tif", "tiff"})
BMPType = newMediaType("image", "bmp", []string{"bmp"})
// Common video types
AVIType = Type{MainType: "video", SubType: "x-msvideo", Suffixes: []string{"avi"}, Delimiter: defaultDelimiter}
MPEGType = Type{MainType: "video", SubType: "mpeg", Suffixes: []string{"mpg", "mpeg"}, Delimiter: defaultDelimiter}
MP4Type = Type{MainType: "video", SubType: "mp4", Suffixes: []string{"mp4"}, Delimiter: defaultDelimiter}
OGGType = Type{MainType: "video", SubType: "ogg", Suffixes: []string{"ogv"}, Delimiter: defaultDelimiter}
WEBMType = Type{MainType: "video", SubType: "webm", Suffixes: []string{"webm"}, Delimiter: defaultDelimiter}
GPPType = Type{MainType: "video", SubType: "3gpp", Suffixes: []string{"3gpp", "3gp"}, Delimiter: defaultDelimiter}
AVIType = newMediaType("video", "x-msvideo", []string{"avi"})
MPEGType = newMediaType("video", "mpeg", []string{"mpg", "mpeg"})
MP4Type = newMediaType("video", "mp4", []string{"mp4"})
OGGType = newMediaType("video", "ogg", []string{"ogv"})
WEBMType = newMediaType("video", "webm", []string{"webm"})
GPPType = newMediaType("video", "3gpp", []string{"3gpp", "3gp"})
OctetType = Type{MainType: "application", SubType: "octet-stream"}
OctetType = newMediaType("application", "octet-stream", nil)
)
// DefaultTypes is the default media types supported by Hugo.
@ -221,54 +254,56 @@ func (t Types) GetByType(tp string) (Type, bool) {
// BySuffix will return all media types matching a suffix.
func (t Types) BySuffix(suffix string) []Type {
suffix = strings.ToLower(suffix)
var types []Type
for _, tt := range t {
if match := tt.matchSuffix(suffix); match != "" {
if tt.hasSuffix(suffix) {
types = append(types, tt)
}
}
return types
}
// GetFirstBySuffix will return the first media type matching the given suffix.
func (t Types) GetFirstBySuffix(suffix string) (Type, bool) {
// GetFirstBySuffix will return the first type matching the given suffix.
func (t Types) GetFirstBySuffix(suffix string) (Type, SuffixInfo, bool) {
suffix = strings.ToLower(suffix)
for _, tt := range t {
if match := tt.matchSuffix(suffix); match != "" {
tt.fileSuffix = match
return tt, true
if tt.hasSuffix(suffix) {
return tt, SuffixInfo{
FullSuffix: tt.Delimiter + suffix,
Suffix: suffix,
}, true
}
}
return Type{}, false
return Type{}, SuffixInfo{}, false
}
// GetBySuffix gets a media type given as suffix, e.g. "html".
// It will return false if no format could be found, or if the suffix given
// is ambiguous.
// The lookup is case insensitive.
func (t Types) GetBySuffix(suffix string) (tp Type, found bool) {
func (t Types) GetBySuffix(suffix string) (tp Type, si SuffixInfo, found bool) {
suffix = strings.ToLower(suffix)
for _, tt := range t {
if match := tt.matchSuffix(suffix); match != "" {
if tt.hasSuffix(suffix) {
if found {
// ambiguous
found = false
return
}
tp = tt
tp.fileSuffix = match
si = SuffixInfo{
FullSuffix: tt.Delimiter + suffix,
Suffix: suffix,
}
found = true
}
}
return
}
func (m Type) matchSuffix(suffix string) string {
for _, s := range m.Suffixes {
if strings.EqualFold(suffix, s) {
return s
}
}
return ""
func (m Type) hasSuffix(suffix string) bool {
return strings.Contains(m.suffixesCSV, suffix)
}
// GetByMainSubType gets a media type given a main and a sub type e.g. "text" and "plain".
@ -328,9 +363,6 @@ func DecodeTypes(mms ...map[string]interface{}) (Types, error) {
// Maps type string to Type. Type string is the full application/svg+xml.
mmm := make(map[string]Type)
for _, dt := range DefaultTypes {
suffixes := make([]string, len(dt.Suffixes))
copy(suffixes, dt.Suffixes)
dt.Suffixes = suffixes
mmm[dt.Type()] = dt
}
@ -360,11 +392,17 @@ func DecodeTypes(mms ...map[string]interface{}) (Types, error) {
return Types{}, suffixIsRemoved()
}
if suffixes, found := vm["suffixes"]; found {
mediaType.suffixesCSV = strings.TrimSpace(strings.ToLower(strings.Join(cast.ToStringSlice(suffixes), ",")))
}
// The user may set the delimiter as an empty string.
if !delimiterSet && len(mediaType.Suffixes) != 0 {
if !delimiterSet && mediaType.suffixesCSV != "" {
mediaType.Delimiter = defaultDelimiter
}
mediaType.init()
mmm[k] = mediaType
}
@ -387,12 +425,14 @@ func (m Type) IsZero() bool {
func (m Type) MarshalJSON() ([]byte, error) {
type Alias Type
return json.Marshal(&struct {
Alias
Type string `json:"type"`
String string `json:"string"`
Alias
Suffixes []string `json:"suffixes"`
}{
Alias: (Alias)(m),
Type: m.Type(),
String: m.String(),
Alias: (Alias)(m),
Suffixes: strings.Split(m.suffixesCSV, ","),
})
}

98
media/mediaType_test.go
View file

@ -14,16 +14,12 @@
package media
import (
"encoding/json"
"testing"
qt "github.com/frankban/quicktest"
"github.com/google/go-cmp/cmp"
)
var eq = qt.CmpEquals(cmp.Comparer(func(m1, m2 Type) bool {
return m1.Type() == m2.Type()
}))
func TestDefaultTypes(t *testing.T) {
c := qt.New(t)
for _, test := range []struct {
@ -53,8 +49,6 @@ func TestDefaultTypes(t *testing.T) {
} {
c.Assert(test.tp.MainType, qt.Equals, test.expectedMainType)
c.Assert(test.tp.SubType, qt.Equals, test.expectedSubType)
c.Assert(test.tp.Suffix(), qt.Equals, test.expectedSuffix)
c.Assert(test.tp.Delimiter, qt.Equals, defaultDelimiter)
c.Assert(test.tp.Type(), qt.Equals, test.expectedType)
c.Assert(test.tp.String(), qt.Equals, test.expectedString)
@ -71,25 +65,25 @@ func TestGetByType(t *testing.T) {
mt, found := types.GetByType("text/HTML")
c.Assert(found, qt.Equals, true)
c.Assert(HTMLType, eq, mt)
c.Assert(HTMLType, qt.Equals, mt)
_, found = types.GetByType("text/nono")
c.Assert(found, qt.Equals, false)
mt, found = types.GetByType("application/rss+xml")
c.Assert(found, qt.Equals, true)
c.Assert(RSSType, eq, mt)
c.Assert(RSSType, qt.Equals, mt)
mt, found = types.GetByType("application/rss")
c.Assert(found, qt.Equals, true)
c.Assert(RSSType, eq, mt)
c.Assert(RSSType, qt.Equals, mt)
}
func TestGetByMainSubType(t *testing.T) {
c := qt.New(t)
f, found := DefaultTypes.GetByMainSubType("text", "plain")
c.Assert(found, qt.Equals, true)
c.Assert(TextType, eq, f)
c.Assert(f, qt.Equals, TextType)
_, found = DefaultTypes.GetByMainSubType("foo", "plain")
c.Assert(found, qt.Equals, false)
}
@ -104,48 +98,63 @@ func TestBySuffix(t *testing.T) {
func TestGetFirstBySuffix(t *testing.T) {
c := qt.New(t)
f, found := DefaultTypes.GetFirstBySuffix("xml")
_, f, found := DefaultTypes.GetFirstBySuffix("xml")
c.Assert(found, qt.Equals, true)
c.Assert(f, eq, Type{MainType: "application", SubType: "rss", mimeSuffix: "xml", Delimiter: ".", Suffixes: []string{"xml"}, fileSuffix: "xml"})
c.Assert(f, qt.Equals, SuffixInfo{
Suffix: "xml",
FullSuffix: ".xml"})
}
func TestFromTypeString(t *testing.T) {
c := qt.New(t)
f, err := fromString("text/html")
c.Assert(err, qt.IsNil)
c.Assert(f.Type(), eq, HTMLType.Type())
c.Assert(f.Type(), qt.Equals, HTMLType.Type())
f, err = fromString("application/custom")
c.Assert(err, qt.IsNil)
c.Assert(f, eq, Type{MainType: "application", SubType: "custom", mimeSuffix: "", fileSuffix: ""})
c.Assert(f, qt.Equals, Type{MainType: "application", SubType: "custom", mimeSuffix: ""})
f, err = fromString("application/custom+sfx")
c.Assert(err, qt.IsNil)
c.Assert(f, eq, Type{MainType: "application", SubType: "custom", mimeSuffix: "sfx"})
c.Assert(f, qt.Equals, Type{MainType: "application", SubType: "custom", mimeSuffix: "sfx"})
_, err = fromString("noslash")
c.Assert(err, qt.Not(qt.IsNil))
f, err = fromString("text/xml; charset=utf-8")
c.Assert(err, qt.IsNil)
c.Assert(f, eq, Type{MainType: "text", SubType: "xml", mimeSuffix: ""})
c.Assert(f.Suffix(), qt.Equals, "")
c.Assert(f, qt.Equals, Type{MainType: "text", SubType: "xml", mimeSuffix: ""})
}
func TestFromStringAndExt(t *testing.T) {
c := qt.New(t)
f, err := FromStringAndExt("text/html", "html")
c.Assert(err, qt.IsNil)
c.Assert(f, qt.Equals, HTMLType)
f, err = FromStringAndExt("text/html", ".html")
c.Assert(err, qt.IsNil)
c.Assert(f, qt.Equals, HTMLType)
}
// Add a test for the SVG case
// https://github.com/gohugoio/hugo/issues/4920
func TestFromExtensionMultipleSuffixes(t *testing.T) {
c := qt.New(t)
tp, found := DefaultTypes.GetBySuffix("svg")
tp, si, found := DefaultTypes.GetBySuffix("svg")
c.Assert(found, qt.Equals, true)
c.Assert(tp.String(), qt.Equals, "image/svg+xml")
c.Assert(tp.fileSuffix, qt.Equals, "svg")
c.Assert(tp.FullSuffix(), qt.Equals, ".svg")
tp, found = DefaultTypes.GetByType("image/svg+xml")
c.Assert(si.Suffix, qt.Equals, "svg")
c.Assert(si.FullSuffix, qt.Equals, ".svg")
c.Assert(tp.FirstSuffix.Suffix, qt.Equals, si.Suffix)
c.Assert(tp.FirstSuffix.FullSuffix, qt.Equals, si.FullSuffix)
ftp, found := DefaultTypes.GetByType("image/svg+xml")
c.Assert(found, qt.Equals, true)
c.Assert(tp.String(), qt.Equals, "image/svg+xml")
c.Assert(ftp.String(), qt.Equals, "image/svg+xml")
c.Assert(found, qt.Equals, true)
c.Assert(tp.FullSuffix(), qt.Equals, ".svg")
}
func TestDecodeTypes(t *testing.T) {
@ -169,10 +178,10 @@ func TestDecodeTypes(t *testing.T) {
false,
func(t *testing.T, name string, tt Types) {
c.Assert(len(tt), qt.Equals, len(DefaultTypes))
json, found := tt.GetBySuffix("jasn")
json, si, found := tt.GetBySuffix("jasn")
c.Assert(found, qt.Equals, true)
c.Assert(json.String(), qt.Equals, "application/json")
c.Assert(json.FullSuffix(), qt.Equals, ".jasn")
c.Assert(si.FullSuffix, qt.Equals, ".jasn")
},
},
{
@ -180,7 +189,7 @@ func TestDecodeTypes(t *testing.T) {
[]map[string]interface{}{
{
"application/hugo+hg": map[string]interface{}{
"suffixes": []string{"hg1", "hg2"},
"suffixes": []string{"hg1", "hG2"},
"Delimiter": "_",
},
},
@ -188,15 +197,18 @@ func TestDecodeTypes(t *testing.T) {
false,
func(t *testing.T, name string, tt Types) {
c.Assert(len(tt), qt.Equals, len(DefaultTypes)+1)
hg, found := tt.GetBySuffix("hg2")
hg, si, found := tt.GetBySuffix("hg2")
c.Assert(found, qt.Equals, true)
c.Assert(hg.mimeSuffix, qt.Equals, "hg")
c.Assert(hg.Suffix(), qt.Equals, "hg2")
c.Assert(hg.FullSuffix(), qt.Equals, "_hg2")
c.Assert(hg.FirstSuffix.Suffix, qt.Equals, "hg1")
c.Assert(hg.FirstSuffix.FullSuffix, qt.Equals, "_hg1")
c.Assert(si.Suffix, qt.Equals, "hg2")
c.Assert(si.FullSuffix, qt.Equals, "_hg2")
c.Assert(hg.String(), qt.Equals, "application/hugo+hg")
hg, found = tt.GetByType("application/hugo+hg")
_, found = tt.GetByType("application/hugo+hg")
c.Assert(found, qt.Equals, true)
},
},
{
@ -209,14 +221,14 @@ func TestDecodeTypes(t *testing.T) {
},
},
false,
func(t *testing.T, name string, tt Types) {
c.Assert(len(tt), qt.Equals, len(DefaultTypes)+1)
func(t *testing.T, name string, tp Types) {
c.Assert(len(tp), qt.Equals, len(DefaultTypes)+1)
// Make sure we have not broken the default config.
_, found := tt.GetBySuffix("json")
_, _, found := tp.GetBySuffix("json")
c.Assert(found, qt.Equals, true)
hugo, found := tt.GetBySuffix("hgo2")
hugo, _, found := tp.GetBySuffix("hgo2")
c.Assert(found, qt.Equals, true)
c.Assert(hugo.String(), qt.Equals, "text/hugo+hgo")
},
@ -234,25 +246,33 @@ func TestDecodeTypes(t *testing.T) {
}
}
func TestToJSON(t *testing.T) {
c := qt.New(t)
b, err := json.Marshal(MPEGType)
c.Assert(err, qt.IsNil)
c.Assert(string(b), qt.Equals, `{"mainType":"video","subType":"mpeg","delimiter":".","firstSuffix":{"suffix":"mpg","fullSuffix":".mpg"},"type":"video/mpeg","string":"video/mpeg","suffixes":["mpg","mpeg"]}`)
}
func BenchmarkTypeOps(b *testing.B) {
mt := MPEGType
mts := DefaultTypes
for i := 0; i < b.N; i++ {
_ = mt.FullSuffix()
ff := mt.FirstSuffix
_ = ff.FullSuffix
_ = mt.IsZero()
c, err := mt.MarshalJSON()
if c == nil || err != nil {
b.Fatal("failed")
}
_ = mt.String()
_ = mt.Suffix()
_ = ff.Suffix
_ = mt.Suffixes
_ = mt.Type()
_ = mts.BySuffix("xml")
_, _ = mts.GetByMainSubType("application", "xml")
_, _ = mts.GetBySuffix("xml")
_, _, _ = mts.GetBySuffix("xml")
_, _ = mts.GetByType("application")
_, _ = mts.GetFirstBySuffix("xml")
_, _, _ = mts.GetFirstBySuffix("xml")
}
}

2
output/docshelper.go
View file

@ -76,7 +76,7 @@ func createLayoutExamples() interface{} {
Example: example.name,
Kind: example.d.Kind,
OutputFormat: example.f.Name,
Suffix: example.f.MediaType.Suffix(),
Suffix: example.f.MediaType.FirstSuffix.Suffix,
Layouts: makeLayoutsPresentable(layouts),
})
}

2
output/layout.go
View file

@ -229,7 +229,7 @@ func (l *layoutBuilder) resolveVariations() []string {
continue
}
s := constructLayoutPath(typeVar, layoutVar, variation, l.f.MediaType.Suffix())
s := constructLayoutPath(typeVar, layoutVar, variation, l.f.MediaType.FirstSuffix.Suffix)
if s != "" {
layouts = append(layouts, s)
}

8
output/layout_test.go
View file

@ -28,12 +28,8 @@ import (
func TestLayout(t *testing.T) {
c := qt.New(t)
noExtNoDelimMediaType := media.TextType
noExtNoDelimMediaType.Suffixes = nil
noExtNoDelimMediaType.Delimiter = ""
noExtMediaType := media.TextType
noExtMediaType.Suffixes = nil
noExtNoDelimMediaType := media.WithDelimiterAndSuffixes(media.TextType, "", "")
noExtMediaType := media.WithDelimiterAndSuffixes(media.TextType, ".", "")
var (
ampType = Format{

25
output/outputFormat.go
View file

@ -20,6 +20,8 @@ import (
"sort"
"strings"
"github.com/pkg/errors"
"github.com/mitchellh/mapstructure"
"github.com/gohugoio/hugo/media"
@ -207,7 +209,8 @@ func (formats Formats) Less(i, j int) bool {
// The lookup is case insensitive.
func (formats Formats) GetBySuffix(suffix string) (f Format, found bool) {
for _, ff := range formats {
if strings.EqualFold(suffix, ff.MediaType.Suffix()) {
for _, suffix2 := range ff.MediaType.Suffixes() {
if strings.EqualFold(suffix, suffix2) {
if found {
// ambiguous
found = false
@ -217,6 +220,7 @@ func (formats Formats) GetBySuffix(suffix string) (f Format, found bool) {
found = true
}
}
}
return
}
@ -310,6 +314,7 @@ func DecodeFormats(mediaTypes media.Types, maps ...map[string]interface{}) (Form
}
f = append(f, newOutFormat)
}
}
}
@ -319,7 +324,7 @@ func DecodeFormats(mediaTypes media.Types, maps ...map[string]interface{}) (Form
return f, nil
}
func decode(mediaTypes media.Types, input, output interface{}) error {
func decode(mediaTypes media.Types, input interface{}, output *Format) error {
config := &mapstructure.DecoderConfig{
Metadata: nil,
Result: output,
@ -337,12 +342,19 @@ func decode(mediaTypes media.Types, input, output interface{}) error {
// If mediaType is a string, look it up and replace it
// in the map.
vv := dataVal.MapIndex(key)
if mediaTypeStr, ok := vv.Interface().(string); ok {
mediaType, found := mediaTypes.GetByType(mediaTypeStr)
vvi := vv.Interface()
switch vviv := vvi.(type) {
case media.Type:
// OK
case string:
mediaType, found := mediaTypes.GetByType(vviv)
if !found {
return c, fmt.Errorf("media type %q not found", mediaTypeStr)
return c, fmt.Errorf("media type %q not found", vviv)
}
dataVal.SetMapIndex(key, reflect.ValueOf(mediaType))
default:
return nil, errors.Errorf("invalid output format configuration; wrong type for media type, expected string (e.g. text/html), got %T", vvi)
}
}
}
@ -357,12 +369,13 @@ func decode(mediaTypes media.Types, input, output interface{}) error {
}
return decoder.Decode(input)
}
// BaseFilename returns the base filename of f including an extension (ie.
// "index.xml").
func (f Format) BaseFilename() string {
return f.BaseName + f.MediaType.FullSuffix()
return f.BaseName + f.MediaType.FirstSuffix.FullSuffix
}
// MarshalJSON returns the JSON encoding of f.

42
output/outputFormat_test.go
View file

@ -19,36 +19,26 @@ import (
qt "github.com/frankban/quicktest"
"github.com/gohugoio/hugo/media"
"github.com/google/go-cmp/cmp"
)
var eq = qt.CmpEquals(
cmp.Comparer(func(m1, m2 media.Type) bool {
return m1.Type() == m2.Type()
}),
cmp.Comparer(func(o1, o2 Format) bool {
return o1.Name == o2.Name
}),
)
func TestDefaultTypes(t *testing.T) {
c := qt.New(t)
c.Assert(CalendarFormat.Name, qt.Equals, "Calendar")
c.Assert(CalendarFormat.MediaType, eq, media.CalendarType)
c.Assert(CalendarFormat.MediaType, qt.Equals, media.CalendarType)
c.Assert(CalendarFormat.Protocol, qt.Equals, "webcal://")
c.Assert(CalendarFormat.Path, qt.HasLen, 0)
c.Assert(CalendarFormat.IsPlainText, qt.Equals, true)
c.Assert(CalendarFormat.IsHTML, qt.Equals, false)
c.Assert(CSSFormat.Name, qt.Equals, "CSS")
c.Assert(CSSFormat.MediaType, eq, media.CSSType)
c.Assert(CSSFormat.MediaType, qt.Equals, media.CSSType)
c.Assert(CSSFormat.Path, qt.HasLen, 0)
c.Assert(CSSFormat.Protocol, qt.HasLen, 0) // Will inherit the BaseURL protocol.
c.Assert(CSSFormat.IsPlainText, qt.Equals, true)
c.Assert(CSSFormat.IsHTML, qt.Equals, false)
c.Assert(CSVFormat.Name, qt.Equals, "CSV")
c.Assert(CSVFormat.MediaType, eq, media.CSVType)
c.Assert(CSVFormat.MediaType, qt.Equals, media.CSVType)
c.Assert(CSVFormat.Path, qt.HasLen, 0)
c.Assert(CSVFormat.Protocol, qt.HasLen, 0)
c.Assert(CSVFormat.IsPlainText, qt.Equals, true)
@ -56,7 +46,7 @@ func TestDefaultTypes(t *testing.T) {
c.Assert(CSVFormat.Permalinkable, qt.Equals, false)
c.Assert(HTMLFormat.Name, qt.Equals, "HTML")
c.Assert(HTMLFormat.MediaType, eq, media.HTMLType)
c.Assert(HTMLFormat.MediaType, qt.Equals, media.HTMLType)
c.Assert(HTMLFormat.Path, qt.HasLen, 0)
c.Assert(HTMLFormat.Protocol, qt.HasLen, 0)
c.Assert(HTMLFormat.IsPlainText, qt.Equals, false)
@ -64,7 +54,7 @@ func TestDefaultTypes(t *testing.T) {
c.Assert(AMPFormat.Permalinkable, qt.Equals, true)
c.Assert(AMPFormat.Name, qt.Equals, "AMP")
c.Assert(AMPFormat.MediaType, eq, media.HTMLType)
c.Assert(AMPFormat.MediaType, qt.Equals, media.HTMLType)
c.Assert(AMPFormat.Path, qt.Equals, "amp")
c.Assert(AMPFormat.Protocol, qt.HasLen, 0)
c.Assert(AMPFormat.IsPlainText, qt.Equals, false)
@ -72,7 +62,7 @@ func TestDefaultTypes(t *testing.T) {
c.Assert(AMPFormat.Permalinkable, qt.Equals, true)
c.Assert(RSSFormat.Name, qt.Equals, "RSS")
c.Assert(RSSFormat.MediaType, eq, media.RSSType)
c.Assert(RSSFormat.MediaType, qt.Equals, media.RSSType)
c.Assert(RSSFormat.Path, qt.HasLen, 0)
c.Assert(RSSFormat.IsPlainText, qt.Equals, false)
c.Assert(RSSFormat.NoUgly, qt.Equals, true)
@ -83,7 +73,7 @@ func TestGetFormatByName(t *testing.T) {
c := qt.New(t)
formats := Formats{AMPFormat, CalendarFormat}
tp, _ := formats.GetByName("AMp")
c.Assert(tp, eq, AMPFormat)
c.Assert(tp, qt.Equals, AMPFormat)
_, found := formats.GetByName("HTML")
c.Assert(found, qt.Equals, false)
_, found = formats.GetByName("FOO")
@ -95,9 +85,9 @@ func TestGetFormatByExt(t *testing.T) {
formats1 := Formats{AMPFormat, CalendarFormat}
formats2 := Formats{AMPFormat, HTMLFormat, CalendarFormat}
tp, _ := formats1.GetBySuffix("html")
c.Assert(tp, eq, AMPFormat)
c.Assert(tp, qt.Equals, AMPFormat)
tp, _ = formats1.GetBySuffix("ics")
c.Assert(tp, eq, CalendarFormat)
c.Assert(tp, qt.Equals, CalendarFormat)
_, found := formats1.GetBySuffix("not")
c.Assert(found, qt.Equals, false)
@ -129,18 +119,18 @@ func TestGetFormatByFilename(t *testing.T) {
formats := Formats{AMPFormat, HTMLFormat, noExtDelimFormat, noExt, CalendarFormat}
f, found := formats.FromFilename("my.amp.html")
c.Assert(found, qt.Equals, true)
c.Assert(f, eq, AMPFormat)
c.Assert(f, qt.Equals, AMPFormat)
_, found = formats.FromFilename("my.ics")
c.Assert(found, qt.Equals, true)
f, found = formats.FromFilename("my.html")
c.Assert(found, qt.Equals, true)
c.Assert(f, eq, HTMLFormat)
c.Assert(f, qt.Equals, HTMLFormat)
f, found = formats.FromFilename("my.nem")
c.Assert(found, qt.Equals, true)
c.Assert(f, eq, noExtDelimFormat)
c.Assert(f, qt.Equals, noExtDelimFormat)
f, found = formats.FromFilename("my.nex")
c.Assert(found, qt.Equals, true)
c.Assert(f, eq, noExt)
c.Assert(f, qt.Equals, noExt)
_, found = formats.FromFilename("my.css")
c.Assert(found, qt.Equals, false)
}
@ -172,7 +162,7 @@ func TestDecodeFormats(t *testing.T) {
c.Assert(len(f), qt.Equals, len(DefaultFormats), msg)
json, _ := f.GetByName("JSON")
c.Assert(json.BaseName, qt.Equals, "myindex")
c.Assert(json.MediaType, eq, media.JSONType)
c.Assert(json.MediaType, qt.Equals, media.JSONType)
c.Assert(json.IsPlainText, qt.Equals, false)
},
},
@ -192,7 +182,7 @@ func TestDecodeFormats(t *testing.T) {
xml, found := f.GetByName("MYXMLFORMAT")
c.Assert(found, qt.Equals, true)
c.Assert(xml.BaseName, qt.Equals, "myxml")
c.Assert(xml.MediaType, eq, media.XMLType)
c.Assert(xml.MediaType, qt.Equals, media.XMLType)
// Verify that we haven't changed the DefaultFormats slice.
json, _ := f.GetByName("JSON")
@ -234,7 +224,7 @@ func TestDecodeFormats(t *testing.T) {
xml, found := f.GetByName("MYOTHERXMLFORMAT")
c.Assert(found, qt.Equals, true)
c.Assert(xml.BaseName, qt.Equals, "myredefined")
c.Assert(xml.MediaType, eq, media.XMLType)
c.Assert(xml.MediaType, qt.Equals, media.XMLType)
},
},
}

2
parser/metadecoders/format.go
View file

@ -59,7 +59,7 @@ func FormatFromString(formatStr string) Format {
// FormatFromMediaType gets the Format given a MIME type, empty string
// if unknown.
func FormatFromMediaType(m media.Type) Format {
for _, suffix := range m.Suffixes {
for _, suffix := range m.Suffixes() {
if f := FormatFromString(suffix); f != "" {
return f
}

2
resources/images/image.go
View file

@ -265,7 +265,7 @@ func (f Format) SupportsTransparency() bool {
// DefaultExtension returns the default file extension of this format, starting with a dot.
// For example: .jpg for JPEG
func (f Format) DefaultExtension() string {
return f.MediaType().FullSuffix()
return f.MediaType().FirstSuffix.FullSuffix
}
// MediaType returns the media type of this image, e.g. image/jpeg for JPEG

11
resources/page/page_paths.go
View file

@ -128,6 +128,7 @@ func CreateTargetPaths(d TargetPathDescriptor) (tp TargetPaths) {
}
pagePath := slash
fullSuffix := d.Type.MediaType.FirstSuffix.FullSuffix
var (
pagePathDir string
@ -172,7 +173,7 @@ func CreateTargetPaths(d TargetPathDescriptor) (tp TargetPaths) {
hasSlash := strings.HasSuffix(d.URL, slash)
if hasSlash || !hasDot {
pagePath = pjoin(pagePath, d.Type.BaseName+d.Type.MediaType.FullSuffix())
pagePath = pjoin(pagePath, d.Type.BaseName+fullSuffix)
} else if hasDot {
pagePathDir = path.Dir(pagePathDir)
}
@ -229,9 +230,9 @@ func CreateTargetPaths(d TargetPathDescriptor) (tp TargetPaths) {
linkDir = pagePathDir
if isUgly {
pagePath = addSuffix(pagePath, d.Type.MediaType.FullSuffix())
pagePath = addSuffix(pagePath, fullSuffix)
} else {
pagePath = pjoin(pagePath, d.Type.BaseName+d.Type.MediaType.FullSuffix())
pagePath = pjoin(pagePath, d.Type.BaseName+fullSuffix)
}
if !isHtmlIndex(pagePath) {
@ -267,9 +268,9 @@ func CreateTargetPaths(d TargetPathDescriptor) (tp TargetPaths) {
linkDir = pagePathDir
if base != "" {
pagePath = path.Join(pagePath, addSuffix(base, d.Type.MediaType.FullSuffix()))
pagePath = path.Join(pagePath, addSuffix(base, fullSuffix))
} else {
pagePath = addSuffix(pagePath, d.Type.MediaType.FullSuffix())
pagePath = addSuffix(pagePath, fullSuffix)
}
if !isHtmlIndex(pagePath) {

11
resources/page/page_paths_test.go
View file

@ -27,8 +27,7 @@ import (
func TestPageTargetPath(t *testing.T) {
pathSpec := newTestPathSpec()
noExtNoDelimMediaType := media.TextType
noExtNoDelimMediaType.Suffixes = []string{}
noExtNoDelimMediaType := media.WithDelimiterAndSuffixes(media.TextType, "", "")
noExtNoDelimMediaType.Delimiter = ""
// Netlify style _redirects
@ -209,11 +208,11 @@ func TestPageTargetPath(t *testing.T) {
// TODO(bep) simplify
if test.d.Kind == KindPage && test.d.BaseName == test.d.Type.BaseName {
} else if test.d.Kind == KindHome && test.d.Type.Path != "" {
} else if test.d.Type.MediaType.Suffix() != "" && (!strings.HasPrefix(expected.TargetFilename, "/index") || test.d.Addends != "") && test.d.URL == "" && isUgly {
} else if test.d.Type.MediaType.FirstSuffix.Suffix != "" && (!strings.HasPrefix(expected.TargetFilename, "/index") || test.d.Addends != "") && test.d.URL == "" && isUgly {
expected.TargetFilename = strings.Replace(expected.TargetFilename,
"/"+test.d.Type.BaseName+"."+test.d.Type.MediaType.Suffix(),
"."+test.d.Type.MediaType.Suffix(), 1)
expected.Link = strings.TrimSuffix(expected.Link, "/") + "." + test.d.Type.MediaType.Suffix()
"/"+test.d.Type.BaseName+"."+test.d.Type.MediaType.FirstSuffix.Suffix,
"."+test.d.Type.MediaType.FirstSuffix.Suffix, 1)
expected.Link = strings.TrimSuffix(expected.Link, "/") + "." + test.d.Type.MediaType.FirstSuffix.Suffix
}

11
resources/postpub/fields_test.go
View file

@ -31,15 +31,14 @@ func TestCreatePlaceholders(t *testing.T) {
})
c.Assert(m, qt.DeepEquals, map[string]interface{}{
"FullSuffix": "pre_foo.FullSuffix_post",
"IsZero": "pre_foo.IsZero_post",
"MarshalJSON": "pre_foo.MarshalJSON_post",
"Suffixes": "pre_foo.Suffixes_post",
"Delimiter": "pre_foo.Delimiter_post",
"FirstSuffix": "pre_foo.FirstSuffix_post",
"String": "pre_foo.String_post",
"Type": "pre_foo.Type_post",
"MainType": "pre_foo.MainType_post",
"Delimiter": "pre_foo.Delimiter_post",
"MarshalJSON": "pre_foo.MarshalJSON_post",
"String": "pre_foo.String_post",
"Suffix": "pre_foo.Suffix_post",
"SubType": "pre_foo.SubType_post",
"Suffixes": "pre_foo.Suffixes_post",
})
}

4
resources/resource_spec.go
View file

@ -268,10 +268,10 @@ func (r *Spec) newResource(sourceFs afero.Fs, fd ResourceSourceDescriptor) (reso
}
ext := strings.ToLower(filepath.Ext(fd.RelTargetFilename))
mimeType, found := r.MediaTypes.GetFirstBySuffix(strings.TrimPrefix(ext, "."))
mimeType, suffixInfo, found := r.MediaTypes.GetFirstBySuffix(strings.TrimPrefix(ext, "."))
// TODO(bep) we need to handle these ambiguous types better, but in this context
// we most likely want the application/xml type.
if mimeType.Suffix() == "xml" && mimeType.SubType == "rss" {
if suffixInfo.Suffix == "xml" && mimeType.SubType == "rss" {
mimeType, found = r.MediaTypes.GetByType("application/xml")
}

2
tpl/tplimpl/shortcodes.go
View file

@ -56,7 +56,7 @@ func (s *shortcodeTemplates) fromVariants(variants tpl.TemplateVariants) (shortc
return s.fromVariantsSlice([]string{
variants.Language,
strings.ToLower(variants.OutputFormat.Name),
variants.OutputFormat.MediaType.Suffix(),
variants.OutputFormat.MediaType.FirstSuffix.Suffix,
})
}