mirror of
https://github.com/gohugoio/hugo.git
synced 2024-12-25 13:01:25 +00:00
138 lines
3 KiB
Go
138 lines
3 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 hugolib
|
|
|
|
import (
|
|
"github.com/gohugoio/hugo/markup/converter"
|
|
"github.com/gohugoio/hugo/output"
|
|
"github.com/gohugoio/hugo/resources/page"
|
|
"github.com/gohugoio/hugo/resources/resource"
|
|
)
|
|
|
|
func newPageOutput(
|
|
ps *pageState,
|
|
pp pagePaths,
|
|
f output.Format,
|
|
render bool) *pageOutput {
|
|
|
|
var targetPathsProvider targetPathsHolder
|
|
var linksProvider resource.ResourceLinksProvider
|
|
|
|
ft, found := pp.targetPaths[f.Name]
|
|
if !found {
|
|
// Link to the main output format
|
|
ft = pp.targetPaths[pp.firstOutputFormat.Format.Name]
|
|
}
|
|
targetPathsProvider = ft
|
|
linksProvider = ft
|
|
|
|
var paginatorProvider page.PaginatorProvider = page.NopPage
|
|
var pag *pagePaginator
|
|
|
|
if render && ps.IsNode() {
|
|
pag = newPagePaginator(ps)
|
|
paginatorProvider = pag
|
|
}
|
|
|
|
providers := struct {
|
|
page.PaginatorProvider
|
|
resource.ResourceLinksProvider
|
|
targetPather
|
|
}{
|
|
paginatorProvider,
|
|
linksProvider,
|
|
targetPathsProvider,
|
|
}
|
|
|
|
po := &pageOutput{
|
|
f: f,
|
|
pagePerOutputProviders: providers,
|
|
ContentProvider: page.NopPage,
|
|
TableOfContentsProvider: page.NopPage,
|
|
render: render,
|
|
paginator: pag,
|
|
}
|
|
|
|
return po
|
|
|
|
}
|
|
|
|
// We create a pageOutput for every output format combination, even if this
|
|
// particular page isn't configured to be rendered to that format.
|
|
type pageOutput struct {
|
|
// Set if this page isn't configured to be rendered to this format.
|
|
render bool
|
|
|
|
f output.Format
|
|
|
|
// Only set if render is set.
|
|
// Note that this will be lazily initialized, so only used if actually
|
|
// used in template(s).
|
|
paginator *pagePaginator
|
|
|
|
// These interface provides the functionality that is specific for this
|
|
// output format.
|
|
pagePerOutputProviders
|
|
page.ContentProvider
|
|
page.TableOfContentsProvider
|
|
|
|
// May be nil.
|
|
cp *pageContentOutput
|
|
}
|
|
|
|
func (o *pageOutput) initRenderHooks() error {
|
|
if o.cp == nil {
|
|
return nil
|
|
}
|
|
|
|
var initErr error
|
|
|
|
o.cp.renderHooks.init.Do(func() {
|
|
ps := o.cp.p
|
|
|
|
c := ps.getContentConverter()
|
|
if c == nil || !c.Supports(converter.FeatureRenderHooks) {
|
|
return
|
|
}
|
|
|
|
h, err := ps.createRenderHooks(o.f)
|
|
if err != nil {
|
|
initErr = err
|
|
}
|
|
if h == nil {
|
|
return
|
|
}
|
|
|
|
o.cp.renderHooks.hooks = h
|
|
})
|
|
|
|
return initErr
|
|
|
|
}
|
|
|
|
func (p *pageOutput) initContentProvider(cp *pageContentOutput) {
|
|
if cp == nil {
|
|
return
|
|
}
|
|
p.ContentProvider = cp
|
|
p.TableOfContentsProvider = cp
|
|
p.cp = cp
|
|
}
|
|
|
|
func (p *pageOutput) enablePlaceholders() {
|
|
if p.cp != nil {
|
|
p.cp.enablePlaceholders()
|
|
}
|
|
|
|
}
|