diff --git a/hugolib/pagination.go b/hugolib/pagination.go index c6db86550..67cc02167 100644 --- a/hugolib/pagination.go +++ b/hugolib/pagination.go @@ -88,19 +88,11 @@ func (p *pager) Next() *pager { // First returns the pager for the first page. func (p *pager) First() *pager { - if p.TotalPages() == 0 { - return nil - } - return p.pagers[0] } // Last returns the pager for the last page. func (p *pager) Last() *pager { - if p.TotalPages() == 0 { - return nil - } - return p.pagers[len(p.pagers)-1] } @@ -138,10 +130,6 @@ func splitPages(pages Pages, size int) []Pages { // If it's not, one will be created with all pages in Data["Pages"]. func (n *Node) Paginator() (*pager, error) { - if n.IsPage() { - return nil, errors.New("Paginators isn't supported for content pages.") - } - var initError error n.paginatorInit.Do(func() { @@ -170,15 +158,18 @@ func (n *Node) Paginator() (*pager, error) { return n.paginator, nil } +func (p *Page) Paginator() (*pager, error) { + return nil, errors.New("Paginators not supported for content pages.") +} +func (p *Page) Paginate(seq interface{}) (*pager, error) { + return nil, errors.New("Paginators not supported for content pages.") +} + // Paginate gets this Node's paginator if it's already created. // If it's not, one will be created with the qiven sequence. // Note that repeated calls will return the same result, even if the sequence is different. func (n *Node) Paginate(seq interface{}) (*pager, error) { - if n.IsPage() { - return nil, errors.New("Paginators isn't supported for content pages.") - } - var initError error n.paginatorInit.Do(func() { @@ -227,16 +218,16 @@ func paginatePages(seq interface{}, section string) (pagers, error) { } urlFactory := newPaginationUrlFactory(section) - paginator := newPaginator(pages, paginateSize, urlFactory) + paginator, _ := newPaginator(pages, paginateSize, urlFactory) pagers := paginator.Pagers() return pagers, nil } -func newPaginator(pages Pages, size int, urlFactory paginationUrlFactory) *paginator { +func newPaginator(pages Pages, size int, urlFactory paginationUrlFactory) (*paginator, error) { if size <= 0 { - panic("Paginator size must be positive") + return nil, errors.New("Paginator size must be positive") } split := splitPages(pages, size) @@ -250,7 +241,7 @@ func newPaginator(pages Pages, size int, urlFactory paginationUrlFactory) *pagin p.pagers = pagers - return p + return p, nil } func newPaginationUrlFactory(pathElements ...string) paginationUrlFactory { diff --git a/hugolib/pagination_test.go b/hugolib/pagination_test.go index 080866f6f..cbf14e163 100644 --- a/hugolib/pagination_test.go +++ b/hugolib/pagination_test.go @@ -24,14 +24,17 @@ func TestSplitPages(t *testing.T) { } -func TestPaginator(t *testing.T) { +func TestPager(t *testing.T) { pages := createTestPages(21) urlFactory := func(page int) string { return fmt.Sprintf("page/%d/", page) } - paginator := newPaginator(pages, 5, urlFactory) + _, err := newPaginator(pages, -1, urlFactory) + assert.NotNil(t, err) + + paginator, _ := newPaginator(pages, 5, urlFactory) paginatorPages := paginator.Pagers() assert.Equal(t, 5, len(paginatorPages)) @@ -43,22 +46,40 @@ func TestPaginator(t *testing.T) { assert.Equal(t, "page/1/", first.Url()) assert.Equal(t, first, first.First()) assert.Equal(t, true, first.HasNext()) + assert.Equal(t, paginatorPages[1], first.Next()) assert.Equal(t, false, first.HasPrev()) + assert.Nil(t, first.Prev()) assert.Equal(t, 5, first.NumberOfElements()) assert.Equal(t, 1, first.PageNumber()) third := paginatorPages[2] assert.Equal(t, true, third.HasNext()) assert.Equal(t, true, third.HasPrev()) + assert.Equal(t, paginatorPages[1], third.Prev()) last := paginatorPages[4] assert.Equal(t, "page/5/", last.Url()) assert.Equal(t, last, last.Last()) assert.Equal(t, false, last.HasNext()) + assert.Nil(t, last.Next()) assert.Equal(t, true, last.HasPrev()) assert.Equal(t, 1, last.NumberOfElements()) assert.Equal(t, 5, last.PageNumber()) +} +func TestPagerNoPages(t *testing.T) { + pages := createTestPages(0) + urlFactory := func(page int) string { + return fmt.Sprintf("page/%d/", page) + } + + paginator, _ := newPaginator(pages, 5, urlFactory) + paginatorPages := paginator.Pagers() + + assert.Equal(t, 0, len(paginatorPages)) + assert.Equal(t, 0, paginator.TotalNumberOfElements()) + assert.Equal(t, 5, paginator.PageSize()) + assert.Equal(t, 0, paginator.TotalPages()) } func TestPaginationUrlFactory(t *testing.T) { @@ -73,6 +94,88 @@ func TestPaginationUrlFactory(t *testing.T) { } +func TestPaginator(t *testing.T) { + viper.Set("paginate", 5) + pages := createTestPages(12) + s := &Site{} + n1 := s.newHomeNode() + n2 := s.newHomeNode() + n1.Data["Pages"] = pages + + paginator1, err := n1.Paginator() + + assert.Nil(t, err) + assert.NotNil(t, paginator1) + assert.Equal(t, 3, paginator1.TotalPages()) + assert.Equal(t, 12, paginator1.TotalNumberOfElements()) + + n2.paginator = paginator1.Next() + paginator2, err := n2.Paginator() + assert.Nil(t, err) + assert.Equal(t, paginator2, paginator1.Next()) + + n1.Data["Pages"] = createTestPages(1) + samePaginator, _ := n1.Paginator() + assert.Equal(t, paginator1, samePaginator) + + p, _ := NewPage("test") + _, err = p.Paginator() + assert.NotNil(t, err) +} + +func TestPaginatorWithNegativePaginate(t *testing.T) { + viper.Set("paginate", -1) + s := &Site{} + _, err := s.newHomeNode().Paginator() + assert.NotNil(t, err) +} + +func TestPaginate(t *testing.T) { + viper.Set("paginate", 5) + pages := createTestPages(6) + s := &Site{} + n1 := s.newHomeNode() + n2 := s.newHomeNode() + + paginator1, err := n1.Paginate(pages) + + assert.Nil(t, err) + assert.NotNil(t, paginator1) + assert.Equal(t, 2, paginator1.TotalPages()) + assert.Equal(t, 6, paginator1.TotalNumberOfElements()) + + n2.paginator = paginator1.Next() + paginator2, err := n2.Paginate(pages) + assert.Nil(t, err) + assert.Equal(t, paginator2, paginator1.Next()) + + samePaginator, err := n1.Paginate(createTestPages(2)) + assert.Equal(t, paginator1, samePaginator) + + p, _ := NewPage("test") + _, err = p.Paginate(pages) + assert.NotNil(t, err) +} + +func TestPaginateWithNegativePaginate(t *testing.T) { + viper.Set("paginate", -1) + s := &Site{} + _, err := s.newHomeNode().Paginate(createTestPages(2)) + assert.NotNil(t, err) +} + +func TestPaginatePages(t *testing.T) { + viper.Set("paginate", 11) + for i, seq := range []interface{}{createTestPages(11), WeightedPages{}, PageGroup{}, &Pages{}} { + v, err := paginatePages(seq, "t") + assert.NotNil(t, v, "Val %d", i) + assert.Nil(t, err, "Err %d", i) + } + _, err := paginatePages(Site{}, "t") + assert.NotNil(t, err) + +} + func createTestPages(num int) Pages { pages := make(Pages, num)