URI: 
       hugolib: Fix preserveTaxonomyNames regressions - 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 bcb3ef74131f8119e290ddb68908ce27760a80a7
   DIR parent 862f09babebbf6e9bc0d204ad8eabe1cdefbfcf3
  HTML Author: Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com>
       Date:   Mon, 26 Dec 2016 19:30:57 +0100
       
       hugolib: Fix preserveTaxonomyNames regressions
       
       Fixes #2809
       
       Diffstat:
         M hugolib/hugo_sites.go               |       3 +++
         M hugolib/node_as_page_test.go        |      16 ++++++++++++----
         M hugolib/page.go                     |       6 ++++++
         M hugolib/site.go                     |      15 +++++++++++++++
       
       4 files changed, 36 insertions(+), 4 deletions(-)
       ---
   DIR diff --git a/hugolib/hugo_sites.go b/hugolib/hugo_sites.go
       @@ -225,6 +225,9 @@ func (h *HugoSites) createMissingPages() error {
                                        foundTaxonomyPage := false
                                        foundTaxonomyTermsPage := false
                                        for key := range tax {
       +                                        if s.Info.preserveTaxonomyNames {
       +                                                key = s.Info.pathSpec.MakePathSanitized(key)
       +                                        }
                                                for _, p := range taxonomyPages {
                                                        if p.sections[0] == plural && p.sections[1] == key {
                                                                foundTaxonomyPage = true
   DIR diff --git a/hugolib/node_as_page_test.go b/hugolib/node_as_page_test.go
       @@ -33,12 +33,14 @@ import (
        */
        
        func TestNodesAsPage(t *testing.T) {
       -        for _, ugly := range []bool{false, true} {
       -                doTestNodeAsPage(t, ugly)
       +        for _, preserveTaxonomyNames := range []bool{false, true} {
       +                for _, ugly := range []bool{true, false} {
       +                        doTestNodeAsPage(t, ugly, preserveTaxonomyNames)
       +                }
                }
        }
        
       -func doTestNodeAsPage(t *testing.T, ugly bool) {
       +func doTestNodeAsPage(t *testing.T, ugly, preserveTaxonomyNames bool) {
                //jww.SetStdoutThreshold(jww.LevelDebug)
                jww.SetStdoutThreshold(jww.LevelFatal)
        
       @@ -55,6 +57,7 @@ func doTestNodeAsPage(t *testing.T, ugly bool) {
                testCommonResetState()
        
                viper.Set("uglyURLs", ugly)
       +        viper.Set("preserveTaxonomyNames", preserveTaxonomyNames)
        
                writeLayoutsForNodeAsPageTests(t)
                writeNodePagesForNodeAsPageTests("", t)
       @@ -86,6 +89,7 @@ func doTestNodeAsPage(t *testing.T, ugly bool) {
        
                h := s.owner
                nodes := h.findAllPagesByKindNotIn(KindPage)
       +
                require.Len(t, nodes, 6)
        
                home := nodes[5] // oldest
       @@ -139,6 +143,10 @@ func doTestNodeAsPage(t *testing.T, ugly bool) {
                        "Lastmod: 2009-01-09",
                )
        
       +        web := s.getPage(KindTaxonomy, "categories", "web")
       +        require.NotNil(t, web)
       +        require.Len(t, web.Data["Pages"].(Pages), 4)
       +
                assertFileContent(t, expectedFilePath(ugly, "public", "categories", "web"), false,
                        "Taxonomy Title: Taxonomy Web",
                        "Taxonomy Web <strong>Content!</strong>",
       @@ -728,7 +736,7 @@ Lastmod: {{ .Lastmod.Format "2006-01-02" }}
        Taxonomy Terms Title: {{ .Title }}
        Taxonomy Terms Content: {{ .Content }}
        {{ range $key, $value := .Data.Terms }}
       -        k/v: {{ $key }} / {{ printf "%s" $value }}
       +        k/v: {{ $key | lower }} / {{ printf "%s" $value }}
        {{ end }}
        {{ with .Site.Menus.mymenu }}
        {{ range . }}
   DIR diff --git a/hugolib/page.go b/hugolib/page.go
       @@ -1494,6 +1494,12 @@ func (p *Page) prepareData(s *Site) error {
                        plural := p.sections[0]
                        term := p.sections[1]
        
       +                if s.Info.preserveTaxonomyNames {
       +                        if v, ok := s.taxonomiesOrigKey[fmt.Sprintf("%s-%s", plural, term)]; ok {
       +                                term = v
       +                        }
       +                }
       +
                        singular := s.taxonomiesPluralSingular[plural]
                        taxonomy := s.Taxonomies[plural].Get(term)
        
   DIR diff --git a/hugolib/site.go b/hugolib/site.go
       @@ -88,6 +88,11 @@ type Site struct {
                // to get the singular form from that value.
                taxonomiesPluralSingular map[string]string
        
       +        // This is temporary, see https://github.com/spf13/hugo/issues/2835
       +        // Maps         "actors-gerard-depardieu" to "Gérard Depardieu" when preserveTaxonomyNames
       +        // is set.
       +        taxonomiesOrigKey map[string]string
       +
                Source         source.Input
                Sections       Taxonomy
                Info           SiteInfo
       @@ -1477,8 +1482,10 @@ func (s *Site) assembleMenus() {
        func (s *Site) assembleTaxonomies() {
                s.Taxonomies = make(TaxonomyList)
                s.taxonomiesPluralSingular = make(map[string]string)
       +        s.taxonomiesOrigKey = make(map[string]string)
        
                taxonomies := s.Language.GetStringMapString("taxonomies")
       +
                jww.INFO.Printf("found taxonomies: %#v\n", taxonomies)
        
                for singular, plural := range taxonomies {
       @@ -1496,10 +1503,18 @@ func (s *Site) assembleTaxonomies() {
                                                for _, idx := range v {
                                                        x := WeightedPage{weight.(int), p}
                                                        s.Taxonomies[plural].add(idx, x, s.Info.preserveTaxonomyNames)
       +                                                if s.Info.preserveTaxonomyNames {
       +                                                        // Need to track the original
       +                                                        s.taxonomiesOrigKey[fmt.Sprintf("%s-%s", plural, kp(idx))] = idx
       +                                                }
                                                }
                                        } else if v, ok := vals.(string); ok {
                                                x := WeightedPage{weight.(int), p}
                                                s.Taxonomies[plural].add(v, x, s.Info.preserveTaxonomyNames)
       +                                        if s.Info.preserveTaxonomyNames {
       +                                                // Need to track the original
       +                                                s.taxonomiesOrigKey[fmt.Sprintf("%s-%s", plural, kp(v))] = v
       +                                        }
                                        } else {
                                                jww.ERROR.Printf("Invalid %s in %s\n", plural, p.File.Path())
                                        }