for _, s := range h.Sites {
for _, p := range s.Pages {
// May have been set in front matter
- if len(p.outputTypes) == 0 {
- p.outputTypes = s.defaultOutputDefinitions.ForKind(p.Kind)
+ if len(p.outputFormats) == 0 {
+ p.outputFormats = s.defaultOutputDefinitions.ForKind(p.Kind)
}
}
s.assembleMenus()
lang string
- // The output types this page will be rendered to.
- outputTypes output.Types
+ // The output formats this page will be rendered to.
+ outputFormats output.Formats
- // This is the PageOutput that represents the first item in outputTypes.
+ // This is the PageOutput that represents the first item in outputFormats.
// Use with care, as there are potential for inifinite loops.
mainPageOutput *PageOutput
return p.extension
}
//
- // TODO(bep) return p.outputType.MediaType.Suffix
+ // TODO(bep) return MediaType.Suffix
// TODO(bep) remove this config option =>
return p.s.Cfg.GetString("defaultExtension")
case "outputs":
outputs := cast.ToStringSlice(v)
if len(outputs) > 0 {
- // Output types are exlicitly set in front matter, use those.
- outTypes, err := output.GetTypes(outputs...)
+ // Output formats are exlicitly set in front matter, use those.
+ outFormats, err := output.GetTypes(outputs...)
if err != nil {
- p.s.Log.ERROR.Printf("Failed to resolve output types: %s", err)
+ p.s.Log.ERROR.Printf("Failed to resolve output formats: %s", err)
} else {
- p.outputTypes = outTypes
- p.Params[loki] = outTypes
+ p.outputFormats = outFormats
+ p.Params[loki] = outFormats
}
}
// Keep this to create URL/path variations, i.e. paginators.
targetPathDescriptor targetPathDescriptor
- outputType output.Type
+ outputFormat output.Format
}
func (p *PageOutput) targetPath(addends ...string) (string, error) {
- tp, err := p.createTargetPath(p.outputType, addends...)
+ tp, err := p.createTargetPath(p.outputFormat, addends...)
if err != nil {
return "", err
}
}
-func newPageOutput(p *Page, createCopy bool, outputType output.Type) (*PageOutput, error) {
+func newPageOutput(p *Page, createCopy bool, f output.Format) (*PageOutput, error) {
if createCopy {
p.initURLs()
p = p.copy()
}
- td, err := p.createTargetPathDescriptor(outputType)
+ td, err := p.createTargetPathDescriptor(f)
if err != nil {
return nil, err
return &PageOutput{
Page: p,
- outputType: outputType,
+ outputFormat: f,
targetPathDescriptor: td,
}, nil
}
// copy creates a copy of this PageOutput with the lazy sync.Once vars reset
// so they will be evaluated again, for word count calculations etc.
func (p *PageOutput) copy() *PageOutput {
- c, err := newPageOutput(p.Page, true, p.outputType)
+ c, err := newPageOutput(p.Page, true, p.outputFormat)
if err != nil {
panic(err)
}
type targetPathDescriptor struct {
PathSpec *helpers.PathSpec
- Type output.Type
+ Type output.Format
Kind string
Sections []string
UglyURLs bool
}
-// createTargetPathDescriptor adapts a Page and the given output.Type into
+// createTargetPathDescriptor adapts a Page and the given output.Format into
// a targetPathDescriptor. This descriptor can then be used to create paths
// and URLs for this Page.
-func (p *Page) createTargetPathDescriptor(t output.Type) (targetPathDescriptor, error) {
+func (p *Page) createTargetPathDescriptor(t output.Format) (targetPathDescriptor, error) {
d := targetPathDescriptor{
PathSpec: p.s.PathSpec,
Type: t,
}
// createTargetPath creates the target filename for this Page for the given
-// output.Type. Some additional URL parts can also be provided, the typical
+// output.Format. Some additional URL parts can also be provided, the typical
// use case being pagination.
-func (p *Page) createTargetPath(t output.Type, addends ...string) (string, error) {
+func (p *Page) createTargetPath(t output.Format, addends ...string) (string, error) {
d, err := p.createTargetPathDescriptor(t)
if err != nil {
return "", nil
func (p *Page) createRelativePermalink() string {
- if len(p.outputTypes) == 0 {
+ if len(p.outputFormats) == 0 {
panic(fmt.Sprintf("Page %q missing output format(s)", p.Title))
}
// Choose the main output format. In most cases, this will be HTML.
- outputType := p.outputTypes[0]
- tp, err := p.createTargetPath(outputType)
+ outFormat := p.outputFormats[0]
+ tp, err := p.createTargetPath(outFormat)
if err != nil {
p.s.Log.ERROR.Printf("Failed to create permalink for page %q: %s", p.FullFilePath(), err)
return ""
}
- tp = strings.TrimSuffix(tp, outputType.BaseFilename())
+ tp = strings.TrimSuffix(tp, outFormat.BaseFilename())
return p.s.PathSpec.URLizeFilename(tp)
}
}
func (s *Site) layouts(p *PageOutput) []string {
- return s.layoutHandler.For(p.layoutIdentifier, "", p.outputType)
+ return s.layoutHandler.For(p.layoutIdentifier, "", p.outputFormat)
}
func (s *Site) preparePages() error {
}
-func (s *Site) renderAndWritePage(tp output.Type, name string, dest string, d interface{}, layouts ...string) error {
+func (s *Site) renderAndWritePage(f output.Format, name string, dest string, d interface{}, layouts ...string) error {
renderBuffer := bp.GetBuffer()
defer bp.PutBuffer(renderBuffer)
}
- if err = w.writeDestPage(tp, dest, outBuffer); err != nil {
+ if err = w.writeDestPage(f, dest, outBuffer); err != nil {
return err
}
Data: make(map[string]interface{}),
Site: &s.Info,
s: s}
- p.outputTypes = p.s.defaultOutputDefinitions.ForKind(typ)
+ p.outputFormats = p.s.defaultOutputDefinitions.ForKind(typ)
p.layoutIdentifier = pageLayoutIdentifier{p}
return p
// Comma separated list (for now).
ExcludedKinds string
- Outputs []output.Type
+ Outputs []output.Format
}
-func (defs siteOutputDefinitions) ForKind(kind string) []output.Type {
- var result []output.Type
+func (defs siteOutputDefinitions) ForKind(kind string) []output.Format {
+ var result []output.Format
for _, def := range defs {
if def.ExcludedKinds == "" || !strings.Contains(def.ExcludedKinds, kind) {
var defs siteOutputDefinitions
// All have HTML
- defs = append(defs, siteOutputDefinition{ExcludedKinds: "", Outputs: []output.Type{output.HTMLType}})
+ defs = append(defs, siteOutputDefinition{ExcludedKinds: "", Outputs: []output.Format{output.HTMLType}})
// TODO(bep) output deprecate rssURI
rssBase := cfg.GetString("rssURI")
rssType.BaseName = rssBase
// Some have RSS
- defs = append(defs, siteOutputDefinition{ExcludedKinds: "page", Outputs: []output.Type{rssType}})
+ defs = append(defs, siteOutputDefinition{ExcludedKinds: "page", Outputs: []output.Format{rssType}})
return defs
}
tests := []struct {
name string
kind string
- want []output.Type
+ want []output.Format
}{
- {"RSS not for regular pages", KindPage, []output.Type{output.HTMLType}},
- {"Home Sweet Home", KindHome, []output.Type{output.HTMLType, output.RSSType}},
+ {"RSS not for regular pages", KindPage, []output.Format{output.HTMLType}},
+ {"Home Sweet Home", KindHome, []output.Format{output.HTMLType, output.RSSType}},
}
for _, tt := range tests {
require.NotNil(t, home)
- require.Len(t, home.outputTypes, 1)
+ require.Len(t, home.outputFormats, 1)
// TODO(bep) output assert template/text
var mainPageOutput *PageOutput
for page := range pages {
- for i, outputType := range page.outputTypes {
- pageOutput, err := newPageOutput(page, i > 0, outputType)
+ for i, outFormat := range page.outputFormats {
+ pageOutput, err := newPageOutput(page, i > 0, outFormat)
if err != nil {
- s.Log.ERROR.Printf("Failed to create output page for type %q for page %q: %s", outputType.Name, page, err)
+ s.Log.ERROR.Printf("Failed to create output page for type %q for page %q: %s", outFormat.Name, page, err)
continue
}
if i == 0 {
layouts = s.layouts(pageOutput)
}
- switch pageOutput.outputType.Name {
+ switch pageOutput.outputFormat.Name {
case "RSS":
if err := s.renderRSS(pageOutput); err != nil {
default:
targetPath, err := pageOutput.targetPath()
if err != nil {
- s.Log.ERROR.Printf("Failed to create target path for output %q for page %q: %s", outputType.Name, page, err)
+ s.Log.ERROR.Printf("Failed to create target path for output %q for page %q: %s", outFormat.Name, page, err)
continue
}
s.Log.DEBUG.Printf("Render %s to %q with layouts %q", pageOutput.Kind, targetPath, layouts)
- if err := s.renderAndWritePage(outputType, "page "+pageOutput.FullFilePath(), targetPath, pageOutput, layouts...); err != nil {
+ if err := s.renderAndWritePage(outFormat, "page "+pageOutput.FullFilePath(), targetPath, pageOutput, layouts...); err != nil {
results <- err
}
addend := fmt.Sprintf("/%s/%d", paginatePath, pageNumber)
targetPath, _ := p.targetPath(addend)
- if err := s.renderAndWritePage(p.outputType, pagerNode.Title,
+ if err := s.renderAndWritePage(p.outputFormat, pagerNode.Title,
targetPath, pagerNode, p.layouts()...); err != nil {
return err
}
)
// We may find some abstractions/interface(s) here once we star with
-// "Multiple Output Types".
+// "Multiple Output Formats".
type siteWriter struct {
langDir string
publishDir string
log *jww.Notepad
}
-func (w siteWriter) targetPathPage(tp output.Type, src string) (string, error) {
- dir, err := w.baseTargetPathPage(tp, src)
+func (w siteWriter) targetPathPage(f output.Format, src string) (string, error) {
+ dir, err := w.baseTargetPathPage(f, src)
if err != nil {
return "", err
}
return dir, nil
}
-func (w siteWriter) baseTargetPathPage(tp output.Type, src string) (string, error) {
+func (w siteWriter) baseTargetPathPage(f output.Format, src string) (string, error) {
if src == helpers.FilePathSeparator {
return "index.html", nil
}
return f[:len(f)-len(ext)]
}
-func (w siteWriter) writeDestPage(tp output.Type, path string, reader io.Reader) error {
+func (w siteWriter) writeDestPage(f output.Format, path string, reader io.Reader) error {
w.log.DEBUG.Println("creating page:", path)
path, _ = w.targetPathFile(path)
// TODO(bep) output remove this file ... targetPath, err := w.targetPathPage(tp, path)
w := siteWriter{log: newErrorLogger(), uglyURLs: true}
tests := []struct {
- outputType output.Type
- content string
- expected string
+ outFormat output.Format
+ content string
+ expected string
}{
{output.HTMLType, "foo.html", "foo.html"},
{output.HTMLType, "/", "index.html"},
}
for i, test := range tests {
- dest, err := w.targetPathPage(test.outputType, filepath.FromSlash(test.content))
+ dest, err := w.targetPathPage(test.outFormat, filepath.FromSlash(test.content))
if err != nil {
t.Fatalf(" [%d] targetPathPage returned an unexpected err: %s", i, err)
}
`
)
-func (l *LayoutHandler) For(id LayoutIdentifier, layoutOverride string, tp Type) []string {
+func (l *LayoutHandler) For(id LayoutIdentifier, layoutOverride string, f Format) []string {
var layouts []string
layout := id.PageLayout()
switch id.PageKind() {
// TODO(bep) move the Kind constants some common place.
case "home":
- layouts = resolveTemplate(layoutsHome, id, tp)
+ layouts = resolveTemplate(layoutsHome, id, f)
case "section":
- layouts = resolveTemplate(layoutsSection, id, tp)
+ layouts = resolveTemplate(layoutsSection, id, f)
case "taxonomy":
- layouts = resolveTemplate(layoutTaxonomy, id, tp)
+ layouts = resolveTemplate(layoutTaxonomy, id, f)
case "taxonomyTerm":
- layouts = resolveTemplate(layoutTaxonomyTerm, id, tp)
+ layouts = resolveTemplate(layoutTaxonomyTerm, id, f)
case "page":
- layouts = regularPageLayouts(id.PageType(), layout, tp)
+ layouts = regularPageLayouts(id.PageType(), layout, f)
}
if l.hasTheme {
return layouts
}
-func resolveTemplate(templ string, id LayoutIdentifier, tp Type) []string {
+func resolveTemplate(templ string, id LayoutIdentifier, f Format) []string {
return strings.Fields(replaceKeyValues(templ,
- "SUFFIX", tp.MediaType.Suffix,
- "NAME", strings.ToLower(tp.Name),
+ "SUFFIX", f.MediaType.Suffix,
+ "NAME", strings.ToLower(f.Name),
"SECTION", id.PageSection()))
}
return replacer.Replace(s)
}
-func regularPageLayouts(types string, layout string, tp Type) (layouts []string) {
+func regularPageLayouts(types string, layout string, f Format) (layouts []string) {
if layout == "" {
layout = "single"
}
- suffix := tp.MediaType.Suffix
- name := strings.ToLower(tp.Name)
+ suffix := f.MediaType.Suffix
+ name := strings.ToLower(f.Name)
if types != "" {
t := strings.Split(types, "/")
return l.pageSection
}
-var ampType = Type{
+var ampType = Format{
Name: "AMP",
MediaType: media.HTMLType,
BaseName: "index",
li testLayoutIdentifier
hasTheme bool
layoutOverride string
- tp Type
+ tp Format
expect []string
}{
{"Home", testLayoutIdentifier{"home", "", "", ""}, true, "", ampType,
--- /dev/null
+// Copyright 2017-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 output
+
+import (
+ "fmt"
+ "strings"
+
+ "github.com/spf13/hugo/media"
+)
+
+var (
+ // An ordered list of built-in output formats
+ // See https://www.ampproject.org/learn/overview/
+ AMPType = Format{
+ Name: "AMP",
+ MediaType: media.HTMLType,
+ BaseName: "index",
+ Path: "amp",
+ }
+
+ CSSType = Format{
+ Name: "CSS",
+ MediaType: media.CSSType,
+ BaseName: "styles",
+ }
+
+ HTMLType = Format{
+ Name: "HTML",
+ MediaType: media.HTMLType,
+ BaseName: "index",
+ }
+
+ JSONType = Format{
+ Name: "JSON",
+ MediaType: media.JSONType,
+ BaseName: "index",
+ IsPlainText: true,
+ }
+
+ RSSType = Format{
+ Name: "RSS",
+ MediaType: media.RSSType,
+ BaseName: "index",
+ NoUgly: true,
+ }
+)
+
+var builtInTypes = map[string]Format{
+ strings.ToLower(AMPType.Name): AMPType,
+ strings.ToLower(CSSType.Name): CSSType,
+ strings.ToLower(HTMLType.Name): HTMLType,
+ strings.ToLower(JSONType.Name): JSONType,
+ strings.ToLower(RSSType.Name): RSSType,
+}
+
+type Formats []Format
+
+// Format represents an output represenation, usually to a file on disk.
+type Format struct {
+ // The Name is used as an identifier. Internal output formats (i.e. HTML and RSS)
+ // can be overridden by providing a new definition for those types.
+ Name string
+
+ MediaType media.Type
+
+ // Must be set to a value when there are two or more conflicting mediatype for the same resource.
+ Path string
+
+ // The base output file name used when not using "ugly URLs", defaults to "index".
+ BaseName string
+
+ // The protocol to use, i.e. "webcal://". Defaults to the protocol of the baseURL.
+ Protocol string
+
+ // IsPlainText decides whether to use text/template or html/template
+ // as template parser.
+ IsPlainText bool
+
+ // Enable to ignore the global uglyURLs setting.
+ NoUgly bool
+}
+
+func GetType(key string) (Format, bool) {
+ found, ok := builtInTypes[key]
+ if !ok {
+ found, ok = builtInTypes[strings.ToLower(key)]
+ }
+ return found, ok
+}
+
+// TODO(bep) outputs rewamp on global config?
+func GetTypes(keys ...string) (Formats, error) {
+ var types []Format
+
+ for _, key := range keys {
+ tpe, ok := GetType(key)
+ if !ok {
+ return types, fmt.Errorf("OutputFormat with key %q not found", key)
+ }
+ types = append(types, tpe)
+ }
+
+ return types, nil
+}
+
+func (t Format) BaseFilename() string {
+ return t.BaseName + "." + t.MediaType.Suffix
+}
--- /dev/null
+// Copyright 2017-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 output
+
+import (
+ "testing"
+
+ "github.com/spf13/hugo/media"
+ "github.com/stretchr/testify/require"
+)
+
+func TestDefaultTypes(t *testing.T) {
+ require.Equal(t, "HTML", HTMLType.Name)
+ require.Equal(t, media.HTMLType, HTMLType.MediaType)
+ require.Empty(t, HTMLType.Path)
+ require.False(t, HTMLType.IsPlainText)
+
+ require.Equal(t, "RSS", RSSType.Name)
+ require.Equal(t, media.RSSType, RSSType.MediaType)
+ require.Empty(t, RSSType.Path)
+ require.False(t, RSSType.IsPlainText)
+ require.True(t, RSSType.NoUgly)
+}
+
+func TestGetType(t *testing.T) {
+ tp, _ := GetType("html")
+ require.Equal(t, HTMLType, tp)
+ tp, _ = GetType("HTML")
+ require.Equal(t, HTMLType, tp)
+ _, found := GetType("FOO")
+ require.False(t, found)
+}
+++ /dev/null
-// Copyright 2017-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 output
-
-import (
- "fmt"
- "strings"
-
- "github.com/spf13/hugo/media"
-)
-
-var (
- // An ordered list of built-in output formats
- // See https://www.ampproject.org/learn/overview/
- AMPType = Type{
- Name: "AMP",
- MediaType: media.HTMLType,
- BaseName: "index",
- Path: "amp",
- }
-
- CSSType = Type{
- Name: "CSS",
- MediaType: media.CSSType,
- BaseName: "styles",
- }
-
- HTMLType = Type{
- Name: "HTML",
- MediaType: media.HTMLType,
- BaseName: "index",
- }
-
- JSONType = Type{
- Name: "JSON",
- MediaType: media.JSONType,
- BaseName: "index",
- IsPlainText: true,
- }
-
- RSSType = Type{
- Name: "RSS",
- MediaType: media.RSSType,
- BaseName: "index",
- NoUgly: true,
- }
-)
-
-var builtInTypes = map[string]Type{
- strings.ToLower(AMPType.Name): AMPType,
- strings.ToLower(CSSType.Name): CSSType,
- strings.ToLower(HTMLType.Name): HTMLType,
- strings.ToLower(JSONType.Name): JSONType,
- strings.ToLower(RSSType.Name): RSSType,
-}
-
-type Types []Type
-
-// Type represents an output represenation, usually to a file on disk.
-type Type struct {
- // The Name is used as an identifier. Internal output types (i.e. HTML and RSS)
- // can be overridden by providing a new definition for those types.
- Name string
-
- MediaType media.Type
-
- // Must be set to a value when there are two or more conflicting mediatype for the same resource.
- Path string
-
- // The base output file name used when not using "ugly URLs", defaults to "index".
- BaseName string
-
- // The protocol to use, i.e. "webcal://". Defaults to the protocol of the baseURL.
- Protocol string
-
- // IsPlainText decides whether to use text/template or html/template
- // as template parser.
- IsPlainText bool
-
- // Enable to ignore the global uglyURLs setting.
- NoUgly bool
-}
-
-func GetType(key string) (Type, bool) {
- found, ok := builtInTypes[key]
- if !ok {
- found, ok = builtInTypes[strings.ToLower(key)]
- }
- return found, ok
-}
-
-// TODO(bep) outputs rewamp on global config?
-func GetTypes(keys ...string) (Types, error) {
- var types []Type
-
- for _, key := range keys {
- tpe, ok := GetType(key)
- if !ok {
- return types, fmt.Errorf("OutputType with key %q not found", key)
- }
- types = append(types, tpe)
- }
-
- return types, nil
-}
-
-func (t Type) BaseFilename() string {
- return t.BaseName + "." + t.MediaType.Suffix
-}
+++ /dev/null
-// Copyright 2017-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 output
-
-import (
- "testing"
-
- "github.com/spf13/hugo/media"
- "github.com/stretchr/testify/require"
-)
-
-func TestDefaultTypes(t *testing.T) {
- require.Equal(t, "HTML", HTMLType.Name)
- require.Equal(t, media.HTMLType, HTMLType.MediaType)
- require.Empty(t, HTMLType.Path)
- require.False(t, HTMLType.IsPlainText)
-
- require.Equal(t, "RSS", RSSType.Name)
- require.Equal(t, media.RSSType, RSSType.MediaType)
- require.Empty(t, RSSType.Path)
- require.False(t, RSSType.IsPlainText)
- require.True(t, RSSType.NoUgly)
-}
-
-func TestGetType(t *testing.T) {
- tp, _ := GetType("html")
- require.Equal(t, HTMLType, tp)
- tp, _ = GetType("HTML")
- require.Equal(t, HTMLType, tp)
- _, found := GetType("FOO")
- require.False(t, found)
-}
projects / brevno-suite / hugo / commitdiff