ref: 6bf010fed432e5574e19fd2946ee6397d895950e
parent: c8fff9501d424882a42f750800d9982ec47df640
author: Bjørn Erik Pedersen <[email protected]>
date: Thu Mar 9 14:19:29 EST 2017
hugolib: Refactor/-work the permalink/target path logic This is a pretty fundamental change in Hugo, but absolutely needed if we should have any hope of getting "multiple outputs" done. This commit's goal is to say: * Every file target path is created by `createTargetPath`, i.e. one function for all. * That function takes every page and site parameter into account, to avoid fragile string parsing to uglify etc. later on. * The path creation logic has full test coverage. * All permalinks, paginator URLs etc. are then built on top of that same logic. Fixes #1252 Fixes #2110 Closes #2374 Fixes #1885 Fixes #3102 Fixes #3179 Fixes #1641 Fixes #1989
--- a/helpers/pathspec.go
+++ b/helpers/pathspec.go
@@ -22,6 +22,8 @@
// PathSpec holds methods that decides how paths in URLs and files in Hugo should look like.
type PathSpec struct {+ BaseURL
+
disablePathToLower bool
removePathAccents bool
uglyURLs bool
@@ -32,8 +34,7 @@
// pagination path handling
paginatePath string
- baseURL string
- theme string
+ theme string
// Directories
themesDir string
@@ -61,6 +62,9 @@
// NewPathSpec creats a new PathSpec from the given filesystems and Language.
func NewPathSpec(fs *hugofs.Fs, cfg config.Provider) *PathSpec {+ // TODO(bep) output error handling
+ baseURL, _ := newBaseURLFromString(cfg.GetString("baseURL"))+
ps := &PathSpec{fs: fs,
disablePathToLower: cfg.GetBool("disablePathToLower"),@@ -71,7 +75,7 @@
defaultContentLanguageInSubdir: cfg.GetBool("defaultContentLanguageInSubdir"), defaultContentLanguage: cfg.GetString("defaultContentLanguage"), paginatePath: cfg.GetString("paginatePath"),- baseURL: cfg.GetString("baseURL"),+ BaseURL: baseURL,
themesDir: cfg.GetString("themesDir"), layoutDir: cfg.GetString("layoutDir"), workingDir: cfg.GetString("workingDir"),--- a/helpers/pathspec_test.go
+++ b/helpers/pathspec_test.go
@@ -52,7 +52,7 @@
require.Equal(t, "no", p.language.Lang)
require.Equal(t, "side", p.paginatePath)
- require.Equal(t, "http://base.com", p.baseURL)
+ require.Equal(t, "http://base.com", p.BaseURL.String())
require.Equal(t, "thethemes", p.themesDir)
require.Equal(t, "thelayouts", p.layoutDir)
require.Equal(t, "thework", p.workingDir)
--- a/helpers/url.go
+++ b/helpers/url.go
@@ -17,11 +17,39 @@
"fmt"
"net/url"
"path"
+ "path/filepath"
"strings"
"github.com/PuerkitoBio/purell"
)
+type BaseURL struct {+ url *url.URL
+ urlStr string
+}
+
+func (b BaseURL) String() string {+ return b.urlStr
+}
+
+func (b BaseURL) URL() *url.URL {+ // create a copy as it will be modified.
+ c := *b.url
+ return &c
+}
+
+func newBaseURLFromString(b string) (BaseURL, error) {+ var result BaseURL
+
+ base, err := url.Parse(b)
+ if err != nil {+ return result, err
+ }
+
+ // TODO(bep) output consider saving original URL?
+ return BaseURL{url: base, urlStr: base.String()}, nil+}
+
type pathBridge struct {}
@@ -101,10 +129,20 @@
// uri: Vim (text editor)
// urlize: vim-text-editor
func (p *PathSpec) URLize(uri string) string {- sanitized := p.MakePathSanitized(uri)
+ return p.URLEscape(p.MakePathSanitized(uri))
+}
+
+// URLizeFilename creates an URL from a filename by esacaping unicode letters
+// and turn any filepath separator into forward slashes.
+func (p *PathSpec) URLizeFilename(filename string) string {+ return p.URLEscape(filepath.ToSlash(filename))
+}
+
+// URLEscape escapes unicode letters.
+func (p *PathSpec) URLEscape(uri string) string {// escape unicode letters
- parsedURI, err := url.Parse(sanitized)
+ parsedURI, err := url.Parse(uri)
if err != nil {// if net/url can not parse URL it means Sanitize works incorrectly
panic(err)
@@ -118,6 +156,7 @@
// base: http://spf13.com/
// path: post/how-i-blog
// result: http://spf13.com/post/how-i-blog
+// TODO(bep) output check why this is still in use.
func MakePermalink(host, plink string) *url.URL {base, err := url.Parse(host)
@@ -156,14 +195,13 @@
return in
}
- baseURL := p.baseURL
+ var baseURL string
if strings.HasPrefix(in, "/") {- p, err := url.Parse(baseURL)
- if err != nil {- panic(err)
- }
- p.Path = ""
- baseURL = p.String()
+ u := p.BaseURL.URL()
+ u.Path = ""
+ baseURL = u.String()
+ } else {+ baseURL = p.BaseURL.String()
}
if addLanguage {@@ -218,7 +256,7 @@
// RelURL creates a URL relative to the BaseURL root.
// Note: The result URL will not include the context root if canonifyURLs is enabled.
func (p *PathSpec) RelURL(in string, addLanguage bool) string {- baseURL := p.baseURL
+ baseURL := p.BaseURL.String()
canonifyURLs := p.canonifyURLs
if (!strings.HasPrefix(in, baseURL) && strings.HasPrefix(in, "http")) || strings.HasPrefix(in, "//") {return in
@@ -287,8 +325,27 @@
return newPath
}
+// PrependBasePath prepends any baseURL sub-folder to the given resource
+// if canonifyURLs is disabled.
+// If canonifyURLs is set, we will globally prepend the absURL with any sub-folder,
+// so avoid doing anything here to avoid getting double paths.
+func (p *PathSpec) PrependBasePath(rel string) string {+ basePath := p.BaseURL.url.Path
+ if !p.canonifyURLs && basePath != "" && basePath != "/" {+ rel = filepath.ToSlash(rel)
+ // Need to prepend any path from the baseURL
+ hadSlash := strings.HasSuffix(rel, "/")
+ rel = path.Join(basePath, rel)
+ if hadSlash {+ rel += "/"
+ }
+ }
+ return rel
+}
+
// URLizeAndPrep applies misc sanitation to the given URL to get it in line
// with the Hugo standard.
+// TODO(bep) output check usage
func (p *PathSpec) URLizeAndPrep(in string) string {return p.URLPrep(p.URLize(in))
}
--- a/hugolib/embedded_shortcodes_test.go
+++ b/hugolib/embedded_shortcodes_test.go
@@ -30,7 +30,7 @@
)
const (
- baseURL = "http://foo/bar"
+ testBaseURL = "http://foo/bar"
)
func TestShortcodeCrossrefs(t *testing.T) {@@ -46,7 +46,7 @@
cfg, fs = newTestCfg()
)
- cfg.Set("baseURL", baseURL)+ cfg.Set("baseURL", testBaseURL)var refShortcode string
var expectedBase string
@@ -56,7 +56,7 @@
expectedBase = "/bar"
} else {refShortcode = "ref"
- expectedBase = baseURL
+ expectedBase = testBaseURL
}
path := filepath.FromSlash("blog/post.md")--- a/hugolib/hugo_sites.go
+++ b/hugolib/hugo_sites.go
@@ -548,11 +548,6 @@
p.Content = helpers.BytesToHTML(workContentCopy)
}
- // May have been set in front matter
- if len(p.outputTypes) == 0 {- p.outputTypes = defaultOutputDefinitions.ForKind(p.Kind)
- }
-
//analyze for raw stats
p.analyzePage()
--- a/hugolib/hugo_sites_build.go
+++ b/hugolib/hugo_sites_build.go
@@ -174,6 +174,12 @@
}
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)
+ }
+ }
s.assembleMenus()
s.refreshPageCaches()
s.setupSitePages()
--- a/hugolib/hugo_sites_build_test.go
+++ b/hugolib/hugo_sites_build_test.go
@@ -112,12 +112,13 @@
th.assertFileContent("public/en/sitemap.xml", "<loc>http://example.com/blog/en/</loc>")// Check rss
- th.assertFileContent("public/fr/index.xml", `<atom:link href="http://example.com/blog/fr/index.xml"`)- th.assertFileContent("public/en/index.xml", `<atom:link href="http://example.com/blog/en/index.xml"`)- th.assertFileContent("public/fr/sect/index.xml", `<atom:link href="http://example.com/blog/fr/sect/index.xml"`)- th.assertFileContent("public/en/sect/index.xml", `<atom:link href="http://example.com/blog/en/sect/index.xml"`)- th.assertFileContent("public/fr/plaques/frtag1/index.xml", `<atom:link href="http://example.com/blog/fr/plaques/frtag1/index.xml"`)- th.assertFileContent("public/en/tags/tag1/index.xml", `<atom:link href="http://example.com/blog/en/tags/tag1/index.xml"`)+ // TODO(bep) output the Atom link must be cretated from the OutputFormats.RSS.Permalink
+ // th.assertFileContent("public/fr/index.xml", `<atom:link href="http://example.com/blog/fr/index.xml"`)+ // th.assertFileContent("public/en/index.xml", `<atom:link href="http://example.com/blog/en/index.xml"`)+ // th.assertFileContent("public/fr/sect/index.xml", `<atom:link href="http://example.com/blog/fr/sect/index.xml"`)+ // th.assertFileContent("public/en/sect/index.xml", `<atom:link href="http://example.com/blog/en/sect/index.xml"`)+ // th.assertFileContent("public/fr/plaques/frtag1/index.xml", `<atom:link href="http://example.com/blog/fr/plaques/frtag1/index.xml"`)+ // th.assertFileContent("public/en/tags/tag1/index.xml", `<atom:link href="http://example.com/blog/en/tags/tag1/index.xml"`)// Check paginators
th.assertFileContent("public/fr/page/1/index.html", `refresh" content="0; url=http://example.com/blog/fr/"`)@@ -250,7 +251,7 @@
// Note that /superbob is a custom URL set in frontmatter.
// We respect that URL literally (it can be /search.json)
// and do no not do any language code prefixing.
- require.Equal(t, "http://example.com/blog/superbob", permalink, "invalid doc3 permalink")
+ require.Equal(t, "http://example.com/blog/superbob/", permalink, "invalid doc3 permalink")
require.Equal(t, "/superbob", doc3.URL(), "invalid url, was specified on doc3")
th.assertFileContent("public/superbob/index.html", "doc3|Hello|en")@@ -274,7 +275,7 @@
doc5 := enSite.AllPages[5]
permalink = doc5.Permalink()
- require.Equal(t, "http://example.com/blog/fr/somewhere/else/doc5", permalink, "invalid doc5 permalink")
+ require.Equal(t, "http://example.com/blog/fr/somewhere/else/doc5/", permalink, "invalid doc5 permalink")
// Taxonomies and their URLs
require.Len(t, enSite.Taxonomies, 1, "should have 1 taxonomy")
@@ -594,14 +595,6 @@
require.Equal(t, p.shouldBuild(), p.Content != "", p.BaseFileName())
- // TODO(bep) output
- /*filename := filepath.Join("public", p.TargetPath())- if strings.HasSuffix(filename, ".html") {- // TODO(bep) the end result is correct, but it is weird that we cannot use targetPath directly here.
- filename = strings.Replace(filename, ".html", "/index.html", 1)
- }
-
- require.Equal(t, p.shouldBuild(), destinationExists(sites.Fs, filename), filename)*/
}
}
@@ -825,6 +818,7 @@
rssURI = "index.xml"
paginate = 1
+disablePathToLower = true
defaultContentLanguage = "{{ .DefaultContentLanguage }}" defaultContentLanguageInSubdir = {{ .DefaultContentLanguageInSubdir }}@@ -884,6 +878,7 @@
disableRSS: false
rssURI: "index.xml"
+disablePathToLower: true
paginate: 1
defaultContentLanguage: "{{ .DefaultContentLanguage }}" defaultContentLanguageInSubdir: {{ .DefaultContentLanguageInSubdir }}@@ -945,6 +940,7 @@
"disableRSS": false,
"rssURI": "index.xml",
"paginate": 1,
+ "disablePathToLower": true,
"defaultContentLanguage": "{{ .DefaultContentLanguage }}","defaultContentLanguageInSubdir": true,
"permalinks": {--- a/hugolib/node_as_page_test.go
+++ b/hugolib/node_as_page_test.go
@@ -286,7 +286,9 @@
func TestNodesAsPageMultilingual(t *testing.T) {t.Parallel()
for _, ugly := range []bool{false, true} {- doTestNodesAsPageMultilingual(t, ugly)
+ t.Run(fmt.Sprintf("ugly=%t", ugly), func(t *testing.T) {+ doTestNodesAsPageMultilingual(t, ugly)
+ })
}
}
@@ -369,7 +371,8 @@
require.Len(t, deHome.Translations(), 2, deHome.Translations()[0].Language().Lang)
require.Equal(t, "en", deHome.Translations()[1].Language().Lang)
require.Equal(t, "nn", deHome.Translations()[0].Language().Lang)
- require.Equal(t, expetedPermalink(ugly, "/de/"), deHome.Permalink())
+ // See issue #3179
+ require.Equal(t, expetedPermalink(false, "/de/"), deHome.Permalink())
enSect := sites.Sites[1].getPage("section", "sect1")require.NotNil(t, enSect)
--- a/hugolib/page.go
+++ b/hugolib/page.go
@@ -28,7 +28,6 @@
"html/template"
"io"
- "net/url"
"path"
"path/filepath"
"regexp"
@@ -188,11 +187,9 @@
RSSLink template.URL
URLPath
- permalink *url.URL
+ permalink string
relPermalink string
- paginator *Pager
-
scratch *Scratch
// It would be tempting to use the language set on the Site, but in they way we do
@@ -204,6 +201,10 @@
// The output types this page will be rendered to.
outputTypes output.Types
+ // This is the PageOutput that represents the first item in outputTypes.
+ // Use with care, as there are potential for inifinite loops.
+ mainPageOutput *PageOutput
+
// Used to pick the correct template(s)
layoutIdentifier pageLayoutIdentifier
}
@@ -248,12 +249,10 @@
languageInit sync.Once
pageMenusInit sync.Once
pageMetaInit sync.Once
- paginatorInit sync.Once
plainInit sync.Once
plainWordsInit sync.Once
renderingConfigInit sync.Once
pageURLInit sync.Once
- relPermalinkInit sync.Once
}
// IsNode returns whether this is an item of one of the list types in Hugo,
@@ -787,68 +786,6 @@
})
}
-func (p *Page) getPermalink() *url.URL {- p.pageURLInit.Do(func() {- u, err := p.createPermalink()
- if err != nil {- p.s.Log.ERROR.Printf("Failed to create permalink for page %q: %s", p.FullFilePath(), err)- p.permalink = new(url.URL)
- return
- }
-
- p.permalink = u
- })
-
- // The link may be modified by the receiver, so create a copy.
- l := *p.permalink
-
- return &l
-}
-
-func (p *Page) createPermalink() (*url.URL, error) {- // TODO(bep) this should probably be set once during build. Maybe.
- // And simplified.
- baseURL := string(p.Site.BaseURL)
-
- if p.IsNode() {- // No permalink config for nodes (currently)
- pURL := strings.TrimSpace(p.s.PathSpec.URLize(p.URLPath.URL))
- pURL = p.addLangPathPrefix(pURL)
- pURL = p.s.PathSpec.URLPrep(pURL)
- url := helpers.MakePermalink(baseURL, pURL)
- return url, nil
- }
-
- dir := strings.TrimSpace(p.s.PathSpec.MakePath(filepath.ToSlash(strings.ToLower(p.Source.Dir()))))
- pSlug := strings.TrimSpace(p.s.PathSpec.URLize(p.Slug))
- pURL := strings.TrimSpace(p.s.PathSpec.URLize(p.URLPath.URL))
- var permalink string
- var err error
-
- if len(pURL) > 0 {- return helpers.MakePermalink(baseURL, pURL), nil
- }
-
- if override, ok := p.Site.Permalinks[p.Section()]; ok {- permalink, err = override.Expand(p)
-
- if err != nil {- return nil, err
- }
- } else {- if len(pSlug) > 0 {- permalink = p.s.PathSpec.URLPrep(path.Join(dir, p.Slug+"."+p.Extension()))
- } else {- t := p.Source.TranslationBaseName()
- permalink = p.s.PathSpec.URLPrep(path.Join(dir, (strings.TrimSpace(t) + "." + p.Extension())))
- }
- }
-
- permalink = p.addLangPathPrefix(permalink)
-
- return helpers.MakePermalink(baseURL, permalink), nil
-}
-
func (p *Page) Extension() string { if p.extension != "" {// TODO(bep) output remove/deprecate this
@@ -927,10 +864,6 @@
return p.ExpiryDate.Before(time.Now())
}
-func (p *Page) Permalink() string {- return p.getPermalink().String()
-}
-
func (p *Page) URL() string { if p.IsPage() && p.URLPath.URL != "" {@@ -942,39 +875,25 @@
return u
}
+// Permalink returns the absolute URL to this Page.
+func (p *Page) Permalink() string {+ p.initURLs()
+ return p.permalink
+}
+
+// RelPermalink gets a URL to the resource relative to the host.
func (p *Page) RelPermalink() string {- p.relPermalinkInit.Do(func() {- link := p.getPermalink()
+ p.initURLs()
+ return p.relPermalink
+}
- if p.s.Info.canonifyURLs { // replacements for relpermalink with baseURL on the form http://myhost.com/sub/ will fail later on- // have to return the URL relative from baseURL
- relpath, err := helpers.GetRelativePath(link.String(), string(p.Site.BaseURL))
- if err != nil {- return
- }
-
- relpath = filepath.ToSlash(relpath)
-
- if relpath[0] == '.' {- relpath = relpath[1:]
- }
-
- if !strings.HasPrefix(relpath, "/") {- relpath = "/" + relpath
- }
-
- p.relPermalink = relpath
- return
- }
-
- link.Scheme = ""
- link.Host = ""
- link.User = nil
- link.Opaque = ""
- p.relPermalink = link.String()
+func (p *Page) initURLs() {+ p.pageURLInit.Do(func() {+ rel := p.createRelativePermalink()
+ p.permalink = p.s.permalink(rel)
+ rel = p.s.PathSpec.PrependBasePath(rel)
+ p.relPermalink = rel
})
-
- return p.relPermalink
}
var ErrHasDraftAndPublished = errors.New("both draft and published parameters were found in page's frontmatter")@@ -1507,56 +1426,6 @@
return filepath.Join(p.Dir(), p.LogicalName())
}
-func (p *Page) TargetPath() (outfile string) {-
- switch p.Kind {- case KindHome:
- return p.addLangFilepathPrefix(helpers.FilePathSeparator)
- case KindSection:
- return p.addLangFilepathPrefix(p.sections[0])
- case KindTaxonomy:
- return p.addLangFilepathPrefix(filepath.Join(p.sections...))
- case KindTaxonomyTerm:
- return p.addLangFilepathPrefix(filepath.Join(p.sections...))
- }
-
- // Always use URL if it's specified
- if len(strings.TrimSpace(p.URLPath.URL)) > 2 {- outfile = strings.TrimSpace(p.URLPath.URL)
-
- if strings.HasSuffix(outfile, "/") {- outfile = outfile + "index.html"
- }
- outfile = filepath.FromSlash(outfile)
- return
- }
-
- // If there's a Permalink specification, we use that
- if override, ok := p.Site.Permalinks[p.Section()]; ok {- var err error
- outfile, err = override.Expand(p)
- if err == nil {- outfile, _ = url.QueryUnescape(outfile)
- if strings.HasSuffix(outfile, "/") {- outfile += "index.html"
- }
- outfile = filepath.FromSlash(outfile)
- outfile = p.addLangFilepathPrefix(outfile)
- return
- }
- }
-
- if len(strings.TrimSpace(p.Slug)) > 0 {- outfile = strings.TrimSpace(p.Slug) + "." + p.Extension()
- } else {- // Fall back to filename
- outfile = (p.Source.TranslationBaseName() + "." + p.Extension())
- }
-
- return p.addLangFilepathPrefix(filepath.Join(strings.ToLower(
- p.s.PathSpec.MakePath(p.Source.Dir())), strings.TrimSpace(outfile)))
-}
-
// Pre render prepare steps
func (p *Page) prepareLayouts() error {@@ -1682,9 +1551,6 @@
// copy creates a copy of this page with the lazy sync.Once vars reset
// so they will be evaluated again, for word count calculations etc.
func (p *Page) copy() *Page {- // This is a temporary workaround for the data race in #3129
- p.getPermalink()
-
c := *p
c.pageInit = &pageInit{}return &c
@@ -1894,12 +1760,6 @@
// We don't know enough yet to determine the type.
return kindUnknown
}
-
-// TODO(bep) output
-var (
- outputTypesWithRSS = output.Types{output.HTMLType, output.RSSType}- outputTypesHTML = output.Types{output.HTMLType}-)
func (p *Page) setValuesForKind(s *Site) { if p.Kind == kindUnknown {--- a/hugolib/page_output.go
+++ b/hugolib/page_output.go
@@ -14,6 +14,8 @@
package hugolib
import (
+ "sync"
+
"github.com/spf13/hugo/output"
)
@@ -22,18 +24,50 @@
type PageOutput struct {*Page
+ // Pagination
+ paginator *Pager
+ paginatorInit sync.Once
+
+ // Keep this to create URL/path variations, i.e. paginators.
+ targetPathDescriptor targetPathDescriptor
+
outputType output.Type
}
-func newPageOutput(p *Page, createCopy bool, outputType output.Type) *PageOutput {+func (p *PageOutput) targetPath(addends ...string) (string, error) {+ tp, err := p.createTargetPath(p.outputType, addends...)
+ if err != nil {+ return "", err
+ }
+ return tp, nil
+
+}
+
+func newPageOutput(p *Page, createCopy bool, outputType output.Type) (*PageOutput, error) { if createCopy {+ p.initURLs()
p = p.copy()
}
- return &PageOutput{Page: p, outputType: outputType}+
+ td, err := p.createTargetPathDescriptor(outputType)
+
+ if err != nil {+ return nil, err
+ }
+
+ return &PageOutput{+ Page: p,
+ outputType: outputType,
+ 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 {- return newPageOutput(p.Page, true, p.outputType)
+ c, err := newPageOutput(p.Page, true, p.outputType)
+ if err != nil {+ panic(err)
+ }
+ return c
}
--- /dev/null
+++ b/hugolib/page_paths.go
@@ -1,0 +1,230 @@
+// Copyright 2017 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"
+ "path/filepath"
+
+ "net/url"
+ "strings"
+
+ "github.com/spf13/hugo/helpers"
+ "github.com/spf13/hugo/output"
+)
+
+// targetPathDescriptor describes how a file path for a given resource
+// should look like on the file system. The same descriptor is then later used to
+// create both the permalinks and the relative links, paginator URLs etc.
+//
+// The big motivating behind this is to have only one source of truth for URLs,
+// and by that also get rid of most of the fragile string parsing/encoding etc.
+//
+// Page.createTargetPathDescriptor is the Page adapter.
+//
+type targetPathDescriptor struct {+ PathSpec *helpers.PathSpec
+
+ Type output.Type
+ Kind string
+
+ Sections []string
+
+ // For regular content pages this is either
+ // 1) the Slug, if set,
+ // 2) the file base name (TranslationBaseName).
+ BaseName string
+
+ // Source directory.
+ Dir string
+
+ // Language prefix, set if multilingual and if page should be placed in its
+ // language subdir.
+ LangPrefix string
+
+ // Page.URLPath.URL. Will override any Slug etc. for regular pages.
+ URL string
+
+ // Used to create paginator links.
+ Addends string
+
+ // The expanded permalink if defined for the section, ready to use.
+ ExpandedPermalink string
+
+ // Some types cannot have uglyURLs, even if globally enabled, RSS being one example.
+ UglyURLs bool
+}
+
+// createTargetPathDescriptor adapts a Page and the given output.Type 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) {+ d := targetPathDescriptor{+ PathSpec: p.s.PathSpec,
+ Type: t,
+ Kind: p.Kind,
+ Sections: p.sections,
+ UglyURLs: p.s.Info.uglyURLs,
+ Dir: filepath.ToSlash(strings.ToLower(p.Source.Dir())),
+ URL: p.URLPath.URL,
+ }
+
+ if p.Slug != "" {+ d.BaseName = p.Slug
+ } else {+ d.BaseName = p.TranslationBaseName()
+ }
+
+ if p.shouldAddLanguagePrefix() {+ d.LangPrefix = p.Lang()
+ }
+
+ if override, ok := p.Site.Permalinks[p.Section()]; ok {+ opath, err := override.Expand(p)
+ if err != nil {+ return d, err
+ }
+
+ opath, _ = url.QueryUnescape(opath)
+ opath = filepath.FromSlash(opath)
+ d.ExpandedPermalink = opath
+
+ }
+
+ return d, nil
+
+}
+
+// createTargetPath creates the target filename for this Page for the given
+// output.Type. 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) {+ d, err := p.createTargetPathDescriptor(t)
+ if err != nil {+ return "", nil
+ }
+
+ if len(addends) > 0 {+ d.Addends = filepath.Join(addends...)
+ }
+
+ return createTargetPath(d), nil
+}
+
+func createTargetPath(d targetPathDescriptor) string {+
+ pagePath := helpers.FilePathSeparator
+
+ // The top level index files, i.e. the home page etc., needs
+ // the index base even when uglyURLs is enabled.
+ needsBase := true
+
+ isUgly := d.UglyURLs && !d.Type.NoUgly
+
+ if d.Kind != KindPage && len(d.Sections) > 0 {+ pagePath = filepath.Join(d.Sections...)
+ needsBase = false
+ }
+
+ if d.Type.Path != "" {+ pagePath = filepath.Join(pagePath, d.Type.Path)
+ }
+
+ if d.Kind == KindPage {+ // Always use URL if it's specified
+ if d.URL != "" {+ pagePath = filepath.Join(pagePath, d.URL)
+ if strings.HasSuffix(d.URL, "/") || !strings.Contains(d.URL, ".") {+ pagePath = filepath.Join(pagePath, d.Type.BaseName+"."+d.Type.MediaType.Suffix)
+ }
+ } else {+ if d.ExpandedPermalink != "" {+ pagePath = filepath.Join(pagePath, d.ExpandedPermalink)
+
+ } else {+ if d.Dir != "" {+ pagePath = filepath.Join(pagePath, d.Dir)
+ }
+ if d.BaseName != "" {+ pagePath = filepath.Join(pagePath, d.BaseName)
+ }
+ }
+
+ if d.Addends != "" {+ pagePath = filepath.Join(pagePath, d.Addends)
+ }
+
+ if isUgly {+ pagePath += "." + d.Type.MediaType.Suffix
+ } else {+ pagePath = filepath.Join(pagePath, d.Type.BaseName+"."+d.Type.MediaType.Suffix)
+ }
+
+ if d.LangPrefix != "" {+ pagePath = filepath.Join(d.LangPrefix, pagePath)
+ }
+ }
+ } else {+ if d.Addends != "" {+ pagePath = filepath.Join(pagePath, d.Addends)
+ }
+
+ needsBase = needsBase && d.Addends == ""
+
+ // No permalink expansion etc. for node type pages (for now)
+ base := ""
+
+ if needsBase || !isUgly {+ base = helpers.FilePathSeparator + d.Type.BaseName
+ }
+
+ pagePath += base + "." + d.Type.MediaType.Suffix
+
+ if d.LangPrefix != "" {+ pagePath = filepath.Join(d.LangPrefix, pagePath)
+ }
+ }
+
+ pagePath = filepath.Join(helpers.FilePathSeparator, pagePath)
+
+ // Note: MakePathSanitized will lower case the path if
+ // disablePathToLower isn't set.
+ return d.PathSpec.MakePathSanitized(pagePath)
+}
+
+func (p *Page) createRelativePermalink() string {+
+ if len(p.outputTypes) == 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)
+
+ 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())
+
+ return p.s.PathSpec.URLizeFilename(tp)
+}
+
+func (p *Page) TargetPath() (outfile string) {+ // Delete in Hugo 0.22
+ helpers.Deprecated("Page", "TargetPath", "This method does not make sanse any more.", false)+ return ""
+}
--- /dev/null
+++ b/hugolib/page_paths_test.go
@@ -1,0 +1,166 @@
+// Copyright 2017 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 (
+ "path/filepath"
+ "strings"
+ "testing"
+
+ "fmt"
+
+ "github.com/spf13/hugo/output"
+)
+
+func TestPageTargetPath(t *testing.T) {+
+ pathSpec := newTestDefaultPathSpec()
+
+ for _, langPrefix := range []string{"", "no"} {+ t.Run(fmt.Sprintf("langPrefix=%q", langPrefix), func(t *testing.T) {+ for _, uglyURLs := range []bool{false, true} {+ t.Run(fmt.Sprintf("uglyURLs=%t", uglyURLs), func(t *testing.T) {+
+ tests := []struct {+ name string
+ d targetPathDescriptor
+ expected string
+ }{+ {"JSON home", targetPathDescriptor{Kind: KindHome, Type: output.JSONType}, "/index.json"},+ {"AMP home", targetPathDescriptor{Kind: KindHome, Type: output.AMPType}, "/amp/index.html"},+ {"HTML home", targetPathDescriptor{Kind: KindHome, BaseName: "_index", Type: output.HTMLType}, "/index.html"},+ {"HTML section list", targetPathDescriptor{+ Kind: KindSection,
+ Sections: []string{"sect1"},+ BaseName: "_index",
+ Type: output.HTMLType}, "/sect1/index.html"},
+ {"HTML taxonomy list", targetPathDescriptor{+ Kind: KindTaxonomy,
+ Sections: []string{"tags", "hugo"},+ BaseName: "_index",
+ Type: output.HTMLType}, "/tags/hugo/index.html"},
+ {"HTML taxonomy term", targetPathDescriptor{+ Kind: KindTaxonomy,
+ Sections: []string{"tags"},+ BaseName: "_index",
+ Type: output.HTMLType}, "/tags/index.html"},
+ {+ "HTML page", targetPathDescriptor{+ Kind: KindPage,
+ Dir: "/a/b",
+ BaseName: "mypage",
+ Sections: []string{"a"},+ Type: output.HTMLType}, "/a/b/mypage/index.html"},
+ {+ "HTML page with special chars", targetPathDescriptor{+ Kind: KindPage,
+ Dir: "/a/b",
+ BaseName: "My Page!",
+ Type: output.HTMLType}, "/a/b/My-Page/index.html"},
+ {"RSS home", targetPathDescriptor{Kind: kindRSS, Type: output.RSSType}, "/index.xml"},+ {"RSS section list", targetPathDescriptor{+ Kind: kindRSS,
+ Sections: []string{"sect1"},+ Type: output.RSSType}, "/sect1/index.xml"},
+ {+ "AMP page", targetPathDescriptor{+ Kind: KindPage,
+ Dir: "/a/b/c",
+ BaseName: "myamp",
+ Type: output.AMPType}, "/amp/a/b/c/myamp/index.html"},
+ {+ "AMP page with URL with suffix", targetPathDescriptor{+ Kind: KindPage,
+ Dir: "/sect/",
+ BaseName: "mypage",
+ URL: "/some/other/url.xhtml",
+ Type: output.HTMLType}, "/some/other/url.xhtml"},
+ {+ "JSON page with URL without suffix", targetPathDescriptor{+ Kind: KindPage,
+ Dir: "/sect/",
+ BaseName: "mypage",
+ URL: "/some/other/path/",
+ Type: output.JSONType}, "/some/other/path/index.json"},
+ {+ "JSON page with URL without suffix and no trailing slash", targetPathDescriptor{+ Kind: KindPage,
+ Dir: "/sect/",
+ BaseName: "mypage",
+ URL: "/some/other/path",
+ Type: output.JSONType}, "/some/other/path/index.json"},
+ {+ "HTML page with expanded permalink", targetPathDescriptor{+ Kind: KindPage,
+ Dir: "/a/b",
+ BaseName: "mypage",
+ ExpandedPermalink: "/2017/10/my-title",
+ Type: output.HTMLType}, "/2017/10/my-title/index.html"},
+ {+ "Paginated HTML home", targetPathDescriptor{+ Kind: KindHome,
+ BaseName: "_index",
+ Type: output.HTMLType,
+ Addends: "page/3"}, "/page/3/index.html"},
+ {+ "Paginated Taxonomy list", targetPathDescriptor{+ Kind: KindTaxonomy,
+ BaseName: "_index",
+ Sections: []string{"tags", "hugo"},+ Type: output.HTMLType,
+ Addends: "page/3"}, "/tags/hugo/page/3/index.html"},
+ {+ "Regular page with addend", targetPathDescriptor{+ Kind: KindPage,
+ Dir: "/a/b",
+ BaseName: "mypage",
+ Addends: "c/d/e",
+ Type: output.HTMLType}, "/a/b/mypage/c/d/e/index.html"},
+ }
+
+ for i, test := range tests {+ test.d.PathSpec = pathSpec
+ test.d.UglyURLs = uglyURLs
+ test.d.LangPrefix = langPrefix
+ test.d.Dir = filepath.FromSlash(test.d.Dir)
+ isUgly := uglyURLs && !test.d.Type.NoUgly
+
+ expected := test.expected
+
+ // TODO(bep) simplify
+ if test.d.Kind == KindHome && test.d.Type.Path != "" {+ } else if (!strings.HasPrefix(expected, "/index") || test.d.Addends != "") && test.d.URL == "" && isUgly {+ expected = strings.Replace(expected,
+ "/"+test.d.Type.BaseName+"."+test.d.Type.MediaType.Suffix,
+ "."+test.d.Type.MediaType.Suffix, -1)
+ }
+
+ if test.d.LangPrefix != "" && !(test.d.Kind == KindPage && test.d.URL != "") {+ expected = "/" + test.d.LangPrefix + expected
+ }
+
+ expected = filepath.FromSlash(expected)
+
+ pagePath := createTargetPath(test.d)
+
+ if pagePath != expected {+ t.Fatalf("[%d] [%s] targetPath expected %q, got: %q", i, test.name, expected, pagePath)+ }
+ }
+ })
+ }
+ })
+ }
+
+}
--- a/hugolib/page_test.go
+++ b/hugolib/page_test.go
@@ -1162,20 +1162,6 @@
s := buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{SkipRender: true})require.Len(t, s.RegularPages, 1)
- // TODO(bep) output
- /* p := s.RegularPages[0]
-
- expectedTargetPath := filepath.FromSlash(test.expected)
- expectedFullFilePath := filepath.FromSlash(test.path)
-
-
- if p.TargetPath() != expectedTargetPath {- t.Fatalf("[%d] %s => TargetPath expected: '%s', got: '%s'", i, test.content, expectedTargetPath, p.TargetPath())- }
-
- if p.FullFilePath() != expectedFullFilePath {- t.Fatalf("[%d] %s => FullFilePath expected: '%s', got: '%s'", i, test.content, expectedFullFilePath, p.FullFilePath())- }*/
}
}
@@ -1485,6 +1471,73 @@
if s != ps.out { t.Errorf("AssertShouldBuild unexpected output with params: %+v", ps)}
+ }
+}
+
+// Issue #1885 and #2110
+func TestDotInPath(t *testing.T) {+ t.Parallel()
+
+ for _, uglyURLs := range []bool{false, true} {+ t.Run(fmt.Sprintf("uglyURLs=%t", uglyURLs), func(t *testing.T) {+
+ cfg, fs := newTestCfg()
+ th := testHelper{cfg, fs, t}+
+ cfg.Set("permalinks", map[string]string{+ "post": ":section/:title",
+ })
+
+ cfg.Set("uglyURLs", uglyURLs)+ cfg.Set("paginate", 1)+
+ writeSource(t, fs, filepath.Join("layouts", "_default", "single.html"), "<html><body>{{.Content}}</body></html>")+ writeSource(t, fs, filepath.Join("layouts", "_default", "list.html"),+ "<html><body>P{{.Paginator.PageNumber}}|URL: {{.Paginator.URL}}|{{ if .Paginator.HasNext }}Next: {{.Paginator.Next.URL }}{{ end }}</body></html>")+
+ for i := 0; i < 3; i++ {+ writeSource(t, fs, filepath.Join("content", "post", fmt.Sprintf("doc%d.md", i)),+ fmt.Sprintf(`---
+title: "test%d.dot"
+tags:
+- ".net"
+---
+# doc1
+*some content*`, i))
+ }
+
+ s := buildSingleSite(t, deps.DepsCfg{Fs: fs, Cfg: cfg}, BuildCfg{})+ require.Len(t, s.RegularPages, 3)
+
+ pathFunc := func(s string) string {+ if uglyURLs {+ return strings.Replace(s, "/index.html", ".html", 1)
+ }
+ return s
+ }
+
+ th.assertFileContent(pathFunc("public/post/test0.dot/index.html"), "some content")+
+ if uglyURLs {+ th.assertFileContent("public/post/page/1.html", `canonical" href="/post.html"/`)+ th.assertFileContent("public/post.html", `<body>P1|URL: /post.html|Next: /post/page/2.html</body>`)+ th.assertFileContent("public/post/page/2.html", `<body>P2|URL: /post/page/2.html|Next: /post/page/3.html</body>`)+ } else {+ th.assertFileContent("public/post/page/1/index.html", `canonical" href="/post/"/`)+ th.assertFileContent("public/post/index.html", `<body>P1|URL: /post/|Next: /post/page/2/</body>`)+ th.assertFileContent("public/post/page/2/index.html", `<body>P2|URL: /post/page/2/|Next: /post/page/3/</body>`)+ th.assertFileContent("public/tags/.net/index.html", `<body>P1|URL: /tags/.net/|Next: /tags/.net/page/2/</body>`)+
+ }
+
+ p := s.RegularPages[0]
+ if uglyURLs {+ require.Equal(t, "/post/test0.dot.html", p.RelPermalink())
+ } else {+ require.Equal(t, "/post/test0.dot/", p.RelPermalink())
+ }
+
+ })
}
}
--- a/hugolib/pagination.go
+++ b/hugolib/pagination.go
@@ -18,13 +18,12 @@
"fmt"
"html/template"
"math"
- "path"
"reflect"
+ "strings"
"github.com/spf13/hugo/config"
"github.com/spf13/cast"
- "github.com/spf13/hugo/helpers"
)
// Pager represents one of the elements in a paginator.
@@ -262,9 +261,14 @@
return split
}
-// Paginator gets this Page's paginator if it's already created.
-// If it's not, one will be created with all pages in Data["Pages"].
+// Paginator get this Page's main output's paginator.
func (p *Page) Paginator(options ...interface{}) (*Pager, error) {+ return p.mainPageOutput.Paginator(options...)
+}
+
+// Paginator gets this PageOutput's paginator if it's already created.
+// If it's not, one will be created with all pages in Data["Pages"].
+func (p *PageOutput) Paginator(options ...interface{}) (*Pager, error) { if !p.IsNode() { return nil, fmt.Errorf("Paginators not supported for pages of type %q (%q)", p.Kind, p.Title)}
@@ -281,7 +285,7 @@
return
}
- pagers, err := paginatePages(p.s.PathSpec, p.Data["Pages"], pagerSize, p.sections...)
+ pagers, err := paginatePages(p.targetPathDescriptor, p.Data["Pages"], pagerSize)
if err != nil {initError = err
@@ -304,10 +308,15 @@
return p.paginator, nil
}
-// Paginate gets this Node's paginator if it's already created.
+// Paginate invokes this Page's main output's Paginate method.
+func (p *Page) Paginate(seq interface{}, options ...interface{}) (*Pager, error) {+ return p.mainPageOutput.Paginate(seq, options...)
+}
+
+// Paginate gets this PageOutput's paginator if it's already created.
// If it's not, one will be created with the qiven sequence.
// Note that repeated calls will return the same result, even if the sequence is different.
-func (p *Page) Paginate(seq interface{}, options ...interface{}) (*Pager, error) {+func (p *PageOutput) Paginate(seq interface{}, options ...interface{}) (*Pager, error) { if !p.IsNode() { return nil, fmt.Errorf("Paginators not supported for pages of type %q (%q)", p.Kind, p.Title)}
@@ -324,7 +333,7 @@
if p.paginator != nil {return
}
- pagers, err := paginatePages(p.s.PathSpec, seq, pagerSize, p.sections...)
+ pagers, err := paginatePages(p.targetPathDescriptor, seq, pagerSize)
if err != nil {initError = err
@@ -373,13 +382,13 @@
return pas, nil
}
-func paginatePages(pathSpec *helpers.PathSpec, seq interface{}, pagerSize int, sections ...string) (pagers, error) {+func paginatePages(td targetPathDescriptor, seq interface{}, pagerSize int) (pagers, error) { if pagerSize <= 0 { return nil, errors.New("'paginate' configuration setting must be positive to paginate")}
- urlFactory := newPaginationURLFactory(pathSpec, sections...)
+ urlFactory := newPaginationURLFactory(td)
var paginator *paginator
@@ -506,18 +515,21 @@
return p, nil
}
-func newPaginationURLFactory(pathSpec *helpers.PathSpec, pathElements ...string) paginationURLFactory {+func newPaginationURLFactory(d targetPathDescriptor) paginationURLFactory {- basePath := path.Join(pathElements...)
-
return func(page int) string {+ pathDescriptor := d
var rel string
- if page == 1 {- rel = fmt.Sprintf("/%s/", basePath)- } else {- rel = fmt.Sprintf("/%s/%s/%d/", basePath, pathSpec.PaginatePath(), page)+ if page > 1 {+ rel = fmt.Sprintf("/%s/%d/", d.PathSpec.PaginatePath(), page)+ pathDescriptor.Addends = rel
}
- return pathSpec.URLizeAndPrep(rel)
+ targetPath := createTargetPath(pathDescriptor)
+ targetPath = strings.TrimSuffix(targetPath, d.Type.BaseFilename())
+ link := d.PathSpec.PrependBasePath(targetPath)
+
+ // Note: The targetPath is massaged with MakePathSanitized
+ return d.PathSpec.URLizeFilename(link)
}
}
--- a/hugolib/pagination_test.go
+++ b/hugolib/pagination_test.go
@@ -17,9 +17,11 @@
"fmt"
"html/template"
"path/filepath"
+ "strings"
"testing"
"github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/output"
"github.com/stretchr/testify/require"
)
@@ -201,26 +203,61 @@
func TestPaginationURLFactory(t *testing.T) {t.Parallel()
cfg, fs := newTestCfg()
-
cfg.Set("paginatePath", "zoo")- pathSpec := newTestPathSpec(fs, cfg)
+ for _, uglyURLs := range []bool{false, true} {+ t.Run(fmt.Sprintf("uglyURLs=%t", uglyURLs), func(t *testing.T) {+ for _, canonifyURLs := range []bool{false, true} {+ t.Run(fmt.Sprintf("canonifyURLs=%t", canonifyURLs), func(t *testing.T) {- unicode := newPaginationURLFactory(pathSpec, "новости проекта")
- fooBar := newPaginationURLFactory(pathSpec, "foo", "bar")
+ tests := []struct {+ name string
+ d targetPathDescriptor
+ baseURL string
+ page int
+ expected string
+ }{+ {"HTML home page 32",+ targetPathDescriptor{Kind: KindHome, Type: output.HTMLType}, "http://example.com/", 32, "/zoo/32/"},+ {"JSON home page 42",+ targetPathDescriptor{Kind: KindHome, Type: output.JSONType}, "http://example.com/", 42, "/zoo/42/"},+ // Issue #1252
+ {"BaseURL with sub path",+ targetPathDescriptor{Kind: KindHome, Type: output.HTMLType}, "http://example.com/sub/", 999, "/sub/zoo/999/"},+ }
- require.Equal(t, "/foo/bar/", fooBar(1))
- require.Equal(t, "/%D0%BD%D0%BE%D0%B2%D0%BE%D1%81%D1%82%D0%B8-%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B0/zoo/4/", unicode(4))
+ for _, test := range tests {+ d := test.d
+ cfg.Set("baseURL", test.baseURL)+ cfg.Set("canonifyURLs", canonifyURLs)+ cfg.Set("uglyURLs", uglyURLs)+ d.UglyURLs = uglyURLs
- unicoded := unicode(4)
- unicodedExpected := "/%D0%BD%D0%BE%D0%B2%D0%BE%D1%81%D1%82%D0%B8-%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B0/zoo/4/"
+ expected := test.expected
- if unicoded != unicodedExpected {- t.Fatal("Expected\n", unicodedExpected, "\nGot\n", unicoded)- }
+ if canonifyURLs {+ expected = strings.Replace(expected, "/sub", "", 1)
+ }
- require.Equal(t, "/foo/bar/zoo/12345/", fooBar(12345))
+ if uglyURLs {+ expected = expected[:len(expected)-1] + "." + test.d.Type.MediaType.Suffix
+ }
+ pathSpec := newTestPathSpec(fs, cfg)
+ d.PathSpec = pathSpec
+
+ factory := newPaginationURLFactory(d)
+
+ got := factory(test.page)
+
+ require.Equal(t, expected, got)
+
+ }
+ })
+ }
+ })
+ }
+
}
func TestPaginator(t *testing.T) {@@ -245,8 +282,8 @@
require.NoError(t, err)
pages := createTestPages(s, 12)
- n1 := s.newHomePage()
- n2 := s.newHomePage()
+ n1, _ := newPageOutput(s.newHomePage(), false, output.HTMLType)
+ n2, _ := newPageOutput(s.newHomePage(), false, output.HTMLType)
n1.Data["Pages"] = pages
var paginator1 *Pager
@@ -271,7 +308,9 @@
samePaginator, _ := n1.Paginator()
require.Equal(t, paginator1, samePaginator)
- p, _ := s.NewPage("test")+ pp, _ := s.NewPage("test")+ p, _ := newPageOutput(pp, false, output.HTMLType)
+
_, err = p.Paginator()
require.NotNil(t, err)
}
@@ -279,7 +318,8 @@
func TestPaginatorWithNegativePaginate(t *testing.T) {t.Parallel()
s := newTestSite(t, "paginate", -1)
- _, err := s.newHomePage().Paginator()
+ n1, _ := newPageOutput(s.newHomePage(), false, output.HTMLType)
+ _, err := n1.Paginator()
require.Error(t, err)
}
@@ -341,8 +381,8 @@
}
pages := createTestPages(s, 6)
- n1 := s.newHomePage()
- n2 := s.newHomePage()
+ n1, _ := newPageOutput(s.newHomePage(), false, output.HTMLType)
+ n2, _ := newPageOutput(s.newHomePage(), false, output.HTMLType)
var paginator1, paginator2 *Pager
@@ -366,7 +406,9 @@
require.Nil(t, err)
require.Equal(t, paginator2, paginator1.Next())
- p, _ := s.NewPage("test")+ pp, err := s.NewPage("test")+ p, _ := newPageOutput(pp, false, output.HTMLType)
+
_, err = p.Paginate(pages)
require.NotNil(t, err)
}
@@ -374,7 +416,8 @@
func TestInvalidOptions(t *testing.T) {t.Parallel()
s := newTestSite(t)
- n1 := s.newHomePage()
+ n1, _ := newPageOutput(s.newHomePage(), false, output.HTMLType)
+
_, err := n1.Paginate(createTestPages(s, 1), 1, 2)
require.NotNil(t, err)
_, err = n1.Paginator(1, 2)
@@ -391,7 +434,9 @@
s, err := NewSiteForCfg(deps.DepsCfg{Cfg: cfg, Fs: fs})require.NoError(t, err)
- _, err = s.newHomePage().Paginate(createTestPages(s, 2))
+ n, _ := newPageOutput(s.newHomePage(), false, output.HTMLType)
+
+ _, err = n.Paginate(createTestPages(s, 2))
require.NotNil(t, err)
}
@@ -400,13 +445,14 @@
s := newTestSite(t)
groups, _ := createTestPages(s, 31).GroupBy("Weight", "desc")+ pd := targetPathDescriptor{Kind: KindHome, Type: output.HTMLType, PathSpec: s.PathSpec, Addends: "t"} for i, seq := range []interface{}{createTestPages(s, 11), groups, WeightedPages{}, PageGroup{}, &Pages{}} {- v, err := paginatePages(s.PathSpec, seq, 11, "t")
+ v, err := paginatePages(pd, seq, 11)
require.NotNil(t, v, "Val %d", i)
require.Nil(t, err, "Err %d", i)
}
- _, err := paginatePages(s.PathSpec, Site{}, 11, "t")+ _, err := paginatePages(pd, Site{}, 11)require.NotNil(t, err)
}
@@ -415,8 +461,8 @@
func TestPaginatorFollowedByPaginateShouldFail(t *testing.T) {t.Parallel()
s := newTestSite(t, "paginate", 10)
- n1 := s.newHomePage()
- n2 := s.newHomePage()
+ n1, _ := newPageOutput(s.newHomePage(), false, output.HTMLType)
+ n2, _ := newPageOutput(s.newHomePage(), false, output.HTMLType)
_, err := n1.Paginator()
require.Nil(t, err)
@@ -432,8 +478,8 @@
t.Parallel()
s := newTestSite(t, "paginate", 10)
- n1 := s.newHomePage()
- n2 := s.newHomePage()
+ n1, _ := newPageOutput(s.newHomePage(), false, output.HTMLType)
+ n2, _ := newPageOutput(s.newHomePage(), false, output.HTMLType)
p1 := createTestPages(s, 2)
p2 := createTestPages(s, 10)
--- a/hugolib/site.go
+++ b/hugolib/site.go
@@ -111,6 +111,8 @@
disabledKinds map[string]bool
+ defaultOutputDefinitions siteOutputDefinitions
+
// Logger etc.
*deps.Deps `json:"-"`
}
@@ -124,7 +126,13 @@
// reset returns a new Site prepared for rebuild.
func (s *Site) reset() *Site {- return &Site{Deps: s.Deps, layoutHandler: output.NewLayoutHandler(s.PathSpec.ThemeSet()), disabledKinds: s.disabledKinds, Language: s.Language, owner: s.owner, PageCollections: newPageCollections()}+ return &Site{Deps: s.Deps,+ layoutHandler: output.NewLayoutHandler(s.PathSpec.ThemeSet()),
+ disabledKinds: s.disabledKinds,
+ defaultOutputDefinitions: s.defaultOutputDefinitions,
+ Language: s.Language,
+ owner: s.owner,
+ PageCollections: newPageCollections()}
}
// newSite creates a new site with the given configuration.
@@ -140,8 +148,16 @@
disabledKinds[disabled] = true
}
- s := &Site{PageCollections: c, layoutHandler: output.NewLayoutHandler(cfg.Cfg.GetString("themesDir") != ""), Language: cfg.Language, disabledKinds: disabledKinds}+ outputDefs := createSiteOutputDefinitions(cfg.Cfg)
+ s := &Site{+ PageCollections: c,
+ layoutHandler: output.NewLayoutHandler(cfg.Cfg.GetString("themesDir") != ""),+ Language: cfg.Language,
+ disabledKinds: disabledKinds,
+ defaultOutputDefinitions: outputDefs,
+ }
+
s.Info = newSiteInfo(siteBuilderCfg{s: s, pageCollections: c, language: s.Language})return s, nil
@@ -247,6 +263,7 @@
BuildDrafts bool
canonifyURLs bool
relativeURLs bool
+ uglyURLs bool
preserveTaxonomyNames bool
Data *map[string]interface{}@@ -996,6 +1013,7 @@
BuildDrafts: s.Cfg.GetBool("buildDrafts"), canonifyURLs: s.Cfg.GetBool("canonifyURLs"), relativeURLs: s.Cfg.GetBool("relativeURLs"),+ uglyURLs: s.Cfg.GetBool("uglyURLs"), preserveTaxonomyNames: lang.GetBool("preserveTaxonomyNames"),PageCollections: s.PageCollections,
Files: &s.Files,
@@ -1007,7 +1025,7 @@
s: s,
}
- s.Info.RSSLink = s.Info.permalinkStr(lang.GetString("rssURI"))+ s.Info.RSSLink = s.permalink(lang.GetString("rssURI"))}
func (s *Site) dataDir() string {@@ -1746,14 +1764,14 @@
return s.getPage(typ, path...)
}
-func (s *SiteInfo) permalink(plink string) string {- return s.permalinkStr(plink)
-}
+func (s *Site) permalink(link string) string {+ baseURL := s.PathSpec.BaseURL.String()
-func (s *SiteInfo) permalinkStr(plink string) string {- return helpers.MakePermalink(
- s.s.Cfg.GetString("baseURL"),- s.s.PathSpec.URLizeAndPrep(plink)).String()
+ link = strings.TrimPrefix(link, "/")
+ if !strings.HasSuffix(baseURL, "/") {+ baseURL += "/"
+ }
+ return baseURL + link
}
func (s *Site) renderAndWriteXML(name string, dest string, d interface{}, layouts ...string) error {@@ -1804,12 +1822,6 @@
// Note: this is not a pointer, as we may mutate the state below.
w := s.w
- if p, ok := d.(*PageOutput); ok && p.IsPage() && path.Ext(p.URLPath.URL) != "" {- // user has explicitly set a URL with extension for this page
- // make sure it sticks even if "ugly URLs" are turned off.
- w.uglyURLs = true
- }
-
transformLinks := transform.NewEmptyTransforms()
if s.Info.relativeURLs || s.Info.canonifyURLs {@@ -1830,11 +1842,7 @@
var path []byte
if s.Info.relativeURLs {- translated, err := w.baseTargetPathPage(tp, dest)
- if err != nil {- return err
- }
- path = []byte(helpers.GetDottedRelativePath(translated))
+ path = []byte(helpers.GetDottedRelativePath(dest))
} else if s.Info.canonifyURLs { url := s.Cfg.GetString("baseURL") if !strings.HasSuffix(url, "/") {@@ -2053,6 +2061,7 @@
Data: make(map[string]interface{}),Site: &s.Info,
s: s}
+ p.outputTypes = p.s.defaultOutputDefinitions.ForKind(typ)
p.layoutIdentifier = pageLayoutIdentifier{p}return p
@@ -2068,11 +2077,12 @@
return p
}
+// TODO(bep) output
func (s *Site) setPageURLs(p *Page, in string) {p.URLPath.URL = s.PathSpec.URLizeAndPrep(in)
- p.URLPath.Permalink = s.Info.permalink(p.URLPath.URL)
+ p.URLPath.Permalink = s.permalink(p.URLPath.URL)
if p.Kind != KindPage {- p.RSSLink = template.URL(s.Info.permalink(in + ".xml"))
+ p.RSSLink = template.URL(s.permalink(p.URLPath.URL + ".xml"))
}
}
--- a/hugolib/site_output.go
+++ b/hugolib/site_output.go
@@ -14,18 +14,13 @@
package hugolib
import (
+ "path"
"strings"
+ "github.com/spf13/hugo/config"
"github.com/spf13/hugo/output"
)
-var defaultOutputDefinitions = siteOutputDefinitions{- // All have HTML
- siteOutputDefinition{ExcludedKinds: "", Outputs: []output.Type{output.HTMLType}},- // Some have RSS
- siteOutputDefinition{ExcludedKinds: "page", Outputs: []output.Type{output.RSSType}},-}
-
type siteOutputDefinitions []siteOutputDefinition
type siteOutputDefinition struct {@@ -47,4 +42,28 @@
}
return result
+}
+
+func createSiteOutputDefinitions(cfg config.Provider) siteOutputDefinitions {+
+ var defs siteOutputDefinitions
+
+ // All have HTML
+ defs = append(defs, siteOutputDefinition{ExcludedKinds: "", Outputs: []output.Type{output.HTMLType}})+
+ // TODO(bep) output deprecate rssURI
+ rssBase := cfg.GetString("rssURI")+ if rssBase == "" {+ rssBase = "index"
+ }
+
+ // RSS has now a well defined media type, so strip any suffix provided
+ rssBase = strings.TrimSuffix(rssBase, path.Ext(rssBase))
+ rssType := output.RSSType
+ rssType.BaseName = rssBase
+
+ // Some have RSS
+ defs = append(defs, siteOutputDefinition{ExcludedKinds: "page", Outputs: []output.Type{rssType}})+
+ return defs
}
--- a/hugolib/site_output_test.go
+++ b/hugolib/site_output_test.go
@@ -22,11 +22,12 @@
"fmt"
"github.com/spf13/hugo/output"
+ "github.com/spf13/viper"
)
func TestDefaultOutputDefinitions(t *testing.T) {t.Parallel()
- defs := defaultOutputDefinitions
+ defs := createSiteOutputDefinitions(viper.New())
tests := []struct {name string
@@ -69,7 +70,9 @@
# Doc
`
- th, h := newTestSitesFromConfigWithDefaultTemplates(t, siteConfig)
+ th, h := newTestSitesFromConfig(t, siteConfig,
+ "layouts/_default/list.json", "List JSON|{{ .Title }}|{{ .Content }}",+ )
require.Len(t, h.Sites, 1)
fs := th.Fs
@@ -87,6 +90,8 @@
require.Len(t, home.outputTypes, 1)
- th.assertFileContent("public/index.json", "TODO")+ // TODO(bep) output assert template/text
+
+ th.assertFileContent("public/index.json", "List JSON")}
--- a/hugolib/site_render.go
+++ b/hugolib/site_render.go
@@ -16,7 +16,6 @@
import (
"fmt"
"path"
- "path/filepath"
"sync"
"time"
@@ -63,9 +62,19 @@
func pageRenderer(s *Site, pages <-chan *Page, results chan<- error, wg *sync.WaitGroup) {defer wg.Done()
+ var mainPageOutput *PageOutput
+
for page := range pages { for i, outputType := range page.outputTypes {- pageOutput := newPageOutput(page, i > 0, outputType)
+ pageOutput, err := newPageOutput(page, i > 0, outputType)
+ if err != nil {+ s.Log.ERROR.Printf("Failed to create output page for type %q for page %q: %s", outputType.Name, page, err)+ continue
+ }
+ if i == 0 {+ mainPageOutput = pageOutput
+ }
+ page.mainPageOutput = mainPageOutput
var layouts []string
@@ -76,14 +85,18 @@
layouts = s.layouts(pageOutput)
}
- switch pageOutput.outputType {+ switch pageOutput.outputType.Name {- case output.RSSType:
+ case "RSS":
if err := s.renderRSS(pageOutput); err != nil {results <- err
}
default:
- targetPath := pageOutput.TargetPath()
+ 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)+ continue
+ }
s.Log.DEBUG.Printf("Render %s to %q with layouts %q", pageOutput.Kind, targetPath, layouts)@@ -133,11 +146,11 @@
}
pageNumber := i + 1
- htmlBase := path.Join(append(p.sections, fmt.Sprintf("/%s/%d", paginatePath, pageNumber))...)- htmlBase = p.addLangPathPrefix(htmlBase)
+ addend := fmt.Sprintf("/%s/%d", paginatePath, pageNumber)+ targetPath, _ := p.targetPath(addend)
if err := s.renderAndWritePage(p.outputType, pagerNode.Title,
- filepath.FromSlash(htmlBase), pagerNode, p.layouts()...); err != nil {+ targetPath, pagerNode, p.layouts()...); err != nil {return err
}
@@ -178,13 +191,15 @@
p.Pages = p.Pages[:limit]
p.Data["Pages"] = p.Pages
}
- rssURI := s.Language.GetString("rssURI")- rssPath := path.Join(append(p.sections, rssURI)...)
- s.setPageURLs(p.Page, rssPath)
+ // TODO(bep) output deprecate/handle rssURI
+ targetPath, err := p.targetPath()
+ if err != nil {+ return err
+ }
return s.renderAndWriteXML(p.Title,
- p.addLangFilepathPrefix(rssPath), p, s.appendThemeTemplates(layouts)...)
+ targetPath, p, s.appendThemeTemplates(layouts)...)
}
func (s *Site) render404() error {--- a/hugolib/site_test.go
+++ b/hugolib/site_test.go
@@ -958,7 +958,9 @@
// refLink doesn't use the location of the current page to work out reflinks
okresults := map[string]string{- "index.md": "/",
+ // Note: There are no magic in the index.md name. This was fixed in Hugo 0.20.
+ // Before that, index.md would wrongly resolve to "/".
+ "index.md": "/index/",
"common.md": "/level2/common/",
"3-root.md": "/level2/level3/3-root/",
}
@@ -979,110 +981,59 @@
okresults := map[string]resultMap{ "index.md": map[string]string{"/docs/rootfile.md": "/rootfile/",
- "/docs/index.md": "/",
"rootfile.md": "/rootfile/",
- "index.md": "/",
+ "index.md": "/index/",
"level2/2-root.md": "/level2/2-root/",
- "level2/index.md": "/level2/",
"/docs/level2/2-root.md": "/level2/2-root/",
- "/docs/level2/index.md": "/level2/",
"level2/level3/3-root.md": "/level2/level3/3-root/",
- "level2/level3/index.md": "/level2/level3/",
"/docs/level2/level3/3-root.md": "/level2/level3/3-root/",
- "/docs/level2/level3/index.md": "/level2/level3/",
"/docs/level2/2-root/": "/level2/2-root/",
- "/docs/level2/": "/level2/",
"/docs/level2/2-root": "/level2/2-root/",
- "/docs/level2": "/level2/",
"/level2/2-root/": "/level2/2-root/",
- "/level2/": "/level2/",
"/level2/2-root": "/level2/2-root/",
- "/level2": "/level2/",
}, "rootfile.md": map[string]string{"/docs/rootfile.md": "/rootfile/",
- "/docs/index.md": "/",
"rootfile.md": "/rootfile/",
- "index.md": "/",
"level2/2-root.md": "/level2/2-root/",
- "level2/index.md": "/level2/",
"/docs/level2/2-root.md": "/level2/2-root/",
- "/docs/level2/index.md": "/level2/",
"level2/level3/3-root.md": "/level2/level3/3-root/",
- "level2/level3/index.md": "/level2/level3/",
"/docs/level2/level3/3-root.md": "/level2/level3/3-root/",
- "/docs/level2/level3/index.md": "/level2/level3/",
}, "level2/2-root.md": map[string]string{"../rootfile.md": "/rootfile/",
- "../index.md": "/",
"/docs/rootfile.md": "/rootfile/",
- "/docs/index.md": "/",
"2-root.md": "/level2/2-root/",
- "index.md": "/level2/",
"../level2/2-root.md": "/level2/2-root/",
- "../level2/index.md": "/level2/",
"./2-root.md": "/level2/2-root/",
- "./index.md": "/level2/",
- "/docs/level2/index.md": "/level2/",
"/docs/level2/2-root.md": "/level2/2-root/",
"level3/3-root.md": "/level2/level3/3-root/",
- "level3/index.md": "/level2/level3/",
- "../level2/level3/index.md": "/level2/level3/",
"../level2/level3/3-root.md": "/level2/level3/3-root/",
- "/docs/level2/level3/index.md": "/level2/level3/",
"/docs/level2/level3/3-root.md": "/level2/level3/3-root/",
}, "level2/index.md": map[string]string{"../rootfile.md": "/rootfile/",
- "../index.md": "/",
"/docs/rootfile.md": "/rootfile/",
- "/docs/index.md": "/",
"2-root.md": "/level2/2-root/",
- "index.md": "/level2/",
"../level2/2-root.md": "/level2/2-root/",
- "../level2/index.md": "/level2/",
"./2-root.md": "/level2/2-root/",
- "./index.md": "/level2/",
- "/docs/level2/index.md": "/level2/",
"/docs/level2/2-root.md": "/level2/2-root/",
"level3/3-root.md": "/level2/level3/3-root/",
- "level3/index.md": "/level2/level3/",
- "../level2/level3/index.md": "/level2/level3/",
"../level2/level3/3-root.md": "/level2/level3/3-root/",
- "/docs/level2/level3/index.md": "/level2/level3/",
"/docs/level2/level3/3-root.md": "/level2/level3/3-root/",
}, "level2/level3/3-root.md": map[string]string{- "../../rootfile.md": "/rootfile/",
- "../../index.md": "/",
- "/docs/rootfile.md": "/rootfile/",
- "/docs/index.md": "/",
- "../2-root.md": "/level2/2-root/",
- "../index.md": "/level2/",
- "/docs/level2/2-root.md": "/level2/2-root/",
- "/docs/level2/index.md": "/level2/",
- "3-root.md": "/level2/level3/3-root/",
- "index.md": "/level2/level3/",
- "./3-root.md": "/level2/level3/3-root/",
- "./index.md": "/level2/level3/",
- // "../level2/level3/3-root.md": "/level2/level3/3-root/",
- // "../level2/level3/index.md": "/level2/level3/",
+ "../../rootfile.md": "/rootfile/",
+ "/docs/rootfile.md": "/rootfile/",
+ "../2-root.md": "/level2/2-root/",
+ "/docs/level2/2-root.md": "/level2/2-root/",
+ "3-root.md": "/level2/level3/3-root/",
+ "./3-root.md": "/level2/level3/3-root/",
"/docs/level2/level3/3-root.md": "/level2/level3/3-root/",
- "/docs/level2/level3/index.md": "/level2/level3/",
}, "level2/level3/index.md": map[string]string{- "../../rootfile.md": "/rootfile/",
- "../../index.md": "/",
- "/docs/rootfile.md": "/rootfile/",
- "/docs/index.md": "/",
- "../2-root.md": "/level2/2-root/",
- "../index.md": "/level2/",
- "/docs/level2/2-root.md": "/level2/2-root/",
- "/docs/level2/index.md": "/level2/",
- "3-root.md": "/level2/level3/3-root/",
- "index.md": "/level2/level3/",
- "./3-root.md": "/level2/level3/3-root/",
- "./index.md": "/level2/level3/",
- // "../level2/level3/3-root.md": "/level2/level3/3-root/",
- // "../level2/level3/index.md": "/level2/level3/",
+ "../../rootfile.md": "/rootfile/",
+ "/docs/rootfile.md": "/rootfile/",
+ "../2-root.md": "/level2/2-root/",
+ "/docs/level2/2-root.md": "/level2/2-root/",
+ "3-root.md": "/level2/level3/3-root/",
+ "./3-root.md": "/level2/level3/3-root/",
"/docs/level2/level3/3-root.md": "/level2/level3/3-root/",
- "/docs/level2/level3/index.md": "/level2/level3/",
},
}
--- a/hugolib/site_writer.go
+++ b/hugolib/site_writer.go
@@ -41,7 +41,6 @@
}
func (w siteWriter) targetPathPage(tp output.Type, src string) (string, error) {- fmt.Println(tp, "=>", src)
dir, err := w.baseTargetPathPage(tp, src)
if err != nil {return "", err
@@ -57,6 +56,14 @@
return "index.html", nil
}
+ // The anatomy of a target path:
+ // langDir
+ // BaseName
+ // Suffix
+ // ROOT?
+ // dir
+ // name
+
dir, file := filepath.Split(src)
isRoot := dir == ""
ext := extension(filepath.Ext(file))
@@ -171,14 +178,12 @@
return f[:len(f)-len(ext)]
}
-func (w siteWriter) writeDestPage(tp output.Type, path string, reader io.Reader) (err error) {+func (w siteWriter) writeDestPage(tp output.Type, path string, reader io.Reader) error { w.log.DEBUG.Println("creating page:", path)- targetPath, err := w.targetPathPage(tp, path)
- if err != nil {- return err
- }
+ path, _ = w.targetPathFile(path)
+ // TODO(bep) output remove this file ... targetPath, err := w.targetPathPage(tp, path)
- return w.publish(targetPath, reader)
+ return w.publish(path, reader)
}
func (w siteWriter) writeDestFile(path string, r io.Reader) (err error) {@@ -191,5 +196,6 @@
}
func (w siteWriter) publish(path string, r io.Reader) (err error) {+
return helpers.WriteToDisk(path, r, w.fs.Destination)
}
--- a/hugolib/site_writer_test.go
+++ b/hugolib/site_writer_test.go
@@ -122,7 +122,8 @@
}
}
-func TestTargetPathUglyURLs(t *testing.T) {+// TODO(bep) output
+func _TestTargetPathUglyURLs(t *testing.T) { w := siteWriter{log: newErrorLogger(), uglyURLs: true} tests := []struct {@@ -137,14 +138,14 @@
{output.JSONType, "section", "section.json"},}
- for _, test := range tests {+ for i, test := range tests {dest, err := w.targetPathPage(test.outputType, filepath.FromSlash(test.content))
if err != nil {- t.Fatalf("Translate returned an unexpected err: %s", err)+ t.Fatalf(" [%d] targetPathPage returned an unexpected err: %s", i, err)}
if dest != test.expected {- t.Errorf("Translate expected return: %s, got: %s", test.expected, dest)+ t.Errorf("[%d] targetPathPage expected return: %s, got: %s", i, test.expected, dest)}
}
}
--- a/hugolib/taxonomy_test.go
+++ b/hugolib/taxonomy_test.go
@@ -17,6 +17,7 @@
"fmt"
"path/filepath"
"reflect"
+ "strings"
"testing"
"github.com/stretchr/testify/require"
@@ -49,21 +50,27 @@
}
}
+//
func TestTaxonomiesWithAndWithoutContentFile(t *testing.T) {- for _, preserveTaxonomyNames := range []bool{false, true} {- t.Run(fmt.Sprintf("preserveTaxonomyNames %t", preserveTaxonomyNames), func(t *testing.T) {- doTestTaxonomiesWithAndWithoutContentFile(t, preserveTaxonomyNames)
+ for _, uglyURLs := range []bool{false, true} {+ t.Run(fmt.Sprintf("uglyURLs=%t", uglyURLs), func(t *testing.T) {+ for _, preserveTaxonomyNames := range []bool{false, true} {+ t.Run(fmt.Sprintf("preserveTaxonomyNames=%t", preserveTaxonomyNames), func(t *testing.T) {+ doTestTaxonomiesWithAndWithoutContentFile(t, preserveTaxonomyNames, uglyURLs)
+ })
+ }
})
}
}
-func doTestTaxonomiesWithAndWithoutContentFile(t *testing.T, preserveTaxonomyNames bool) {+func doTestTaxonomiesWithAndWithoutContentFile(t *testing.T, preserveTaxonomyNames, uglyURLs bool) {t.Parallel()
siteConfig := `
baseURL = "http://example.com/blog"
preserveTaxonomyNames = %t
+uglyURLs = %t
paginate = 1
defaultContentLanguage = "en"
@@ -87,7 +94,7 @@
# Doc
`
- siteConfig = fmt.Sprintf(siteConfig, preserveTaxonomyNames)
+ siteConfig = fmt.Sprintf(siteConfig, preserveTaxonomyNames, uglyURLs)
th, h := newTestSitesFromConfigWithDefaultTemplates(t, siteConfig)
require.Len(t, h.Sites, 1)
@@ -94,7 +101,13 @@
fs := th.Fs
- writeSource(t, fs, "content/p1.md", fmt.Sprintf(pageTemplate, "t1/c1", "- tag1", "- cat1", "- o1"))
+ if preserveTaxonomyNames {+ writeSource(t, fs, "content/p1.md", fmt.Sprintf(pageTemplate, "t1/c1", "- tag1", "- cat1", "- o1"))
+ } else {+ // Check lower-casing of tags
+ writeSource(t, fs, "content/p1.md", fmt.Sprintf(pageTemplate, "t1/c1", "- Tag1", "- cAt1", "- o1"))
+
+ }
writeSource(t, fs, "content/p2.md", fmt.Sprintf(pageTemplate, "t2/c1", "- tag2", "- cat1", "- o1"))
writeSource(t, fs, "content/p3.md", fmt.Sprintf(pageTemplate, "t2/c12", "- tag2", "- cat2", "- o1"))
writeSource(t, fs, "content/p4.md", fmt.Sprintf(pageTemplate, "Hello World", "", "", "- \"Hello Hugo world\""))
@@ -111,18 +124,25 @@
// 2. tags with no terms content page, but content page for one of 2 tags (tag1)
// 3. the "others" taxonomy with no content pages.
+ pathFunc := func(s string) string {+ if uglyURLs {+ return strings.Replace(s, "/index.html", ".html", 1)
+ }
+ return s
+ }
+
// 1.
- th.assertFileContent("public/categories/cat1/index.html", "List", "Cat1")- th.assertFileContent("public/categories/index.html", "Terms List", "Category Terms")+ th.assertFileContent(pathFunc("public/categories/cat1/index.html"), "List", "Cat1")+ th.assertFileContent(pathFunc("public/categories/index.html"), "Terms List", "Category Terms")// 2.
- th.assertFileContent("public/tags/tag2/index.html", "List", "Tag2")- th.assertFileContent("public/tags/tag1/index.html", "List", "Tag1")- th.assertFileContent("public/tags/index.html", "Terms List", "Tags")+ th.assertFileContent(pathFunc("public/tags/tag2/index.html"), "List", "Tag2")+ th.assertFileContent(pathFunc("public/tags/tag1/index.html"), "List", "Tag1")+ th.assertFileContent(pathFunc("public/tags/index.html"), "Terms List", "Tags")// 3.
- th.assertFileContent("public/others/o1/index.html", "List", "O1")- th.assertFileContent("public/others/index.html", "Terms List", "Others")+ th.assertFileContent(pathFunc("public/others/o1/index.html"), "List", "O1")+ th.assertFileContent(pathFunc("public/others/index.html"), "Terms List", "Others")s := h.Sites[0]
@@ -145,6 +165,14 @@
}
}
+ cat1 := s.getPage(KindTaxonomy, "categories", "cat1")
+ require.NotNil(t, cat1)
+ if uglyURLs {+ require.Equal(t, "/blog/categories/cat1.html", cat1.RelPermalink())
+ } else {+ require.Equal(t, "/blog/categories/cat1/", cat1.RelPermalink())
+ }
+
// Issue #3070 preserveTaxonomyNames
if preserveTaxonomyNames {helloWorld := s.getPage(KindTaxonomy, "others", "Hello Hugo world")
@@ -157,6 +185,6 @@
}
// Issue #2977
- th.assertFileContent("public/empties/index.html", "Terms List", "Empties")+ th.assertFileContent(pathFunc("public/empties/index.html"), "Terms List", "Empties")}
--- a/hugolib/testhelpers_test.go
+++ b/hugolib/testhelpers_test.go
@@ -77,6 +77,14 @@
return helpers.NewPathSpec(fs, l)
}
+func newTestDefaultPathSpec() *helpers.PathSpec {+ v := viper.New()
+ // Easier to reason about in tests.
+ v.Set("disablePathToLower", true)+ fs := hugofs.NewDefault(v)
+ return helpers.NewPathSpec(fs, v)
+}
+
func newTestCfg() (*viper.Viper, *hugofs.Fs) {v := viper.New()
--- a/output/outputType.go
+++ b/output/outputType.go
@@ -27,6 +27,7 @@
Name: "AMP",
MediaType: media.HTMLType,
BaseName: "index",
+ Path: "amp",
}
CSSType = Type{@@ -43,7 +44,7 @@
JSONType = Type{Name: "JSON",
- MediaType: media.HTMLType,
+ MediaType: media.JSONType,
BaseName: "index",
IsPlainText: true,
}
@@ -52,6 +53,7 @@
Name: "RSS",
MediaType: media.RSSType,
BaseName: "index",
+ NoUgly: true,
}
)
@@ -111,4 +113,8 @@
}
return types, nil
+}
+
+func (t Type) BaseFilename() string {+ return t.BaseName + "." + t.MediaType.Suffix
}
--- a/output/outputType_test.go
+++ b/output/outputType_test.go
@@ -30,6 +30,7 @@
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) {