2016-08-05 05:04:52 -04:00
// Copyright 2016-present 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 hugolib
import (
"fmt"
2018-11-15 03:28:02 -05:00
"os"
"path/filepath"
2017-09-25 02:59:02 -04:00
"strings"
2018-11-15 03:28:02 -05:00
"github.com/gohugoio/hugo/parser/metadecoders"
2018-10-22 14:20:48 -04:00
2018-11-15 03:28:02 -05:00
"github.com/gohugoio/hugo/common/herrors"
"github.com/gohugoio/hugo/common/hugo"
"github.com/gohugoio/hugo/hugofs"
2018-10-03 08:58:09 -04:00
"github.com/gohugoio/hugo/hugolib/paths"
2018-11-15 03:28:02 -05:00
"github.com/pkg/errors"
2018-10-03 08:58:09 -04:00
_errors "github.com/pkg/errors"
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
"github.com/gohugoio/hugo/langs"
2017-11-02 03:25:20 -04:00
"github.com/gohugoio/hugo/config"
2018-05-22 08:00:36 -04:00
"github.com/gohugoio/hugo/config/privacy"
2018-05-22 08:40:06 -04:00
"github.com/gohugoio/hugo/config/services"
2017-06-13 12:42:45 -04:00
"github.com/gohugoio/hugo/helpers"
2017-06-13 13:07:35 -04:00
"github.com/spf13/afero"
2016-08-05 05:04:52 -04:00
"github.com/spf13/viper"
)
2018-05-22 08:00:36 -04:00
// SiteConfig represents the config in .Site.Config.
type SiteConfig struct {
// This contains all privacy related settings that can be used to
// make the YouTube template etc. GDPR compliant.
Privacy privacy . Config
2018-05-22 08:40:06 -04:00
// Services contains config for services such as Google Analytics etc.
Services services . Config
}
func loadSiteConfig ( cfg config . Provider ) ( scfg SiteConfig , err error ) {
privacyConfig , err := privacy . DecodeConfig ( cfg )
if err != nil {
return
}
servicesConfig , err := services . DecodeConfig ( cfg )
if err != nil {
return
}
scfg . Privacy = privacyConfig
scfg . Services = servicesConfig
return
2018-05-22 08:00:36 -04:00
}
2018-03-18 05:32:29 -04:00
// ConfigSourceDescriptor describes where to find the config (e.g. config.toml etc.).
type ConfigSourceDescriptor struct {
2018-03-18 06:07:24 -04:00
Fs afero . Fs
2018-11-15 03:28:02 -05:00
// Path to the config file to use, e.g. /my/project/config.toml
2018-03-18 06:07:24 -04:00
Filename string
// The path to the directory to look for configuration. Is used if Filename is not
2018-11-15 03:28:02 -05:00
// set or if it is set to a relative filename.
2018-03-18 06:07:24 -04:00
Path string
// The project's working dir. Is used to look for additional theme config.
WorkingDir string
2018-11-15 03:28:02 -05:00
// The (optional) directory for additional configuration files.
AbsConfigDir string
// production, development
Environment string
2018-03-18 05:32:29 -04:00
}
func ( d ConfigSourceDescriptor ) configFilenames ( ) [ ] string {
2018-11-15 03:28:02 -05:00
if d . Filename == "" {
return [ ] string { "config" }
}
2018-03-18 06:07:24 -04:00
return strings . Split ( d . Filename , "," )
2018-03-18 05:32:29 -04:00
}
2018-11-15 03:28:02 -05:00
func ( d ConfigSourceDescriptor ) configFileDir ( ) string {
if d . Path != "" {
return d . Path
}
return d . WorkingDir
}
2018-03-18 05:32:29 -04:00
// LoadConfigDefault is a convenience method to load the default "config.toml" config.
func LoadConfigDefault ( fs afero . Fs ) ( * viper . Viper , error ) {
2018-03-18 06:07:24 -04:00
v , _ , err := LoadConfig ( ConfigSourceDescriptor { Fs : fs , Filename : "config.toml" } )
return v , err
2018-03-18 05:32:29 -04:00
}
2018-11-15 03:28:02 -05:00
var ErrNoConfigFile = errors . New ( "Unable to locate config file or config directory. Perhaps you need to create a new site.\n Run `hugo help new` for details.\n" )
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
2017-02-04 22:20:06 -05:00
// LoadConfig loads Hugo configuration into a new Viper and then adds
// a set of defaults.
2018-04-07 05:27:22 -04:00
func LoadConfig ( d ConfigSourceDescriptor , doWithConfig ... func ( cfg config . Provider ) error ) ( * viper . Viper , [ ] string , error ) {
2018-11-15 03:28:02 -05:00
if d . Environment == "" {
d . Environment = hugo . EnvironmentProduction
}
2018-03-18 06:07:24 -04:00
var configFiles [ ] string
2017-02-04 22:20:06 -05:00
v := viper . New ( )
2018-11-15 03:28:02 -05:00
l := configLoader { ConfigSourceDescriptor : d }
2018-03-18 05:32:29 -04:00
2017-02-04 22:20:06 -05:00
v . AutomaticEnv ( )
v . SetEnvPrefix ( "hugo" )
2018-03-18 05:32:29 -04:00
2018-11-15 03:28:02 -05:00
var cerr error
2018-10-22 14:20:48 -04:00
2018-11-15 03:28:02 -05:00
for _ , name := range d . configFilenames ( ) {
var filename string
if filename , cerr = l . loadConfig ( name , v ) ; cerr != nil && cerr != ErrNoConfigFile {
return nil , nil , cerr
2016-08-05 05:04:52 -04:00
}
2018-11-15 03:28:02 -05:00
configFiles = append ( configFiles , filename )
2018-03-18 06:07:24 -04:00
}
2018-11-15 03:28:02 -05:00
if d . AbsConfigDir != "" {
dirnames , err := l . loadConfigFromConfigDir ( v )
if err == nil {
configFiles = append ( configFiles , dirnames ... )
2017-08-09 14:13:02 -04:00
}
2018-11-15 03:28:02 -05:00
cerr = err
2017-08-09 14:13:02 -04:00
}
2016-08-05 05:04:52 -04:00
2017-11-02 03:25:20 -04:00
if err := loadDefaultSettingsFor ( v ) ; err != nil {
2018-03-18 06:07:24 -04:00
return v , configFiles , err
2017-11-02 03:25:20 -04:00
}
2016-08-05 05:04:52 -04:00
2018-11-15 03:28:02 -05:00
if cerr == nil {
themeConfigFiles , err := l . loadThemeConfig ( v )
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
if err != nil {
return v , configFiles , err
}
if len ( themeConfigFiles ) > 0 {
configFiles = append ( configFiles , themeConfigFiles ... )
}
2018-03-18 06:07:24 -04:00
}
2018-04-07 05:27:22 -04:00
// We create languages based on the settings, so we need to make sure that
// all configuration is loaded/set before doing that.
for _ , d := range doWithConfig {
if err := d ( v ) ; err != nil {
return v , configFiles , err
}
}
2018-03-18 06:07:24 -04:00
if err := loadLanguageSettings ( v , nil ) ; err != nil {
return v , configFiles , err
}
2018-11-15 03:28:02 -05:00
return v , configFiles , cerr
}
type configLoader struct {
ConfigSourceDescriptor
}
func ( l configLoader ) wrapFileInfoError ( err error , fi os . FileInfo ) error {
rfi , ok := fi . ( hugofs . RealFilenameInfo )
if ! ok {
return err
}
return l . wrapFileError ( err , rfi . RealFilename ( ) )
}
func ( l configLoader ) loadConfig ( configName string , v * viper . Viper ) ( string , error ) {
baseDir := l . configFileDir ( )
var baseFilename string
if filepath . IsAbs ( configName ) {
baseFilename = configName
} else {
baseFilename = filepath . Join ( baseDir , configName )
}
var filename string
fileExt := helpers . ExtNoDelimiter ( configName )
if fileExt != "" {
exists , _ := helpers . Exists ( baseFilename , l . Fs )
if exists {
filename = baseFilename
}
} else {
2019-01-31 07:06:18 -05:00
for _ , ext := range config . ValidConfigFileExtensions {
2018-11-15 03:28:02 -05:00
filenameToCheck := baseFilename + "." + ext
exists , _ := helpers . Exists ( filenameToCheck , l . Fs )
if exists {
filename = filenameToCheck
fileExt = ext
break
}
}
}
if filename == "" {
return "" , ErrNoConfigFile
}
m , err := config . FromFileToMap ( l . Fs , filename )
if err != nil {
return "" , l . wrapFileError ( err , filename )
}
if err = v . MergeConfigMap ( m ) ; err != nil {
return "" , l . wrapFileError ( err , filename )
}
return filename , nil
}
func ( l configLoader ) wrapFileError ( err error , filename string ) error {
err , _ = herrors . WithFileContextForFile (
err ,
filename ,
filename ,
l . Fs ,
herrors . SimpleLineMatcher )
return err
}
func ( l configLoader ) newRealBaseFs ( path string ) afero . Fs {
return hugofs . NewBasePathRealFilenameFs ( afero . NewBasePathFs ( l . Fs , path ) . ( * afero . BasePathFs ) )
}
func ( l configLoader ) loadConfigFromConfigDir ( v * viper . Viper ) ( [ ] string , error ) {
sourceFs := l . Fs
configDir := l . AbsConfigDir
if _ , err := sourceFs . Stat ( configDir ) ; err != nil {
// Config dir does not exist.
return nil , nil
}
defaultConfigDir := filepath . Join ( configDir , "_default" )
environmentConfigDir := filepath . Join ( configDir , l . Environment )
var configDirs [ ] string
// Merge from least to most specific.
for _ , dir := range [ ] string { defaultConfigDir , environmentConfigDir } {
if _ , err := sourceFs . Stat ( dir ) ; err == nil {
configDirs = append ( configDirs , dir )
}
}
if len ( configDirs ) == 0 {
return nil , nil
}
// Keep track of these so we can watch them for changes.
var dirnames [ ] string
for _ , configDir := range configDirs {
err := afero . Walk ( sourceFs , configDir , func ( path string , fi os . FileInfo , err error ) error {
if fi == nil {
return nil
}
if fi . IsDir ( ) {
dirnames = append ( dirnames , path )
return nil
}
2019-02-01 01:45:35 -05:00
if ! config . IsValidConfigFilename ( path ) {
return nil
}
2018-11-15 03:28:02 -05:00
name := helpers . Filename ( filepath . Base ( path ) )
2018-12-23 04:40:32 -05:00
item , err := metadecoders . Default . UnmarshalFileToMap ( sourceFs , path )
2018-11-15 03:28:02 -05:00
if err != nil {
return l . wrapFileError ( err , path )
}
var keyPath [ ] string
if name != "config" {
// Can be params.jp, menus.en etc.
name , lang := helpers . FileAndExtNoDelimiter ( name )
keyPath = [ ] string { name }
if lang != "" {
keyPath = [ ] string { "languages" , lang }
switch name {
case "menu" , "menus" :
keyPath = append ( keyPath , "menus" )
case "params" :
keyPath = append ( keyPath , "params" )
}
}
}
root := item
if len ( keyPath ) > 0 {
root = make ( map [ string ] interface { } )
m := root
for i , key := range keyPath {
if i >= len ( keyPath ) - 1 {
m [ key ] = item
} else {
nm := make ( map [ string ] interface { } )
m [ key ] = nm
m = nm
}
}
}
// Migrate menu => menus etc.
config . RenameKeys ( root )
if err := v . MergeConfigMap ( root ) ; err != nil {
return l . wrapFileError ( err , path )
}
return nil
} )
if err != nil {
return nil , err
}
}
2018-03-18 06:07:24 -04:00
2018-11-15 03:28:02 -05:00
return dirnames , nil
2016-08-05 05:04:52 -04:00
}
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
func loadLanguageSettings ( cfg config . Provider , oldLangs langs . Languages ) error {
2018-01-25 11:03:29 -05:00
defaultLang := cfg . GetString ( "defaultContentLanguage" )
var languages map [ string ] interface { }
languagesFromConfig := cfg . GetStringMap ( "languages" )
disableLanguages := cfg . GetStringSlice ( "disableLanguages" )
if len ( disableLanguages ) == 0 {
languages = languagesFromConfig
} else {
languages = make ( map [ string ] interface { } )
for k , v := range languagesFromConfig {
for _ , disabled := range disableLanguages {
if disabled == defaultLang {
return fmt . Errorf ( "cannot disable default language %q" , defaultLang )
}
if strings . EqualFold ( k , disabled ) {
2018-03-21 12:21:46 -04:00
v . ( map [ string ] interface { } ) [ "disabled" ] = true
2018-01-25 11:03:29 -05:00
break
}
}
2018-03-21 12:21:46 -04:00
languages [ k ] = v
2018-01-25 11:03:29 -05:00
}
}
2017-11-02 03:25:20 -04:00
var (
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
languages2 langs . Languages
err error
2017-11-02 03:25:20 -04:00
)
2018-01-25 11:03:29 -05:00
if len ( languages ) == 0 {
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
languages2 = append ( languages2 , langs . NewDefaultLanguage ( cfg ) )
2017-11-02 03:25:20 -04:00
} else {
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
languages2 , err = toSortedLanguages ( cfg , languages )
2017-11-02 03:25:20 -04:00
if err != nil {
2018-10-03 08:58:09 -04:00
return _errors . Wrap ( err , "Failed to parse multilingual config" )
2017-11-02 03:25:20 -04:00
}
}
2017-11-12 04:03:56 -05:00
if oldLangs != nil {
// When in multihost mode, the languages are mapped to a server, so
// some structural language changes will need a restart of the dev server.
// The validation below isn't complete, but should cover the most
// important cases.
var invalid bool
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
if languages2 . IsMultihost ( ) != oldLangs . IsMultihost ( ) {
2017-11-12 04:03:56 -05:00
invalid = true
} else {
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
if languages2 . IsMultihost ( ) && len ( languages2 ) != len ( oldLangs ) {
2017-11-12 04:03:56 -05:00
invalid = true
}
}
if invalid {
return errors . New ( "language change needing a server restart detected" )
}
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
if languages2 . IsMultihost ( ) {
2017-11-12 04:03:56 -05:00
// We need to transfer any server baseURL to the new language
for i , ol := range oldLangs {
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
nl := languages2 [ i ]
2017-11-12 04:03:56 -05:00
nl . Set ( "baseURL" , ol . GetString ( "baseURL" ) )
}
}
}
2018-01-19 02:24:10 -05:00
// The defaultContentLanguage is something the user has to decide, but it needs
// to match a language in the language definition list.
langExists := false
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
for _ , lang := range languages2 {
2018-01-19 02:24:10 -05:00
if lang . Lang == defaultLang {
langExists = true
break
}
}
if ! langExists {
return fmt . Errorf ( "site config value %q for defaultContentLanguage does not match any language definition" , defaultLang )
}
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
cfg . Set ( "languagesSorted" , languages2 )
cfg . Set ( "multilingual" , len ( languages2 ) > 1 )
2017-11-12 04:03:56 -05:00
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
multihost := languages2 . IsMultihost ( )
2017-11-12 04:03:56 -05:00
2018-01-06 12:42:32 -05:00
if multihost {
2017-11-12 04:03:56 -05:00
cfg . Set ( "defaultContentLanguageInSubdir" , true )
cfg . Set ( "multihost" , true )
}
2017-11-02 03:25:20 -04:00
2018-01-06 12:42:32 -05:00
if multihost {
// The baseURL may be provided at the language level. If that is true,
// then every language must have a baseURL. In this case we always render
// to a language sub folder, which is then stripped from all the Permalink URLs etc.
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
for _ , l := range languages2 {
2018-01-06 12:42:32 -05:00
burl := l . GetLocal ( "baseURL" )
if burl == nil {
return errors . New ( "baseURL must be set on all or none of the languages" )
}
}
}
2017-11-02 03:25:20 -04:00
return nil
}
2018-11-15 03:28:02 -05:00
func ( l configLoader ) loadThemeConfig ( v1 * viper . Viper ) ( [ ] string , error ) {
themesDir := paths . AbsPathify ( l . WorkingDir , v1 . GetString ( "themesDir" ) )
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
themes := config . GetStringSlicePreserveString ( v1 , "theme" )
2018-03-18 06:07:24 -04:00
2018-11-15 03:28:02 -05:00
themeConfigs , err := paths . CollectThemes ( l . Fs , themesDir , themes )
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
if err != nil {
return nil , err
2018-03-18 06:07:24 -04:00
}
2018-07-15 09:35:41 -04:00
if len ( themeConfigs ) == 0 {
return nil , nil
}
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
v1 . Set ( "allThemes" , themeConfigs )
var configFilenames [ ] string
for _ , tc := range themeConfigs {
if tc . ConfigFilename != "" {
configFilenames = append ( configFilenames , tc . ConfigFilename )
2018-11-15 03:28:02 -05:00
if err := l . applyThemeConfig ( v1 , tc ) ; err != nil {
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
return nil , err
}
2018-03-18 06:07:24 -04:00
}
}
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
return configFilenames , nil
2018-03-18 06:07:24 -04:00
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
}
2018-03-18 06:07:24 -04:00
2018-11-15 03:28:02 -05:00
func ( l configLoader ) applyThemeConfig ( v1 * viper . Viper , theme paths . ThemeConfig ) error {
2018-03-18 06:07:24 -04:00
const (
paramsKey = "params"
languagesKey = "languages"
2018-11-15 03:28:02 -05:00
menuKey = "menus"
2018-03-18 06:07:24 -04:00
)
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
v2 := theme . Cfg
2018-03-18 06:07:24 -04:00
for _ , key := range [ ] string { paramsKey , "outputformats" , "mediatypes" } {
2018-11-15 03:28:02 -05:00
l . mergeStringMapKeepLeft ( "" , key , v1 , v2 )
2018-03-18 06:07:24 -04:00
}
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
themeLower := strings . ToLower ( theme . Name )
2018-03-18 06:07:24 -04:00
themeParamsNamespace := paramsKey + "." + themeLower
// Set namespaced params
if v2 . IsSet ( paramsKey ) && ! v1 . IsSet ( themeParamsNamespace ) {
// Set it in the default store to make sure it gets in the same or
// behind the others.
v1 . SetDefault ( themeParamsNamespace , v2 . Get ( paramsKey ) )
}
// Only add params and new menu entries, we do not add language definitions.
if v1 . IsSet ( languagesKey ) && v2 . IsSet ( languagesKey ) {
v1Langs := v1 . GetStringMap ( languagesKey )
2018-10-23 17:18:24 -04:00
for k := range v1Langs {
2018-03-18 06:07:24 -04:00
langParamsKey := languagesKey + "." + k + "." + paramsKey
2018-11-15 03:28:02 -05:00
l . mergeStringMapKeepLeft ( paramsKey , langParamsKey , v1 , v2 )
2018-03-18 06:07:24 -04:00
}
v2Langs := v2 . GetStringMap ( languagesKey )
2018-10-23 17:18:24 -04:00
for k := range v2Langs {
2018-03-18 06:07:24 -04:00
if k == "" {
continue
}
langParamsKey := languagesKey + "." + k + "." + paramsKey
langParamsThemeNamespace := langParamsKey + "." + themeLower
// Set namespaced params
if v2 . IsSet ( langParamsKey ) && ! v1 . IsSet ( langParamsThemeNamespace ) {
v1 . SetDefault ( langParamsThemeNamespace , v2 . Get ( langParamsKey ) )
}
langMenuKey := languagesKey + "." + k + "." + menuKey
if v2 . IsSet ( langMenuKey ) {
// Only add if not in the main config.
v2menus := v2 . GetStringMap ( langMenuKey )
for k , v := range v2menus {
menuEntry := menuKey + "." + k
menuLangEntry := langMenuKey + "." + k
if ! v1 . IsSet ( menuEntry ) && ! v1 . IsSet ( menuLangEntry ) {
v1 . Set ( menuLangEntry , v )
}
}
}
}
}
// Add menu definitions from theme not found in project
2018-11-15 03:28:02 -05:00
if v2 . IsSet ( menuKey ) {
2018-03-18 06:07:24 -04:00
v2menus := v2 . GetStringMap ( menuKey )
for k , v := range v2menus {
menuEntry := menuKey + "." + k
if ! v1 . IsSet ( menuEntry ) {
v1 . SetDefault ( menuEntry , v )
}
}
}
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
return nil
2018-03-18 06:07:24 -04:00
}
2018-11-15 03:28:02 -05:00
func ( configLoader ) mergeStringMapKeepLeft ( rootKey , key string , v1 , v2 config . Provider ) {
2018-03-18 06:07:24 -04:00
if ! v2 . IsSet ( key ) {
return
}
if ! v1 . IsSet ( key ) && ! ( rootKey != "" && rootKey != key && v1 . IsSet ( rootKey ) ) {
v1 . Set ( key , v2 . Get ( key ) )
return
}
m1 := v1 . GetStringMap ( key )
m2 := v2 . GetStringMap ( key )
for k , v := range m2 {
if _ , found := m1 [ k ] ; ! found {
if rootKey != "" && v1 . IsSet ( rootKey + "." + k ) {
continue
}
m1 [ k ] = v
}
}
}
2017-09-25 02:59:02 -04:00
func loadDefaultSettingsFor ( v * viper . Viper ) error {
2017-02-04 22:20:06 -05:00
2017-09-25 02:59:02 -04:00
c , err := helpers . NewContentSpec ( v )
if err != nil {
return err
}
2017-02-04 22:20:06 -05:00
2018-03-18 05:32:29 -04:00
v . RegisterAlias ( "indexes" , "taxonomies" )
2018-01-10 10:53:40 -05:00
v . SetDefault ( "cleanDestinationDir" , false )
2017-02-04 22:20:06 -05:00
v . SetDefault ( "watch" , false )
v . SetDefault ( "metaDataFormat" , "toml" )
v . SetDefault ( "contentDir" , "content" )
v . SetDefault ( "layoutDir" , "layouts" )
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
v . SetDefault ( "assetDir" , "assets" )
2017-02-04 22:20:06 -05:00
v . SetDefault ( "staticDir" , "static" )
:sparkles: Implement Page bundling and image handling
This commit is not the smallest in Hugo's history.
Some hightlights include:
* Page bundles (for complete articles, keeping images and content together etc.).
* Bundled images can be processed in as many versions/sizes as you need with the three methods `Resize`, `Fill` and `Fit`.
* Processed images are cached inside `resources/_gen/images` (default) in your project.
* Symbolic links (both files and dirs) are now allowed anywhere inside /content
* A new table based build summary
* The "Total in nn ms" now reports the total including the handling of the files inside /static. So if it now reports more than you're used to, it is just **more real** and probably faster than before (see below).
A site building benchmark run compared to `v0.31.1` shows that this should be slightly faster and use less memory:
```bash
▶ ./benchSite.sh "TOML,num_langs=.*,num_root_sections=5,num_pages=(500|1000),tags_per_page=5,shortcodes,render"
benchmark old ns/op new ns/op delta
BenchmarkSiteBuilding/TOML,num_langs=1,num_root_sections=5,num_pages=500,tags_per_page=5,shortcodes,render-4 101785785 78067944 -23.30%
BenchmarkSiteBuilding/TOML,num_langs=1,num_root_sections=5,num_pages=1000,tags_per_page=5,shortcodes,render-4 185481057 149159919 -19.58%
BenchmarkSiteBuilding/TOML,num_langs=3,num_root_sections=5,num_pages=500,tags_per_page=5,shortcodes,render-4 103149918 85679409 -16.94%
BenchmarkSiteBuilding/TOML,num_langs=3,num_root_sections=5,num_pages=1000,tags_per_page=5,shortcodes,render-4 203515478 169208775 -16.86%
benchmark old allocs new allocs delta
BenchmarkSiteBuilding/TOML,num_langs=1,num_root_sections=5,num_pages=500,tags_per_page=5,shortcodes,render-4 532464 391539 -26.47%
BenchmarkSiteBuilding/TOML,num_langs=1,num_root_sections=5,num_pages=1000,tags_per_page=5,shortcodes,render-4 1056549 772702 -26.87%
BenchmarkSiteBuilding/TOML,num_langs=3,num_root_sections=5,num_pages=500,tags_per_page=5,shortcodes,render-4 555974 406630 -26.86%
BenchmarkSiteBuilding/TOML,num_langs=3,num_root_sections=5,num_pages=1000,tags_per_page=5,shortcodes,render-4 1086545 789922 -27.30%
benchmark old bytes new bytes delta
BenchmarkSiteBuilding/TOML,num_langs=1,num_root_sections=5,num_pages=500,tags_per_page=5,shortcodes,render-4 53243246 43598155 -18.12%
BenchmarkSiteBuilding/TOML,num_langs=1,num_root_sections=5,num_pages=1000,tags_per_page=5,shortcodes,render-4 105811617 86087116 -18.64%
BenchmarkSiteBuilding/TOML,num_langs=3,num_root_sections=5,num_pages=500,tags_per_page=5,shortcodes,render-4 54558852 44545097 -18.35%
BenchmarkSiteBuilding/TOML,num_langs=3,num_root_sections=5,num_pages=1000,tags_per_page=5,shortcodes,render-4 106903858 86978413 -18.64%
```
Fixes #3651
Closes #3158
Fixes #1014
Closes #2021
Fixes #1240
Updates #3757
2017-07-24 03:00:23 -04:00
v . SetDefault ( "resourceDir" , "resources" )
2017-02-04 22:20:06 -05:00
v . SetDefault ( "archetypeDir" , "archetypes" )
v . SetDefault ( "publishDir" , "public" )
v . SetDefault ( "dataDir" , "data" )
v . SetDefault ( "i18nDir" , "i18n" )
v . SetDefault ( "themesDir" , "themes" )
v . SetDefault ( "buildDrafts" , false )
v . SetDefault ( "buildFuture" , false )
v . SetDefault ( "buildExpired" , false )
2018-11-15 03:28:02 -05:00
v . SetDefault ( "environment" , hugo . EnvironmentProduction )
2017-02-04 22:20:06 -05:00
v . SetDefault ( "uglyURLs" , false )
v . SetDefault ( "verbose" , false )
v . SetDefault ( "ignoreCache" , false )
v . SetDefault ( "canonifyURLs" , false )
v . SetDefault ( "relativeURLs" , false )
v . SetDefault ( "removePathAccents" , false )
2017-07-30 11:46:04 -04:00
v . SetDefault ( "titleCaseStyle" , "AP" )
2017-02-04 22:20:06 -05:00
v . SetDefault ( "taxonomies" , map [ string ] string { "tag" : "tags" , "category" : "categories" } )
v . SetDefault ( "permalinks" , make ( PermalinkOverrides , 0 ) )
v . SetDefault ( "sitemap" , Sitemap { Priority : - 1 , Filename : "sitemap.xml" } )
v . SetDefault ( "pygmentsStyle" , "monokai" )
v . SetDefault ( "pygmentsUseClasses" , false )
v . SetDefault ( "pygmentsCodeFences" , false )
2017-09-25 02:59:02 -04:00
v . SetDefault ( "pygmentsUseClassic" , false )
2017-02-04 22:20:06 -05:00
v . SetDefault ( "pygmentsOptions" , "" )
v . SetDefault ( "disableLiveReload" , false )
v . SetDefault ( "pluralizeListTitles" , true )
v . SetDefault ( "preserveTaxonomyNames" , false )
v . SetDefault ( "forceSyncStatic" , false )
v . SetDefault ( "footnoteAnchorPrefix" , "" )
v . SetDefault ( "footnoteReturnLinkContents" , "" )
v . SetDefault ( "newContentEditor" , "" )
v . SetDefault ( "paginate" , 10 )
v . SetDefault ( "paginatePath" , "page" )
2017-09-29 03:04:55 -04:00
v . SetDefault ( "summaryLength" , 70 )
Reuse the BlackFriday instance when possible
This is in heavy use in rendering, so this makes a difference:
```bash
benchmark old ns/op new ns/op delta
BenchmarkSiteBuilding/TOML,num_langs=1,num_pages=500,tags_per_page=5,shortcodes,render-4 124551144 107743429 -13.49%
benchmark old allocs new allocs delta
BenchmarkSiteBuilding/TOML,num_langs=1,num_pages=500,tags_per_page=5,shortcodes,render-4 528684 435118 -17.70%
benchmark old bytes new bytes delta
BenchmarkSiteBuilding/TOML,num_langs=1,num_pages=500,tags_per_page=5,shortcodes,render-4 53306848 45147832 -15.31%
```
2017-12-16 12:56:58 -05:00
v . SetDefault ( "blackfriday" , c . BlackFriday )
2017-03-09 19:41:59 -05:00
v . SetDefault ( "rssLimit" , - 1 )
2017-02-04 22:20:06 -05:00
v . SetDefault ( "sectionPagesMenu" , "" )
v . SetDefault ( "disablePathToLower" , false )
v . SetDefault ( "hasCJKLanguage" , false )
v . SetDefault ( "enableEmoji" , false )
v . SetDefault ( "pygmentsCodeFencesGuessSyntax" , false )
v . SetDefault ( "defaultContentLanguage" , "en" )
v . SetDefault ( "defaultContentLanguageInSubdir" , false )
v . SetDefault ( "enableMissingTranslationPlaceholders" , false )
v . SetDefault ( "enableGitInfo" , false )
2017-05-06 03:41:24 -04:00
v . SetDefault ( "ignoreFiles" , make ( [ ] string , 0 ) )
2017-06-20 04:30:40 -04:00
v . SetDefault ( "disableAliases" , false )
2017-07-27 16:36:22 -04:00
v . SetDefault ( "debug" , false )
Only re-render the view(s) you're working on
Hugo already, in its server mode, support partial rebuilds. To put it simply: If you change `about.md`, only that content page is read and processed, then Hugo does some processing (taxonomies etc.) and the full site is rendered.
This commit covers the rendering part: We now only re-render the pages you work on, i.e. the last n pages you watched in the browser (which obviously also includes the page in the example above).
To be more specific: When you are running the hugo server in watch (aka. livereload) mode, and change a template or a content file, then we do a partial re-rendering of the following:
* The current content page (if it is a content change)
* The home page
* Up to the last 10 pages you visited on the site.
This should in most cases be enough, but if you navigate to something completely different, you may see stale content. Doing an edit will then refresh that page.
Note that this feature is enabled by default. To turn it off, run `hugo server --disableFastRender`.
Fixes #3962
See #1643
2017-10-14 07:40:43 -04:00
v . SetDefault ( "disableFastRender" , false )
2018-04-19 12:06:40 -04:00
v . SetDefault ( "timeout" , 10000 ) // 10 seconds
2018-11-26 05:01:27 -05:00
v . SetDefault ( "enableInlineShortcodes" , false )
2018-03-18 06:07:24 -04:00
return nil
2016-08-05 05:04:52 -04:00
}