mirror of
https://github.com/gohugoio/hugo.git
synced 2024-11-14 20:37:55 -05:00
b874a1ba7a
Before this commit, `Suffix` on `MediaType` was used both to set a custom file suffix and as a way to augment the mediatype definition (what you see after the "+", e.g. "image/svg+xml").
This had its limitations. For one, it was only possible with one file extension per MIME type.
Now you can specify multiple file suffixes using "suffixes", but you need to specify the full MIME type
identifier:
[mediaTypes]
[mediaTypes."image/svg+xml"]
suffixes = ["svg", "abc ]
In most cases, it will be enough to just change:
[mediaTypes]
[mediaTypes."my/custom-mediatype"]
suffix = "txt"
To:
[mediaTypes]
[mediaTypes."my/custom-mediatype"]
suffixes = ["txt"]
Hugo will still respect values set in "suffix" if no value for "suffixes" is provided, but this will be removed in a future release.
Note that you can still get the Media Type's suffix from a template: {{ $mediaType.Suffix }}. But this will now map to the MIME type filename.
Fixes #4920
121 lines
3.3 KiB
Go
121 lines
3.3 KiB
Go
// 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 bundler contains functions for concatenation etc. of Resource objects.
|
|
package bundler
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"path/filepath"
|
|
|
|
"github.com/gohugoio/hugo/media"
|
|
"github.com/gohugoio/hugo/resource"
|
|
)
|
|
|
|
// Client contains methods perform concatenation and other bundling related
|
|
// tasks to Resource objects.
|
|
type Client struct {
|
|
rs *resource.Spec
|
|
}
|
|
|
|
// New creates a new Client with the given specification.
|
|
func New(rs *resource.Spec) *Client {
|
|
return &Client{rs: rs}
|
|
}
|
|
|
|
type multiReadSeekCloser struct {
|
|
mr io.Reader
|
|
sources []resource.ReadSeekCloser
|
|
}
|
|
|
|
func (r *multiReadSeekCloser) Read(p []byte) (n int, err error) {
|
|
return r.mr.Read(p)
|
|
}
|
|
|
|
func (r *multiReadSeekCloser) Seek(offset int64, whence int) (newOffset int64, err error) {
|
|
for _, s := range r.sources {
|
|
newOffset, err = s.Seek(offset, whence)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (r *multiReadSeekCloser) Close() error {
|
|
for _, s := range r.sources {
|
|
s.Close()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Concat concatenates the list of Resource objects.
|
|
func (c *Client) Concat(targetPath string, resources []resource.Resource) (resource.Resource, error) {
|
|
// The CACHE_OTHER will make sure this will be re-created and published on rebuilds.
|
|
return c.rs.ResourceCache.GetOrCreate(resource.CACHE_OTHER, targetPath, func() (resource.Resource, error) {
|
|
var resolvedm media.Type
|
|
|
|
// The given set of resources must be of the same Media Type.
|
|
// We may improve on that in the future, but then we need to know more.
|
|
for i, r := range resources {
|
|
if i > 0 && r.MediaType().Type() != resolvedm.Type() {
|
|
return nil, errors.New("resources in Concat must be of the same Media Type")
|
|
}
|
|
resolvedm = r.MediaType()
|
|
}
|
|
|
|
concatr := func() (resource.ReadSeekCloser, error) {
|
|
var rcsources []resource.ReadSeekCloser
|
|
for _, s := range resources {
|
|
rcr, ok := s.(resource.ReadSeekCloserResource)
|
|
if !ok {
|
|
return nil, fmt.Errorf("resource %T does not implement resource.ReadSeekerCloserResource", s)
|
|
}
|
|
rc, err := rcr.ReadSeekCloser()
|
|
if err != nil {
|
|
// Close the already opened.
|
|
for _, rcs := range rcsources {
|
|
rcs.Close()
|
|
}
|
|
return nil, err
|
|
}
|
|
rcsources = append(rcsources, rc)
|
|
}
|
|
|
|
readers := make([]io.Reader, len(rcsources))
|
|
for i := 0; i < len(rcsources); i++ {
|
|
readers[i] = rcsources[i]
|
|
}
|
|
|
|
mr := io.MultiReader(readers...)
|
|
|
|
return &multiReadSeekCloser{mr: mr, sources: rcsources}, nil
|
|
}
|
|
|
|
composite, err := c.rs.NewForFs(
|
|
c.rs.BaseFs.Resources.Fs,
|
|
resource.ResourceSourceDescriptor{
|
|
LazyPublish: true,
|
|
OpenReadSeekCloser: concatr,
|
|
RelTargetFilename: filepath.Clean(targetPath)})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return composite, nil
|
|
})
|
|
|
|
}
|