shithub: hugo

--- a/helpers/path.go

+++ b/helpers/path.go

@@ -77,17 +77,6 @@

 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,

--- a/helpers/path_test.go

+++ b/helpers/path_test.go

@@ -36,39 +36,6 @@

 	"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

--- a/hugolib/hugo_sites.go

+++ b/hugolib/hugo_sites.go

@@ -567,7 +567,7 @@

 						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.

--- a/hugolib/page_paths.go

+++ b/hugolib/page_paths.go

@@ -197,13 +197,7 @@

 		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

--- a/hugolib/page_paths_test.go

+++ b/hugolib/page_paths_test.go

@@ -151,13 +151,6 @@

 									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 {

--- a/hugolib/page_taxonomy_test.go

+++ b/hugolib/page_taxonomy_test.go

@@ -20,7 +20,7 @@

 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 @@

  - "a"

  - "B"

  - "c"

- - "x/y"

 categories: 'd'

---

 YAML frontmatter with tags and categories taxonomy.`

@@ -46,14 +45,13 @@

   "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 @@

 		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)

--- a/hugolib/permalinks.go

+++ b/hugolib/permalinks.go

@@ -152,13 +152,9 @@

 // 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 @@

 		_, 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,7 +181,7 @@

 		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)

@@ -192,23 +188,11 @@

 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() {

--- a/hugolib/taxonomy_test.go

+++ b/hugolib/taxonomy_test.go

@@ -45,9 +45,8 @@

 		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 @@

 baseURL = "http://example.com/blog"

 preserveTaxonomyNames = %t

 uglyURLs = %t

 paginate = 1

 defaultContentLanguage = "en"

 [Taxonomies]

 tag = "tags"

 category = "categories"

@@ -80,7 +77,6 @@

 empty = "empties"

 permalinked = "permalinkeds"

 subcats = "subcats"

 [permalinks]

 permalinkeds = "/perma/:slug/"

 subcats = "/subcats/:slug/"

@@ -242,4 +238,39 @@

 	// Issue #2977

 	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/|")