mirror of
https://github.com/gohugoio/hugo.git
synced 2024-07-02 15:20:28 +00:00
90da7664bf
The main topic of this commit is that you can now index fragments (content heading identifiers) when calling `.Related`.
You can do this by:
* Configure one or more indices with type `fragments`
* The name of those index configurations maps to an (optional) front matter slice with fragment references. This allows you to link
page<->fragment and page<->page.
* This also will index all the fragments (heading identifiers) of the pages.
It's also possible to use type `fragments` indices in shortcode, e.g.:
```
{{ $related := site.RegularPages.Related .Page }}
```
But, and this is important, you need to include the shortcode using the `{{<` delimiter. Not doing so will create infinite loops and timeouts.
This commit also:
* Adds two new methods to Page: Fragments (can also be used to build ToC) and HeadingsFiltered (this is only used in Related Content with
index type `fragments` and `enableFilter` set to true.
* Consolidates all `.Related*` methods into one, which takes either a `Page` or an options map as its only argument.
* Add `context.Context` to all of the content related Page API. Turns out it wasn't strictly needed for this particular feature, but it will
soon become usefil, e.g. in #9339.
Closes #10711
Updates #9339
Updates #10725
468 lines
14 KiB
Go
468 lines
14 KiB
Go
// Copyright 2019 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 page
|
|
|
|
import (
|
|
"context"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
qt "github.com/frankban/quicktest"
|
|
"github.com/spf13/cast"
|
|
)
|
|
|
|
type pageGroupTestObject struct {
|
|
path string
|
|
weight int
|
|
date string
|
|
param string
|
|
}
|
|
|
|
var pageGroupTestSources = []pageGroupTestObject{
|
|
{"/section1/testpage1.md", 3, "2012-04-06", "foo"},
|
|
{"/section1/testpage2.md", 3, "2012-01-01", "bar"},
|
|
{"/section1/testpage3.md", 2, "2012-04-06", "foo"},
|
|
{"/section2/testpage4.md", 1, "2012-03-02", "bar"},
|
|
// date might also be a full datetime:
|
|
{"/section2/testpage5.md", 1, "2012-04-06T00:00:00Z", "baz"},
|
|
}
|
|
|
|
func preparePageGroupTestPages(t *testing.T) Pages {
|
|
var pages Pages
|
|
for _, src := range pageGroupTestSources {
|
|
p := newTestPage()
|
|
p.path = src.path
|
|
if p.path != "" {
|
|
p.section = strings.Split(strings.TrimPrefix(p.path, "/"), "/")[0]
|
|
}
|
|
p.weight = src.weight
|
|
p.date = cast.ToTime(src.date)
|
|
p.pubDate = cast.ToTime(src.date)
|
|
p.expiryDate = cast.ToTime(src.date)
|
|
p.lastMod = cast.ToTime(src.date).AddDate(3, 0, 0)
|
|
p.params["custom_param"] = src.param
|
|
p.params["custom_date"] = cast.ToTime(src.date)
|
|
p.params["custom_string_date"] = src.date
|
|
pages = append(pages, p)
|
|
}
|
|
return pages
|
|
}
|
|
|
|
func TestGroupByWithFieldNameArg(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: 1, Pages: Pages{pages[3], pages[4]}},
|
|
{Key: 2, Pages: Pages{pages[2]}},
|
|
{Key: 3, Pages: Pages{pages[0], pages[1]}},
|
|
}
|
|
|
|
groups, err := pages.GroupBy(context.Background(), "Weight")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByWithMethodNameArg(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "section1", Pages: Pages{pages[0], pages[1], pages[2]}},
|
|
{Key: "section2", Pages: Pages{pages[3], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupBy(context.Background(), "Type")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByWithSectionArg(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "section1", Pages: Pages{pages[0], pages[1], pages[2]}},
|
|
{Key: "section2", Pages: Pages{pages[3], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupBy(context.Background(), "Section")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be\n%#v, got\n%#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByInReverseOrder(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: 3, Pages: Pages{pages[0], pages[1]}},
|
|
{Key: 2, Pages: Pages{pages[2]}},
|
|
{Key: 1, Pages: Pages{pages[3], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupBy(context.Background(), "Weight", "desc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByCalledWithEmptyPages(t *testing.T) {
|
|
t.Parallel()
|
|
var pages Pages
|
|
groups, err := pages.GroupBy(context.Background(), "Weight")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if groups != nil {
|
|
t.Errorf("PagesGroup isn't empty. It should be %#v, got %#v", nil, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamCalledWithUnavailableKey(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
_, err := pages.GroupByParam("UnavailableKey")
|
|
if err == nil {
|
|
t.Errorf("GroupByParam should return an error but didn't")
|
|
}
|
|
}
|
|
|
|
func TestReverse(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
|
|
groups1, err := pages.GroupBy(context.Background(), "Weight", "desc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
|
|
groups2, err := pages.GroupBy(context.Background(), "Weight")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
groups2 = groups2.Reverse()
|
|
|
|
if !reflect.DeepEqual(groups2, groups1) {
|
|
t.Errorf("PagesGroup is sorted in unexpected order. It should be %#v, got %#v", groups2, groups1)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParam(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "bar", Pages: Pages{pages[1], pages[3]}},
|
|
{Key: "baz", Pages: Pages{pages[4]}},
|
|
{Key: "foo", Pages: Pages{pages[0], pages[2]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByParam("custom_param")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamInReverseOrder(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "foo", Pages: Pages{pages[0], pages[2]}},
|
|
{Key: "baz", Pages: Pages{pages[4]}},
|
|
{Key: "bar", Pages: Pages{pages[1], pages[3]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByParam("custom_param", "desc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamCalledWithCapitalLetterString(t *testing.T) {
|
|
c := qt.New(t)
|
|
testStr := "TestString"
|
|
p := newTestPage()
|
|
p.params["custom_param"] = testStr
|
|
pages := Pages{p}
|
|
|
|
groups, err := pages.GroupByParam("custom_param")
|
|
|
|
c.Assert(err, qt.IsNil)
|
|
c.Assert(groups[0].Key, qt.Equals, testStr)
|
|
}
|
|
|
|
func TestGroupByParamCalledWithSomeUnavailableParams(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
delete(pages[1].Params(), "custom_param")
|
|
delete(pages[3].Params(), "custom_param")
|
|
delete(pages[4].Params(), "custom_param")
|
|
|
|
expect := PagesGroup{
|
|
{Key: "foo", Pages: Pages{pages[0], pages[2]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByParam("custom_param")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamCalledWithEmptyPages(t *testing.T) {
|
|
t.Parallel()
|
|
var pages Pages
|
|
groups, err := pages.GroupByParam("custom_param")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if groups != nil {
|
|
t.Errorf("PagesGroup isn't empty. It should be %#v, got %#v", nil, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamCalledWithUnavailableParam(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
_, err := pages.GroupByParam("unavailable_param")
|
|
if err == nil {
|
|
t.Errorf("GroupByParam should return an error but didn't")
|
|
}
|
|
}
|
|
|
|
func TestGroupByDate(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-04", Pages: Pages{pages[4], pages[2], pages[0]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByDate("2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByDateInReverseOrder(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-04", Pages: Pages{pages[0], pages[2], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByDate("2006-01", "asc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByPublishDate(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-04", Pages: Pages{pages[4], pages[2], pages[0]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByPublishDate("2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByPublishDateInReverseOrder(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-04", Pages: Pages{pages[0], pages[2], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByDate("2006-01", "asc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByPublishDateWithEmptyPages(t *testing.T) {
|
|
t.Parallel()
|
|
var pages Pages
|
|
groups, err := pages.GroupByPublishDate("2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if groups != nil {
|
|
t.Errorf("PagesGroup isn't empty. It should be %#v, got %#v", nil, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByExpiryDate(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-04", Pages: Pages{pages[4], pages[2], pages[0]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByExpiryDate("2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamDate(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-04", Pages: Pages{pages[4], pages[2], pages[0]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByParamDate("custom_date", "2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
// https://github.com/gohugoio/hugo/issues/3983
|
|
func TestGroupByParamDateWithStringParams(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-04", Pages: Pages{pages[4], pages[2], pages[0]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByParamDate("custom_string_date", "2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByLastmod(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2015-04", Pages: Pages{pages[4], pages[2], pages[0]}},
|
|
{Key: "2015-03", Pages: Pages{pages[3]}},
|
|
{Key: "2015-01", Pages: Pages{pages[1]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByLastmod("2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByLastmodInReverseOrder(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2015-01", Pages: Pages{pages[1]}},
|
|
{Key: "2015-03", Pages: Pages{pages[3]}},
|
|
{Key: "2015-04", Pages: Pages{pages[0], pages[2], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByLastmod("2006-01", "asc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be\n%#v, got\n%#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamDateInReverseOrder(t *testing.T) {
|
|
t.Parallel()
|
|
pages := preparePageGroupTestPages(t)
|
|
expect := PagesGroup{
|
|
{Key: "2012-01", Pages: Pages{pages[1]}},
|
|
{Key: "2012-03", Pages: Pages{pages[3]}},
|
|
{Key: "2012-04", Pages: Pages{pages[0], pages[2], pages[4]}},
|
|
}
|
|
|
|
groups, err := pages.GroupByParamDate("custom_date", "2006-01", "asc")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if !reflect.DeepEqual(groups, expect) {
|
|
t.Errorf("PagesGroup has unexpected groups. It should be %#v, got %#v", expect, groups)
|
|
}
|
|
}
|
|
|
|
func TestGroupByParamDateWithEmptyPages(t *testing.T) {
|
|
t.Parallel()
|
|
var pages Pages
|
|
groups, err := pages.GroupByParamDate("custom_date", "2006-01")
|
|
if err != nil {
|
|
t.Fatalf("Unable to make PagesGroup array: %s", err)
|
|
}
|
|
if groups != nil {
|
|
t.Errorf("PagesGroup isn't empty. It should be %#v, got %#v", nil, groups)
|
|
}
|
|
}
|