mirror of
https://github.com/gohugoio/hugo.git
synced 2024-11-21 20:46:30 -05:00
dea71670c0
Before this commit, you would have to use page bundles to do image processing etc. in Hugo.
This commit adds
* A new `/assets` top-level project or theme dir (configurable via `assetDir`)
* A new template func, `resources.Get` which can be used to "get a resource" that can be further processed.
This means that you can now do this in your templates (or shortcodes):
```bash
{{ $sunset := (resources.Get "images/sunset.jpg").Fill "300x200" }}
```
This also adds a new `extended` build tag that enables powerful SCSS/SASS support with source maps. To compile this from source, you will also need a C compiler installed:
```
HUGO_BUILD_TAGS=extended mage install
```
Note that you can use output of the SCSS processing later in a non-SCSSS-enabled Hugo.
The `SCSS` processor is a _Resource transformation step_ and it can be chained with the many others in a pipeline:
```bash
{{ $css := resources.Get "styles.scss" | resources.ToCSS | resources.PostCSS | resources.Minify | resources.Fingerprint }}
<link rel="stylesheet" href="{{ $styles.RelPermalink }}" integrity="{{ $styles.Data.Digest }}" media="screen">
```
The transformation funcs above have aliases, so it can be shortened to:
```bash
{{ $css := resources.Get "styles.scss" | toCSS | postCSS | minify | fingerprint }}
<link rel="stylesheet" href="{{ $styles.RelPermalink }}" integrity="{{ $styles.Data.Digest }}" media="screen">
```
A quick tip would be to avoid the fingerprinting part, and possibly also the not-superfast `postCSS` when you're doing development, as it allows Hugo to be smarter about the rebuilding.
Documentation will follow, but have a look at the demo repo in https://github.com/bep/hugo-sass-test
New functions to create `Resource` objects:
* `resources.Get` (see above)
* `resources.FromString`: Create a Resource from a string.
New `Resource` transformation funcs:
* `resources.ToCSS`: Compile `SCSS` or `SASS` into `CSS`.
* `resources.PostCSS`: Process your CSS with PostCSS. Config file support (project or theme or passed as an option).
* `resources.Minify`: Currently supports `css`, `js`, `json`, `html`, `svg`, `xml`.
* `resources.Fingerprint`: Creates a fingerprinted version of the given Resource with Subresource Integrity..
* `resources.Concat`: Concatenates a list of Resource objects. Think of this as a poor man's bundler.
* `resources.ExecuteAsTemplate`: Parses and executes the given Resource and data context (e.g. .Site) as a Go template.
Fixes #4381
Fixes #4903
Fixes #4858
250 lines
8.7 KiB
Go
250 lines
8.7 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 filesystems
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/spf13/afero"
|
|
|
|
"github.com/gohugoio/hugo/hugofs"
|
|
"github.com/gohugoio/hugo/hugolib/paths"
|
|
"github.com/spf13/viper"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestNewBaseFs(t *testing.T) {
|
|
assert := require.New(t)
|
|
v := viper.New()
|
|
|
|
fs := hugofs.NewMem(v)
|
|
|
|
themes := []string{"btheme", "atheme"}
|
|
|
|
workingDir := filepath.FromSlash("/my/work")
|
|
v.Set("workingDir", workingDir)
|
|
v.Set("themesDir", "themes")
|
|
v.Set("theme", themes[:1])
|
|
|
|
// Write some data to the themes
|
|
for _, theme := range themes {
|
|
for _, dir := range []string{"i18n", "data"} {
|
|
base := filepath.Join(workingDir, "themes", theme, dir)
|
|
fs.Source.Mkdir(base, 0755)
|
|
afero.WriteFile(fs.Source, filepath.Join(base, fmt.Sprintf("theme-file-%s-%s.txt", theme, dir)), []byte(fmt.Sprintf("content:%s:%s", theme, dir)), 0755)
|
|
}
|
|
}
|
|
|
|
afero.WriteFile(fs.Source, filepath.Join(workingDir, "themes", "btheme", "config.toml"), []byte(`
|
|
theme = ["atheme"]
|
|
`), 0755)
|
|
|
|
setConfigAndWriteSomeFilesTo(fs.Source, v, "contentDir", "mycontent", 3)
|
|
setConfigAndWriteSomeFilesTo(fs.Source, v, "i18nDir", "myi18n", 4)
|
|
setConfigAndWriteSomeFilesTo(fs.Source, v, "layoutDir", "mylayouts", 5)
|
|
setConfigAndWriteSomeFilesTo(fs.Source, v, "staticDir", "mystatic", 6)
|
|
setConfigAndWriteSomeFilesTo(fs.Source, v, "dataDir", "mydata", 7)
|
|
setConfigAndWriteSomeFilesTo(fs.Source, v, "archetypeDir", "myarchetypes", 8)
|
|
setConfigAndWriteSomeFilesTo(fs.Source, v, "assetDir", "myassets", 9)
|
|
setConfigAndWriteSomeFilesTo(fs.Source, v, "resourceDir", "myrsesource", 10)
|
|
|
|
v.Set("publishDir", "public")
|
|
|
|
p, err := paths.New(fs, v)
|
|
assert.NoError(err)
|
|
|
|
bfs, err := NewBase(p)
|
|
assert.NoError(err)
|
|
assert.NotNil(bfs)
|
|
|
|
root, err := bfs.I18n.Fs.Open("")
|
|
assert.NoError(err)
|
|
dirnames, err := root.Readdirnames(-1)
|
|
assert.NoError(err)
|
|
assert.Equal([]string{projectVirtualFolder, "btheme", "atheme"}, dirnames)
|
|
ff, err := bfs.I18n.Fs.Open("myi18n")
|
|
assert.NoError(err)
|
|
_, err = ff.Readdirnames(-1)
|
|
assert.NoError(err)
|
|
|
|
root, err = bfs.Data.Fs.Open("")
|
|
assert.NoError(err)
|
|
dirnames, err = root.Readdirnames(-1)
|
|
assert.NoError(err)
|
|
assert.Equal([]string{projectVirtualFolder, "btheme", "atheme"}, dirnames)
|
|
ff, err = bfs.I18n.Fs.Open("mydata")
|
|
assert.NoError(err)
|
|
_, err = ff.Readdirnames(-1)
|
|
assert.NoError(err)
|
|
|
|
checkFileCount(bfs.Content.Fs, "", assert, 3)
|
|
checkFileCount(bfs.I18n.Fs, "", assert, 6) // 4 + 2 themes
|
|
checkFileCount(bfs.Layouts.Fs, "", assert, 5)
|
|
checkFileCount(bfs.Static[""].Fs, "", assert, 6)
|
|
checkFileCount(bfs.Data.Fs, "", assert, 9) // 7 + 2 themes
|
|
checkFileCount(bfs.Archetypes.Fs, "", assert, 8)
|
|
checkFileCount(bfs.Assets.Fs, "", assert, 9)
|
|
checkFileCount(bfs.Resources.Fs, "", assert, 10)
|
|
checkFileCount(bfs.Work.Fs, "", assert, 57)
|
|
|
|
assert.Equal([]string{filepath.FromSlash("/my/work/mydata"), filepath.FromSlash("/my/work/themes/btheme/data"), filepath.FromSlash("/my/work/themes/atheme/data")}, bfs.Data.Dirnames)
|
|
|
|
assert.True(bfs.IsData(filepath.Join(workingDir, "mydata", "file1.txt")))
|
|
assert.True(bfs.IsI18n(filepath.Join(workingDir, "myi18n", "file1.txt")))
|
|
assert.True(bfs.IsLayout(filepath.Join(workingDir, "mylayouts", "file1.txt")))
|
|
assert.True(bfs.IsStatic(filepath.Join(workingDir, "mystatic", "file1.txt")))
|
|
assert.True(bfs.IsAsset(filepath.Join(workingDir, "myassets", "file1.txt")))
|
|
|
|
contentFilename := filepath.Join(workingDir, "mycontent", "file1.txt")
|
|
assert.True(bfs.IsContent(contentFilename))
|
|
rel := bfs.RelContentDir(contentFilename)
|
|
assert.Equal("file1.txt", rel)
|
|
|
|
}
|
|
|
|
func createConfig() *viper.Viper {
|
|
v := viper.New()
|
|
v.Set("contentDir", "mycontent")
|
|
v.Set("i18nDir", "myi18n")
|
|
v.Set("staticDir", "mystatic")
|
|
v.Set("dataDir", "mydata")
|
|
v.Set("layoutDir", "mylayouts")
|
|
v.Set("archetypeDir", "myarchetypes")
|
|
v.Set("assetDir", "myassets")
|
|
v.Set("resourceDir", "resources")
|
|
v.Set("publishDir", "public")
|
|
|
|
return v
|
|
}
|
|
|
|
func TestNewBaseFsEmpty(t *testing.T) {
|
|
assert := require.New(t)
|
|
v := createConfig()
|
|
fs := hugofs.NewMem(v)
|
|
p, err := paths.New(fs, v)
|
|
assert.NoError(err)
|
|
bfs, err := NewBase(p)
|
|
assert.NoError(err)
|
|
assert.NotNil(bfs)
|
|
assert.Equal(hugofs.NoOpFs, bfs.Archetypes.Fs)
|
|
assert.Equal(hugofs.NoOpFs, bfs.Layouts.Fs)
|
|
assert.Equal(hugofs.NoOpFs, bfs.Data.Fs)
|
|
assert.Equal(hugofs.NoOpFs, bfs.Assets.Fs)
|
|
assert.Equal(hugofs.NoOpFs, bfs.I18n.Fs)
|
|
assert.NotNil(bfs.Work.Fs)
|
|
assert.NotNil(bfs.Content.Fs)
|
|
assert.NotNil(bfs.Static)
|
|
}
|
|
|
|
func TestRealDirs(t *testing.T) {
|
|
assert := require.New(t)
|
|
v := createConfig()
|
|
fs := hugofs.NewDefault(v)
|
|
sfs := fs.Source
|
|
|
|
root, err := afero.TempDir(sfs, "", "realdir")
|
|
assert.NoError(err)
|
|
themesDir, err := afero.TempDir(sfs, "", "themesDir")
|
|
assert.NoError(err)
|
|
defer func() {
|
|
os.RemoveAll(root)
|
|
os.RemoveAll(themesDir)
|
|
}()
|
|
|
|
v.Set("workingDir", root)
|
|
v.Set("contentDir", "content")
|
|
v.Set("resourceDir", "resources")
|
|
v.Set("publishDir", "public")
|
|
v.Set("themesDir", themesDir)
|
|
v.Set("theme", "mytheme")
|
|
|
|
assert.NoError(sfs.MkdirAll(filepath.Join(root, "myassets", "scss", "sf1"), 0755))
|
|
assert.NoError(sfs.MkdirAll(filepath.Join(root, "myassets", "scss", "sf2"), 0755))
|
|
assert.NoError(sfs.MkdirAll(filepath.Join(themesDir, "mytheme", "assets", "scss", "sf2"), 0755))
|
|
assert.NoError(sfs.MkdirAll(filepath.Join(themesDir, "mytheme", "assets", "scss", "sf3"), 0755))
|
|
assert.NoError(sfs.MkdirAll(filepath.Join(root, "resources"), 0755))
|
|
assert.NoError(sfs.MkdirAll(filepath.Join(themesDir, "mytheme", "resources"), 0755))
|
|
|
|
assert.NoError(sfs.MkdirAll(filepath.Join(root, "myassets", "js", "f2"), 0755))
|
|
|
|
afero.WriteFile(sfs, filepath.Join(filepath.Join(root, "myassets", "scss", "sf1", "a1.scss")), []byte("content"), 0755)
|
|
afero.WriteFile(sfs, filepath.Join(filepath.Join(root, "myassets", "scss", "sf2", "a3.scss")), []byte("content"), 0755)
|
|
afero.WriteFile(sfs, filepath.Join(filepath.Join(root, "myassets", "scss", "a2.scss")), []byte("content"), 0755)
|
|
afero.WriteFile(sfs, filepath.Join(filepath.Join(themesDir, "mytheme", "assets", "scss", "sf2", "a3.scss")), []byte("content"), 0755)
|
|
afero.WriteFile(sfs, filepath.Join(filepath.Join(themesDir, "mytheme", "assets", "scss", "sf3", "a4.scss")), []byte("content"), 0755)
|
|
|
|
afero.WriteFile(sfs, filepath.Join(filepath.Join(themesDir, "mytheme", "resources", "t1.txt")), []byte("content"), 0755)
|
|
afero.WriteFile(sfs, filepath.Join(filepath.Join(root, "resources", "p1.txt")), []byte("content"), 0755)
|
|
afero.WriteFile(sfs, filepath.Join(filepath.Join(root, "resources", "p2.txt")), []byte("content"), 0755)
|
|
|
|
afero.WriteFile(sfs, filepath.Join(filepath.Join(root, "myassets", "js", "f2", "a1.js")), []byte("content"), 0755)
|
|
afero.WriteFile(sfs, filepath.Join(filepath.Join(root, "myassets", "js", "a2.js")), []byte("content"), 0755)
|
|
|
|
p, err := paths.New(fs, v)
|
|
assert.NoError(err)
|
|
bfs, err := NewBase(p)
|
|
assert.NoError(err)
|
|
assert.NotNil(bfs)
|
|
checkFileCount(bfs.Assets.Fs, "", assert, 6)
|
|
|
|
realDirs := bfs.Assets.RealDirs("scss")
|
|
assert.Equal(2, len(realDirs))
|
|
assert.Equal(filepath.Join(root, "myassets/scss"), realDirs[0])
|
|
assert.Equal(filepath.Join(themesDir, "mytheme/assets/scss"), realDirs[len(realDirs)-1])
|
|
|
|
checkFileCount(bfs.Resources.Fs, "", assert, 3)
|
|
|
|
}
|
|
|
|
func checkFileCount(fs afero.Fs, dirname string, assert *require.Assertions, expected int) {
|
|
count, _, err := countFileaAndGetDirs(fs, dirname)
|
|
assert.NoError(err)
|
|
assert.Equal(expected, count)
|
|
}
|
|
|
|
func countFileaAndGetDirs(fs afero.Fs, dirname string) (int, []string, error) {
|
|
if fs == nil {
|
|
return 0, nil, errors.New("no fs")
|
|
}
|
|
|
|
counter := 0
|
|
var dirs []string
|
|
|
|
afero.Walk(fs, dirname, func(path string, info os.FileInfo, err error) error {
|
|
if info != nil {
|
|
if !info.IsDir() {
|
|
counter++
|
|
} else if info.Name() != "." {
|
|
dirs = append(dirs, filepath.Join(path, info.Name()))
|
|
}
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
return counter, dirs, nil
|
|
}
|
|
|
|
func setConfigAndWriteSomeFilesTo(fs afero.Fs, v *viper.Viper, key, val string, num int) {
|
|
workingDir := v.GetString("workingDir")
|
|
v.Set(key, val)
|
|
fs.Mkdir(val, 0755)
|
|
for i := 0; i < num; i++ {
|
|
afero.WriteFile(fs, filepath.Join(workingDir, val, fmt.Sprintf("file%d.txt", i+1)), []byte(fmt.Sprintf("content:%s:%d", key, i+1)), 0755)
|
|
}
|
|
}
|