new menus system including active link & nesting

hugolib/menu.go

@@ -0,0 +1,144 @@
+// Copyright © 2013-14 Steve Francia <spf@spf13.com>.
+//
+// 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
+}

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
 }
 

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)

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