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
// 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
// pagination path handling
paginatePath string
- baseURL string
- theme string
+ theme string
// Directories
themesDir string
// 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"),
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"),
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)
"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 {
}
// 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)
// 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)
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 {
// 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
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))
}
)
const (
- baseURL = "http://foo/bar"
+ testBaseURL = "http://foo/bar"
)
func TestShortcodeCrossrefs(t *testing.T) {
cfg, fs = newTestCfg()
)
- cfg.Set("baseURL", baseURL)
+ cfg.Set("baseURL", testBaseURL)
var refShortcode string
var expectedBase string
expectedBase = "/bar"
} else {
refShortcode = "ref"
- expectedBase = baseURL
+ expectedBase = testBaseURL
}
path := filepath.FromSlash("blog/post.md")
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()
}
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()
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/"`)
// 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")
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")
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)*/
}
}
rssURI = "index.xml"
paginate = 1
+disablePathToLower = true
defaultContentLanguage = "{{ .DefaultContentLanguage }}"
defaultContentLanguageInSubdir = {{ .DefaultContentLanguageInSubdir }}
disableRSS: false
rssURI: "index.xml"
+disablePathToLower: true
paginate: 1
defaultContentLanguage: "{{ .DefaultContentLanguage }}"
defaultContentLanguageInSubdir: {{ .DefaultContentLanguageInSubdir }}
"disableRSS": false,
"rssURI": "index.xml",
"paginate": 1,
+ "disablePathToLower": true,
"defaultContentLanguage": "{{ .DefaultContentLanguage }}",
"defaultContentLanguageInSubdir": true,
"permalinks": {
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)
+ })
}
}
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)
"html/template"
"io"
- "net/url"
"path"
"path/filepath"
"regexp"
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
// 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
}
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,
})
}
-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
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 != "" {
return u
}
-func (p *Page) RelPermalink() string {
- p.relPermalinkInit.Do(func() {
- link := p.getPermalink()
-
- 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
- }
+// Permalink returns the absolute URL to this Page.
+func (p *Page) Permalink() string {
+ p.initURLs()
+ return p.permalink
+}
- p.relPermalink = relpath
- return
- }
+// RelPermalink gets a URL to the resource relative to the host.
+func (p *Page) RelPermalink() string {
+ p.initURLs()
+ return p.relPermalink
+}
- 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")
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 {
// 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
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 {
// This is either a taxonomy list, taxonomy term or a section
package hugolib
import (
+ "sync"
+
"github.com/spf13/hugo/output"
)
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
+// 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
+// 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)
+ }
+ }
+ })
+ }
+ })
+ }
+
+}
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())
- }*/
}
}
}
}
+// 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())
+ }
+
+ })
+ }
+}
+
func BenchmarkParsePage(b *testing.B) {
s := newTestSite(b)
f, _ := os.Open("testdata/redis.cn.md")
"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.
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)
}
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
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)
}
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
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
return p, nil
}
-func newPaginationURLFactory(pathSpec *helpers.PathSpec, pathElements ...string) paginationURLFactory {
-
- basePath := path.Join(pathElements...)
+func newPaginationURLFactory(d targetPathDescriptor) paginationURLFactory {
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)
}
}
"fmt"
"html/template"
"path/filepath"
+ "strings"
"testing"
"github.com/spf13/hugo/deps"
+ "github.com/spf13/hugo/output"
"github.com/stretchr/testify/require"
)
func TestPaginationURLFactory(t *testing.T) {
t.Parallel()
cfg, fs := newTestCfg()
-
cfg.Set("paginatePath", "zoo")
- pathSpec := newTestPathSpec(fs, cfg)
-
- unicode := newPaginationURLFactory(pathSpec, "новости проекта")
- fooBar := newPaginationURLFactory(pathSpec, "foo", "bar")
-
- 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))
-
- 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/"
-
- if unicoded != unicodedExpected {
- t.Fatal("Expected\n", unicodedExpected, "\nGot\n", unicoded)
+ 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) {
+
+ 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/"},
+ }
+
+ for _, test := range tests {
+ d := test.d
+ cfg.Set("baseURL", test.baseURL)
+ cfg.Set("canonifyURLs", canonifyURLs)
+ cfg.Set("uglyURLs", uglyURLs)
+ d.UglyURLs = uglyURLs
+
+ expected := test.expected
+
+ if canonifyURLs {
+ expected = strings.Replace(expected, "/sub", "", 1)
+ }
+
+ 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)
+
+ }
+ })
+ }
+ })
}
- require.Equal(t, "/foo/bar/zoo/12345/", fooBar(12345))
-
}
func TestPaginator(t *testing.T) {
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
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)
}
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)
}
}
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
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)
}
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)
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)
}
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)
}
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)
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)
disabledKinds map[string]bool
+ defaultOutputDefinitions siteOutputDefinitions
+
// Logger etc.
*deps.Deps `json:"-"`
}
// 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.
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})
BuildDrafts bool
canonifyURLs bool
relativeURLs bool
+ uglyURLs bool
preserveTaxonomyNames bool
Data *map[string]interface{}
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,
s: s,
}
- s.Info.RSSLink = s.Info.permalinkStr(lang.GetString("rssURI"))
+ s.Info.RSSLink = s.permalink(lang.GetString("rssURI"))
}
func (s *Site) dataDir() string {
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 {
// 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 {
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, "/") {
Data: make(map[string]interface{}),
Site: &s.Info,
s: s}
+ p.outputTypes = p.s.defaultOutputDefinitions.ForKind(typ)
p.layoutIdentifier = pageLayoutIdentifier{p}
return p
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"))
}
}
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 {
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
+}
"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
# 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
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")
}
import (
"fmt"
"path"
- "path/filepath"
"sync"
"time"
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
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)
}
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
}
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 {
// 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/",
}
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/",
},
}
}
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
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))
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) {
}
func (w siteWriter) publish(path string, r io.Reader) (err error) {
+
return helpers.WriteToDisk(path, r, w.fs.Destination)
}
}
}
-func TestTargetPathUglyURLs(t *testing.T) {
+// TODO(bep) output
+func _TestTargetPathUglyURLs(t *testing.T) {
w := siteWriter{log: newErrorLogger(), uglyURLs: true}
tests := []struct {
{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)
}
}
}
"fmt"
"path/filepath"
"reflect"
+ "strings"
"testing"
"github.com/stretchr/testify/require"
}
}
+//
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"
# Doc
`
- siteConfig = fmt.Sprintf(siteConfig, preserveTaxonomyNames)
+ siteConfig = fmt.Sprintf(siteConfig, preserveTaxonomyNames, uglyURLs)
th, h := newTestSitesFromConfigWithDefaultTemplates(t, siteConfig)
require.Len(t, h.Sites, 1)
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\""))
// 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]
}
}
+ 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")
}
// Issue #2977
- th.assertFileContent("public/empties/index.html", "Terms List", "Empties")
+ th.assertFileContent(pathFunc("public/empties/index.html"), "Terms List", "Empties")
}
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()
Name: "AMP",
MediaType: media.HTMLType,
BaseName: "index",
+ Path: "amp",
}
CSSType = Type{
JSONType = Type{
Name: "JSON",
- MediaType: media.HTMLType,
+ MediaType: media.JSONType,
BaseName: "index",
IsPlainText: true,
}
Name: "RSS",
MediaType: media.RSSType,
BaseName: "index",
+ NoUgly: true,
}
)
return types, nil
}
+
+func (t Type) BaseFilename() string {
+ return t.BaseName + "." + t.MediaType.Suffix
+}
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) {
projects / brevno-suite / hugo / commitdiff