2019-01-02 06:33:26 -05:00
|
|
|
// Copyright 2019 The Hugo Authors. All rights reserved.
|
2017-02-17 07:30:50 -05:00
|
|
|
//
|
|
|
|
// 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 tplimpl
|
|
|
|
|
|
|
|
import (
|
2019-12-10 13:56:44 -05:00
|
|
|
"io"
|
2020-01-15 09:59:56 -05:00
|
|
|
"os"
|
|
|
|
"path/filepath"
|
2019-12-10 13:56:44 -05:00
|
|
|
"reflect"
|
|
|
|
"regexp"
|
2020-01-15 09:59:56 -05:00
|
|
|
"strings"
|
|
|
|
"sync"
|
2019-12-10 13:56:44 -05:00
|
|
|
"time"
|
2020-01-30 14:02:26 -05:00
|
|
|
"unicode"
|
|
|
|
"unicode/utf8"
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
"github.com/gohugoio/hugo/common/types"
|
2019-11-27 07:42:36 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
"github.com/gohugoio/hugo/helpers"
|
2019-12-10 02:02:15 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
"github.com/gohugoio/hugo/output"
|
2019-12-10 02:02:15 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
"github.com/gohugoio/hugo/deps"
|
|
|
|
"github.com/spf13/afero"
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
"github.com/gohugoio/hugo/common/herrors"
|
2018-10-03 08:58:09 -04:00
|
|
|
"github.com/gohugoio/hugo/hugofs"
|
2020-01-15 09:59:56 -05:00
|
|
|
"github.com/gohugoio/hugo/hugofs/files"
|
2018-10-03 08:58:09 -04:00
|
|
|
"github.com/pkg/errors"
|
2018-05-04 11:53:56 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
"github.com/gohugoio/hugo/tpl/tplimpl/embedded"
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
htmltemplate "github.com/gohugoio/hugo/tpl/internal/go_templates/htmltemplate"
|
|
|
|
texttemplate "github.com/gohugoio/hugo/tpl/internal/go_templates/texttemplate"
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
"github.com/gohugoio/hugo/identity"
|
2017-06-13 12:42:45 -04:00
|
|
|
"github.com/gohugoio/hugo/tpl"
|
2017-03-27 14:43:49 -04:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
textTmplNamePrefix = "_text/"
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2019-04-15 09:17:46 -04:00
|
|
|
shortcodesPathPrefix = "shortcodes/"
|
|
|
|
internalPathPrefix = "_internal/"
|
2020-01-15 09:59:56 -05:00
|
|
|
baseFileBase = "baseof"
|
2019-04-15 09:17:46 -04:00
|
|
|
)
|
|
|
|
|
2019-12-10 13:56:44 -05:00
|
|
|
// The identifiers may be truncated in the log, e.g.
|
|
|
|
// "executing "main" at <$scaled.SRelPermalin...>: can't evaluate field SRelPermalink in type *resource.Image"
|
|
|
|
var identifiersRe = regexp.MustCompile(`at \<(.*?)(\.{3})?\>:`)
|
2019-01-02 06:33:26 -05:00
|
|
|
|
2019-12-10 13:56:44 -05:00
|
|
|
var embeddedTemplatesAliases = map[string][]string{
|
|
|
|
"shortcodes/twitter.html": {"shortcodes/tweet.html"},
|
2019-01-02 06:33:26 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
var (
|
|
|
|
_ tpl.TemplateManager = (*templateExec)(nil)
|
|
|
|
_ tpl.TemplateHandler = (*templateExec)(nil)
|
|
|
|
_ tpl.TemplateFuncGetter = (*templateExec)(nil)
|
|
|
|
_ tpl.TemplateFinder = (*templateExec)(nil)
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
_ tpl.Template = (*templateState)(nil)
|
|
|
|
_ tpl.Info = (*templateState)(nil)
|
|
|
|
)
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-30 14:02:26 -05:00
|
|
|
var baseTemplateDefineRe = regexp.MustCompile(`^{{-?\s*define`)
|
2020-01-23 11:34:19 -05:00
|
|
|
|
2020-01-30 14:02:26 -05:00
|
|
|
// needsBaseTemplate returns true if the first non-comment template block is a
|
|
|
|
// define block.
|
|
|
|
// If a base template does not exist, we will handle that when it's used.
|
2020-01-23 11:34:19 -05:00
|
|
|
func needsBaseTemplate(templ string) bool {
|
2020-01-30 14:02:26 -05:00
|
|
|
idx := -1
|
|
|
|
inComment := false
|
|
|
|
for i := 0; i < len(templ); {
|
|
|
|
if !inComment && strings.HasPrefix(templ[i:], "{{/*") {
|
|
|
|
inComment = true
|
|
|
|
i += 4
|
|
|
|
} else if inComment && strings.HasPrefix(templ[i:], "*/}}") {
|
|
|
|
inComment = false
|
|
|
|
i += 4
|
|
|
|
} else {
|
|
|
|
r, size := utf8.DecodeRuneInString(templ[i:])
|
|
|
|
if !inComment {
|
|
|
|
if strings.HasPrefix(templ[i:], "{{") {
|
|
|
|
idx = i
|
|
|
|
break
|
|
|
|
} else if !unicode.IsSpace(r) {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
i += size
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if idx == -1 {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
return baseTemplateDefineRe.MatchString(templ[idx:])
|
2020-01-23 11:34:19 -05:00
|
|
|
}
|
2018-10-03 08:58:09 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func newIdentity(name string) identity.Manager {
|
|
|
|
return identity.NewManager(identity.NewPathIdentity(files.ComponentFolderLayouts, name))
|
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func newStandaloneTextTemplate(funcs map[string]interface{}) tpl.TemplateParseFinder {
|
|
|
|
return &textTemplateWrapperWithLock{
|
|
|
|
RWMutex: &sync.RWMutex{},
|
|
|
|
Template: texttemplate.New("").Funcs(funcs),
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func newTemplateExec(d *deps.Deps) (*templateExec, error) {
|
|
|
|
exec, funcs := newTemplateExecuter(d)
|
|
|
|
funcMap := make(map[string]interface{})
|
|
|
|
for k, v := range funcs {
|
|
|
|
funcMap[k] = v.Interface()
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
h := &templateHandler{
|
|
|
|
nameBaseTemplateName: make(map[string]string),
|
|
|
|
transformNotFound: make(map[string]*templateState),
|
|
|
|
identityNotFound: make(map[string][]identity.Manager),
|
2018-10-03 08:58:09 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
shortcodes: make(map[string]*shortcodeTemplates),
|
|
|
|
templateInfo: make(map[string]tpl.Info),
|
|
|
|
baseof: make(map[string]templateInfo),
|
|
|
|
needsBaseof: make(map[string]templateInfo),
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-07-13 07:40:35 -04:00
|
|
|
main: newTemplateNamespace(funcMap),
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
Deps: d,
|
|
|
|
layoutHandler: output.NewLayoutHandler(),
|
|
|
|
layoutsFs: d.BaseFs.Layouts.Fs,
|
|
|
|
layoutTemplateCache: make(map[layoutCacheKey]tpl.Template),
|
|
|
|
}
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
if err := h.loadEmbedded(); err != nil {
|
|
|
|
return nil, err
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
2018-10-03 08:58:09 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
if err := h.loadTemplates(); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
e := &templateExec{
|
|
|
|
d: d,
|
|
|
|
executor: exec,
|
|
|
|
funcs: funcs,
|
|
|
|
templateHandler: h,
|
|
|
|
}
|
Add support for theme composition and inheritance
This commit adds support for theme composition and inheritance in Hugo.
With this, it helps thinking about a theme as a set of ordered components:
```toml
theme = ["my-shortcodes", "base-theme", "hyde"]
```
The theme definition example above in `config.toml` creates a theme with the 3 components with presedence from left to right.
So, Hugo will, for any given file, data entry etc., look first in the project, and then in `my-shortcode`, `base-theme` and lastly `hyde`.
Hugo uses two different algorithms to merge the filesystems, depending on the file type:
* For `i18n` and `data` files, Hugo merges deeply using the translation id and data key inside the files.
* For `static`, `layouts` (templates) and `archetypes` files, these are merged on file level. So the left-most file will be chosen.
The name used in the `theme` definition above must match a folder in `/your-site/themes`, e.g. `/your-site/themes/my-shortcodes`. There are plans to improve on this and get a URL scheme so this can be resolved automatically.
Also note that a component that is part of a theme can have its own configuration file, e.g. `config.toml`. There are currently some restrictions to what a theme component can configure:
* `params` (global and per language)
* `menu` (global and per language)
* `outputformats` and `mediatypes`
The same rules apply here: The left-most param/menu etc. with the same ID will win. There are some hidden and experimental namespace support in the above, which we will work to improve in the future, but theme authors are encouraged to create their own namespaces to avoid naming conflicts.
A final note: Themes/components can also have a `theme` definition in their `config.toml` and similar, which is the "inheritance" part of this commit's title. This is currently not supported by the Hugo theme site. We will have to wait for some "auto dependency" feature to be implemented for that to happen, but this can be a powerful feature if you want to create your own theme-variant based on others.
Fixes #4460
Fixes #4450
2018-03-01 09:01:25 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
d.SetTmpl(e)
|
|
|
|
d.SetTextTmpl(newStandaloneTextTemplate(funcMap))
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
if d.WithTemplate != nil {
|
|
|
|
if err := d.WithTemplate(e); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
return e, nil
|
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-07-13 07:40:35 -04:00
|
|
|
func newTemplateNamespace(funcs map[string]interface{}) *templateNamespace {
|
2020-01-15 09:59:56 -05:00
|
|
|
return &templateNamespace{
|
|
|
|
prototypeHTML: htmltemplate.New("").Funcs(funcs),
|
|
|
|
prototypeText: texttemplate.New("").Funcs(funcs),
|
|
|
|
templateStateMap: &templateStateMap{
|
|
|
|
templates: make(map[string]*templateState),
|
|
|
|
},
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
}
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func newTemplateState(templ tpl.Template, info templateInfo) *templateState {
|
|
|
|
return &templateState{
|
|
|
|
info: info,
|
|
|
|
typ: info.resolveType(),
|
|
|
|
Template: templ,
|
|
|
|
Manager: newIdentity(info.name),
|
|
|
|
parseInfo: tpl.DefaultParseInfo,
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
Add Hugo Piper with SCSS support and much more
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
2018-02-20 04:02:14 -05:00
|
|
|
}
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
type layoutCacheKey struct {
|
|
|
|
d output.LayoutDescriptor
|
|
|
|
f string
|
|
|
|
}
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
type templateExec struct {
|
|
|
|
d *deps.Deps
|
|
|
|
executor texttemplate.Executer
|
|
|
|
funcs map[string]reflect.Value
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
*templateHandler
|
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t templateExec) Clone(d *deps.Deps) *templateExec {
|
|
|
|
exec, funcs := newTemplateExecuter(d)
|
|
|
|
t.executor = exec
|
|
|
|
t.funcs = funcs
|
|
|
|
t.d = d
|
|
|
|
return &t
|
|
|
|
}
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateExec) Execute(templ tpl.Template, wr io.Writer, data interface{}) error {
|
|
|
|
if rlocker, ok := templ.(types.RLocker); ok {
|
|
|
|
rlocker.RLock()
|
|
|
|
defer rlocker.RUnlock()
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
if t.Metrics != nil {
|
|
|
|
defer t.Metrics.MeasureSince(templ.Name(), time.Now())
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
execErr := t.executor.Execute(templ, wr, data)
|
|
|
|
if execErr != nil {
|
|
|
|
execErr = t.addFileContext(templ, execErr)
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
return execErr
|
|
|
|
}
|
Add support for theme composition and inheritance
This commit adds support for theme composition and inheritance in Hugo.
With this, it helps thinking about a theme as a set of ordered components:
```toml
theme = ["my-shortcodes", "base-theme", "hyde"]
```
The theme definition example above in `config.toml` creates a theme with the 3 components with presedence from left to right.
So, Hugo will, for any given file, data entry etc., look first in the project, and then in `my-shortcode`, `base-theme` and lastly `hyde`.
Hugo uses two different algorithms to merge the filesystems, depending on the file type:
* For `i18n` and `data` files, Hugo merges deeply using the translation id and data key inside the files.
* For `static`, `layouts` (templates) and `archetypes` files, these are merged on file level. So the left-most file will be chosen.
The name used in the `theme` definition above must match a folder in `/your-site/themes`, e.g. `/your-site/themes/my-shortcodes`. There are plans to improve on this and get a URL scheme so this can be resolved automatically.
Also note that a component that is part of a theme can have its own configuration file, e.g. `config.toml`. There are currently some restrictions to what a theme component can configure:
* `params` (global and per language)
* `menu` (global and per language)
* `outputformats` and `mediatypes`
The same rules apply here: The left-most param/menu etc. with the same ID will win. There are some hidden and experimental namespace support in the above, which we will work to improve in the future, but theme authors are encouraged to create their own namespaces to avoid naming conflicts.
A final note: Themes/components can also have a `theme` definition in their `config.toml` and similar, which is the "inheritance" part of this commit's title. This is currently not supported by the Hugo theme site. We will have to wait for some "auto dependency" feature to be implemented for that to happen, but this can be a powerful feature if you want to create your own theme-variant based on others.
Fixes #4460
Fixes #4450
2018-03-01 09:01:25 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateExec) GetFunc(name string) (reflect.Value, bool) {
|
|
|
|
v, found := t.funcs[name]
|
|
|
|
return v, found
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateExec) MarkReady() error {
|
|
|
|
var err error
|
|
|
|
t.readyInit.Do(func() {
|
|
|
|
// We only need the clones if base templates are in use.
|
|
|
|
if len(t.needsBaseof) > 0 {
|
|
|
|
err = t.main.createPrototypes()
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
})
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-03-09 07:04:33 -04:00
|
|
|
return err
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2019-12-10 13:56:44 -05:00
|
|
|
type templateHandler struct {
|
2020-01-15 09:59:56 -05:00
|
|
|
main *templateNamespace
|
|
|
|
needsBaseof map[string]templateInfo
|
|
|
|
baseof map[string]templateInfo
|
2019-11-27 07:42:36 -05:00
|
|
|
|
2020-03-09 07:04:33 -04:00
|
|
|
readyInit sync.Once
|
2019-12-10 13:56:44 -05:00
|
|
|
|
|
|
|
// This is the filesystem to load the templates from. All the templates are
|
|
|
|
// stored in the root of this filesystem.
|
|
|
|
layoutsFs afero.Fs
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
layoutHandler *output.LayoutHandler
|
|
|
|
|
|
|
|
layoutTemplateCache map[layoutCacheKey]tpl.Template
|
|
|
|
layoutTemplateCacheMu sync.RWMutex
|
|
|
|
|
2019-12-10 13:56:44 -05:00
|
|
|
*deps.Deps
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
// Used to get proper filenames in errors
|
|
|
|
nameBaseTemplateName map[string]string
|
|
|
|
|
|
|
|
// Holds name and source of template definitions not found during the first
|
|
|
|
// AST transformation pass.
|
|
|
|
transformNotFound map[string]*templateState
|
|
|
|
|
|
|
|
// Holds identities of templates not found during first pass.
|
|
|
|
identityNotFound map[string][]identity.Manager
|
|
|
|
|
|
|
|
// shortcodes maps shortcode name to template variants
|
|
|
|
// (language, output format etc.) of that shortcode.
|
|
|
|
shortcodes map[string]*shortcodeTemplates
|
|
|
|
|
|
|
|
// templateInfo maps template name to some additional information about that template.
|
|
|
|
// Note that for shortcodes that same information is embedded in the
|
|
|
|
// shortcodeTemplates type.
|
|
|
|
templateInfo map[string]tpl.Info
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// AddTemplate parses and adds a template to the collection.
|
|
|
|
// Templates with name prefixed with "_text" will be handled as plain
|
|
|
|
// text templates.
|
|
|
|
func (t *templateHandler) AddTemplate(name, tpl string) error {
|
2020-01-15 09:59:56 -05:00
|
|
|
templ, err := t.addTemplateTo(t.newTemplateInfo(name, tpl), t.main)
|
|
|
|
if err == nil {
|
|
|
|
t.applyTemplateTransformers(t.main, templ)
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
return err
|
2017-04-30 15:52:56 -04:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) Lookup(name string) (tpl.Template, bool) {
|
|
|
|
templ, found := t.main.Lookup(name)
|
|
|
|
if found {
|
|
|
|
return templ, true
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
return nil, false
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) LookupLayout(d output.LayoutDescriptor, f output.Format) (tpl.Template, bool, error) {
|
|
|
|
key := layoutCacheKey{d, f.Name}
|
|
|
|
t.layoutTemplateCacheMu.RLock()
|
|
|
|
if cacheVal, found := t.layoutTemplateCache[key]; found {
|
|
|
|
t.layoutTemplateCacheMu.RUnlock()
|
|
|
|
return cacheVal, true, nil
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
t.layoutTemplateCacheMu.RUnlock()
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
t.layoutTemplateCacheMu.Lock()
|
|
|
|
defer t.layoutTemplateCacheMu.Unlock()
|
2019-01-02 06:33:26 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
templ, found, err := t.findLayout(d, f)
|
|
|
|
if err == nil && found {
|
|
|
|
t.layoutTemplateCache[key] = templ
|
|
|
|
return templ, true, nil
|
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
return nil, false, err
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// This currently only applies to shortcodes and what we get here is the
|
|
|
|
// shortcode name.
|
|
|
|
func (t *templateHandler) LookupVariant(name string, variants tpl.TemplateVariants) (tpl.Template, bool, bool) {
|
|
|
|
name = templateBaseName(templateShortcode, name)
|
|
|
|
s, found := t.shortcodes[name]
|
|
|
|
if !found {
|
|
|
|
return nil, false, false
|
2019-04-16 03:13:55 -04:00
|
|
|
}
|
|
|
|
|
2019-12-10 13:56:44 -05:00
|
|
|
sv, found := s.fromVariants(variants)
|
|
|
|
if !found {
|
|
|
|
return nil, false, false
|
2017-04-02 08:20:34 -04:00
|
|
|
}
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2019-12-10 13:56:44 -05:00
|
|
|
more := len(s.variants) > 1
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
return sv.ts, true, more
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
|
|
|
|
2020-07-03 12:02:32 -04:00
|
|
|
// LookupVariants returns all variants of name, nil if none found.
|
|
|
|
func (t *templateHandler) LookupVariants(name string) []tpl.Template {
|
|
|
|
name = templateBaseName(templateShortcode, name)
|
|
|
|
s, found := t.shortcodes[name]
|
|
|
|
if !found {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
variants := make([]tpl.Template, len(s.variants))
|
|
|
|
for i := 0; i < len(variants); i++ {
|
|
|
|
variants[i] = s.variants[i].ts
|
|
|
|
}
|
|
|
|
|
|
|
|
return variants
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) HasTemplate(name string) bool {
|
|
|
|
if _, found := t.baseof[name]; found {
|
|
|
|
return true
|
2017-05-06 14:15:28 -04:00
|
|
|
}
|
2020-02-28 06:39:58 -05:00
|
|
|
|
|
|
|
if _, found := t.needsBaseof[name]; found {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
_, found := t.Lookup(name)
|
|
|
|
return found
|
|
|
|
}
|
2017-05-06 14:15:28 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) findLayout(d output.LayoutDescriptor, f output.Format) (tpl.Template, bool, error) {
|
|
|
|
layouts, _ := t.layoutHandler.For(d, f)
|
|
|
|
for _, name := range layouts {
|
|
|
|
templ, found := t.main.Lookup(name)
|
|
|
|
if found {
|
|
|
|
return templ, true, nil
|
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
overlay, found := t.needsBaseof[name]
|
|
|
|
|
|
|
|
if !found {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
d.Baseof = true
|
|
|
|
baseLayouts, _ := t.layoutHandler.For(d, f)
|
|
|
|
var base templateInfo
|
|
|
|
found = false
|
|
|
|
for _, l := range baseLayouts {
|
|
|
|
base, found = t.baseof[l]
|
|
|
|
if found {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
templ, err := t.applyBaseTemplate(overlay, base)
|
|
|
|
if err != nil {
|
|
|
|
return nil, false, err
|
|
|
|
}
|
|
|
|
|
|
|
|
ts := newTemplateState(templ, overlay)
|
|
|
|
|
2020-01-23 11:34:19 -05:00
|
|
|
if found {
|
|
|
|
ts.baseInfo = base
|
|
|
|
|
|
|
|
// Add the base identity to detect changes
|
|
|
|
ts.Add(identity.NewPathIdentity(files.ComponentFolderLayouts, base.name))
|
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
|
|
|
|
t.applyTemplateTransformers(t.main, ts)
|
|
|
|
|
2020-07-13 07:40:35 -04:00
|
|
|
if err := t.extractPartials(ts.Template); err != nil {
|
|
|
|
return nil, false, err
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
return ts, true, nil
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
|
|
|
|
return nil, false, nil
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) findTemplate(name string) *templateState {
|
|
|
|
if templ, found := t.Lookup(name); found {
|
|
|
|
return templ.(*templateState)
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
return nil
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) newTemplateInfo(name, tpl string) templateInfo {
|
|
|
|
var isText bool
|
|
|
|
name, isText = t.nameIsText(name)
|
|
|
|
return templateInfo{
|
|
|
|
name: name,
|
|
|
|
isText: isText,
|
|
|
|
template: tpl,
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
Add Hugo Piper with SCSS support and much more
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
2018-02-20 04:02:14 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) addFileContext(templ tpl.Template, inerr error) error {
|
|
|
|
if strings.HasPrefix(templ.Name(), "_internal") {
|
2019-12-10 13:56:44 -05:00
|
|
|
return inerr
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
ts, ok := templ.(*templateState)
|
|
|
|
if !ok {
|
2019-12-10 13:56:44 -05:00
|
|
|
return inerr
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
//lint:ignore ST1008 the error is the main result
|
|
|
|
checkFilename := func(info templateInfo, inErr error) (error, bool) {
|
|
|
|
if info.filename == "" {
|
|
|
|
return inErr, false
|
|
|
|
}
|
|
|
|
|
|
|
|
lineMatcher := func(m herrors.LineMatcher) bool {
|
|
|
|
if m.Position.LineNumber != m.LineNumber {
|
|
|
|
return false
|
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
identifiers := t.extractIdentifiers(m.Error.Error())
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
for _, id := range identifiers {
|
|
|
|
if strings.Contains(m.Line, id) {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
f, err := t.layoutsFs.Open(info.filename)
|
|
|
|
if err != nil {
|
|
|
|
return inErr, false
|
|
|
|
}
|
|
|
|
defer f.Close()
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
fe, ok := herrors.WithFileContext(inErr, info.realFilename, f, lineMatcher)
|
|
|
|
if ok {
|
|
|
|
return fe, true
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
return inErr, false
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
inerr = errors.Wrap(inerr, "execute of template failed")
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
if err, ok := checkFilename(ts.info, inerr); ok {
|
2019-12-10 13:56:44 -05:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
err, _ := checkFilename(ts.baseInfo, inerr)
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
return err
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
2019-01-31 05:53:21 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) addShortcodeVariant(ts *templateState) {
|
|
|
|
name := ts.Name()
|
2019-12-10 13:56:44 -05:00
|
|
|
base := templateBaseName(templateShortcode, name)
|
|
|
|
|
|
|
|
shortcodename, variants := templateNameAndVariants(base)
|
|
|
|
|
|
|
|
templs, found := t.shortcodes[shortcodename]
|
|
|
|
if !found {
|
|
|
|
templs = &shortcodeTemplates{}
|
|
|
|
t.shortcodes[shortcodename] = templs
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
sv := shortcodeVariant{variants: variants, ts: ts}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
|
|
|
i := templs.indexOf(variants)
|
|
|
|
|
|
|
|
if i != -1 {
|
|
|
|
// Only replace if it's an override of an internal template.
|
|
|
|
if !isInternal(name) {
|
|
|
|
templs.variants[i] = sv
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
templs.variants = append(templs.variants, sv)
|
|
|
|
}
|
Add Hugo Piper with SCSS support and much more
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
2018-02-20 04:02:14 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) addTemplateFile(name, path string) error {
|
2019-12-10 13:56:44 -05:00
|
|
|
getTemplate := func(filename string) (templateInfo, error) {
|
|
|
|
fs := t.Layouts.Fs
|
|
|
|
b, err := afero.ReadFile(fs, filename)
|
|
|
|
if err != nil {
|
|
|
|
return templateInfo{filename: filename, fs: fs}, err
|
|
|
|
}
|
|
|
|
|
|
|
|
s := removeLeadingBOM(string(b))
|
|
|
|
|
|
|
|
realFilename := filename
|
|
|
|
if fi, err := fs.Stat(filename); err == nil {
|
|
|
|
if fim, ok := fi.(hugofs.FileMetaInfo); ok {
|
|
|
|
realFilename = fim.Meta().Filename()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
var isText bool
|
|
|
|
name, isText = t.nameIsText(name)
|
|
|
|
|
|
|
|
return templateInfo{
|
|
|
|
name: name,
|
|
|
|
isText: isText,
|
|
|
|
template: s,
|
|
|
|
filename: filename,
|
|
|
|
realFilename: realFilename,
|
|
|
|
fs: fs,
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
tinfo, err := getTemplate(path)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
Add Hugo Piper with SCSS support and much more
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
2018-02-20 04:02:14 -05:00
|
|
|
}
|
|
|
|
|
2020-01-23 11:34:19 -05:00
|
|
|
if isBaseTemplatePath(name) {
|
2020-01-15 09:59:56 -05:00
|
|
|
// Store it for later.
|
|
|
|
t.baseof[name] = tinfo
|
2019-12-10 13:56:44 -05:00
|
|
|
return nil
|
2020-01-15 09:59:56 -05:00
|
|
|
}
|
|
|
|
|
2020-01-30 14:02:26 -05:00
|
|
|
needsBaseof := !t.noBaseNeeded(name) && needsBaseTemplate(tinfo.template)
|
2020-01-15 09:59:56 -05:00
|
|
|
if needsBaseof {
|
|
|
|
t.needsBaseof[name] = tinfo
|
2019-12-10 13:56:44 -05:00
|
|
|
return nil
|
2020-01-15 09:59:56 -05:00
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
templ, err := t.addTemplateTo(tinfo, t.main)
|
|
|
|
if err != nil {
|
|
|
|
return tinfo.errWithFileContext("parse failed", err)
|
|
|
|
}
|
|
|
|
t.applyTemplateTransformers(t.main, templ)
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) addTemplateTo(info templateInfo, to *templateNamespace) (*templateState, error) {
|
|
|
|
return to.parse(info)
|
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) applyBaseTemplate(overlay, base templateInfo) (tpl.Template, error) {
|
|
|
|
if overlay.isText {
|
2020-01-23 11:34:19 -05:00
|
|
|
var (
|
|
|
|
templ = t.main.prototypeTextClone.New(overlay.name)
|
|
|
|
err error
|
|
|
|
)
|
|
|
|
|
|
|
|
if !base.IsZero() {
|
|
|
|
templ, err = templ.Parse(base.template)
|
|
|
|
if err != nil {
|
|
|
|
return nil, base.errWithFileContext("parse failed", err)
|
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
2020-01-23 11:34:19 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
templ, err = templ.Parse(overlay.template)
|
2019-12-10 13:56:44 -05:00
|
|
|
if err != nil {
|
2020-01-15 09:59:56 -05:00
|
|
|
return nil, overlay.errWithFileContext("parse failed", err)
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
return templ, nil
|
Add Hugo Piper with SCSS support and much more
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
2018-02-20 04:02:14 -05:00
|
|
|
}
|
|
|
|
|
2020-01-23 11:34:19 -05:00
|
|
|
var (
|
|
|
|
templ = t.main.prototypeHTMLClone.New(overlay.name)
|
|
|
|
err error
|
|
|
|
)
|
|
|
|
|
|
|
|
if !base.IsZero() {
|
|
|
|
templ, err = templ.Parse(base.template)
|
|
|
|
if err != nil {
|
|
|
|
return nil, base.errWithFileContext("parse failed", err)
|
|
|
|
}
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
templ, err = htmltemplate.Must(templ.Clone()).Parse(overlay.template)
|
|
|
|
if err != nil {
|
|
|
|
return nil, overlay.errWithFileContext("parse failed", err)
|
2019-04-16 03:13:55 -04:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
|
|
|
|
// The extra lookup is a workaround, see
|
|
|
|
// * https://github.com/golang/go/issues/16101
|
|
|
|
// * https://github.com/gohugoio/hugo/issues/2549
|
|
|
|
templ = templ.Lookup(templ.Name())
|
|
|
|
|
|
|
|
return templ, err
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
2019-04-16 03:13:55 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) applyTemplateTransformers(ns *templateNamespace, ts *templateState) (*templateContext, error) {
|
|
|
|
c, err := applyTemplateTransformers(ts, ns.newTemplateLookup(ts))
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
for k := range c.templateNotFound {
|
|
|
|
t.transformNotFound[k] = ts
|
|
|
|
t.identityNotFound[k] = append(t.identityNotFound[k], c.t)
|
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
for k := range c.identityNotFound {
|
|
|
|
t.identityNotFound[k] = append(t.identityNotFound[k], c.t)
|
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
return c, err
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
func (t *templateHandler) extractIdentifiers(line string) []string {
|
|
|
|
m := identifiersRe.FindAllStringSubmatch(line, -1)
|
|
|
|
identifiers := make([]string, len(m))
|
|
|
|
for i := 0; i < len(m); i++ {
|
|
|
|
identifiers[i] = m[i][1]
|
2017-05-06 14:15:28 -04:00
|
|
|
}
|
2019-12-10 13:56:44 -05:00
|
|
|
return identifiers
|
|
|
|
}
|
2017-05-06 14:15:28 -04:00
|
|
|
|
2019-12-10 13:56:44 -05:00
|
|
|
func (t *templateHandler) loadEmbedded() error {
|
|
|
|
for _, kv := range embedded.EmbeddedTemplates {
|
|
|
|
name, templ := kv[0], kv[1]
|
2020-01-15 09:59:56 -05:00
|
|
|
if err := t.AddTemplate(internalPathPrefix+name, templ); err != nil {
|
2019-12-10 13:56:44 -05:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
if aliases, found := embeddedTemplatesAliases[name]; found {
|
2020-01-15 09:59:56 -05:00
|
|
|
// TODO(bep) avoid reparsing these aliases
|
2019-12-10 13:56:44 -05:00
|
|
|
for _, alias := range aliases {
|
2020-01-15 09:59:56 -05:00
|
|
|
alias = internalPathPrefix + alias
|
|
|
|
if err := t.AddTemplate(alias, templ); err != nil {
|
2019-12-10 13:56:44 -05:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) loadTemplates() error {
|
2019-12-10 13:56:44 -05:00
|
|
|
walker := func(path string, fi hugofs.FileMetaInfo, err error) error {
|
|
|
|
if err != nil || fi.IsDir() {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
if isDotFile(path) || isBackupFile(path) {
|
2019-12-10 13:56:44 -05:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
name := strings.TrimPrefix(filepath.ToSlash(path), "/")
|
|
|
|
filename := filepath.Base(path)
|
|
|
|
outputFormat, found := t.OutputFormatsConfig.FromFilename(filename)
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
if found && outputFormat.IsPlainText {
|
|
|
|
name = textTmplNamePrefix + name
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
if err := t.addTemplateFile(name, path); err != nil {
|
2019-12-10 13:56:44 -05:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := helpers.SymbolicWalk(t.Layouts.Fs, "", walker); err != nil {
|
|
|
|
if !os.IsNotExist(err) {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) nameIsText(name string) (string, bool) {
|
|
|
|
isText := strings.HasPrefix(name, textTmplNamePrefix)
|
|
|
|
if isText {
|
|
|
|
name = strings.TrimPrefix(name, textTmplNamePrefix)
|
2019-04-16 03:13:55 -04:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
return name, isText
|
2019-11-27 07:42:36 -05:00
|
|
|
}
|
2019-04-16 03:13:55 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateHandler) noBaseNeeded(name string) bool {
|
|
|
|
if strings.HasPrefix(name, "shortcodes/") || strings.HasPrefix(name, "partials/") {
|
|
|
|
return true
|
2019-11-27 07:42:36 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
return strings.Contains(name, "_markup/")
|
2019-11-27 07:42:36 -05:00
|
|
|
}
|
|
|
|
|
2020-07-13 07:40:35 -04:00
|
|
|
func (t *templateHandler) extractPartials(templ tpl.Template) error {
|
|
|
|
templs := templates(templ)
|
|
|
|
for _, templ := range templs {
|
|
|
|
if templ.Name() == "" || !strings.HasPrefix(templ.Name(), "partials/") {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
ts := newTemplateState(templ, templateInfo{name: templ.Name()})
|
|
|
|
ts.typ = templatePartial
|
|
|
|
|
|
|
|
t.main.mu.RLock()
|
|
|
|
_, found := t.main.templates[templ.Name()]
|
|
|
|
t.main.mu.RUnlock()
|
|
|
|
|
|
|
|
if !found {
|
|
|
|
t.main.mu.Lock()
|
|
|
|
// This is a template defined inline.
|
|
|
|
_, err := applyTemplateTransformers(ts, t.main.newTemplateLookup(ts))
|
|
|
|
if err != nil {
|
|
|
|
t.main.mu.Unlock()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
t.main.templates[templ.Name()] = ts
|
|
|
|
t.main.mu.Unlock()
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-11-27 07:42:36 -05:00
|
|
|
func (t *templateHandler) postTransform() error {
|
2020-07-01 04:43:17 -04:00
|
|
|
defineCheckedHTML := false
|
|
|
|
defineCheckedText := false
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
for _, v := range t.main.templates {
|
|
|
|
if v.typ == templateShortcode {
|
|
|
|
t.addShortcodeVariant(v)
|
2019-11-27 07:42:36 -05:00
|
|
|
}
|
2020-07-01 04:43:17 -04:00
|
|
|
|
|
|
|
if defineCheckedHTML && defineCheckedText {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
isText := isText(v.Template)
|
|
|
|
if isText {
|
|
|
|
if defineCheckedText {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
defineCheckedText = true
|
|
|
|
} else {
|
|
|
|
if defineCheckedHTML {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
defineCheckedHTML = true
|
|
|
|
}
|
|
|
|
|
2020-07-13 07:40:35 -04:00
|
|
|
if err := t.extractPartials(v.Template); err != nil {
|
|
|
|
return err
|
2020-07-01 04:43:17 -04:00
|
|
|
}
|
2019-11-27 07:42:36 -05:00
|
|
|
}
|
2019-04-16 03:13:55 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
for name, source := range t.transformNotFound {
|
|
|
|
lookup := t.main.newTemplateLookup(source)
|
|
|
|
templ := lookup(name)
|
|
|
|
if templ != nil {
|
|
|
|
_, err := applyTemplateTransformers(templ, lookup)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
2019-04-16 03:13:55 -04:00
|
|
|
}
|
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
}
|
2019-11-27 07:42:36 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
for k, v := range t.identityNotFound {
|
|
|
|
ts := t.findTemplate(k)
|
|
|
|
if ts != nil {
|
|
|
|
for _, im := range v {
|
|
|
|
im.Add(ts)
|
2019-11-27 07:42:36 -05:00
|
|
|
}
|
|
|
|
}
|
2019-04-16 03:13:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
type templateNamespace struct {
|
|
|
|
prototypeText *texttemplate.Template
|
|
|
|
prototypeHTML *htmltemplate.Template
|
|
|
|
prototypeTextClone *texttemplate.Template
|
|
|
|
prototypeHTMLClone *htmltemplate.Template
|
2019-11-27 07:42:36 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
*templateStateMap
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
|
|
|
|
2020-07-13 07:40:35 -04:00
|
|
|
func (t templateNamespace) Clone() *templateNamespace {
|
|
|
|
t.mu.Lock()
|
|
|
|
defer t.mu.Unlock()
|
Add support for theme composition and inheritance
This commit adds support for theme composition and inheritance in Hugo.
With this, it helps thinking about a theme as a set of ordered components:
```toml
theme = ["my-shortcodes", "base-theme", "hyde"]
```
The theme definition example above in `config.toml` creates a theme with the 3 components with presedence from left to right.
So, Hugo will, for any given file, data entry etc., look first in the project, and then in `my-shortcode`, `base-theme` and lastly `hyde`.
Hugo uses two different algorithms to merge the filesystems, depending on the file type:
* For `i18n` and `data` files, Hugo merges deeply using the translation id and data key inside the files.
* For `static`, `layouts` (templates) and `archetypes` files, these are merged on file level. So the left-most file will be chosen.
The name used in the `theme` definition above must match a folder in `/your-site/themes`, e.g. `/your-site/themes/my-shortcodes`. There are plans to improve on this and get a URL scheme so this can be resolved automatically.
Also note that a component that is part of a theme can have its own configuration file, e.g. `config.toml`. There are currently some restrictions to what a theme component can configure:
* `params` (global and per language)
* `menu` (global and per language)
* `outputformats` and `mediatypes`
The same rules apply here: The left-most param/menu etc. with the same ID will win. There are some hidden and experimental namespace support in the above, which we will work to improve in the future, but theme authors are encouraged to create their own namespaces to avoid naming conflicts.
A final note: Themes/components can also have a `theme` definition in their `config.toml` and similar, which is the "inheritance" part of this commit's title. This is currently not supported by the Hugo theme site. We will have to wait for some "auto dependency" feature to be implemented for that to happen, but this can be a powerful feature if you want to create your own theme-variant based on others.
Fixes #4460
Fixes #4450
2018-03-01 09:01:25 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
t.templateStateMap = &templateStateMap{
|
|
|
|
templates: make(map[string]*templateState),
|
|
|
|
}
|
Add support for theme composition and inheritance
This commit adds support for theme composition and inheritance in Hugo.
With this, it helps thinking about a theme as a set of ordered components:
```toml
theme = ["my-shortcodes", "base-theme", "hyde"]
```
The theme definition example above in `config.toml` creates a theme with the 3 components with presedence from left to right.
So, Hugo will, for any given file, data entry etc., look first in the project, and then in `my-shortcode`, `base-theme` and lastly `hyde`.
Hugo uses two different algorithms to merge the filesystems, depending on the file type:
* For `i18n` and `data` files, Hugo merges deeply using the translation id and data key inside the files.
* For `static`, `layouts` (templates) and `archetypes` files, these are merged on file level. So the left-most file will be chosen.
The name used in the `theme` definition above must match a folder in `/your-site/themes`, e.g. `/your-site/themes/my-shortcodes`. There are plans to improve on this and get a URL scheme so this can be resolved automatically.
Also note that a component that is part of a theme can have its own configuration file, e.g. `config.toml`. There are currently some restrictions to what a theme component can configure:
* `params` (global and per language)
* `menu` (global and per language)
* `outputformats` and `mediatypes`
The same rules apply here: The left-most param/menu etc. with the same ID will win. There are some hidden and experimental namespace support in the above, which we will work to improve in the future, but theme authors are encouraged to create their own namespaces to avoid naming conflicts.
A final note: Themes/components can also have a `theme` definition in their `config.toml` and similar, which is the "inheritance" part of this commit's title. This is currently not supported by the Hugo theme site. We will have to wait for some "auto dependency" feature to be implemented for that to happen, but this can be a powerful feature if you want to create your own theme-variant based on others.
Fixes #4460
Fixes #4450
2018-03-01 09:01:25 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
t.prototypeText = texttemplate.Must(t.prototypeText.Clone())
|
|
|
|
t.prototypeHTML = htmltemplate.Must(t.prototypeHTML.Clone())
|
2019-11-27 07:42:36 -05:00
|
|
|
|
2019-12-10 13:56:44 -05:00
|
|
|
return &t
|
|
|
|
}
|
2018-10-03 08:58:09 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateNamespace) Lookup(name string) (tpl.Template, bool) {
|
2020-07-13 07:40:35 -04:00
|
|
|
t.mu.RLock()
|
|
|
|
defer t.mu.RUnlock()
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
templ, found := t.templates[name]
|
|
|
|
if !found {
|
|
|
|
return nil, false
|
|
|
|
}
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
return templ, found
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateNamespace) createPrototypes() error {
|
|
|
|
t.prototypeTextClone = texttemplate.Must(t.prototypeText.Clone())
|
|
|
|
t.prototypeHTMLClone = htmltemplate.Must(t.prototypeHTML.Clone())
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
return nil
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateNamespace) newTemplateLookup(in *templateState) func(name string) *templateState {
|
|
|
|
return func(name string) *templateState {
|
|
|
|
if templ, found := t.templates[name]; found {
|
|
|
|
if templ.isText() != in.isText() {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return templ
|
|
|
|
}
|
|
|
|
if templ, found := findTemplateIn(name, in); found {
|
|
|
|
return newTemplateState(templ, templateInfo{name: templ.Name()})
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateNamespace) parse(info templateInfo) (*templateState, error) {
|
2020-07-13 07:40:35 -04:00
|
|
|
t.mu.Lock()
|
|
|
|
defer t.mu.Unlock()
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
if info.isText {
|
|
|
|
prototype := t.prototypeText
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
templ, err := prototype.New(info.name).Parse(info.template)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
ts := newTemplateState(templ, info)
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
t.templates[info.name] = ts
|
|
|
|
|
|
|
|
return ts, nil
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
prototype := t.prototypeHTML
|
2019-12-10 13:56:44 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
templ, err := prototype.New(info.name).Parse(info.template)
|
2017-02-17 07:30:50 -05:00
|
|
|
if err != nil {
|
2019-12-10 13:56:44 -05:00
|
|
|
return nil, err
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
ts := newTemplateState(templ, info)
|
Add support for theme composition and inheritance
This commit adds support for theme composition and inheritance in Hugo.
With this, it helps thinking about a theme as a set of ordered components:
```toml
theme = ["my-shortcodes", "base-theme", "hyde"]
```
The theme definition example above in `config.toml` creates a theme with the 3 components with presedence from left to right.
So, Hugo will, for any given file, data entry etc., look first in the project, and then in `my-shortcode`, `base-theme` and lastly `hyde`.
Hugo uses two different algorithms to merge the filesystems, depending on the file type:
* For `i18n` and `data` files, Hugo merges deeply using the translation id and data key inside the files.
* For `static`, `layouts` (templates) and `archetypes` files, these are merged on file level. So the left-most file will be chosen.
The name used in the `theme` definition above must match a folder in `/your-site/themes`, e.g. `/your-site/themes/my-shortcodes`. There are plans to improve on this and get a URL scheme so this can be resolved automatically.
Also note that a component that is part of a theme can have its own configuration file, e.g. `config.toml`. There are currently some restrictions to what a theme component can configure:
* `params` (global and per language)
* `menu` (global and per language)
* `outputformats` and `mediatypes`
The same rules apply here: The left-most param/menu etc. with the same ID will win. There are some hidden and experimental namespace support in the above, which we will work to improve in the future, but theme authors are encouraged to create their own namespaces to avoid naming conflicts.
A final note: Themes/components can also have a `theme` definition in their `config.toml` and similar, which is the "inheritance" part of this commit's title. This is currently not supported by the Hugo theme site. We will have to wait for some "auto dependency" feature to be implemented for that to happen, but this can be a powerful feature if you want to create your own theme-variant based on others.
Fixes #4460
Fixes #4450
2018-03-01 09:01:25 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
t.templates[info.name] = ts
|
Add support for theme composition and inheritance
This commit adds support for theme composition and inheritance in Hugo.
With this, it helps thinking about a theme as a set of ordered components:
```toml
theme = ["my-shortcodes", "base-theme", "hyde"]
```
The theme definition example above in `config.toml` creates a theme with the 3 components with presedence from left to right.
So, Hugo will, for any given file, data entry etc., look first in the project, and then in `my-shortcode`, `base-theme` and lastly `hyde`.
Hugo uses two different algorithms to merge the filesystems, depending on the file type:
* For `i18n` and `data` files, Hugo merges deeply using the translation id and data key inside the files.
* For `static`, `layouts` (templates) and `archetypes` files, these are merged on file level. So the left-most file will be chosen.
The name used in the `theme` definition above must match a folder in `/your-site/themes`, e.g. `/your-site/themes/my-shortcodes`. There are plans to improve on this and get a URL scheme so this can be resolved automatically.
Also note that a component that is part of a theme can have its own configuration file, e.g. `config.toml`. There are currently some restrictions to what a theme component can configure:
* `params` (global and per language)
* `menu` (global and per language)
* `outputformats` and `mediatypes`
The same rules apply here: The left-most param/menu etc. with the same ID will win. There are some hidden and experimental namespace support in the above, which we will work to improve in the future, but theme authors are encouraged to create their own namespaces to avoid naming conflicts.
A final note: Themes/components can also have a `theme` definition in their `config.toml` and similar, which is the "inheritance" part of this commit's title. This is currently not supported by the Hugo theme site. We will have to wait for some "auto dependency" feature to be implemented for that to happen, but this can be a powerful feature if you want to create your own theme-variant based on others.
Fixes #4460
Fixes #4450
2018-03-01 09:01:25 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
return ts, nil
|
|
|
|
}
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
type templateState struct {
|
|
|
|
tpl.Template
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
typ templateType
|
|
|
|
parseInfo tpl.ParseInfo
|
|
|
|
identity.Manager
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
info templateInfo
|
|
|
|
baseInfo templateInfo // Set when a base template is used.
|
|
|
|
}
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateState) ParseInfo() tpl.ParseInfo {
|
|
|
|
return t.parseInfo
|
|
|
|
}
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *templateState) isText() bool {
|
2020-07-01 04:43:17 -04:00
|
|
|
return isText(t.Template)
|
|
|
|
}
|
|
|
|
|
|
|
|
func isText(templ tpl.Template) bool {
|
|
|
|
_, isText := templ.(*texttemplate.Template)
|
2020-01-15 09:59:56 -05:00
|
|
|
return isText
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
type templateStateMap struct {
|
2020-07-13 07:40:35 -04:00
|
|
|
mu sync.RWMutex
|
2020-01-15 09:59:56 -05:00
|
|
|
templates map[string]*templateState
|
|
|
|
}
|
Add support for theme composition and inheritance
This commit adds support for theme composition and inheritance in Hugo.
With this, it helps thinking about a theme as a set of ordered components:
```toml
theme = ["my-shortcodes", "base-theme", "hyde"]
```
The theme definition example above in `config.toml` creates a theme with the 3 components with presedence from left to right.
So, Hugo will, for any given file, data entry etc., look first in the project, and then in `my-shortcode`, `base-theme` and lastly `hyde`.
Hugo uses two different algorithms to merge the filesystems, depending on the file type:
* For `i18n` and `data` files, Hugo merges deeply using the translation id and data key inside the files.
* For `static`, `layouts` (templates) and `archetypes` files, these are merged on file level. So the left-most file will be chosen.
The name used in the `theme` definition above must match a folder in `/your-site/themes`, e.g. `/your-site/themes/my-shortcodes`. There are plans to improve on this and get a URL scheme so this can be resolved automatically.
Also note that a component that is part of a theme can have its own configuration file, e.g. `config.toml`. There are currently some restrictions to what a theme component can configure:
* `params` (global and per language)
* `menu` (global and per language)
* `outputformats` and `mediatypes`
The same rules apply here: The left-most param/menu etc. with the same ID will win. There are some hidden and experimental namespace support in the above, which we will work to improve in the future, but theme authors are encouraged to create their own namespaces to avoid naming conflicts.
A final note: Themes/components can also have a `theme` definition in their `config.toml` and similar, which is the "inheritance" part of this commit's title. This is currently not supported by the Hugo theme site. We will have to wait for some "auto dependency" feature to be implemented for that to happen, but this can be a powerful feature if you want to create your own theme-variant based on others.
Fixes #4460
Fixes #4450
2018-03-01 09:01:25 -05:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
type templateWrapperWithLock struct {
|
|
|
|
*sync.RWMutex
|
|
|
|
tpl.Template
|
|
|
|
}
|
2017-03-27 14:43:49 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
type textTemplateWrapperWithLock struct {
|
|
|
|
*sync.RWMutex
|
|
|
|
*texttemplate.Template
|
|
|
|
}
|
2018-05-24 05:24:38 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *textTemplateWrapperWithLock) Lookup(name string) (tpl.Template, bool) {
|
|
|
|
t.RLock()
|
|
|
|
templ := t.Template.Lookup(name)
|
|
|
|
t.RUnlock()
|
|
|
|
if templ == nil {
|
|
|
|
return nil, false
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
return &textTemplateWrapperWithLock{
|
|
|
|
RWMutex: t.RWMutex,
|
|
|
|
Template: templ,
|
|
|
|
}, true
|
|
|
|
}
|
2018-05-04 11:53:56 -04:00
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *textTemplateWrapperWithLock) LookupVariant(name string, variants tpl.TemplateVariants) (tpl.Template, bool, bool) {
|
|
|
|
panic("not supported")
|
2019-12-10 13:56:44 -05:00
|
|
|
}
|
2018-10-03 08:58:09 -04:00
|
|
|
|
2020-07-03 12:02:32 -04:00
|
|
|
func (t *textTemplateWrapperWithLock) LookupVariants(name string) []tpl.Template {
|
|
|
|
panic("not supported")
|
|
|
|
}
|
|
|
|
|
2020-01-15 09:59:56 -05:00
|
|
|
func (t *textTemplateWrapperWithLock) Parse(name, tpl string) (tpl.Template, error) {
|
|
|
|
t.Lock()
|
|
|
|
defer t.Unlock()
|
|
|
|
return t.Template.New(name).Parse(tpl)
|
2017-03-27 14:43:49 -04:00
|
|
|
}
|
2017-02-17 07:30:50 -05:00
|
|
|
|
2019-12-10 13:56:44 -05:00
|
|
|
func isBackupFile(path string) bool {
|
|
|
|
return path[len(path)-1] == '~'
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
|
|
|
|
2020-01-23 11:34:19 -05:00
|
|
|
func isBaseTemplatePath(path string) bool {
|
2019-12-10 13:56:44 -05:00
|
|
|
return strings.Contains(filepath.Base(path), baseFileBase)
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
func isDotFile(path string) bool {
|
|
|
|
return filepath.Base(path)[0] == '.'
|
|
|
|
}
|
|
|
|
|
2019-12-10 13:56:44 -05:00
|
|
|
func removeLeadingBOM(s string) string {
|
|
|
|
const bom = '\ufeff'
|
|
|
|
|
|
|
|
for i, r := range s {
|
|
|
|
if i == 0 && r != bom {
|
|
|
|
return s
|
|
|
|
}
|
|
|
|
if i > 0 {
|
|
|
|
return s[i:]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return s
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
|
|
|
|
2019-12-10 13:56:44 -05:00
|
|
|
// resolves _internal/shortcodes/param.html => param.html etc.
|
|
|
|
func templateBaseName(typ templateType, name string) string {
|
|
|
|
name = strings.TrimPrefix(name, internalPathPrefix)
|
|
|
|
switch typ {
|
|
|
|
case templateShortcode:
|
|
|
|
return strings.TrimPrefix(name, shortcodesPathPrefix)
|
|
|
|
default:
|
|
|
|
panic("not implemented")
|
|
|
|
}
|
2017-02-17 07:30:50 -05:00
|
|
|
}
|
2020-01-15 09:59:56 -05:00
|
|
|
|
|
|
|
func unwrap(templ tpl.Template) tpl.Template {
|
|
|
|
if ts, ok := templ.(*templateState); ok {
|
|
|
|
return ts.Template
|
|
|
|
}
|
|
|
|
return templ
|
|
|
|
}
|
2020-07-01 04:43:17 -04:00
|
|
|
|
|
|
|
func templates(in tpl.Template) []tpl.Template {
|
|
|
|
var templs []tpl.Template
|
|
|
|
in = unwrap(in)
|
|
|
|
if textt, ok := in.(*texttemplate.Template); ok {
|
|
|
|
for _, t := range textt.Templates() {
|
|
|
|
templs = append(templs, t)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if htmlt, ok := in.(*htmltemplate.Template); ok {
|
|
|
|
for _, t := range htmlt.Templates() {
|
|
|
|
templs = append(templs, t)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return templs
|
|
|
|
}
|