From 4bae8b04aadd72d298bf2dd1bb1430806bf2869c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B8rn=20Erik=20Pedersen?= Date: Sat, 29 Dec 2018 10:14:37 +0100 Subject: [PATCH] Revert " Fix handling of taxonomy terms containing slashes" See #4090 See #5571 This reverts commit fff132537b4094221f4f099e2251f3cda613060f. --- helpers/path.go | 11 --------- helpers/path_test.go | 33 --------------------------- hugolib/hugo_sites.go | 2 +- hugolib/page_paths.go | 8 +------ hugolib/page_paths_test.go | 7 ------ hugolib/page_taxonomy_test.go | 10 ++++---- hugolib/permalinks.go | 30 ++++++------------------ hugolib/taxonomy_test.go | 43 ++++++++++++++++++++++++++++++----- 8 files changed, 50 insertions(+), 94 deletions(-) diff --git a/helpers/path.go b/helpers/path.go index 2d0e8aa6..bf7e3bf9 100644 --- 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, diff --git a/helpers/path_test.go b/helpers/path_test.go index a1110b09..c249a519 100644 --- 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 diff --git a/hugolib/hugo_sites.go b/hugolib/hugo_sites.go index e44390e4..6a489347 100644 --- 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. diff --git a/hugolib/page_paths.go b/hugolib/page_paths.go index a24789bf..9de7b076 100644 --- 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 } diff --git a/hugolib/page_paths_test.go b/hugolib/page_paths_test.go index 9e8d4ecb..8f8df6ec 100644 --- 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 { diff --git a/hugolib/page_taxonomy_test.go b/hugolib/page_taxonomy_test.go index df6e0e85..ed1d2565 100644 --- 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) } diff --git a/hugolib/permalinks.go b/hugolib/permalinks.go index f306f494..55dcd7db 100644 --- 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() { diff --git a/hugolib/taxonomy_test.go b/hugolib/taxonomy_test.go index ec55dc42..6ea39717 100644 --- 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/|") +}