From 9ecf58e29ba8dafb99f51bfba9bfe9e576410d73 Mon Sep 17 00:00:00 2001 From: spf13 Date: Wed, 23 Apr 2014 02:59:19 -0400 Subject: [PATCH] new menus system including active link & nesting --- hugolib/menu.go | 144 ++++++++++++++++++++++++++++++++++++++++++++++++ hugolib/node.go | 13 ++++- hugolib/page.go | 91 ++++++++++++++++++++++++++++++ hugolib/site.go | 84 +++++++++++++++++++++++----- 4 files changed, 316 insertions(+), 16 deletions(-) create mode 100644 hugolib/menu.go diff --git a/hugolib/menu.go b/hugolib/menu.go new file mode 100644 index 000000000..7c43cfe15 --- /dev/null +++ b/hugolib/menu.go @@ -0,0 +1,144 @@ +// Copyright © 2013-14 Steve Francia . +// +// Licensed under the Simple Public 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://opensource.org/licenses/Simple-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 "sort" + +type MenuEntry struct { + Url string + Name string + Menu string + PreName string + PostName string + Weight int + Parent string + Children Menu +} + +type Menu []*MenuEntry +type Menus map[string]*Menu +type PageMenus map[string]*MenuEntry + +func (me *MenuEntry) AddChild(child *MenuEntry) { + me.Children = append(me.Children, child) + me.Children.Sort() +} + +func (me *MenuEntry) HasChildren() bool { + return me.Children != nil +} + +//func (me *MenuEntry) RelUrl() string { +//link, err := p.permalink() +//if err != nil { +//return "", err +//} + +//link.Scheme = "" +//link.Host = "" +//link.User = nil +//link.Opaque = "" +//return link.String(), nil +//} + +func (m Menu) Add(me *MenuEntry) Menu { + app := func(slice Menu, x ...*MenuEntry) Menu { + n := len(slice) + len(x) + if n > cap(slice) { + size := cap(slice) * 2 + if size < n { + size = n + } + new := make(Menu, size) + copy(new, slice) + slice = new + } + slice = slice[0:n] + copy(slice[n-len(x):], x) + return slice + } + + m = app(m, me) + m.Sort() + return m +} + +/* + * Implementation of a custom sorter for Menu + */ + +// A type to implement the sort interface for Menu +type MenuSorter struct { + menu Menu + by MenuEntryBy +} + +// Closure used in the Sort.Less method. +type MenuEntryBy func(m1, m2 *MenuEntry) bool + +func (by MenuEntryBy) Sort(menu Menu) { + ms := &MenuSorter{ + menu: menu, + by: by, // The Sort method's receiver is the function (closure) that defines the sort order. + } + sort.Sort(ms) +} + +var DefaultMenuEntrySort = func(m1, m2 *MenuEntry) bool { + if m1.Weight == m2.Weight { + return m1.Name < m2.Name + } else { + return m1.Weight < m2.Weight + } +} + +func (ms *MenuSorter) Len() int { return len(ms.menu) } +func (ms *MenuSorter) Swap(i, j int) { ms.menu[i], ms.menu[j] = ms.menu[j], ms.menu[i] } + +// Less is part of sort.Interface. It is implemented by calling the "by" closure in the sorter. +func (ms *MenuSorter) Less(i, j int) bool { return ms.by(ms.menu[i], ms.menu[j]) } + +func (p Menu) Sort() { + MenuEntryBy(DefaultMenuEntrySort).Sort(p) +} + +func (p Menu) Limit(n int) Menu { + if len(p) < n { + return p[0:n] + } else { + return p + } +} + +func (p Menu) ByWeight() Menu { + MenuEntryBy(DefaultMenuEntrySort).Sort(p) + return p +} + +func (p Menu) ByName() Menu { + title := func(m1, m2 *MenuEntry) bool { + return m1.Name < m2.Name + } + + MenuEntryBy(title).Sort(p) + return p +} + +func (m Menu) Reverse() Menu { + for i, j := 0, len(m)-1; i < j; i, j = i+1, j-1 { + m[i], m[j] = m[j], m[i] + } + + return m +} diff --git a/hugolib/node.go b/hugolib/node.go index fa60bb518..8ec0b4a2b 100644 --- a/hugolib/node.go +++ b/hugolib/node.go @@ -31,7 +31,18 @@ type Node struct { UrlPath } -func (n Node) RSSlink() template.HTML { +func (n *Node) Now() time.Time { + return time.Now() +} + +func (n *Node) HasMenuCurrent(menu string, me *MenuEntry) bool { + return false +} +func (n *Node) IsMenuCurrent(menu string, name string) bool { + return false +} + +func (n *Node) RSSlink() template.HTML { return n.RSSLink } diff --git a/hugolib/page.go b/hugolib/page.go index ec5d2f0af..0015c7984 100644 --- a/hugolib/page.go +++ b/hugolib/page.go @@ -419,6 +419,97 @@ func (page *Page) GetParam(key string) interface{} { return nil } +func (page *Page) HasMenuCurrent(menu string, me *MenuEntry) bool { + menus := page.Menus() + + if m, ok := menus[menu]; ok { + if me.HasChildren() { + for _, child := range me.Children { + if child.Name == m.Name { + return true + } + } + } + } + + return false + +} + +func (page *Page) IsMenuCurrent(menu string, name string) bool { + menus := page.Menus() + + if me, ok := menus[menu]; ok { + return me.Name == name + } + + return false +} + +func (page *Page) Menus() PageMenus { + ret := PageMenus{} + + if ms, ok := page.Params["menu"]; ok { + link, _ := page.Permalink() + + me := MenuEntry{Name: page.LinkTitle(), Weight: page.Weight, Url: link} + + // Could be the name of the menu to attach it to + mname, err := cast.ToStringE(ms) + + if err == nil { + me.Menu = mname + ret[mname] = &me + return ret + } + + // Could be an slice of strings + mnames, err := cast.ToStringSliceE(ms) + + if err == nil { + for _, mname := range mnames { + me.Menu = mname + ret[mname] = &me + return ret + } + } + + // Could be a structured menu entry + menus, err := cast.ToStringMapE(ms) + + if err != nil { + jww.ERROR.Printf("unable to process menus for %q\n", page.Title) + } + + for name, menu := range menus { + menuEntry := MenuEntry{Name: page.LinkTitle(), Url: link, Weight: page.Weight, Menu: name} + jww.DEBUG.Printf("found menu: %q, in %q\n", name, page.Title) + + ime, err := cast.ToStringMapE(menu) + if err != nil { + jww.ERROR.Printf("unable to process menus for %q\n", page.Title) + } + + for k, v := range ime { + loki := strings.ToLower(k) + switch loki { + case "weight": + menuEntry.Weight = cast.ToInt(v) + case "name": + menuEntry.Name = cast.ToString(v) + case "parent": + menuEntry.Parent = cast.ToString(v) + } + } + + ret[name] = &menuEntry + } + return ret + } + + return nil +} + type frontmatterType struct { markstart, markend []byte parse func([]byte) (interface{}, error) diff --git a/hugolib/site.go b/hugolib/site.go index bc5d64a8a..4fdfb740b 100644 --- a/hugolib/site.go +++ b/hugolib/site.go @@ -63,6 +63,7 @@ type Site struct { Sections Taxonomy Info *SiteInfo Shortcodes map[string]ShortcodeFunc + Menus Menus timer *nitro.B Target target.Output Alias target.AliasPublisher @@ -76,6 +77,7 @@ type SiteInfo struct { Taxonomies TaxonomyList Indexes *TaxonomyList // legacy, should be identical to Taxonomies Recent *Pages + Menus *Menus Title string Author map[string]string LanguageCode string @@ -241,6 +243,8 @@ func (s *Site) initialize() (err error) { Base: s.absContentDir(), } + s.Menus = Menus{} + s.initializeSiteInfo() s.Shortcodes = make(map[string]ShortcodeFunc) @@ -266,6 +270,7 @@ func (s *Site) initializeSiteInfo() { Copyright: viper.GetString("copyright"), DisqusShortname: viper.GetString("DisqusShortname"), Recent: &s.Pages, + Menus: &s.Menus, Params: params, Permalinks: permalinks, } @@ -343,6 +348,65 @@ func (s *Site) CreatePages() (err error) { } func (s *Site) BuildSiteMeta() (err error) { + + s.assembleMenus() + + if len(s.Pages) == 0 { + return + } + + s.assembleTaxonomies() + s.assembleSections() + s.Info.LastChange = s.Pages[0].Date + + return +} + +func (s *Site) assembleMenus() { + + type twoD struct { + MenuName, EntryName string + } + flat := map[twoD]*MenuEntry{} + children := map[twoD]Menu{} + + //creating flat hash + for _, p := range s.Pages { + for name, me := range p.Menus() { + flat[twoD{name, me.Name}] = me + } + } + + // Create Children Menus First + for _, e := range flat { + if e.Parent != "" { + children[twoD{e.Menu, e.Parent}] = children[twoD{e.Menu, e.Parent}].Add(e) + } + } + + // Placing Children in Parents (in flat) + for p, childmenu := range children { + _, ok := flat[twoD{p.MenuName, p.EntryName}] + if !ok { + // if parent does not exist, create one without a url + flat[twoD{p.MenuName, p.EntryName}] = &MenuEntry{Name: p.EntryName, Url: ""} + } + flat[twoD{p.MenuName, p.EntryName}].Children = childmenu + } + + // Assembling Top Level of Tree + for menu, e := range flat { + if e.Parent == "" { + _, ok := s.Menus[menu.MenuName] + if !ok { + s.Menus[menu.MenuName] = &Menu{} + } + *s.Menus[menu.MenuName] = s.Menus[menu.MenuName].Add(e) + } + } +} + +func (s *Site) assembleTaxonomies() { s.Taxonomies = make(TaxonomyList) s.Sections = make(Taxonomy) @@ -376,6 +440,11 @@ func (s *Site) BuildSiteMeta() (err error) { } } + s.Info.Taxonomies = s.Taxonomies + s.Info.Indexes = &s.Taxonomies +} + +func (s *Site) assembleSections() { for i, p := range s.Pages { s.Sections.Add(p.Section, WeightedPage{s.Pages[i].Weight, s.Pages[i]}) } @@ -383,21 +452,6 @@ func (s *Site) BuildSiteMeta() (err error) { for k := range s.Sections { s.Sections[k].Sort() } - - s.Info.Taxonomies = s.Taxonomies - s.Info.Indexes = &s.Taxonomies - - if len(s.Pages) == 0 { - return - } - s.Info.LastChange = s.Pages[0].Date - - // populate pages with site metadata - for _, p := range s.Pages { - p.Site = s.Info - } - - return } func (s *Site) possibleTaxonomies() (taxonomies []string) {