continue
}
+ p.setNodeTypeVars(s)
+
// If we got this far it means that this is either a new Page pointer
// or a template or similar has changed so wee need to do a rerendering
// of the shortcodes etc.
}
}
-func (h *HugoSites) findPagesByNodeType(n NodeType) Pages {
+func (h *HugoSites) findAllPagesByNodeType(n NodeType) Pages {
var pages Pages
for _, p := range h.Sites[0].AllPages {
if p.NodeType == n {
const (
NodePage NodeType = iota
+ // Temporary state.
+ NodeUnknown
+
// The rest are node types; home page, sections etc.
NodeHome
NodeSection
+ NodeTaxonomy
)
func (p NodeType) IsNode() bool {
return helpers.FilePathSeparator + filepath.Join(n.Lang(), outfile)
}
+func sectionsFromFilename(filename string) []string {
+ dir, _ := filepath.Split(filename)
+ return strings.Split(dir, helpers.FilePathSeparator)
+}
+
+// TODO(bep) np node identificator
func nodeTypeFromFilename(filename string) NodeType {
- // TODO(bep) np
+
if !strings.Contains(filename, "_node") {
return NodePage
}
return NodeHome
}
- return NodeSection
+ // We don't know enough yet to determine the type.
+ return NodeUnknown
+}
+
+func (p *Page) setNodeTypeVars(s *Site) {
+ // TODO(bep) np taxonomies etc.
+ if p.NodeType == NodeUnknown {
+ // This is either a taxonomy or a section
+ if s.isTaxonomy(p.Section()) {
+ p.NodeType = NodeTaxonomy
+ } else {
+ p.NodeType = NodeSection
+ }
+
+ }
+ // TODO(bep) np node URL
+ // Set Node URL
+ switch p.NodeType {
+ case NodeHome:
+ p.URLPath.URL = ""
+ case NodeSection:
+ p.URLPath.URL = p.Section()
+ case NodeTaxonomy:
+ p.URLPath.URL = path.Join(p.sections...)
+ }
+
+ p.site = s
+
}
*/
func TestNodesAsPage(t *testing.T) {
- //jww.SetStdoutThreshold(jww.LevelDebug)
- jww.SetStdoutThreshold(jww.LevelFatal)
+ jww.SetStdoutThreshold(jww.LevelDebug)
+ //jww.SetStdoutThreshold(jww.LevelFatal)
nodePageFeatureFlag = true
defer toggleNodePageFeatureFlag()
title: Section2
---
Section2 **Content!**
+`)
+
+ writeSource(t, filepath.Join("content", "categories", "hugo", "_node.md"), `---
+title: Taxonomy Hugo
+---
+Taxonomy Hugo **Content!**
`)
writeSource(t, filepath.Join("layouts", "index.html"), `
{{ range .Paginator.Pages }}
Pag: {{ .Title }}
{{ end }}
+`)
+
+ writeSource(t, filepath.Join("layouts", "_default", "taxonomy.html"), `
+Taxonomy Title: {{ .Title }}
+Taxonomy Content: {{ .Content }}
+# Pages: {{ len .Data.Pages }}
+{{ range .Paginator.Pages }}
+ Pag: {{ .Title }}
+{{ end }}
`)
// Add some regular pages
assertFileContent(t, filepath.Join("public", "sect1", "regular1", "index.html"), false, "Single Title: Page 01", "Content Page 01")
h := s.owner
- nodes := h.findPagesByNodeType(NodeHome)
+ nodes := h.findAllPagesByNodeType(NodeHome)
require.Len(t, nodes, 1)
home := nodes[0]
require.True(t, home.IsNode())
require.False(t, home.IsPage())
- pages := h.findPagesByNodeType(NodePage)
+ pages := h.findAllPagesByNodeType(NodePage)
require.Len(t, pages, 4)
first := pages[0]
assertFileContent(t, filepath.Join("public", "sect1", "page", "2", "index.html"), false,
"Pag: Page 02")
- sections := h.findPagesByNodeType(NodeSection)
+ sections := h.findAllPagesByNodeType(NodeSection)
require.Len(t, sections, 2)
+ // Check taxonomy list
+ assertFileContent(t, filepath.Join("public", "categories", "hugo", "index.html"), false,
+ "Taxonomy Title: Taxonomy Hugo", "Taxonomy Hugo <strong>Content!</strong>")
+
+ // Check taxonomy list paginator
+ assertFileContent(t, filepath.Join("public", "categories", "hugo", "page", "2", "index.html"), false,
+ "Taxonomy Title: Taxonomy Hugo",
+ "Pag: Page 02")
+
}
Node
GitInfo *gitmap.GitInfo
+
+ // This was added as part of getting the Nodes (taxonomies etc.) to work as
+ // Pages in Hugo 0.18.
+ // It is deliberately named similar to Section, but not exported (for now).
+ // We currently have only one level of section in Hugo, but the page can live
+ // any number of levels down the file path.
+ // To support taxonomies like /categories/hugo etc. we will need to keep track
+ // of that information in a general way.
+ // So, sections represents the path to the content, i.e. a content file or a
+ // virtual content file in the situations where a taxonomy or a section etc.
+ // isn't accomanied by one.
+ sections []string
+
+ // TODO(bep) np Site added to page, keep?
+ site *Site
}
type Source struct {
Node: Node{NodeType: nodeTypeFromFilename(filename), Keywords: []string{}, Sitemap: Sitemap{Priority: -1}},
Params: make(map[string]interface{}),
translations: make(Pages, 0),
+ sections: sectionsFromFilename(filename),
}
jww.DEBUG.Println("Reading from", page.File.Path())
return p.layoutsCalculated
}
- // TODO(bep) np
+ // TODO(bep) np taxonomy etc.
switch p.NodeType {
case NodeHome:
return []string{"index.html", "_default/list.html"}
case NodeSection:
section := p.Section()
return []string{"section/" + section + ".html", "_default/section.html", "_default/list.html", "indexes/" + section + ".html", "_default/indexes.html"}
+ case NodeTaxonomy:
+ singular := p.site.taxonomiesPluralSingular[p.sections[0]]
+ return []string{"taxonomy/" + singular + ".html", "indexes/" + singular + ".html", "_default/taxonomy.html", "_default/list.html"}
}
+ // Regular Page handled below
+
if p.Layout != "" {
return layouts(p.Type(), p.Layout)
}
}
}
- // TODO(bep) np node URL
- // Set Node URL
- switch p.NodeType {
- case NodeHome:
- p.URLPath.URL = ""
- case NodeSection:
- p.URLPath.URL = p.Section()
- }
-
return nil
}
return "index.html"
case NodeSection:
return filepath.Join(p.Section(), "index.html")
+ case NodeTaxonomy:
+ return filepath.Join(append(p.sections, "index.html")...)
}
// Always use URL if it's specified
return nil
}
+// TODO(bep) np naming, move some
func (p *Page) prepareData(s *Site) error {
p.Data = make(map[string]interface{})
switch p.NodeType {
case NodePage:
case NodeHome:
// TODO(bep) np cache the below
- // TODO(bep) np
- p.Data["Pages"] = s.owner.findPagesByNodeType(NodePage)
+ p.Data["Pages"] = s.owner.findAllPagesByNodeType(NodePage)
case NodeSection:
sectionData, ok := s.Sections[p.Section()]
if !ok {
return fmt.Errorf("Data for section %s not found", p.Section())
}
p.Data["Pages"] = sectionData
- }
-
- return nil
-}
-
-// renderPaginator must be run after the owning Page has been rendered.
-// TODO(bep) np
-func (p *Page) renderPaginator(s *Site) error {
- if p.paginator != nil {
- paginatePath := helpers.Config().GetString("paginatePath")
-
- // write alias for page 1
- // TODO(bep) ml all of these n.addLang ... fix.
- //permaLink, _ := p.Permalink()
- // TODO(bep) np fix
- //s.writeDestAlias(p.addLangPathPrefix(helpers.PaginateAliasPath("", 1)), permaLink, nil)
-
- pagers := p.paginator.Pagers()
-
- for i, pager := range pagers {
- if i == 0 {
- // already created
- continue
- }
+ case NodeTaxonomy:
+ plural := p.sections[0]
+ term := p.sections[1]
- pagerNode := p.copy()
+ singular := s.taxonomiesPluralSingular[plural]
+ taxonomy := s.Taxonomies[plural].Get(term)
- pagerNode.paginator = pager
- if pager.TotalPages() > 0 {
- first, _ := pager.page(0)
- pagerNode.Date = first.Date
- pagerNode.Lastmod = first.Lastmod
- }
-
- pageNumber := i + 1
- htmlBase := path.Join(p.URLPath.URL, fmt.Sprintf("/%s/%d", paginatePath, pageNumber))
- htmlBase = p.addLangPathPrefix(htmlBase)
- if err := s.renderAndWritePage(pagerNode.Title,
- filepath.FromSlash(htmlBase), pagerNode, p.layouts()...); err != nil {
- return err
- }
+ p.Data[singular] = taxonomy
+ p.Data["Singular"] = singular
+ p.Data["Plural"] = plural
+ p.Data["Pages"] = taxonomy.Pages()
- }
}
+
return nil
}
nodeCache *nodeCache
nodeCacheInit sync.Once
- Pages Pages
- AllPages Pages
- rawAllPages Pages
- Files []*source.File
- Taxonomies TaxonomyList
+ Pages Pages
+ AllPages Pages
+ rawAllPages Pages
+ Files []*source.File
+ Taxonomies TaxonomyList
+
+ // Plural is what we get in the folder, so keep track of this mapping
+ // to get the singular form from that value.
+ taxonomiesPluralSingular map[string]string
+
Source source.Input
Sections Taxonomy
Info SiteInfo
func (s *Site) assembleTaxonomies() {
s.Taxonomies = make(TaxonomyList)
+ s.taxonomiesPluralSingular = make(map[string]string)
taxonomies := s.Language.GetStringMapString("Taxonomies")
jww.INFO.Printf("found taxonomies: %#v\n", taxonomies)
- for _, plural := range taxonomies {
+ for singular, plural := range taxonomies {
s.Taxonomies[plural] = make(Taxonomy)
+ s.taxonomiesPluralSingular[plural] = singular
for _, p := range s.Pages {
vals := p.getParam(plural, !s.Info.preserveTaxonomyNames)
weight := p.GetParam(plural + "_weight")
func (s *Site) assembleSections() {
s.Sections = make(Taxonomy)
s.Info.Sections = s.Sections
-
- for i, p := range s.Pages {
- s.Sections.add(p.Section(), WeightedPage{s.Pages[i].Weight, s.Pages[i]}, s.Info.preserveTaxonomyNames)
+ regularPages := s.findPagesByNodeType(NodePage)
+ for i, p := range regularPages {
+ section := p.Section()
+ if s.isTaxonomy(section) {
+ continue
+ }
+ s.Sections.add(section, WeightedPage{s.Pages[i].Weight, regularPages[i]}, s.Info.preserveTaxonomyNames)
}
for k := range s.Sections {
}
}
+func (s *Site) isTaxonomy(section string) bool {
+ if _, isTaxonomy := s.Taxonomies[section]; isTaxonomy {
+ return true
+ }
+ return false
+}
+
+func (s *Site) findPagesByNodeType(n NodeType) Pages {
+ var pages Pages
+ for _, p := range s.Pages {
+ if p.NodeType == n {
+ pages = append(pages, p)
+ }
+ }
+ return pages
+}
+
// renderAliases renders shell pages that simply have a redirect in the header.
func (s *Site) renderAliases() error {
for _, p := range s.Pages {
return nil
}
-// renderPages renders pages each corresponding to a markdown file.
-func (s *Site) renderPages() error {
-
- results := make(chan error)
- pages := make(chan *Page)
- errs := make(chan error)
-
- go errorCollator(results, errs)
-
- procs := getGoMaxProcs()
-
- wg := &sync.WaitGroup{}
-
- for i := 0; i < procs*4; i++ {
- wg.Add(1)
- go pageRenderer(s, pages, results, wg)
- }
-
- for _, page := range s.Pages {
- pages <- page
- }
-
- close(pages)
-
- wg.Wait()
-
- close(results)
-
- err := <-errs
- if err != nil {
- return fmt.Errorf("Error(s) rendering pages: %s", err)
- }
- return nil
-}
-
-func pageRenderer(s *Site, pages <-chan *Page, results chan<- error, wg *sync.WaitGroup) {
- defer wg.Done()
- for p := range pages {
- targetPath := p.TargetPath()
- layouts := p.layouts()
- jww.DEBUG.Printf("Render Page to %q with layouts %q", targetPath, layouts)
- if err := s.renderAndWritePage("page "+p.FullFilePath(), targetPath, p, s.appendThemeTemplates(layouts)...); err != nil {
- results <- err
- }
-
- if p.NodeType.IsNode() {
- if err := p.renderPaginator(s); err != nil {
- results <- err
- }
- }
- }
-}
-
func errorCollator(results <-chan error, errs chan<- error) {
errMsgs := []string{}
for err := range results {
// renderTaxonomiesLists renders the listing pages based on the meta data
// each unique term within a taxonomy will have a page created
func (s *Site) renderTaxonomiesLists(prepare bool) error {
+ if nodePageFeatureFlag {
+ return nil
+ }
wg := &sync.WaitGroup{}
taxes := make(chan taxRenderInfo)
--- /dev/null
+// Copyright 2016 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"
+ "path/filepath"
+ "sync"
+
+ "github.com/spf13/hugo/helpers"
+
+ jww "github.com/spf13/jwalterweatherman"
+)
+
+// renderPages renders pages each corresponding to a markdown file.
+// TODO(bep np doc
+func (s *Site) renderPages() error {
+
+ results := make(chan error)
+ pages := make(chan *Page)
+ errs := make(chan error)
+
+ go errorCollator(results, errs)
+
+ procs := getGoMaxProcs()
+
+ wg := &sync.WaitGroup{}
+
+ for i := 0; i < procs*4; i++ {
+ wg.Add(1)
+ go pageRenderer(s, pages, results, wg)
+ }
+
+ for _, page := range s.Pages {
+ pages <- page
+ }
+
+ close(pages)
+
+ wg.Wait()
+
+ close(results)
+
+ err := <-errs
+ if err != nil {
+ return fmt.Errorf("Error(s) rendering pages: %s", err)
+ }
+ return nil
+}
+
+func pageRenderer(s *Site, pages <-chan *Page, results chan<- error, wg *sync.WaitGroup) {
+ defer wg.Done()
+ for p := range pages {
+ targetPath := p.TargetPath()
+ layouts := p.layouts()
+ jww.DEBUG.Printf("Render Page to %q with layouts %q", targetPath, layouts)
+ if err := s.renderAndWritePage("page "+p.FullFilePath(), targetPath, p, s.appendThemeTemplates(layouts)...); err != nil {
+ results <- err
+ }
+
+ if p.NodeType.IsNode() {
+ if err := s.renderPaginator(p); err != nil {
+ results <- err
+ }
+ }
+ }
+}
+
+// renderPaginator must be run after the owning Page has been rendered.
+// TODO(bep) np
+func (s *Site) renderPaginator(p *Page) error {
+ if p.paginator != nil {
+ jww.DEBUG.Printf("Render paginator for page %q", p.Path())
+ paginatePath := helpers.Config().GetString("paginatePath")
+
+ // write alias for page 1
+ // TODO(bep) ml all of these n.addLang ... fix.
+ //permaLink, _ := p.Permalink()
+ // TODO(bep) np fix
+ //s.writeDestAlias(p.addLangPathPrefix(helpers.PaginateAliasPath("", 1)), permaLink, nil)
+
+ pagers := p.paginator.Pagers()
+
+ for i, pager := range pagers {
+ if i == 0 {
+ // already created
+ continue
+ }
+
+ pagerNode := p.copy()
+
+ pagerNode.paginator = pager
+ if pager.TotalPages() > 0 {
+ first, _ := pager.page(0)
+ pagerNode.Date = first.Date
+ pagerNode.Lastmod = first.Lastmod
+ }
+
+ pageNumber := i + 1
+ htmlBase := path.Join(p.URLPath.URL, fmt.Sprintf("/%s/%d", paginatePath, pageNumber))
+ htmlBase = p.addLangPathPrefix(htmlBase)
+ if err := s.renderAndWritePage(pagerNode.Title,
+ filepath.FromSlash(htmlBase), pagerNode, p.layouts()...); err != nil {
+ return err
+ }
+
+ }
+ }
+ return nil
+}
projects / brevno-suite / hugo / commitdiff