2015-12-07 13:57:01 -05:00
|
|
|
// Copyright 2015 The Hugo Authors. All rights reserved.
|
2014-12-27 08:11:19 -05:00
|
|
|
//
|
2015-11-23 22:16:36 -05:00
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
2014-12-27 08:11:19 -05:00
|
|
|
// 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
|
2014-12-27 08:11:19 -05:00
|
|
|
//
|
|
|
|
// 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 (
|
|
|
|
"errors"
|
|
|
|
"fmt"
|
|
|
|
"html/template"
|
|
|
|
"math"
|
|
|
|
"path"
|
2015-03-31 16:33:24 -04:00
|
|
|
"reflect"
|
2016-07-26 13:04:10 -04:00
|
|
|
|
|
|
|
"github.com/spf13/cast"
|
|
|
|
"github.com/spf13/hugo/helpers"
|
2014-12-27 08:11:19 -05:00
|
|
|
)
|
|
|
|
|
2016-03-24 09:18:47 -04:00
|
|
|
// Pager represents one of the elements in a paginator.
|
|
|
|
// The number, starting on 1, represents its place.
|
2015-04-21 15:25:42 -04:00
|
|
|
type Pager struct {
|
2014-12-27 08:11:19 -05:00
|
|
|
number int
|
|
|
|
*paginator
|
|
|
|
}
|
|
|
|
|
2016-11-13 08:27:10 -05:00
|
|
|
func (p Pager) String() string {
|
|
|
|
return fmt.Sprintf("Pager %d", p.number)
|
|
|
|
}
|
|
|
|
|
2015-07-16 07:17:54 -04:00
|
|
|
type paginatedElement interface {
|
|
|
|
Len() int
|
|
|
|
}
|
|
|
|
|
2016-03-24 09:18:47 -04:00
|
|
|
// Len returns the number of pages in the list.
|
2015-07-16 07:17:54 -04:00
|
|
|
func (p Pages) Len() int {
|
|
|
|
return len(p)
|
|
|
|
}
|
|
|
|
|
2016-03-24 09:18:47 -04:00
|
|
|
// Len returns the number of pages in the page group.
|
2015-07-16 07:17:54 -04:00
|
|
|
func (psg PagesGroup) Len() int {
|
|
|
|
l := 0
|
|
|
|
for _, pg := range psg {
|
|
|
|
l += len(pg.Pages)
|
|
|
|
}
|
|
|
|
return l
|
|
|
|
}
|
|
|
|
|
2015-04-21 15:25:42 -04:00
|
|
|
type pagers []*Pager
|
2014-12-27 08:11:19 -05:00
|
|
|
|
2016-01-08 16:55:19 -05:00
|
|
|
var (
|
|
|
|
paginatorEmptyPages Pages
|
|
|
|
paginatorEmptyPageGroups PagesGroup
|
|
|
|
)
|
2015-03-05 18:30:51 -05:00
|
|
|
|
2014-12-27 08:11:19 -05:00
|
|
|
type paginator struct {
|
2015-07-16 07:17:54 -04:00
|
|
|
paginatedElements []paginatedElement
|
2014-12-27 08:11:19 -05:00
|
|
|
pagers
|
2015-03-11 13:34:57 -04:00
|
|
|
paginationURLFactory
|
2015-03-31 16:33:24 -04:00
|
|
|
total int
|
|
|
|
size int
|
|
|
|
source interface{}
|
|
|
|
options []interface{}
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
2015-03-11 13:34:57 -04:00
|
|
|
type paginationURLFactory func(int) string
|
2014-12-27 08:11:19 -05:00
|
|
|
|
|
|
|
// PageNumber returns the current page's number in the pager sequence.
|
2015-04-21 15:25:42 -04:00
|
|
|
func (p *Pager) PageNumber() int {
|
2014-12-27 08:11:19 -05:00
|
|
|
return p.number
|
|
|
|
}
|
|
|
|
|
2015-03-18 01:16:54 -04:00
|
|
|
// URL returns the URL to the current page.
|
2015-04-21 15:25:42 -04:00
|
|
|
func (p *Pager) URL() template.HTML {
|
2015-03-11 13:34:57 -04:00
|
|
|
return template.HTML(p.paginationURLFactory(p.PageNumber()))
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
2015-07-16 07:17:54 -04:00
|
|
|
// Pages returns the Pages on this page.
|
|
|
|
// Note: If this return a non-empty result, then PageGroups() will return empty.
|
2015-04-21 15:25:42 -04:00
|
|
|
func (p *Pager) Pages() Pages {
|
2015-07-16 07:17:54 -04:00
|
|
|
if len(p.paginatedElements) == 0 {
|
|
|
|
return paginatorEmptyPages
|
|
|
|
}
|
|
|
|
|
|
|
|
if pages, ok := p.element().(Pages); ok {
|
|
|
|
return pages
|
|
|
|
}
|
|
|
|
|
|
|
|
return paginatorEmptyPages
|
|
|
|
}
|
|
|
|
|
|
|
|
// PageGroups return Page groups for this page.
|
|
|
|
// Note: If this return non-empty result, then Pages() will return empty.
|
|
|
|
func (p *Pager) PageGroups() PagesGroup {
|
|
|
|
if len(p.paginatedElements) == 0 {
|
|
|
|
return paginatorEmptyPageGroups
|
|
|
|
}
|
|
|
|
|
|
|
|
if groups, ok := p.element().(PagesGroup); ok {
|
|
|
|
return groups
|
|
|
|
}
|
|
|
|
|
|
|
|
return paginatorEmptyPageGroups
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p *Pager) element() paginatedElement {
|
|
|
|
if len(p.paginatedElements) == 0 {
|
2015-03-05 18:30:51 -05:00
|
|
|
return paginatorEmptyPages
|
|
|
|
}
|
2015-07-16 07:17:54 -04:00
|
|
|
return p.paginatedElements[p.PageNumber()-1]
|
|
|
|
}
|
|
|
|
|
|
|
|
// page returns the Page with the given index
|
|
|
|
func (p *Pager) page(index int) (*Page, error) {
|
|
|
|
|
|
|
|
if pages, ok := p.element().(Pages); ok {
|
|
|
|
if pages != nil && len(pages) > index {
|
|
|
|
return pages[index], nil
|
|
|
|
}
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// must be PagesGroup
|
|
|
|
// this construction looks clumsy, but ...
|
|
|
|
// ... it is the difference between 99.5% and 100% test coverage :-)
|
|
|
|
groups := p.element().(PagesGroup)
|
|
|
|
|
|
|
|
i := 0
|
|
|
|
for _, v := range groups {
|
|
|
|
for _, page := range v.Pages {
|
|
|
|
if i == index {
|
|
|
|
return page, nil
|
|
|
|
}
|
|
|
|
i++
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil, nil
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// NumberOfElements gets the number of elements on this page.
|
2015-04-21 15:25:42 -04:00
|
|
|
func (p *Pager) NumberOfElements() int {
|
2015-07-16 07:17:54 -04:00
|
|
|
return p.element().Len()
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// HasPrev tests whether there are page(s) before the current.
|
2015-04-21 15:25:42 -04:00
|
|
|
func (p *Pager) HasPrev() bool {
|
2014-12-27 08:11:19 -05:00
|
|
|
return p.PageNumber() > 1
|
|
|
|
}
|
|
|
|
|
|
|
|
// Prev returns the pager for the previous page.
|
2015-04-21 15:25:42 -04:00
|
|
|
func (p *Pager) Prev() *Pager {
|
2014-12-27 08:11:19 -05:00
|
|
|
if !p.HasPrev() {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return p.pagers[p.PageNumber()-2]
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasNext tests whether there are page(s) after the current.
|
2015-04-21 15:25:42 -04:00
|
|
|
func (p *Pager) HasNext() bool {
|
2015-07-16 07:17:54 -04:00
|
|
|
return p.PageNumber() < len(p.paginatedElements)
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// Next returns the pager for the next page.
|
2015-04-21 15:25:42 -04:00
|
|
|
func (p *Pager) Next() *Pager {
|
2014-12-27 08:11:19 -05:00
|
|
|
if !p.HasNext() {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return p.pagers[p.PageNumber()]
|
|
|
|
}
|
|
|
|
|
|
|
|
// First returns the pager for the first page.
|
2015-04-21 15:25:42 -04:00
|
|
|
func (p *Pager) First() *Pager {
|
2014-12-27 08:11:19 -05:00
|
|
|
return p.pagers[0]
|
|
|
|
}
|
|
|
|
|
|
|
|
// Last returns the pager for the last page.
|
2015-04-21 15:25:42 -04:00
|
|
|
func (p *Pager) Last() *Pager {
|
2014-12-27 08:11:19 -05:00
|
|
|
return p.pagers[len(p.pagers)-1]
|
|
|
|
}
|
|
|
|
|
|
|
|
// Pagers returns a list of pagers that can be used to build a pagination menu.
|
|
|
|
func (p *paginator) Pagers() pagers {
|
|
|
|
return p.pagers
|
|
|
|
}
|
|
|
|
|
|
|
|
// PageSize returns the size of each paginator page.
|
|
|
|
func (p *paginator) PageSize() int {
|
|
|
|
return p.size
|
|
|
|
}
|
|
|
|
|
|
|
|
// TotalPages returns the number of pages in the paginator.
|
|
|
|
func (p *paginator) TotalPages() int {
|
2015-07-16 07:17:54 -04:00
|
|
|
return len(p.paginatedElements)
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// TotalNumberOfElements returns the number of elements on all pages in this paginator.
|
|
|
|
func (p *paginator) TotalNumberOfElements() int {
|
|
|
|
return p.total
|
|
|
|
}
|
|
|
|
|
2015-07-16 07:17:54 -04:00
|
|
|
func splitPages(pages Pages, size int) []paginatedElement {
|
|
|
|
var split []paginatedElement
|
2014-12-27 08:11:19 -05:00
|
|
|
for low, j := 0, len(pages); low < j; low += size {
|
|
|
|
high := int(math.Min(float64(low+size), float64(len(pages))))
|
|
|
|
split = append(split, pages[low:high])
|
|
|
|
}
|
|
|
|
|
|
|
|
return split
|
|
|
|
}
|
|
|
|
|
2015-07-16 07:17:54 -04:00
|
|
|
func splitPageGroups(pageGroups PagesGroup, size int) []paginatedElement {
|
|
|
|
|
|
|
|
type keyPage struct {
|
|
|
|
key interface{}
|
|
|
|
page *Page
|
|
|
|
}
|
|
|
|
|
2016-01-08 16:55:19 -05:00
|
|
|
var (
|
|
|
|
split []paginatedElement
|
|
|
|
flattened []keyPage
|
|
|
|
)
|
2015-07-16 07:17:54 -04:00
|
|
|
|
|
|
|
for _, g := range pageGroups {
|
|
|
|
for _, p := range g.Pages {
|
|
|
|
flattened = append(flattened, keyPage{g.Key, p})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
numPages := len(flattened)
|
|
|
|
|
|
|
|
for low, j := 0, numPages; low < j; low += size {
|
|
|
|
high := int(math.Min(float64(low+size), float64(numPages)))
|
2016-01-08 16:55:19 -05:00
|
|
|
|
|
|
|
var (
|
|
|
|
pg PagesGroup
|
2016-03-24 09:18:47 -04:00
|
|
|
key interface{}
|
|
|
|
groupIndex = -1
|
2016-01-08 16:55:19 -05:00
|
|
|
)
|
|
|
|
|
2015-07-16 07:17:54 -04:00
|
|
|
for k := low; k < high; k++ {
|
|
|
|
kp := flattened[k]
|
|
|
|
if key == nil || key != kp.key {
|
|
|
|
key = kp.key
|
|
|
|
pg = append(pg, PageGroup{Key: key})
|
|
|
|
groupIndex++
|
|
|
|
}
|
|
|
|
pg[groupIndex].Pages = append(pg[groupIndex].Pages, kp.page)
|
|
|
|
}
|
|
|
|
split = append(split, pg)
|
|
|
|
}
|
|
|
|
|
|
|
|
return split
|
|
|
|
}
|
|
|
|
|
2016-11-13 08:27:10 -05:00
|
|
|
// Paginator gets this Page's paginator if it's already created.
|
2014-12-27 08:11:19 -05:00
|
|
|
// If it's not, one will be created with all pages in Data["Pages"].
|
2016-11-13 08:27:10 -05:00
|
|
|
func (p *Page) Paginator(options ...interface{}) (*Pager, error) {
|
|
|
|
if !p.IsNode() {
|
|
|
|
return nil, fmt.Errorf("Paginators not supported for pages of type %q (%q)", p.Kind, p.Title)
|
2016-10-31 05:23:01 -04:00
|
|
|
}
|
2015-03-31 13:12:54 -04:00
|
|
|
pagerSize, err := resolvePagerSize(options...)
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2014-12-27 08:11:19 -05:00
|
|
|
|
|
|
|
var initError error
|
|
|
|
|
2016-11-13 08:27:10 -05:00
|
|
|
p.paginatorInit.Do(func() {
|
|
|
|
if p.paginator != nil {
|
2014-12-27 08:11:19 -05:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-01-10 04:55:03 -05:00
|
|
|
pagers, err := paginatePages(p.s.PathSpec, p.Data["Pages"], pagerSize, p.sections...)
|
2014-12-27 08:11:19 -05:00
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
initError = err
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(pagers) > 0 {
|
|
|
|
// the rest of the nodes will be created later
|
2016-11-13 08:27:10 -05:00
|
|
|
p.paginator = pagers[0]
|
|
|
|
p.paginator.source = "paginator"
|
|
|
|
p.paginator.options = options
|
|
|
|
p.Site.addToPaginationPageCount(uint64(p.paginator.TotalPages()))
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
})
|
|
|
|
|
|
|
|
if initError != nil {
|
|
|
|
return nil, initError
|
|
|
|
}
|
|
|
|
|
2016-11-13 08:27:10 -05:00
|
|
|
return p.paginator, nil
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
2017-01-08 10:54:05 -05:00
|
|
|
func (p *Page) Paginate(seq interface{}, options ...interface{}) (*Pager, error) {
|
|
|
|
if !p.IsNode() {
|
|
|
|
return nil, fmt.Errorf("Paginators not supported for pages of type %q (%q)", p.Kind, p.Title)
|
2016-10-31 05:23:01 -04:00
|
|
|
}
|
2015-03-31 13:12:54 -04:00
|
|
|
|
|
|
|
pagerSize, err := resolvePagerSize(options...)
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2014-12-27 08:11:19 -05:00
|
|
|
|
|
|
|
var initError error
|
|
|
|
|
2017-01-08 10:54:05 -05:00
|
|
|
p.paginatorInit.Do(func() {
|
|
|
|
if p.paginator != nil {
|
2014-12-27 08:11:19 -05:00
|
|
|
return
|
|
|
|
}
|
2017-01-10 04:55:03 -05:00
|
|
|
pagers, err := paginatePages(p.s.PathSpec, seq, pagerSize, p.sections...)
|
2014-12-27 08:11:19 -05:00
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
initError = err
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(pagers) > 0 {
|
|
|
|
// the rest of the nodes will be created later
|
2017-01-08 10:54:05 -05:00
|
|
|
p.paginator = pagers[0]
|
|
|
|
p.paginator.source = seq
|
|
|
|
p.paginator.options = options
|
|
|
|
p.Site.addToPaginationPageCount(uint64(p.paginator.TotalPages()))
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
})
|
|
|
|
|
|
|
|
if initError != nil {
|
|
|
|
return nil, initError
|
|
|
|
}
|
|
|
|
|
2017-01-08 10:54:05 -05:00
|
|
|
if p.paginator.source == "paginator" {
|
2015-03-31 16:33:24 -04:00
|
|
|
return nil, errors.New("a Paginator was previously built for this Node without filters; look for earlier .Paginator usage")
|
2015-04-21 15:25:42 -04:00
|
|
|
}
|
|
|
|
|
2017-01-08 10:54:05 -05:00
|
|
|
if !reflect.DeepEqual(options, p.paginator.options) || !probablyEqualPageLists(p.paginator.source, seq) {
|
2015-04-21 15:25:42 -04:00
|
|
|
return nil, errors.New("invoked multiple times with different arguments")
|
2015-03-31 16:33:24 -04:00
|
|
|
}
|
|
|
|
|
2017-01-08 10:54:05 -05:00
|
|
|
return p.paginator, nil
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
2015-03-31 13:12:54 -04:00
|
|
|
func resolvePagerSize(options ...interface{}) (int, error) {
|
|
|
|
if len(options) == 0 {
|
2016-09-15 03:32:52 -04:00
|
|
|
return helpers.Config().GetInt("paginate"), nil
|
2015-03-31 13:12:54 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if len(options) > 1 {
|
|
|
|
return -1, errors.New("too many arguments, 'pager size' is currently the only option")
|
|
|
|
}
|
|
|
|
|
|
|
|
pas, err := cast.ToIntE(options[0])
|
|
|
|
|
|
|
|
if err != nil || pas <= 0 {
|
|
|
|
return -1, errors.New(("'pager size' must be a positive integer"))
|
|
|
|
}
|
|
|
|
|
|
|
|
return pas, nil
|
|
|
|
}
|
|
|
|
|
2017-01-10 04:55:03 -05:00
|
|
|
func paginatePages(pathSpec *helpers.PathSpec, seq interface{}, pagerSize int, sections ...string) (pagers, error) {
|
2014-12-27 08:11:19 -05:00
|
|
|
|
2015-03-31 13:12:54 -04:00
|
|
|
if pagerSize <= 0 {
|
2014-12-27 08:11:19 -05:00
|
|
|
return nil, errors.New("'paginate' configuration setting must be positive to paginate")
|
|
|
|
}
|
2015-03-31 13:12:54 -04:00
|
|
|
|
2017-01-10 04:55:03 -05:00
|
|
|
urlFactory := newPaginationURLFactory(pathSpec, sections...)
|
2015-07-16 07:17:54 -04:00
|
|
|
|
|
|
|
var paginator *paginator
|
|
|
|
|
|
|
|
if groups, ok := seq.(PagesGroup); ok {
|
|
|
|
paginator, _ = newPaginatorFromPageGroups(groups, pagerSize, urlFactory)
|
|
|
|
} else {
|
|
|
|
pages, err := toPages(seq)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
paginator, _ = newPaginatorFromPages(pages, pagerSize, urlFactory)
|
|
|
|
}
|
|
|
|
|
2015-03-31 16:33:24 -04:00
|
|
|
pagers := paginator.Pagers()
|
|
|
|
|
|
|
|
return pagers, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func toPages(seq interface{}) (Pages, error) {
|
2014-12-27 08:11:19 -05:00
|
|
|
switch seq.(type) {
|
|
|
|
case Pages:
|
2015-03-31 16:33:24 -04:00
|
|
|
return seq.(Pages), nil
|
2014-12-27 08:11:19 -05:00
|
|
|
case *Pages:
|
2015-03-31 16:33:24 -04:00
|
|
|
return *(seq.(*Pages)), nil
|
2014-12-27 08:11:19 -05:00
|
|
|
case WeightedPages:
|
2015-03-31 16:33:24 -04:00
|
|
|
return (seq.(WeightedPages)).Pages(), nil
|
2014-12-27 08:11:19 -05:00
|
|
|
case PageGroup:
|
2015-03-31 16:33:24 -04:00
|
|
|
return (seq.(PageGroup)).Pages, nil
|
2014-12-27 08:11:19 -05:00
|
|
|
default:
|
2015-04-21 15:13:28 -04:00
|
|
|
return nil, fmt.Errorf("unsupported type in paginate, got %T", seq)
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
2015-03-31 16:33:24 -04:00
|
|
|
}
|
2014-12-27 08:11:19 -05:00
|
|
|
|
2015-03-31 16:33:24 -04:00
|
|
|
// probablyEqual checks page lists for probable equality.
|
|
|
|
// It may return false positives.
|
|
|
|
// The motivation behind this is to avoid potential costly reflect.DeepEqual
|
|
|
|
// when "probably" is good enough.
|
|
|
|
func probablyEqualPageLists(a1 interface{}, a2 interface{}) bool {
|
2014-12-27 08:11:19 -05:00
|
|
|
|
2015-03-31 16:33:24 -04:00
|
|
|
if a1 == nil || a2 == nil {
|
|
|
|
return a1 == a2
|
|
|
|
}
|
|
|
|
|
2015-07-16 07:17:54 -04:00
|
|
|
t1 := reflect.TypeOf(a1)
|
|
|
|
t2 := reflect.TypeOf(a2)
|
|
|
|
|
|
|
|
if t1 != t2 {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
if g1, ok := a1.(PagesGroup); ok {
|
|
|
|
g2 := a2.(PagesGroup)
|
|
|
|
if len(g1) != len(g2) {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
if len(g1) == 0 {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
if g1.Len() != g2.Len() {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
return g1[0].Pages[0] == g2[0].Pages[0]
|
|
|
|
}
|
|
|
|
|
2015-03-31 16:33:24 -04:00
|
|
|
p1, err1 := toPages(a1)
|
|
|
|
p2, err2 := toPages(a2)
|
|
|
|
|
|
|
|
// probably the same wrong type
|
|
|
|
if err1 != nil && err2 != nil {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(p1) != len(p2) {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(p1) == 0 {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
return p1[0] == p2[0]
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
2015-07-16 07:17:54 -04:00
|
|
|
func newPaginatorFromPages(pages Pages, size int, urlFactory paginationURLFactory) (*paginator, error) {
|
2014-12-27 08:11:19 -05:00
|
|
|
|
|
|
|
if size <= 0 {
|
2015-01-26 19:27:07 -05:00
|
|
|
return nil, errors.New("Paginator size must be positive")
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
split := splitPages(pages, size)
|
|
|
|
|
2015-07-16 07:17:54 -04:00
|
|
|
return newPaginator(split, len(pages), size, urlFactory)
|
|
|
|
}
|
|
|
|
|
|
|
|
func newPaginatorFromPageGroups(pageGroups PagesGroup, size int, urlFactory paginationURLFactory) (*paginator, error) {
|
|
|
|
|
|
|
|
if size <= 0 {
|
|
|
|
return nil, errors.New("Paginator size must be positive")
|
|
|
|
}
|
|
|
|
|
|
|
|
split := splitPageGroups(pageGroups, size)
|
|
|
|
|
|
|
|
return newPaginator(split, pageGroups.Len(), size, urlFactory)
|
|
|
|
}
|
|
|
|
|
|
|
|
func newPaginator(elements []paginatedElement, total, size int, urlFactory paginationURLFactory) (*paginator, error) {
|
|
|
|
p := &paginator{total: total, paginatedElements: elements, size: size, paginationURLFactory: urlFactory}
|
2014-12-27 08:11:19 -05:00
|
|
|
|
2015-03-05 18:30:51 -05:00
|
|
|
var ps pagers
|
|
|
|
|
2015-07-16 07:17:54 -04:00
|
|
|
if len(elements) > 0 {
|
|
|
|
ps = make(pagers, len(elements))
|
|
|
|
for i := range p.paginatedElements {
|
2015-04-21 15:25:42 -04:00
|
|
|
ps[i] = &Pager{number: (i + 1), paginator: p}
|
2015-03-05 18:30:51 -05:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ps = make(pagers, 1)
|
2015-04-21 15:25:42 -04:00
|
|
|
ps[0] = &Pager{number: 1, paginator: p}
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
2015-03-05 18:30:51 -05:00
|
|
|
p.pagers = ps
|
2014-12-27 08:11:19 -05:00
|
|
|
|
2015-01-26 19:27:07 -05:00
|
|
|
return p, nil
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
2017-01-10 04:55:03 -05:00
|
|
|
func newPaginationURLFactory(pathSpec *helpers.PathSpec, pathElements ...string) paginationURLFactory {
|
2014-12-27 08:11:19 -05:00
|
|
|
|
2017-01-08 10:54:05 -05:00
|
|
|
basePath := path.Join(pathElements...)
|
|
|
|
|
2014-12-27 08:11:19 -05:00
|
|
|
return func(page int) string {
|
|
|
|
var rel string
|
|
|
|
if page == 1 {
|
2017-01-08 10:54:05 -05:00
|
|
|
rel = fmt.Sprintf("/%s/", basePath)
|
2014-12-27 08:11:19 -05:00
|
|
|
} else {
|
2017-01-08 10:54:05 -05:00
|
|
|
rel = fmt.Sprintf("/%s/%s/%d/", basePath, pathSpec.PaginatePath(), page)
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
|
2016-10-24 07:45:30 -04:00
|
|
|
return pathSpec.URLizeAndPrep(rel)
|
2014-12-27 08:11:19 -05:00
|
|
|
}
|
|
|
|
}
|