hugo/hugolib/menu.go

225 lines
5 KiB
Go
Raw Normal View History

// Copyright 2015 The Hugo Authors. All rights reserved.
//
2015-11-23 22:16:36 -05:00
// 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
2015-11-23 22:16:36 -05:00
// 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 (
2014-05-27 18:34:29 -04:00
"html/template"
"sort"
"strings"
"github.com/spf13/cast"
)
2016-03-22 19:29:39 -04:00
// MenuEntry represents a menu item defined in either Page front matter
// or in the site config.
type MenuEntry struct {
URL string
Page *Page
Name string
Menu string
Identifier string
title string
2014-05-27 18:34:29 -04:00
Pre template.HTML
Post template.HTML
Weight int
Parent string
Children Menu
}
2016-03-22 19:29:39 -04:00
// Menu is a collection of menu entries.
type Menu []*MenuEntry
2016-03-22 19:29:39 -04:00
// Menus is a dictionary of menus.
type Menus map[string]*Menu
2016-03-22 19:29:39 -04:00
// PageMenus is a dictionary of menus defined in the Pages.
type PageMenus map[string]*MenuEntry
2016-03-22 19:29:39 -04:00
// HasChildren returns whether this menu item has any children.
func (m *MenuEntry) HasChildren() bool {
return m.Children != nil
}
2016-03-22 19:29:39 -04:00
// KeyName returns the key used to identify this menu entry.
func (m *MenuEntry) KeyName() string {
if m.Identifier != "" {
return m.Identifier
}
2016-03-22 19:29:39 -04:00
return m.Name
}
2016-03-22 19:29:39 -04:00
func (m *MenuEntry) hopefullyUniqueID() string {
if m.Identifier != "" {
return m.Identifier
} else if m.URL != "" {
return m.URL
} else {
2016-03-22 19:29:39 -04:00
return m.Name
}
}
2016-03-22 19:29:39 -04:00
// IsEqual returns whether the two menu entries represents the same menu entry.
func (m *MenuEntry) IsEqual(inme *MenuEntry) bool {
return m.hopefullyUniqueID() == inme.hopefullyUniqueID() && m.Parent == inme.Parent
}
2016-03-22 19:29:39 -04:00
// IsSameResource returns whether the two menu entries points to the same
// resource (URL).
func (m *MenuEntry) IsSameResource(inme *MenuEntry) bool {
return m.URL != "" && inme.URL != "" && m.URL == inme.URL
}
2016-03-22 19:29:39 -04:00
func (m *MenuEntry) marshallMap(ime map[string]interface{}) {
for k, v := range ime {
loki := strings.ToLower(k)
switch loki {
case "url":
2016-03-22 19:29:39 -04:00
m.URL = cast.ToString(v)
case "weight":
2016-03-22 19:29:39 -04:00
m.Weight = cast.ToInt(v)
case "name":
2016-03-22 19:29:39 -04:00
m.Name = cast.ToString(v)
case "title":
m.title = cast.ToString(v)
2014-05-27 18:34:29 -04:00
case "pre":
2016-03-22 19:29:39 -04:00
m.Pre = template.HTML(cast.ToString(v))
2014-05-27 18:34:29 -04:00
case "post":
2016-03-22 19:29:39 -04:00
m.Post = template.HTML(cast.ToString(v))
case "identifier":
2016-03-22 19:29:39 -04:00
m.Identifier = cast.ToString(v)
case "parent":
2016-03-22 19:29:39 -04:00
m.Parent = cast.ToString(v)
}
}
}
2016-03-22 19:29:39 -04:00
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
2016-03-22 19:29:39 -04:00
type menuSorter struct {
menu Menu
2016-03-22 19:29:39 -04:00
by menuEntryBy
}
// Closure used in the Sort.Less method.
2016-03-22 19:29:39 -04:00
type menuEntryBy func(m1, m2 *MenuEntry) bool
2016-03-22 19:29:39 -04:00
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.Stable(ms)
}
var defaultMenuEntrySort = func(m1, m2 *MenuEntry) bool {
if m1.Weight == m2.Weight {
if m1.Name == m2.Name {
return m1.Identifier < m2.Identifier
}
return m1.Name < m2.Name
}
if m2.Weight == 0 {
return true
}
if m1.Weight == 0 {
return false
}
return m1.Weight < m2.Weight
}
2016-03-22 19:29:39 -04:00
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.
2016-03-22 19:29:39 -04:00
func (ms *menuSorter) Less(i, j int) bool { return ms.by(ms.menu[i], ms.menu[j]) }
2016-03-22 19:29:39 -04:00
// Sort sorts the menu by weight, name and then by identifier.
2016-02-07 06:34:43 -05:00
func (m Menu) Sort() Menu {
2016-03-22 19:29:39 -04:00
menuEntryBy(defaultMenuEntrySort).Sort(m)
2016-02-07 06:34:43 -05:00
return m
}
2016-03-22 19:29:39 -04:00
// Limit limits the returned menu to n entries.
func (m Menu) Limit(n int) Menu {
2016-02-06 16:53:59 -05:00
if len(m) > n {
return m[0:n]
}
return m
}
2016-03-22 19:29:39 -04:00
// ByWeight sorts the menu by the weight defined in the menu configuration.
func (m Menu) ByWeight() Menu {
2016-03-22 19:29:39 -04:00
menuEntryBy(defaultMenuEntrySort).Sort(m)
return m
}
2016-03-22 19:29:39 -04:00
// ByName sorts the menu by the name defined in the menu configuration.
func (m Menu) ByName() Menu {
title := func(m1, m2 *MenuEntry) bool {
return m1.Name < m2.Name
}
2016-03-22 19:29:39 -04:00
menuEntryBy(title).Sort(m)
return m
}
2016-03-22 19:29:39 -04:00
// Reverse reverses the order of the menu entries.
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
}
func (m *MenuEntry) Title() string {
if m.title != "" {
return m.title
}
if m.Page != nil {
return m.Page.LinkTitle()
}
return ""
}