Revert " Fix handling of taxonomy terms containing slashes" - hugo - [fork] hugo port for 9front
HTML git clone git@git.drkhsh.at/hugo.git
DIR Log
DIR Files
DIR Refs
DIR Submodules
DIR README
DIR LICENSE
---
DIR commit 4bae8b04aadd72d298bf2dd1bb1430806bf2869c
DIR parent 0584432b078f1e3a488ad4f27f39edac0557e042
HTML Author: Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com>
Date: Sat, 29 Dec 2018 10:14:37 +0100
Revert " Fix handling of taxonomy terms containing slashes"
See #4090
See #5571
This reverts commit fff132537b4094221f4f099e2251f3cda613060f.
Diffstat:
M helpers/path.go | 11 -----------
M helpers/path_test.go | 33 -------------------------------
M hugolib/hugo_sites.go | 2 +-
M hugolib/page_paths.go | 8 +-------
M hugolib/page_paths_test.go | 7 -------
M hugolib/page_taxonomy_test.go | 10 ++++------
M hugolib/permalinks.go | 30 +++++++-----------------------
M hugolib/taxonomy_test.go | 43 ++++++++++++++++++++++++++-----
8 files changed, 50 insertions(+), 94 deletions(-)
---
DIR diff --git a/helpers/path.go b/helpers/path.go
@@ -77,17 +77,6 @@ func (filepathBridge) Separator() string {
var fpb filepathBridge
-// segmentReplacer replaces some URI-reserved characters in a path segments.
-var segmentReplacer = strings.NewReplacer("/", "-", "#", "-")
-
-// MakeSegment returns a copy of string s that is appropriate for a path
-// segment. MakeSegment is similar to MakePath but disallows the '/' and
-// '#' characters because of their reserved meaning in URIs.
-func (p *PathSpec) MakeSegment(s string) string {
- return p.MakePathSanitized(segmentReplacer.Replace(s))
-
-}
-
// MakePath takes a string with any characters and replace it
// so the string could be used in a path.
// It does so by creating a Unicode-sanitized string, with the spaces replaced,
DIR diff --git a/helpers/path_test.go b/helpers/path_test.go
@@ -36,39 +36,6 @@ import (
"github.com/spf13/viper"
)
-func TestMakeSegment(t *testing.T) {
- tests := []struct {
- input string
- expected string
- }{
- {" FOO bar ", "foo-bar"},
- {"Foo.Bar/fOO_bAr-Foo", "foo.bar-foo_bar-foo"},
- {"FOO,bar:FooBar", "foobarfoobar"},
- {"foo/BAR.HTML", "foo-bar.html"},
- {"трям/трям", "трям-трям"},
- {"은행", "은행"},
- {"Say What??", "say-what"},
- {"Your #1 Fan", "your-1-fan"},
- {"Red & Blue", "red-blue"},
- {"double//slash", "double-slash"},
- {"triple///slash", "triple-slash"},
- {"-my/way-", "my-way"},
- }
-
- for _, test := range tests {
- v := newTestCfg()
-
- l := langs.NewDefaultLanguage(v)
- p, err := NewPathSpec(hugofs.NewMem(v), l)
- require.NoError(t, err)
-
- output := p.MakeSegment(test.input)
- if output != test.expected {
- t.Errorf("Expected %#v, got %#v\n", test.expected, output)
- }
- }
-}
-
func TestMakePath(t *testing.T) {
tests := []struct {
input string
DIR diff --git a/hugolib/hugo_sites.go b/hugolib/hugo_sites.go
@@ -567,7 +567,7 @@ func (h *HugoSites) createMissingPages() error {
origKey := key
if s.Info.preserveTaxonomyNames {
- key = s.PathSpec.MakeSegment(key)
+ key = s.PathSpec.MakePathSanitized(key)
}
for _, p := range taxonomyPages {
// Some people may have /authors/MaxMustermann etc. as paths.
DIR diff --git a/hugolib/page_paths.go b/hugolib/page_paths.go
@@ -197,13 +197,7 @@ func createTargetPath(d targetPathDescriptor) string {
if d.ExpandedPermalink != "" {
pagePath = filepath.Join(pagePath, d.ExpandedPermalink)
} else {
- pagePath = ""
- for i, section := range d.Sections {
- if i > 0 {
- pagePath += helpers.FilePathSeparator
- }
- pagePath += d.PathSpec.MakeSegment(section)
- }
+ pagePath = filepath.Join(d.Sections...)
}
needsBase = false
}
DIR diff --git a/hugolib/page_paths_test.go b/hugolib/page_paths_test.go
@@ -151,13 +151,6 @@ func TestPageTargetPath(t *testing.T) {
BaseName: "mypage",
Addends: "c/d/e",
Type: output.HTMLFormat}, "/a/b/mypage/c/d/e/index.html"},
- {
- "Unclean Taxonomy Term", targetPathDescriptor{
- Kind: KindTaxonomy,
- BaseName: "_index",
- Sections: []string{"tags", "x/y"},
- Type: output.HTMLFormat,
- Addends: "page/3"}, "/tags/x-y/page/3/index.html"},
}
for i, test := range tests {
DIR diff --git a/hugolib/page_taxonomy_test.go b/hugolib/page_taxonomy_test.go
@@ -20,7 +20,7 @@ import (
)
var pageYamlWithTaxonomiesA = `---
-tags: ['a', 'B', 'c', 'x/y']
+tags: ['a', 'B', 'c']
categories: 'd'
---
YAML frontmatter with tags and categories taxonomy.`
@@ -30,7 +30,6 @@ tags:
- "a"
- "B"
- "c"
- - "x/y"
categories: 'd'
---
YAML frontmatter with tags and categories taxonomy.`
@@ -46,14 +45,13 @@ var pageJSONWithTaxonomies = `{
"tags": [
"a",
"b",
- "c",
- "x/y"
+ "c"
]
}
JSON Front Matter with tags and categories`
var pageTomlWithTaxonomies = `+++
-tags = [ "a", "B", "c", "x/y" ]
+tags = [ "a", "B", "c" ]
categories = "d"
+++
TOML Front Matter with tags and categories`
@@ -77,7 +75,7 @@ func TestParseTaxonomies(t *testing.T) {
param := p.getParamToLower("tags")
if params, ok := param.([]string); ok {
- expected := []string{"a", "b", "c", "x/y"}
+ expected := []string{"a", "b", "c"}
if !reflect.DeepEqual(params, expected) {
t.Errorf("Expected %s: got: %s", expected, params)
}
DIR diff --git a/hugolib/permalinks.go b/hugolib/permalinks.go
@@ -152,13 +152,9 @@ func pageToPermalinkDate(p *Page, dateField string) (string, error) {
// pageToPermalinkTitle returns the URL-safe form of the title
func pageToPermalinkTitle(p *Page, _ string) (string, error) {
- if p.Kind == KindTaxonomy {
- // Taxonomies are allowed to have '/' characters, so don't normalize
- // them with MakeSegment.
- return p.s.PathSpec.MakePathSanitized(p.title), nil
- }
-
- return p.s.PathSpec.MakeSegment(p.title), nil
+ // Page contains Node which has Title
+ // (also contains URLPath which has Slug, sometimes)
+ return p.s.PathSpec.URLize(p.title), nil
}
// pageToPermalinkFilename returns the URL-safe form of the filename
@@ -170,7 +166,7 @@ func pageToPermalinkFilename(p *Page, _ string) (string, error) {
_, name = filepath.Split(dir)
}
- return p.s.PathSpec.MakeSegment(name), nil
+ return p.s.PathSpec.URLize(name), nil
}
// if the page has a slug, return the slug, else return the title
@@ -185,30 +181,18 @@ func pageToPermalinkSlugElseTitle(p *Page, a string) (string, error) {
if strings.HasSuffix(p.Slug, "-") {
p.Slug = p.Slug[0 : len(p.Slug)-1]
}
- return p.s.PathSpec.MakeSegment(p.Slug), nil
+ return p.s.PathSpec.URLize(p.Slug), nil
}
return pageToPermalinkTitle(p, a)
}
func pageToPermalinkSection(p *Page, _ string) (string, error) {
// Page contains Node contains URLPath which has Section
- return p.s.PathSpec.MakeSegment(p.Section()), nil
+ return p.s.PathSpec.URLize(p.Section()), nil
}
func pageToPermalinkSections(p *Page, _ string) (string, error) {
- // TODO(bep) we have some superflous URLize in this file, but let's
- // deal with that later.
-
- cs := p.CurrentSection()
- if cs == nil {
- return "", errors.New("\":sections\" attribute requires parent page but is nil")
- }
-
- sections := make([]string, len(cs.sections))
- for i := range cs.sections {
- sections[i] = p.s.PathSpec.MakeSegment(cs.sections[i])
- }
- return path.Join(sections...), nil
+ return path.Join(p.CurrentSection().sections...), nil
}
func init() {
DIR diff --git a/hugolib/taxonomy_test.go b/hugolib/taxonomy_test.go
@@ -45,9 +45,8 @@ func TestByCountOrderOfTaxonomies(t *testing.T) {
st = append(st, t.Name)
}
- expect := []string{"a", "b", "c", "x/y"}
- if !reflect.DeepEqual(st, expect) {
- t.Fatalf("ordered taxonomies do not match %v. Got: %s", expect, st)
+ if !reflect.DeepEqual(st, []string{"a", "b", "c"}) {
+ t.Fatalf("ordered taxonomies do not match [a, b, c]. Got: %s", st)
}
}
@@ -69,10 +68,8 @@ func doTestTaxonomiesWithAndWithoutContentFile(t *testing.T, preserveTaxonomyNam
baseURL = "http://example.com/blog"
preserveTaxonomyNames = %t
uglyURLs = %t
-
paginate = 1
defaultContentLanguage = "en"
-
[Taxonomies]
tag = "tags"
category = "categories"
@@ -80,7 +77,6 @@ other = "others"
empty = "empties"
permalinked = "permalinkeds"
subcats = "subcats"
-
[permalinks]
permalinkeds = "/perma/:slug/"
subcats = "/subcats/:slug/"
@@ -243,3 +239,38 @@ subcats:
th.assertFileContent(pathFunc("public/empties/index.html"), "Terms List", "Empties")
}
+
+// https://github.com/gohugoio/hugo/issues/5513
+func TestTaxonomyPathSeparation(t *testing.T) {
+ t.Parallel()
+
+ config := `
+baseURL = "https://example.com"
+[taxonomies]
+"news/tag" = "news/tags"
+"news/category" = "news/categories"
+`
+
+ pageContent := `
++++
+title = "foo"
+"news/categories" = ["a", "b", "c"]
++++
+Content.
+`
+
+ b := newTestSitesBuilder(t)
+ b.WithConfigFile("toml", config)
+ b.WithContent("page.md", pageContent)
+ b.WithContent("news/categories/b/_index.md", `
+---
+title: "This is B"
+---
+`)
+
+ b.CreateSites().Build(BuildCfg{})
+
+ b.AssertFileContent("public/news/categories/index.html", "Taxonomy Term Page 1|News/Categories|Hello|https://example.com/news/categories/|")
+ b.AssertFileContent("public/news/categories/a/index.html", "Taxonomy List Page 1|A|Hello|https://example.com/news/categories/a/|")
+ b.AssertFileContent("public/news/categories/b/index.html", "Taxonomy List Page 1|This is B|Hello|https://example.com/news/categories/b/|")
+}